Merge branch 'remove-bridge-exceptions' into 'master'

Remove unused bridge_exceptions method

Closes #698 and #608

See merge request gitlab-org/gitaly!987

13 files changed, 655 insertions, 849 deletions

diff --git a/changelogs/unreleased/remove-bridge-exceptions.yml b/changelogs/unreleased/remove-bridge-exceptions.yml
new file mode 100644
index 000000000..7c928dc69
--- /dev/null
+++ b/changelogs/unreleased/remove-bridge-exceptions.yml
@@ -0,0 +1,5 @@
+---
+title: Remove unused bridge_exceptions method
+merge_request: 987
+author:
+type: other
diff --git a/ruby/lib/gitaly_server/blob_service.rb b/ruby/lib/gitaly_server/blob_service.rb
index 82e3cf0e7..4e14e882e 100644
--- a/ruby/lib/gitaly_server/blob_service.rb
+++ b/ruby/lib/gitaly_server/blob_service.rb
@@ -7,41 +7,35 @@ module GitalyServer
     MAX_LFS_POINTERS_PER_MESSSAGE = 100
 
     def get_lfs_pointers(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        blobs = Gitlab::Git::Blob.batch_lfs_pointers(repo, request.blob_ids)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      blobs = Gitlab::Git::Blob.batch_lfs_pointers(repo, request.blob_ids)
 
-        Enumerator.new do |y|
-          sliced_gitaly_lfs_pointers(blobs) do |lfs_pointers|
-            y.yield Gitaly::GetLFSPointersResponse.new(lfs_pointers: lfs_pointers)
-          end
+      Enumerator.new do |y|
+        sliced_gitaly_lfs_pointers(blobs) do |lfs_pointers|
+          y.yield Gitaly::GetLFSPointersResponse.new(lfs_pointers: lfs_pointers)
         end
       end
     end
 
     def get_new_lfs_pointers(request, call)
       Enumerator.new do |y|
-        bridge_exceptions do
-          changes = lfs_changes(request, call)
-          object_limit = request.limit.zero? ? nil : request.limit
-          not_in = request.not_in_all ? :all : request.not_in_refs.to_a
-          blobs = changes.new_pointers(object_limit: object_limit, not_in: not_in)
+        changes = lfs_changes(request, call)
+        object_limit = request.limit.zero? ? nil : request.limit
+        not_in = request.not_in_all ? :all : request.not_in_refs.to_a
+        blobs = changes.new_pointers(object_limit: object_limit, not_in: not_in)
 
-          sliced_gitaly_lfs_pointers(blobs) do |lfs_pointers|
-            y.yield Gitaly::GetNewLFSPointersResponse.new(lfs_pointers: lfs_pointers)
-          end
+        sliced_gitaly_lfs_pointers(blobs) do |lfs_pointers|
+          y.yield Gitaly::GetNewLFSPointersResponse.new(lfs_pointers: lfs_pointers)
         end
       end
     end
 
     def get_all_lfs_pointers(request, call)
       Enumerator.new do |y|
-        bridge_exceptions do
-          changes = lfs_changes(request, call)
+        changes = lfs_changes(request, call)
 
-          sliced_gitaly_lfs_pointers(changes.all_pointers) do |lfs_pointers|
-            y.yield Gitaly::GetAllLFSPointersResponse.new(lfs_pointers: lfs_pointers)
-          end
+        sliced_gitaly_lfs_pointers(changes.all_pointers) do |lfs_pointers|
+          y.yield Gitaly::GetAllLFSPointersResponse.new(lfs_pointers: lfs_pointers)
         end
       end
     end
diff --git a/ruby/lib/gitaly_server/commit_service.rb b/ruby/lib/gitaly_server/commit_service.rb
index 99c41962a..0abf22f50 100644
--- a/ruby/lib/gitaly_server/commit_service.rb
+++ b/ruby/lib/gitaly_server/commit_service.rb
@@ -4,149 +4,113 @@ module GitalyServer
     include Gitlab::EncodingHelper
 
     def commit_stats(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        revision = request.revision unless request.revision.empty?
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      revision = request.revision unless request.revision.empty?
 
-        commit = Gitlab::Git::Commit.find(repo, revision)
+      commit = Gitlab::Git::Commit.find(repo, revision)
 
-        # In the odd case that the revision given doesn't exist we need to raise
-        # an exception. Since GitLab (currently) already does this for us we don't
-        # expect this to actually happen, just guarding against future code change
-        raise GRPC::Internal.new("commit not found for revision '#{revision}'") unless commit
+      # In the odd case that the revision given doesn't exist we need to raise
+      # an exception. Since GitLab (currently) already does this for us we don't
+      # expect this to actually happen, just guarding against future code change
+      raise GRPC::Internal.new("commit not found for revision '#{revision}'") unless commit
 
-        stats = Gitlab::Git::CommitStats.new(repo, commit)
+      stats = Gitlab::Git::CommitStats.new(repo, commit)
 
-        Gitaly::CommitStatsResponse.new(oid: stats.id, additions: stats.additions, deletions: stats.deletions)
-      end
-    end
-
-    # TODO remove this implementation in GitLab 11.3
-    def list_commits_by_oid(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-
-        Enumerator.new do |y|
-          request.oid.each_slice(20) do |oids|
-            commits = oids.map do |oid|
-              commit =
-                begin
-                  repository.rev_parse_target(oid)
-                rescue Rugged::ReferenceError, Rugged::InvalidError
-                  nil
-                end
-
-              commit.is_a?(Rugged::Commit) ? gitaly_commit_from_rugged(commit) : nil
-            end.compact
-
-            y.yield Gitaly::ListCommitsByOidResponse.new(commits: commits)
-          end
-        end
-      end
+      Gitaly::CommitStatsResponse.new(oid: stats.id, additions: stats.additions, deletions: stats.deletions)
     end
 
     def find_commits(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        options = {
-          ref: request.revision,
-          limit: request.limit,
-          follow: request.follow,
-          skip_merges: request.skip_merges,
-          disable_walk: request.disable_walk,
-          offset: request.offset,
-          all: request.all
-        }
-        options[:path] = request.paths unless request.paths.empty?
-
-        options[:before] = Time.at(request.before.seconds).to_datetime if request.before
-        options[:after] = Time.at(request.after.seconds).to_datetime if request.after
-
-        Enumerator.new do |y|
-          # Send back 'pages' with 20 commits each
-          repository.raw_log(options).each_slice(20) do |rugged_commits|
-            commits = rugged_commits.map do |rugged_commit|
-              gitaly_commit_from_rugged(rugged_commit)
-            end
-            y.yield Gitaly::FindCommitsResponse.new(commits: commits)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      options = {
+        ref: request.revision,
+        limit: request.limit,
+        follow: request.follow,
+        skip_merges: request.skip_merges,
+        disable_walk: request.disable_walk,
+        offset: request.offset,
+        all: request.all
+      }
+      options[:path] = request.paths unless request.paths.empty?
+
+      options[:before] = Time.at(request.before.seconds).to_datetime if request.before
+      options[:after] = Time.at(request.after.seconds).to_datetime if request.after
+
+      Enumerator.new do |y|
+        # Send back 'pages' with 20 commits each
+        repository.raw_log(options).each_slice(20) do |rugged_commits|
+          commits = rugged_commits.map do |rugged_commit|
+            gitaly_commit_from_rugged(rugged_commit)
           end
+          y.yield Gitaly::FindCommitsResponse.new(commits: commits)
         end
       end
     end
 
     def filter_shas_with_signatures(_session, call)
       Enumerator.new do |y|
-        bridge_exceptions do
-          repository = nil
+        repository = nil
 
-          call.each_remote_read.with_index do |request, index|
-            repository = Gitlab::Git::Repository.from_gitaly(request.repository, call) if index.zero?
+        call.each_remote_read.with_index do |request, index|
+          repository = Gitlab::Git::Repository.from_gitaly(request.repository, call) if index.zero?
 
-            y << Gitaly::FilterShasWithSignaturesResponse.new(shas: Gitlab::Git::Commit.shas_with_signatures(repository, request.shas))
-          end
+          y << Gitaly::FilterShasWithSignaturesResponse.new(shas: Gitlab::Git::Commit.shas_with_signatures(repository, request.shas))
         end
       end
     end
 
     def extract_commit_signature(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        Enumerator.new do |y|
-          each_commit_signature_chunk(repository, request.commit_id) do |signature_chunk, signed_text_chunk|
-            y.yield Gitaly::ExtractCommitSignatureResponse.new(signature: signature_chunk) if signature_chunk.present?
+      Enumerator.new do |y|
+        each_commit_signature_chunk(repository, request.commit_id) do |signature_chunk, signed_text_chunk|
+          y.yield Gitaly::ExtractCommitSignatureResponse.new(signature: signature_chunk) if signature_chunk.present?
 
-            y.yield Gitaly::ExtractCommitSignatureResponse.new(signed_text: signed_text_chunk) if signed_text_chunk.present?
-          end
+          y.yield Gitaly::ExtractCommitSignatureResponse.new(signed_text: signed_text_chunk) if signed_text_chunk.present?
         end
       end
     end
 
     def get_commit_signatures(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        Enumerator.new do |y|
-          request.commit_ids.each do |commit_id|
-            msg = Gitaly::GetCommitSignaturesResponse.new(commit_id: commit_id)
-
-            each_commit_signature_chunk(repository, commit_id) do |signature_chunk, signed_text_chunk|
-              if signature_chunk.present?
-                msg.signature = signature_chunk
-                y.yield msg
-              end
+      Enumerator.new do |y|
+        request.commit_ids.each do |commit_id|
+          msg = Gitaly::GetCommitSignaturesResponse.new(commit_id: commit_id)
 
-              if signed_text_chunk.present?
-                msg.signed_text = signed_text_chunk
-                y.yield msg
-              end
+          each_commit_signature_chunk(repository, commit_id) do |signature_chunk, signed_text_chunk|
+            if signature_chunk.present?
+              msg.signature = signature_chunk
+              y.yield msg
+            end
 
-              msg = Gitaly::GetCommitSignaturesResponse.new
+            if signed_text_chunk.present?
+              msg.signed_text = signed_text_chunk
+              y.yield msg
             end
+
+            msg = Gitaly::GetCommitSignaturesResponse.new
           end
         end
       end
     end
 
     def get_commit_messages(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        Enumerator.new do |y|
-          request.commit_ids.each do |commit_id|
-            commit = Gitlab::Git::Commit.find(repository, commit_id)
-            next unless commit
+      Enumerator.new do |y|
+        request.commit_ids.each do |commit_id|
+          commit = Gitlab::Git::Commit.find(repository, commit_id)
+          next unless commit
 
-            response = Gitaly::GetCommitMessagesResponse.new(commit_id: commit.id)
-            io = StringIO.new(commit.message)
+          response = Gitaly::GetCommitMessagesResponse.new(commit_id: commit.id)
+          io = StringIO.new(commit.message)
 
-            while chunk = io.read(Gitlab.config.git.max_commit_or_tag_message_size)
-              response.message = chunk
+          while chunk = io.read(Gitlab.config.git.max_commit_or_tag_message_size)
+            response.message = chunk
 
-              y.yield response
+            y.yield response
 
-              response = Gitaly::GetCommitMessagesResponse.new
-            end
+            response = Gitaly::GetCommitMessagesResponse.new
           end
         end
       end
diff --git a/ruby/lib/gitaly_server/conflicts_service.rb b/ruby/lib/gitaly_server/conflicts_service.rb
index d3f961d63..737d2118d 100644
--- a/ruby/lib/gitaly_server/conflicts_service.rb
+++ b/ruby/lib/gitaly_server/conflicts_service.rb
@@ -5,75 +5,69 @@ module GitalyServer
     include Utils
 
     def list_conflict_files(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          resolver = Gitlab::Git::Conflict::Resolver.new(repo, request.our_commit_oid, request.their_commit_oid)
-          conflicts = resolver.conflicts
-          files = []
-          msg_size = 0
-
-          Enumerator.new do |y|
-            enumerate_conflicts(conflicts) do |file|
-              files << Gitaly::ConflictFile.new(header: conflict_file_header(file))
-
-              strio = StringIO.new(file.content)
-              while chunk = strio.read(Gitlab.config.git.write_buffer_size - msg_size)
-                files << Gitaly::ConflictFile.new(content: chunk)
-                msg_size += chunk.bytesize
-
-                # We don't send a message for each chunk because the content of
-                # a file may be smaller than the size limit, which means we can
-                # keep adding data to the message
-                next if msg_size < Gitlab.config.git.write_buffer_size
-
-                y.yield(Gitaly::ListConflictFilesResponse.new(files: files))
-
-                files = []
-                msg_size = 0
-              end
-            end
-
-            # Send leftover data, if any
-            y.yield(Gitaly::ListConflictFilesResponse.new(files: files)) if files.any?
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      resolver = Gitlab::Git::Conflict::Resolver.new(repo, request.our_commit_oid, request.their_commit_oid)
+      conflicts = resolver.conflicts
+      files = []
+      msg_size = 0
+
+      Enumerator.new do |y|
+        enumerate_conflicts(conflicts) do |file|
+          files << Gitaly::ConflictFile.new(header: conflict_file_header(file))
+
+          strio = StringIO.new(file.content)
+          while chunk = strio.read(Gitlab.config.git.write_buffer_size - msg_size)
+            files << Gitaly::ConflictFile.new(content: chunk)
+            msg_size += chunk.bytesize
+
+            # We don't send a message for each chunk because the content of
+            # a file may be smaller than the size limit, which means we can
+            # keep adding data to the message
+            next if msg_size < Gitlab.config.git.write_buffer_size
+
+            y.yield(Gitaly::ListConflictFilesResponse.new(files: files))
+
+            files = []
+            msg_size = 0
           end
-        rescue Gitlab::Git::Conflict::Resolver::ListError => e
-          raise GRPC::FailedPrecondition.new(e.message)
         end
+
+        # Send leftover data, if any
+        y.yield(Gitaly::ListConflictFilesResponse.new(files: files)) if files.any?
       end
+    rescue Gitlab::Git::Conflict::Resolver::ListError => e
+      raise GRPC::FailedPrecondition.new(e.message)
     end
 
     def resolve_conflicts(call)
-      bridge_exceptions do
-        header = nil
-        files_json = ""
-
-        call.each_remote_read.each_with_index do |request, index|
-          if index.zero?
-            header = request.header
-          else
-            files_json << request.files_json
-          end
+      header = nil
+      files_json = ""
+
+      call.each_remote_read.each_with_index do |request, index|
+        if index.zero?
+          header = request.header
+        else
+          files_json << request.files_json
         end
+      end
 
-        repo = Gitlab::Git::Repository.from_gitaly(header.repository, call)
-        remote_repo = Gitlab::Git::GitalyRemoteRepository.new(header.target_repository, call)
-        resolver = Gitlab::Git::Conflict::Resolver.new(remote_repo, header.our_commit_oid, header.their_commit_oid)
-        user = Gitlab::Git::User.from_gitaly(header.user)
-        files = JSON.parse(files_json).map(&:with_indifferent_access)
-
-        begin
-          resolution = Gitlab::Git::Conflict::Resolution.new(user, files, header.commit_message.dup)
-          params = {
-            source_branch: header.source_branch,
-            target_branch: header.target_branch
-          }
-          resolver.resolve_conflicts(repo, resolution, params)
-
-          Gitaly::ResolveConflictsResponse.new
-        rescue Gitlab::Git::Conflict::Resolver::ResolutionError => e
-          Gitaly::ResolveConflictsResponse.new(resolution_error: e.message)
-        end
+      repo = Gitlab::Git::Repository.from_gitaly(header.repository, call)
+      remote_repo = Gitlab::Git::GitalyRemoteRepository.new(header.target_repository, call)
+      resolver = Gitlab::Git::Conflict::Resolver.new(remote_repo, header.our_commit_oid, header.their_commit_oid)
+      user = Gitlab::Git::User.from_gitaly(header.user)
+      files = JSON.parse(files_json).map(&:with_indifferent_access)
+
+      begin
+        resolution = Gitlab::Git::Conflict::Resolution.new(user, files, header.commit_message.dup)
+        params = {
+          source_branch: header.source_branch,
+          target_branch: header.target_branch
+        }
+        resolver.resolve_conflicts(repo, resolution, params)
+
+        Gitaly::ResolveConflictsResponse.new
+      rescue Gitlab::Git::Conflict::Resolver::ResolutionError => e
+        Gitaly::ResolveConflictsResponse.new(resolution_error: e.message)
       end
     end
 
diff --git a/ruby/lib/gitaly_server/diff_service.rb b/ruby/lib/gitaly_server/diff_service.rb
index 340146ea8..b48e06565 100644
--- a/ruby/lib/gitaly_server/diff_service.rb
+++ b/ruby/lib/gitaly_server/diff_service.rb
@@ -3,15 +3,13 @@ module GitalyServer
     include Utils
 
     def commit_patch(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        commit = Gitlab::Git::Commit.find(repo, request.revision)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      commit = Gitlab::Git::Commit.find(repo, request.revision)
 
-        Enumerator.new do |y|
-          io = StringIO.new(commit.to_diff)
-          while chunk = io.read(Gitlab.config.git.write_buffer_size)
-            y.yield Gitaly::CommitPatchResponse.new(data: chunk)
-          end
+      Enumerator.new do |y|
+        io = StringIO.new(commit.to_diff)
+        while chunk = io.read(Gitlab.config.git.write_buffer_size)
+          y.yield Gitaly::CommitPatchResponse.new(data: chunk)
         end
       end
     end
diff --git a/ruby/lib/gitaly_server/operations_service.rb b/ruby/lib/gitaly_server/operations_service.rb
index 7bfae31d3..26176884f 100644
--- a/ruby/lib/gitaly_server/operations_service.rb
+++ b/ruby/lib/gitaly_server/operations_service.rb
@@ -3,345 +3,293 @@ module GitalyServer
     include Utils
 
     def user_create_tag(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-          gitaly_user = get_param!(request, :user)
-          user = Gitlab::Git::User.from_gitaly(gitaly_user)
+      gitaly_user = get_param!(request, :user)
+      user = Gitlab::Git::User.from_gitaly(gitaly_user)
 
-          tag_name = get_param!(request, :tag_name)
+      tag_name = get_param!(request, :tag_name)
 
-          target_revision = get_param!(request, :target_revision)
+      target_revision = get_param!(request, :target_revision)
 
-          created_tag = repo.add_tag(tag_name, user: user, target: target_revision, message: request.message.presence)
-          return Gitaly::UserCreateTagResponse.new unless created_tag
+      created_tag = repo.add_tag(tag_name, user: user, target: target_revision, message: request.message.presence)
+      Gitaly::UserCreateTagResponse.new unless created_tag
 
-          rugged_commit = created_tag.dereferenced_target.rugged_commit
-          commit = gitaly_commit_from_rugged(rugged_commit)
-          tag = gitaly_tag_from_gitlab_tag(created_tag, commit)
+      rugged_commit = created_tag.dereferenced_target.rugged_commit
+      commit = gitaly_commit_from_rugged(rugged_commit)
+      tag = gitaly_tag_from_gitlab_tag(created_tag, commit)
 
-          Gitaly::UserCreateTagResponse.new(tag: tag)
-        rescue Gitlab::Git::Repository::InvalidRef => e
-          raise GRPC::FailedPrecondition.new(e.message)
-        rescue Gitlab::Git::Repository::TagExistsError
-          return Gitaly::UserCreateTagResponse.new(exists: true)
-        rescue Gitlab::Git::PreReceiveError => e
-          return Gitaly::UserCreateTagResponse.new(pre_receive_error: set_utf8!(e.message))
-        end
-      end
+      Gitaly::UserCreateTagResponse.new(tag: tag)
+    rescue Gitlab::Git::Repository::InvalidRef => e
+      raise GRPC::FailedPrecondition.new(e.message)
+    rescue Gitlab::Git::Repository::TagExistsError
+      Gitaly::UserCreateTagResponse.new(exists: true)
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserCreateTagResponse.new(pre_receive_error: set_utf8!(e.message))
     end
 
     def user_delete_tag(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-          gitaly_user = get_param!(request, :user)
-          user = Gitlab::Git::User.from_gitaly(gitaly_user)
+      gitaly_user = get_param!(request, :user)
+      user = Gitlab::Git::User.from_gitaly(gitaly_user)
 
-          tag_name = get_param!(request, :tag_name)
+      tag_name = get_param!(request, :tag_name)
 
-          repo.rm_tag(tag_name, user: user)
+      repo.rm_tag(tag_name, user: user)
 
-          Gitaly::UserDeleteTagResponse.new
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserDeleteTagResponse.new(pre_receive_error: set_utf8!(e.message))
-        rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => e
-          raise GRPC::FailedPrecondition.new(e.message)
-        end
-      end
+      Gitaly::UserDeleteTagResponse.new
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserDeleteTagResponse.new(pre_receive_error: set_utf8!(e.message))
+    rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => e
+      raise GRPC::FailedPrecondition.new(e.message)
     end
 
     def user_create_branch(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          target = get_param!(request, :start_point)
-          gitaly_user = get_param!(request, :user)
-
-          branch_name = request.branch_name
-          user = Gitlab::Git::User.from_gitaly(gitaly_user)
-          created_branch = repo.add_branch(branch_name, user: user, target: target)
-          return Gitaly::UserCreateBranchResponse.new unless created_branch
-
-          rugged_commit = created_branch.dereferenced_target.rugged_commit
-          commit = gitaly_commit_from_rugged(rugged_commit)
-          branch = Gitaly::Branch.new(name: branch_name, target_commit: commit)
-          Gitaly::UserCreateBranchResponse.new(branch: branch)
-        rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => ex
-          raise GRPC::FailedPrecondition.new(ex.message)
-        rescue Gitlab::Git::PreReceiveError => ex
-          return Gitaly::UserCreateBranchResponse.new(pre_receive_error: set_utf8!(ex.message))
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      target = get_param!(request, :start_point)
+      gitaly_user = get_param!(request, :user)
+
+      branch_name = request.branch_name
+      user = Gitlab::Git::User.from_gitaly(gitaly_user)
+      created_branch = repo.add_branch(branch_name, user: user, target: target)
+      Gitaly::UserCreateBranchResponse.new unless created_branch
+
+      rugged_commit = created_branch.dereferenced_target.rugged_commit
+      commit = gitaly_commit_from_rugged(rugged_commit)
+      branch = Gitaly::Branch.new(name: branch_name, target_commit: commit)
+      Gitaly::UserCreateBranchResponse.new(branch: branch)
+    rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => ex
+      raise GRPC::FailedPrecondition.new(ex.message)
+    rescue Gitlab::Git::PreReceiveError => ex
+      Gitaly::UserCreateBranchResponse.new(pre_receive_error: set_utf8!(ex.message))
     end
 
     def user_update_branch(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          branch_name = get_param!(request, :branch_name)
-          newrev = get_param!(request, :newrev)
-          oldrev = get_param!(request, :oldrev)
-          gitaly_user = get_param!(request, :user)
-
-          user = Gitlab::Git::User.from_gitaly(gitaly_user)
-          repo.update_branch(branch_name, user: user, newrev: newrev, oldrev: oldrev)
-
-          Gitaly::UserUpdateBranchResponse.new
-        rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => ex
-          raise GRPC::FailedPrecondition.new(ex.message)
-        rescue Gitlab::Git::PreReceiveError => ex
-          return Gitaly::UserUpdateBranchResponse.new(pre_receive_error: set_utf8!(ex.message))
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      branch_name = get_param!(request, :branch_name)
+      newrev = get_param!(request, :newrev)
+      oldrev = get_param!(request, :oldrev)
+      gitaly_user = get_param!(request, :user)
+
+      user = Gitlab::Git::User.from_gitaly(gitaly_user)
+      repo.update_branch(branch_name, user: user, newrev: newrev, oldrev: oldrev)
+
+      Gitaly::UserUpdateBranchResponse.new
+    rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => ex
+      raise GRPC::FailedPrecondition.new(ex.message)
+    rescue Gitlab::Git::PreReceiveError => ex
+      Gitaly::UserUpdateBranchResponse.new(pre_receive_error: set_utf8!(ex.message))
     end
 
     def user_delete_branch(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(request.user)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
 
-          repo.rm_branch(request.branch_name, user: user)
+      repo.rm_branch(request.branch_name, user: user)
 
-          Gitaly::UserDeleteBranchResponse.new
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserDeleteBranchResponse.new(pre_receive_error: set_utf8!(e.message))
-        rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => e
-          raise GRPC::FailedPrecondition.new(e.message)
-        end
-      end
+      Gitaly::UserDeleteBranchResponse.new
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserDeleteBranchResponse.new(pre_receive_error: set_utf8!(e.message))
+    rescue Gitlab::Git::Repository::InvalidRef, Gitlab::Git::CommitError => e
+      raise GRPC::FailedPrecondition.new(e.message)
     end
 
     def user_merge_branch(session, call)
       Enumerator.new do |y|
-        bridge_exceptions do
-          first_request = session.next
-
-          repository = Gitlab::Git::Repository.from_gitaly(first_request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(first_request.user)
-          source_sha = first_request.commit_id.dup
-          target_branch = first_request.branch.dup
-          message = first_request.message.dup
-
-          begin
-            result = repository.merge(user, source_sha, target_branch, message) do |commit_id|
-              y << Gitaly::UserMergeBranchResponse.new(commit_id: commit_id)
-
-              second_request = session.next
-              raise GRPC::FailedPrecondition.new('merge aborted by client') unless second_request.apply
-            end
-
-            y << Gitaly::UserMergeBranchResponse.new(branch_update: branch_update_result(result))
-          rescue Gitlab::Git::PreReceiveError => e
-            y << Gitaly::UserMergeBranchResponse.new(pre_receive_error: set_utf8!(e.message))
-          end
-        end
-      end
-    end
+        first_request = session.next
+
+        repository = Gitlab::Git::Repository.from_gitaly(first_request.repository, call)
+        user = Gitlab::Git::User.from_gitaly(first_request.user)
+        source_sha = first_request.commit_id.dup
+        target_branch = first_request.branch.dup
+        message = first_request.message.dup
 
-    def user_ff_branch(request, call)
-      bridge_exceptions do
         begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(request.user)
+          result = repository.merge(user, source_sha, target_branch, message) do |commit_id|
+            y << Gitaly::UserMergeBranchResponse.new(commit_id: commit_id)
 
-          result = repo.ff_merge(user, request.commit_id, request.branch)
-          branch_update = branch_update_result(result)
+            second_request = session.next
+            raise GRPC::FailedPrecondition.new('merge aborted by client') unless second_request.apply
+          end
 
-          Gitaly::UserFFBranchResponse.new(branch_update: branch_update)
-        rescue Gitlab::Git::CommitError => e
-          raise GRPC::FailedPrecondition.new(e.to_s)
-        rescue ArgumentError => e
-          raise GRPC::InvalidArgument.new(e.to_s)
+          y << Gitaly::UserMergeBranchResponse.new(branch_update: branch_update_result(result))
         rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserFFBranchResponse.new(pre_receive_error: set_utf8!(e.message))
+          y << Gitaly::UserMergeBranchResponse.new(pre_receive_error: set_utf8!(e.message))
         end
       end
     end
 
+    def user_ff_branch(request, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
+
+      result = repo.ff_merge(user, request.commit_id, request.branch)
+      branch_update = branch_update_result(result)
+
+      Gitaly::UserFFBranchResponse.new(branch_update: branch_update)
+    rescue Gitlab::Git::CommitError => e
+      raise GRPC::FailedPrecondition.new(e.to_s)
+    rescue ArgumentError => e
+      raise GRPC::InvalidArgument.new(e.to_s)
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserFFBranchResponse.new(pre_receive_error: set_utf8!(e.message))
+    end
+
     def user_cherry_pick(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(request.user)
-          commit = Gitlab::Git::Commit.new(repo, request.commit)
-          start_repository = Gitlab::Git::GitalyRemoteRepository.new(request.start_repository || request.repository, call)
-
-          result = repo.cherry_pick(
-            user: user,
-            commit: commit,
-            branch_name: request.branch_name,
-            message: request.message.dup,
-            start_branch_name: request.start_branch_name.presence,
-            start_repository: start_repository
-          )
-
-          branch_update = branch_update_result(result)
-          Gitaly::UserCherryPickResponse.new(branch_update: branch_update)
-        rescue Gitlab::Git::Repository::CreateTreeError => e
-          Gitaly::UserCherryPickResponse.new(create_tree_error: set_utf8!(e.message))
-        rescue Gitlab::Git::CommitError => e
-          Gitaly::UserCherryPickResponse.new(commit_error: set_utf8!(e.message))
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserCherryPickResponse.new(pre_receive_error: set_utf8!(e.message))
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
+      commit = Gitlab::Git::Commit.new(repo, request.commit)
+      start_repository = Gitlab::Git::GitalyRemoteRepository.new(request.start_repository || request.repository, call)
+
+      result = repo.cherry_pick(
+        user: user,
+        commit: commit,
+        branch_name: request.branch_name,
+        message: request.message.dup,
+        start_branch_name: request.start_branch_name.presence,
+        start_repository: start_repository
+      )
+
+      branch_update = branch_update_result(result)
+      Gitaly::UserCherryPickResponse.new(branch_update: branch_update)
+    rescue Gitlab::Git::Repository::CreateTreeError => e
+      Gitaly::UserCherryPickResponse.new(create_tree_error: set_utf8!(e.message))
+    rescue Gitlab::Git::CommitError => e
+      Gitaly::UserCherryPickResponse.new(commit_error: set_utf8!(e.message))
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserCherryPickResponse.new(pre_receive_error: set_utf8!(e.message))
     end
 
     def user_revert(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(request.user)
-          commit = Gitlab::Git::Commit.new(repo, request.commit)
-          start_repository = Gitlab::Git::GitalyRemoteRepository.new(request.start_repository || request.repository, call)
-
-          result = repo.revert(
-            user: user,
-            commit: commit,
-            branch_name: request.branch_name,
-            message: request.message.dup,
-            start_branch_name: request.start_branch_name.presence,
-            start_repository: start_repository
-          )
-
-          branch_update = branch_update_result(result)
-          Gitaly::UserRevertResponse.new(branch_update: branch_update)
-        rescue Gitlab::Git::Repository::CreateTreeError => e
-          Gitaly::UserRevertResponse.new(create_tree_error: set_utf8!(e.message))
-        rescue Gitlab::Git::CommitError => e
-          Gitaly::UserRevertResponse.new(commit_error: set_utf8!(e.message))
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserRevertResponse.new(pre_receive_error: set_utf8!(e.message))
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
+      commit = Gitlab::Git::Commit.new(repo, request.commit)
+      start_repository = Gitlab::Git::GitalyRemoteRepository.new(request.start_repository || request.repository, call)
+
+      result = repo.revert(
+        user: user,
+        commit: commit,
+        branch_name: request.branch_name,
+        message: request.message.dup,
+        start_branch_name: request.start_branch_name.presence,
+        start_repository: start_repository
+      )
+
+      branch_update = branch_update_result(result)
+      Gitaly::UserRevertResponse.new(branch_update: branch_update)
+    rescue Gitlab::Git::Repository::CreateTreeError => e
+      Gitaly::UserRevertResponse.new(create_tree_error: set_utf8!(e.message))
+    rescue Gitlab::Git::CommitError => e
+      Gitaly::UserRevertResponse.new(commit_error: set_utf8!(e.message))
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserRevertResponse.new(pre_receive_error: set_utf8!(e.message))
     end
 
     def user_rebase(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          user = Gitlab::Git::User.from_gitaly(request.user)
-          remote_repository = Gitlab::Git::GitalyRemoteRepository.new(request.remote_repository, call)
-          rebase_sha = repo.rebase(user, request.rebase_id,
-                                   branch: request.branch,
-                                   branch_sha: request.branch_sha,
-                                   remote_repository: remote_repository,
-                                   remote_branch: request.remote_branch)
-
-          Gitaly::UserRebaseResponse.new(rebase_sha: rebase_sha)
-        rescue Gitlab::Git::PreReceiveError => e
-          return Gitaly::UserRebaseResponse.new(pre_receive_error: set_utf8!(e.message))
-        rescue Gitlab::Git::Repository::GitError => e
-          return Gitaly::UserRebaseResponse.new(git_error: set_utf8!(e.message))
-        rescue Gitlab::Git::CommitError => e
-          raise GRPC::FailedPrecondition.new(e.message)
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
+      remote_repository = Gitlab::Git::GitalyRemoteRepository.new(request.remote_repository, call)
+      rebase_sha = repo.rebase(user, request.rebase_id,
+                               branch: request.branch,
+                               branch_sha: request.branch_sha,
+                               remote_repository: remote_repository,
+                               remote_branch: request.remote_branch)
+
+      Gitaly::UserRebaseResponse.new(rebase_sha: rebase_sha)
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserRebaseResponse.new(pre_receive_error: set_utf8!(e.message))
+    rescue Gitlab::Git::Repository::GitError => e
+      Gitaly::UserRebaseResponse.new(git_error: set_utf8!(e.message))
+    rescue Gitlab::Git::CommitError => e
+      raise GRPC::FailedPrecondition.new(e.message)
     end
 
     def user_commit_files(call)
-      bridge_exceptions do
-        begin
-          actions = []
-          request_enum = call.each_remote_read
-          header = request_enum.next.header
-
-          loop do
-            action = request_enum.next.action
-
-            if action.header
-              actions << commit_files_action_from_gitaly_request(action.header)
-            else
-              actions.last[:content] << action.content
-            end
-          end
-
-          repo = Gitlab::Git::Repository.from_gitaly(header.repository, call)
-          user = Gitlab::Git::User.from_gitaly(header.user)
-          opts = commit_files_opts(call, header, actions)
+      actions = []
+      request_enum = call.each_remote_read
+      header = request_enum.next.header
 
-          branch_update = branch_update_result(repo.multi_action(user, opts))
+      loop do
+        action = request_enum.next.action
 
-          Gitaly::UserCommitFilesResponse.new(branch_update: branch_update)
-        rescue Gitlab::Git::Index::IndexError => e
-          Gitaly::UserCommitFilesResponse.new(index_error: set_utf8!(e.message))
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserCommitFilesResponse.new(pre_receive_error: set_utf8!(e.message))
-        rescue Gitlab::Git::CommitError => e
-          raise GRPC::FailedPrecondition.new(e.message)
+        if action.header
+          actions << commit_files_action_from_gitaly_request(action.header)
+        else
+          actions.last[:content] << action.content
         end
       end
+
+      repo = Gitlab::Git::Repository.from_gitaly(header.repository, call)
+      user = Gitlab::Git::User.from_gitaly(header.user)
+      opts = commit_files_opts(call, header, actions)
+
+      branch_update = branch_update_result(repo.multi_action(user, opts))
+
+      Gitaly::UserCommitFilesResponse.new(branch_update: branch_update)
+    rescue Gitlab::Git::Index::IndexError => e
+      Gitaly::UserCommitFilesResponse.new(index_error: set_utf8!(e.message))
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserCommitFilesResponse.new(pre_receive_error: set_utf8!(e.message))
+    rescue Gitlab::Git::CommitError => e
+      raise GRPC::FailedPrecondition.new(e.message)
     end
 
     def user_squash(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        user = Gitlab::Git::User.from_gitaly(request.user)
-        author = Gitlab::Git::User.from_gitaly(request.author)
-
-        begin
-          squash_sha = repo.squash(user, request.squash_id,
-                                   branch: request.branch,
-                                   start_sha: request.start_sha,
-                                   end_sha: request.end_sha,
-                                   author: author,
-                                   message: request.commit_message)
-
-          Gitaly::UserSquashResponse.new(squash_sha: squash_sha)
-        rescue Gitlab::Git::Repository::GitError => e
-          Gitaly::UserSquashResponse.new(git_error: set_utf8!(e.message))
-        end
-      end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      user = Gitlab::Git::User.from_gitaly(request.user)
+      author = Gitlab::Git::User.from_gitaly(request.author)
+
+      squash_sha = repo.squash(user, request.squash_id,
+                               branch: request.branch,
+                               start_sha: request.start_sha,
+                               end_sha: request.end_sha,
+                               author: author,
+                               message: request.commit_message)
+
+      Gitaly::UserSquashResponse.new(squash_sha: squash_sha)
+    rescue Gitlab::Git::Repository::GitError => e
+      Gitaly::UserSquashResponse.new(git_error: set_utf8!(e.message))
     end
 
     def user_apply_patch(call)
-      bridge_exceptions do
-        stream = call.each_remote_read
-        first_request = stream.next
-
-        header = first_request.header
-        user = Gitlab::Git::User.from_gitaly(header.user)
-        target_branch = header.target_branch
-        patches = stream.lazy.map(&:patches)
-
-        branch_update = Gitlab::Git::Repository.from_gitaly_with_block(header.repository, call) do |repo|
-          begin
-            Gitlab::Git::CommitPatches.new(user, repo, target_branch, patches).commit
-          rescue Gitlab::Git::PatchError => e
-            raise GRPC::FailedPrecondition.new(e.message)
-          end
-        end
+      stream = call.each_remote_read
+      first_request = stream.next
 
-        Gitaly::UserApplyPatchResponse.new(branch_update: branch_update_result(branch_update))
+      header = first_request.header
+      user = Gitlab::Git::User.from_gitaly(header.user)
+      target_branch = header.target_branch
+      patches = stream.lazy.map(&:patches)
+
+      branch_update = Gitlab::Git::Repository.from_gitaly_with_block(header.repository, call) do |repo|
+        begin
+          Gitlab::Git::CommitPatches.new(user, repo, target_branch, patches).commit
+        rescue Gitlab::Git::PatchError => e
+          raise GRPC::FailedPrecondition.new(e.message)
+        end
       end
+
+      Gitaly::UserApplyPatchResponse.new(branch_update: branch_update_result(branch_update))
     end
 
     def user_update_submodule(request, call)
-      bridge_exceptions do
-        user = Gitlab::Git::User.from_gitaly(request.user)
+      user = Gitlab::Git::User.from_gitaly(request.user)
 
+      branch_update = Gitlab::Git::Repository.from_gitaly_with_block(request.repository, call) do |repo|
         begin
-          branch_update = Gitlab::Git::Repository.from_gitaly_with_block(request.repository, call) do |repo|
-            begin
-              Gitlab::Git::Submodule
-                .new(user, repo, request.submodule, request.branch)
-                .update(request.commit_sha, request.commit_message.dup)
-            rescue ArgumentError => e
-              raise GRPC::InvalidArgument.new(e.to_s)
-            end
-          end
-
-          Gitaly::UserUpdateSubmoduleResponse.new(branch_update: branch_update_result(branch_update))
-        rescue Gitlab::Git::CommitError => e
-          Gitaly::UserUpdateSubmoduleResponse.new(commit_error: set_utf8!(e.message))
-        rescue Gitlab::Git::PreReceiveError => e
-          Gitaly::UserUpdateSubmoduleResponse.new(pre_receive_error: set_utf8!(e.message))
+          Gitlab::Git::Submodule
+            .new(user, repo, request.submodule, request.branch)
+            .update(request.commit_sha, request.commit_message.dup)
+        rescue ArgumentError => e
+          raise GRPC::InvalidArgument.new(e.to_s)
         end
       end
+
+      Gitaly::UserUpdateSubmoduleResponse.new(branch_update: branch_update_result(branch_update))
+    rescue Gitlab::Git::CommitError => e
+      Gitaly::UserUpdateSubmoduleResponse.new(commit_error: set_utf8!(e.message))
+    rescue Gitlab::Git::PreReceiveError => e
+      Gitaly::UserUpdateSubmoduleResponse.new(pre_receive_error: set_utf8!(e.message))
     end
 
     private
diff --git a/ruby/lib/gitaly_server/ref_service.rb b/ruby/lib/gitaly_server/ref_service.rb
index 62243ce3a..4c0497cf9 100644
--- a/ruby/lib/gitaly_server/ref_service.rb
+++ b/ruby/lib/gitaly_server/ref_service.rb
@@ -5,125 +5,109 @@ module GitalyServer
     TAGS_PER_MESSAGE = 100
 
     def create_branch(request, call)
-      bridge_exceptions do
-        begin
-          start_point = request.start_point
-          start_point = 'HEAD' if start_point.empty?
-          branch_name = request.name
-
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          rugged_ref = repo.rugged.branches.create(branch_name, start_point)
-
-          Gitaly::CreateBranchResponse.new(
-            status: :OK,
-            branch: Gitaly::Branch.new(
-              name: rugged_ref.name.b,
-              target_commit: gitaly_commit_from_rugged(rugged_ref.target)
-            )
-          )
-        rescue Rugged::ReferenceError => e
-          status = case e.to_s
-                   when /'refs\/heads\/#{branch_name}' is not valid/
-                     :ERR_INVALID
-                   when /a reference with that name already exists/
-                     :ERR_EXISTS
-                   else
-                     :ERR_INVALID_START_POINT
-                   end
-
-          Gitaly::CreateBranchResponse.new(status: status)
-        end
-      end
+      start_point = request.start_point
+      start_point = 'HEAD' if start_point.empty?
+      branch_name = request.name
+
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      rugged_ref = repo.rugged.branches.create(branch_name, start_point)
+
+      Gitaly::CreateBranchResponse.new(
+        status: :OK,
+        branch: Gitaly::Branch.new(
+          name: rugged_ref.name.b,
+          target_commit: gitaly_commit_from_rugged(rugged_ref.target)
+        )
+      )
+    rescue Rugged::ReferenceError => e
+      status = case e.to_s
+               when /'refs\/heads\/#{branch_name}' is not valid/
+                 :ERR_INVALID
+               when /a reference with that name already exists/
+                 :ERR_EXISTS
+               else
+                 :ERR_INVALID_START_POINT
+               end
+
+      Gitaly::CreateBranchResponse.new(status: status)
     end
 
     def delete_branch(request, call)
-      bridge_exceptions do
-        begin
-          branch_name = request.name
-          raise GRPC::InvalidArgument.new("empty Name") if branch_name.empty?
+      branch_name = request.name
+      raise GRPC::InvalidArgument.new("empty Name") if branch_name.empty?
 
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-          repo.delete_branch(branch_name)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo.delete_branch(branch_name)
 
-          Gitaly::DeleteBranchResponse.new
-        rescue Gitlab::Git::Repository::DeleteBranchError => e
-          raise GRPC::Internal.new(e.to_s)
-        end
-      end
+      Gitaly::DeleteBranchResponse.new
+    rescue Gitlab::Git::Repository::DeleteBranchError => e
+      raise GRPC::Internal.new(e.to_s)
     end
 
     def find_branch(request, call)
-      bridge_exceptions do
-        branch_name = request.name
-        raise GRPC::InvalidArgument.new("empty Name") if branch_name.empty?
-
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        rugged_branch = repo.find_branch(branch_name)
-        gitaly_branch = Gitaly::Branch.new(
-          name: rugged_branch.name.b,
-          target_commit: gitaly_commit_from_rugged(rugged_branch.dereferenced_target.raw_commit)
-        ) unless rugged_branch.nil?
-
-        Gitaly::FindBranchResponse.new(branch: gitaly_branch)
-      end
+      branch_name = request.name
+      raise GRPC::InvalidArgument.new("empty Name") if branch_name.empty?
+
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      rugged_branch = repo.find_branch(branch_name)
+      gitaly_branch = Gitaly::Branch.new(
+        name: rugged_branch.name.b,
+        target_commit: gitaly_commit_from_rugged(rugged_branch.dereferenced_target.raw_commit)
+      ) unless rugged_branch.nil?
+
+      Gitaly::FindBranchResponse.new(branch: gitaly_branch)
     end
 
     def find_all_tags(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-
-        Enumerator.new do |y|
-          repo.tags.each_slice(TAGS_PER_MESSAGE) do |gitlab_tags|
-            tags = gitlab_tags.map do |gitlab_tag|
-              rugged_commit = gitlab_tag.dereferenced_target&.raw_commit
-              gitaly_commit = gitaly_commit_from_rugged(rugged_commit) if rugged_commit
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-              gitaly_tag_from_gitlab_tag(gitlab_tag, gitaly_commit)
-            end
+      Enumerator.new do |y|
+        repo.tags.each_slice(TAGS_PER_MESSAGE) do |gitlab_tags|
+          tags = gitlab_tags.map do |gitlab_tag|
+            rugged_commit = gitlab_tag.dereferenced_target&.raw_commit
+            gitaly_commit = gitaly_commit_from_rugged(rugged_commit) if rugged_commit
 
-            y.yield Gitaly::FindAllTagsResponse.new(tags: tags)
+            gitaly_tag_from_gitlab_tag(gitlab_tag, gitaly_commit)
           end
+
+          y.yield Gitaly::FindAllTagsResponse.new(tags: tags)
         end
       end
     end
 
     def delete_refs(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-
-        begin
-          if request.refs.any?
-            repo.delete_refs(*request.refs)
-          else
-            repo.delete_all_refs_except(request.except_with_prefix)
-          end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-          Gitaly::DeleteRefsResponse.new
-        rescue Gitlab::Git::Repository::GitError => e
-          Gitaly::DeleteRefsResponse.new(git_error: e.message)
+      begin
+        if request.refs.any?
+          repo.delete_refs(*request.refs)
+        else
+          repo.delete_all_refs_except(request.except_with_prefix)
         end
+
+        Gitaly::DeleteRefsResponse.new
+      rescue Gitlab::Git::Repository::GitError => e
+        Gitaly::DeleteRefsResponse.new(git_error: e.message)
       end
     end
 
     def get_tag_messages(request, call)
-      bridge_exceptions do
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        Enumerator.new do |y|
-          request.tag_ids.each do |tag_id|
-            annotation = repository.rugged.rev_parse(tag_id)
-            next unless annotation
+      Enumerator.new do |y|
+        request.tag_ids.each do |tag_id|
+          annotation = repository.rugged.rev_parse(tag_id)
+          next unless annotation
 
-            response = Gitaly::GetTagMessagesResponse.new(tag_id: tag_id)
-            io = StringIO.new(annotation.message)
+          response = Gitaly::GetTagMessagesResponse.new(tag_id: tag_id)
+          io = StringIO.new(annotation.message)
 
-            while chunk = io.read(Gitlab.config.git.max_commit_or_tag_message_size)
-              response.message = chunk
+          while chunk = io.read(Gitlab.config.git.max_commit_or_tag_message_size)
+            response.message = chunk
 
-              y.yield response
+            y.yield response
 
-              response = Gitaly::GetTagMessagesResponse.new
-            end
+            response = Gitaly::GetTagMessagesResponse.new
           end
         end
       end
diff --git a/ruby/lib/gitaly_server/remote_service.rb b/ruby/lib/gitaly_server/remote_service.rb
index 6dca47d3d..959fc3ab4 100644
--- a/ruby/lib/gitaly_server/remote_service.rb
+++ b/ruby/lib/gitaly_server/remote_service.rb
@@ -3,58 +3,50 @@ module GitalyServer
     include Utils
 
     def add_remote(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        mirror_refmap = parse_refmaps(request.mirror_refmaps)
+      mirror_refmap = parse_refmaps(request.mirror_refmaps)
 
-        repo.add_remote(request.name, request.url, mirror_refmap: mirror_refmap)
+      repo.add_remote(request.name, request.url, mirror_refmap: mirror_refmap)
 
-        Gitaly::AddRemoteResponse.new
-      end
+      Gitaly::AddRemoteResponse.new
     end
 
     def remove_remote(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        result = repo.remove_remote(request.name)
+      result = repo.remove_remote(request.name)
 
-        Gitaly::RemoveRemoteResponse.new(result: result)
-      end
+      Gitaly::RemoveRemoteResponse.new(result: result)
     end
 
     def fetch_internal_remote(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        remote_repo = Gitlab::Git::GitalyRemoteRepository.new(request.remote_repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      remote_repo = Gitlab::Git::GitalyRemoteRepository.new(request.remote_repository, call)
 
-        result = repo.fetch_repository_as_mirror(remote_repo)
+      result = repo.fetch_repository_as_mirror(remote_repo)
 
-        Gitaly::FetchInternalRemoteResponse.new(result: result)
-      end
+      Gitaly::FetchInternalRemoteResponse.new(result: result)
     end
 
     def update_remote_mirror(call)
-      bridge_exceptions do
-        request_enum = call.each_remote_read
-        first_request = request_enum.next
-        repo = Gitlab::Git::Repository.from_gitaly(first_request.repository, call)
-        only_branches_matching = first_request.only_branches_matching.to_a
+      request_enum = call.each_remote_read
+      first_request = request_enum.next
+      repo = Gitlab::Git::Repository.from_gitaly(first_request.repository, call)
+      only_branches_matching = first_request.only_branches_matching.to_a
 
-        only_branches_matching += request_enum.flat_map(&:only_branches_matching)
+      only_branches_matching += request_enum.flat_map(&:only_branches_matching)
 
-        remote_mirror = Gitlab::Git::RemoteMirror.new(
-          repo,
-          first_request.ref_name,
-          only_branches_matching: only_branches_matching,
-          ssh_auth: Gitlab::Git::SshAuth.from_gitaly(first_request)
-        )
+      remote_mirror = Gitlab::Git::RemoteMirror.new(
+        repo,
+        first_request.ref_name,
+        only_branches_matching: only_branches_matching,
+        ssh_auth: Gitlab::Git::SshAuth.from_gitaly(first_request)
+      )
 
-        remote_mirror.update
+      remote_mirror.update
 
-        Gitaly::UpdateRemoteMirrorResponse.new
-      end
+      Gitaly::UpdateRemoteMirrorResponse.new
     end
 
     private
diff --git a/ruby/lib/gitaly_server/repository_service.rb b/ruby/lib/gitaly_server/repository_service.rb
index 178c0f4f2..dc5a97977 100644
--- a/ruby/lib/gitaly_server/repository_service.rb
+++ b/ruby/lib/gitaly_server/repository_service.rb
@@ -5,141 +5,119 @@ module GitalyServer
     include Utils
 
     def create_repository(_request, call)
-      bridge_exceptions do
-        repo_path = GitalyServer.repo_path(call)
+      repo_path = GitalyServer.repo_path(call)
 
-        Gitlab::Git::Repository.create(repo_path)
+      Gitlab::Git::Repository.create(repo_path)
 
-        Gitaly::CreateRepositoryResponse.new
-      end
+      Gitaly::CreateRepositoryResponse.new
     end
 
     def fetch_source_branch(request, call)
-      bridge_exceptions do
-        source_repository = Gitlab::Git::GitalyRemoteRepository.new(request.source_repository, call)
-        repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        result = repository.fetch_source_branch!(source_repository, request.source_branch, request.target_ref)
+      source_repository = Gitlab::Git::GitalyRemoteRepository.new(request.source_repository, call)
+      repository = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      result = repository.fetch_source_branch!(source_repository, request.source_branch, request.target_ref)
 
-        Gitaly::FetchSourceBranchResponse.new(result: result)
-      end
+      Gitaly::FetchSourceBranchResponse.new(result: result)
     end
 
     def fetch_remote(request, call)
-      bridge_exceptions do
-        gitlab_projects = Gitlab::Git::GitlabProjects.from_gitaly(request.repository, call)
-
-        success = Gitlab::Git::SshAuth.from_gitaly(request).setup do |env|
-          gitlab_projects.fetch_remote(
-            request.remote,
-            request.timeout,
-            force: request.force,
-            tags: !request.no_tags,
-            env: env
-          )
-        end
+      gitlab_projects = Gitlab::Git::GitlabProjects.from_gitaly(request.repository, call)
+
+      success = Gitlab::Git::SshAuth.from_gitaly(request).setup do |env|
+        gitlab_projects.fetch_remote(
+          request.remote,
+          request.timeout,
+          force: request.force,
+          tags: !request.no_tags,
+          env: env
+        )
+      end
 
-        raise GRPC::Unknown.new("Fetching remote #{request.remote} failed: #{gitlab_projects.output}") unless success
+      raise GRPC::Unknown.new("Fetching remote #{request.remote} failed: #{gitlab_projects.output}") unless success
 
-        Gitaly::FetchRemoteResponse.new
-      end
+      Gitaly::FetchRemoteResponse.new
     end
 
     def is_rebase_in_progress(request, call) # rubocop:disable Naming/PredicateName
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        result = repo.rebase_in_progress?(request.rebase_id)
+      result = repo.rebase_in_progress?(request.rebase_id)
 
-        Gitaly::IsRebaseInProgressResponse.new(in_progress: result)
-      end
+      Gitaly::IsRebaseInProgressResponse.new(in_progress: result)
     end
 
     def is_squash_in_progress(request, call) # rubocop:disable Naming/PredicateName
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        result = repo.squash_in_progress?(request.squash_id)
+      result = repo.squash_in_progress?(request.squash_id)
 
-        Gitaly::IsSquashInProgressResponse.new(in_progress: result)
-      end
+      Gitaly::IsSquashInProgressResponse.new(in_progress: result)
     end
 
     def write_ref(request, call)
-      bridge_exceptions do
-        Gitlab::Git::Repository.from_gitaly(request.repository, call)
-                               .write_ref(request.ref, request.revision, old_ref: request.old_revision)
+      Gitlab::Git::Repository.from_gitaly(request.repository, call)
+                             .write_ref(request.ref, request.revision, old_ref: request.old_revision)
 
-        Gitaly::WriteRefResponse.new
-      end
+      Gitaly::WriteRefResponse.new
     end
 
     def write_config(request, call)
-      bridge_exceptions do
-        begin
-          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-          repo.write_config(full_path: request.full_path)
+      repo.write_config(full_path: request.full_path)
 
-          Gitaly::WriteConfigResponse.new
-        rescue Rugged::Error => ex
-          Gitaly::WriteConfigResponse.new(error: ex.message.b)
-        end
-      end
+      Gitaly::WriteConfigResponse.new
+    rescue Rugged::Error => ex
+      Gitaly::WriteConfigResponse.new(error: ex.message.b)
     end
 
     def set_config(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-
-        request.entries.each do |entry|
-          key = entry.key
-          value = case entry.value
-                  when :value_str
-                    entry.value_str
-                  when :value_int32
-                    entry.value_int32
-                  when :value_bool
-                    entry.value_bool
-                  else
-                    raise GRPC::InvalidArgument, "unknown entry type: #{entry.value}"
-                  end
-
-          repo.rugged.config[key] = value
-        end
-
-        Gitaly::SetConfigResponse.new
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+
+      request.entries.each do |entry|
+        key = entry.key
+        value = case entry.value
+                when :value_str
+                  entry.value_str
+                when :value_int32
+                  entry.value_int32
+                when :value_bool
+                  entry.value_bool
+                else
+                  raise GRPC::InvalidArgument, "unknown entry type: #{entry.value}"
+                end
+
+        repo.rugged.config[key] = value
       end
+
+      Gitaly::SetConfigResponse.new
     end
 
     def find_license(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
 
-        short_name = begin
-                       ::Licensee.license(repo.path).try(:key)
-                     rescue Rugged::Error
-                     end
+      short_name = begin
+                     ::Licensee.license(repo.path).try(:key)
+                   rescue Rugged::Error
+                   end
 
-        Gitaly::FindLicenseResponse.new(license_short_name: short_name || "")
-      end
+      Gitaly::FindLicenseResponse.new(license_short_name: short_name || "")
     end
 
     def get_raw_changes(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-
-        changes = begin
-                    repo
-                      .raw_changes_between(request.from_revision, request.to_revision)
-                      .map { |c| to_proto_raw_change(c) }
-                  rescue ::Gitlab::Git::Repository::GitError => e
-                    raise GRPC::InvalidArgument.new(e.message)
-                  end
-
-        Enumerator.new do |y|
-          changes.each_slice(100) do |batch|
-            y.yield Gitaly::GetRawChangesResponse.new(raw_changes: batch)
-          end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+
+      changes = begin
+                  repo
+                    .raw_changes_between(request.from_revision, request.to_revision)
+                    .map { |c| to_proto_raw_change(c) }
+                rescue ::Gitlab::Git::Repository::GitError => e
+                  raise GRPC::InvalidArgument.new(e.message)
+                end
+
+      Enumerator.new do |y|
+        changes.each_slice(100) do |batch|
+          y.yield Gitaly::GetRawChangesResponse.new(raw_changes: batch)
         end
       end
     end
diff --git a/ruby/lib/gitaly_server/sentry_interceptor.rb b/ruby/lib/gitaly_server/sentry_interceptor.rb
index 4453086a3..bec5a4aca 100644
--- a/ruby/lib/gitaly_server/sentry_interceptor.rb
+++ b/ruby/lib/gitaly_server/sentry_interceptor.rb
@@ -53,11 +53,8 @@ module GitalyServer
       }
       tags.merge!(call.metadata)
 
-      exc_to_report = exc
-      exc_to_report = exc.cause if exc.cause && exc.is_a?(GRPC::Unknown) && exc.metadata.key?(:"gitaly-ruby.exception.class")
-
       Raven.tags_context(tags)
-      Raven.capture_exception(exc_to_report, fingerprint: ['gitaly-ruby', grpc_method, exc_to_report.message])
+      Raven.capture_exception(exc, fingerprint: ['gitaly-ruby', grpc_method, exc.message])
 
       raise exc
     end
diff --git a/ruby/lib/gitaly_server/utils.rb b/ruby/lib/gitaly_server/utils.rb
index 4dddcc7e8..925656d97 100644
--- a/ruby/lib/gitaly_server/utils.rb
+++ b/ruby/lib/gitaly_server/utils.rb
@@ -73,14 +73,5 @@ module GitalyServer
     def sanitize_url(str)
       str.gsub(URL_HOST_PATTERN, '\1[FILTERED]@\3\4')
     end
-
-    def bridge_exceptions
-      yield
-    rescue GRPC::BadStatus => e
-      # Pass GRPC back without wrapping
-      raise e
-    rescue StandardError => e
-      raise GRPC::Unknown.new(e.message, "gitaly-ruby.exception.class": e.class.name)
-    end
   end
 end
diff --git a/ruby/lib/gitaly_server/wiki_service.rb b/ruby/lib/gitaly_server/wiki_service.rb
index c68993cc4..aaef1d0cc 100644
--- a/ruby/lib/gitaly_server/wiki_service.rb
+++ b/ruby/lib/gitaly_server/wiki_service.rb
@@ -3,206 +3,188 @@ module GitalyServer
     include Utils
 
     def wiki_delete_page(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gitlab::Git::Wiki.new(repo)
-        page_path = set_utf8!(request.page_path)
-        commit_details = commit_details_from_gitaly(request.commit_details)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gitlab::Git::Wiki.new(repo)
+      page_path = set_utf8!(request.page_path)
+      commit_details = commit_details_from_gitaly(request.commit_details)
 
-        wiki.delete_page(page_path, commit_details)
+      wiki.delete_page(page_path, commit_details)
 
-        Gitaly::WikiDeletePageResponse.new
-      end
+      Gitaly::WikiDeletePageResponse.new
     end
 
     def wiki_write_page(call)
-      bridge_exceptions do
-        begin
-          repo = name = format = commit_details = nil
-          content = ""
-
-          call.each_remote_read.with_index do |request, index|
-            if index.zero?
-              repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-              name = set_utf8!(request.name)
-              format = request.format
-              commit_details = request.commit_details
-            end
+      repo = name = format = commit_details = nil
+      content = ""
+
+      call.each_remote_read.with_index do |request, index|
+        if index.zero?
+          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+          name = set_utf8!(request.name)
+          format = request.format
+          commit_details = request.commit_details
+        end
 
-            content << request.content
-          end
+        content << request.content
+      end
 
-          wiki = Gitlab::Git::Wiki.new(repo)
-          commit_details = commit_details_from_gitaly(commit_details)
+      wiki = Gitlab::Git::Wiki.new(repo)
+      commit_details = commit_details_from_gitaly(commit_details)
 
-          wiki.write_page(name, format.to_sym, content, commit_details)
+      wiki.write_page(name, format.to_sym, content, commit_details)
 
-          Gitaly::WikiWritePageResponse.new
-        rescue Gitlab::Git::Wiki::DuplicatePageError => e
-          Gitaly::WikiWritePageResponse.new(duplicate_error: e.message.b)
-        end
-      end
+      Gitaly::WikiWritePageResponse.new
+    rescue Gitlab::Git::Wiki::DuplicatePageError => e
+      Gitaly::WikiWritePageResponse.new(duplicate_error: e.message.b)
     end
 
     def wiki_find_page(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gitlab::Git::Wiki.new(repo)
-
-        page = wiki.page(
-          title: set_utf8!(request.title),
-          version: request.revision.presence,
-          dir: set_utf8!(request.directory)
-        )
-
-        unless page
-          return Enumerator.new do |y|
-            y.yield Gitaly::WikiFindPageResponse.new
-          end
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gitlab::Git::Wiki.new(repo)
+
+      page = wiki.page(
+        title: set_utf8!(request.title),
+        version: request.revision.presence,
+        dir: set_utf8!(request.directory)
+      )
+
+      unless page
+        return Enumerator.new do |y|
+          y.yield Gitaly::WikiFindPageResponse.new
         end
+      end
 
-        Enumerator.new do |y|
-          y.yield Gitaly::WikiFindPageResponse.new(page: build_gitaly_wiki_page(page))
+      Enumerator.new do |y|
+        y.yield Gitaly::WikiFindPageResponse.new(page: build_gitaly_wiki_page(page))
 
-          io = StringIO.new(page.text_data)
-          while chunk = io.read(Gitlab.config.git.write_buffer_size)
-            gitaly_wiki_page = Gitaly::WikiPage.new(raw_data: chunk)
+        io = StringIO.new(page.text_data)
+        while chunk = io.read(Gitlab.config.git.write_buffer_size)
+          gitaly_wiki_page = Gitaly::WikiPage.new(raw_data: chunk)
 
-            y.yield Gitaly::WikiFindPageResponse.new(page: gitaly_wiki_page)
-          end
+          y.yield Gitaly::WikiFindPageResponse.new(page: gitaly_wiki_page)
         end
       end
     end
 
     def wiki_get_all_pages(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gitlab::Git::Wiki.new(repo)
-        pages_limit = request.limit.zero? ? nil : request.limit
-
-        Enumerator.new do |y|
-          wiki.pages(limit: pages_limit).each do |page|
-            y.yield Gitaly::WikiGetAllPagesResponse.new(page: build_gitaly_wiki_page(page))
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gitlab::Git::Wiki.new(repo)
+      pages_limit = request.limit.zero? ? nil : request.limit
 
-            io = StringIO.new(page.text_data)
-            while chunk = io.read(Gitlab.config.git.write_buffer_size)
-              gitaly_wiki_page = Gitaly::WikiPage.new(raw_data: chunk)
+      Enumerator.new do |y|
+        wiki.pages(limit: pages_limit).each do |page|
+          y.yield Gitaly::WikiGetAllPagesResponse.new(page: build_gitaly_wiki_page(page))
 
-              y.yield Gitaly::WikiGetAllPagesResponse.new(page: gitaly_wiki_page)
-            end
+          io = StringIO.new(page.text_data)
+          while chunk = io.read(Gitlab.config.git.write_buffer_size)
+            gitaly_wiki_page = Gitaly::WikiPage.new(raw_data: chunk)
 
-            y.yield Gitaly::WikiGetAllPagesResponse.new(end_of_page: true)
+            y.yield Gitaly::WikiGetAllPagesResponse.new(page: gitaly_wiki_page)
           end
+
+          y.yield Gitaly::WikiGetAllPagesResponse.new(end_of_page: true)
         end
       end
     end
 
     def wiki_find_file(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gitlab::Git::Wiki.new(repo)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gitlab::Git::Wiki.new(repo)
 
-        file = wiki.file(set_utf8!(request.name), request.revision.presence)
+      file = wiki.file(set_utf8!(request.name), request.revision.presence)
 
-        unless file
-          return Enumerator.new do |y|
-            y.yield Gitaly::WikiFindFileResponse.new
-          end
+      unless file
+        return Enumerator.new do |y|
+          y.yield Gitaly::WikiFindFileResponse.new
         end
+      end
 
-        response = Gitaly::WikiFindFileResponse.new(
-          name: file.name.b,
-          mime_type: file.mime_type,
-          path: file.path.b
-        )
+      response = Gitaly::WikiFindFileResponse.new(
+        name: file.name.b,
+        mime_type: file.mime_type,
+        path: file.path.b
+      )
 
-        Enumerator.new do |y|
-          y.yield response
+      Enumerator.new do |y|
+        y.yield response
 
-          io = StringIO.new(file.raw_data)
-          while chunk = io.read(Gitlab.config.git.write_buffer_size)
-            y.yield Gitaly::WikiFindFileResponse.new(raw_data: chunk)
-          end
+        io = StringIO.new(file.raw_data)
+        while chunk = io.read(Gitlab.config.git.write_buffer_size)
+          y.yield Gitaly::WikiFindFileResponse.new(raw_data: chunk)
         end
       end
     end
 
     def wiki_get_page_versions(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gollum::Wiki.new(repo.path)
-        path = set_utf8!(request.page_path)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gollum::Wiki.new(repo.path)
+      path = set_utf8!(request.page_path)
 
-        page = wiki.paged(Gollum::Page.canonicalize_filename(path), File.split(path).first)
+      page = wiki.paged(Gollum::Page.canonicalize_filename(path), File.split(path).first)
 
-        unless page
-          return Enumerator.new do |y|
-            y.yield Gitaly::WikiGetPageVersionsResponse.new(versions: [])
-          end
+      unless page
+        return Enumerator.new do |y|
+          y.yield Gitaly::WikiGetPageVersionsResponse.new(versions: [])
         end
+      end
 
-        Enumerator.new do |y|
-          page.versions(per_page: request.per_page, page: request.page).each_slice(20) do |slice|
-            versions =
-              slice.map do |commit|
-                gollum_page = wiki.page(page.title, commit.id)
-                obj = repo.rugged.rev_parse(commit.id)
-
-                Gitaly::WikiPageVersion.new(
-                  commit: gitaly_commit_from_rugged(obj),
-                  format: gollum_page&.format.to_s
-                )
-              end
+      Enumerator.new do |y|
+        page.versions(per_page: request.per_page, page: request.page).each_slice(20) do |slice|
+          versions =
+            slice.map do |commit|
+              gollum_page = wiki.page(page.title, commit.id)
+              obj = repo.rugged.rev_parse(commit.id)
+
+              Gitaly::WikiPageVersion.new(
+                commit: gitaly_commit_from_rugged(obj),
+                format: gollum_page&.format.to_s
+              )
+            end
 
-            y.yield Gitaly::WikiGetPageVersionsResponse.new(versions: versions)
-          end
+          y.yield Gitaly::WikiGetPageVersionsResponse.new(versions: versions)
         end
       end
     end
 
     def wiki_update_page(call)
-      bridge_exceptions do
-        repo = wiki = title = format = page_path = commit_details = nil
-        content = ""
-
-        call.each_remote_read.with_index do |request, index|
-          if index.zero?
-            repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-            wiki = Gitlab::Git::Wiki.new(repo)
-            title = set_utf8!(request.title)
-            page_path = set_utf8!(request.page_path)
-            format = request.format
-
-            commit_details = commit_details_from_gitaly(request.commit_details)
-          end
+      repo = wiki = title = format = page_path = commit_details = nil
+      content = ""
 
-          content << request.content
-        end
+      call.each_remote_read.with_index do |request, index|
+        if index.zero?
+          repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+          wiki = Gitlab::Git::Wiki.new(repo)
+          title = set_utf8!(request.title)
+          page_path = set_utf8!(request.page_path)
+          format = request.format
 
-        wiki.update_page(page_path, title, format.to_sym, content, commit_details)
+          commit_details = commit_details_from_gitaly(request.commit_details)
+        end
 
-        Gitaly::WikiUpdatePageResponse.new
+        content << request.content
       end
+
+      wiki.update_page(page_path, title, format.to_sym, content, commit_details)
+
+      Gitaly::WikiUpdatePageResponse.new
     end
 
     def wiki_get_formatted_data(request, call)
-      bridge_exceptions do
-        repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
-        wiki = Gitlab::Git::Wiki.new(repo)
+      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
+      wiki = Gitlab::Git::Wiki.new(repo)
 
-        page = wiki.page(
-          title: set_utf8!(request.title),
-          version: request.revision.presence,
-          dir: set_utf8!(request.directory).presence
-        )
+      page = wiki.page(
+        title: set_utf8!(request.title),
+        version: request.revision.presence,
+        dir: set_utf8!(request.directory).presence
+      )
 
-        raise GRPC::NotFound unless page
+      raise GRPC::NotFound unless page
 
-        Enumerator.new do |y|
-          io = StringIO.new(page.formatted_data)
-          while chunk = io.read(Gitlab.config.git.write_buffer_size)
-            y.yield Gitaly::WikiGetFormattedDataResponse.new(data: chunk)
-          end
+      Enumerator.new do |y|
+        io = StringIO.new(page.formatted_data)
+        while chunk = io.read(Gitlab.config.git.write_buffer_size)
+          y.yield Gitaly::WikiGetFormattedDataResponse.new(data: chunk)
         end
       end
     end
diff --git a/ruby/spec/lib/gitaly_server/sentry_interceptor_spec.rb b/ruby/spec/lib/gitaly_server/sentry_interceptor_spec.rb
index 4fcd0dbfb..5e48da132 100644
--- a/ruby/spec/lib/gitaly_server/sentry_interceptor_spec.rb
+++ b/ruby/spec/lib/gitaly_server/sentry_interceptor_spec.rb
@@ -63,27 +63,6 @@ describe GitalyServer::SentryInterceptor do
         end
       end
 
-      context 'when exception is GRPC::Unknown raised by bridge_exceptions' do
-        include GitalyServer::Utils
-
-        it 'sends the original cause to Sentry' do
-          expect(Raven).to receive(:capture_exception).with(
-            ex,
-            fingerprint: ['gitaly-ruby', 'GitalyServer::RefService#create_branch', 'unknown encoding']
-          )
-
-          begin
-            described_class.new.server_streamer(call: call, method: meth) do
-              bridge_exceptions do
-                raise ex
-              end
-            end
-          rescue
-            nil
-          end
-        end
-      end
-
       context 'when expcetion is normal' do
         it 'sends the exception to Sentry' do
           expect(Raven).to receive(:capture_exception).with(