Stop using trace error handler

lib/graphql/backtrace.rb

@@ -24,7 +24,8 @@ class Backtrace
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.trace_with(self::Trace)
+      schema_defn.using_backtrace = true
+      # schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)

lib/graphql/backtrace/table.rb

@@ -38,13 +38,13 @@ def to_backtrace
       def rows
         @rows ||= begin
           query = @context.query
-          query_ctx = query.context
+          query_ctx = @context
           runtime_inst = query_ctx.namespace(:interpreter_runtime)[:runtime]
           result = runtime_inst.instance_variable_get(:@response)
           rows = []
           result_path = []
           last_part = nil
-          path = @context.path
+          path = @context.current_path
           path.each do |path_part|
             value = value_at(runtime_inst, result_path)
 

lib/graphql/backtrace/trace.rb

@@ -45,16 +45,16 @@ def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
 
       def execute_multiplex(multiplex:)
         super
-      rescue StandardError => err
-        # This is an unhandled error from execution,
-        # Re-raise it with a GraphQL trace.
-        potential_context = @__backtrace_last_context
-        if potential_context.is_a?(GraphQL::Query::Context) ||
-            potential_context.is_a?(Backtrace::Frame)
-          raise TracedError.new(err, potential_context)
-        else
-          raise
-        end
+      # rescue StandardError => err
+      #   # This is an unhandled error from execution,
+      #   # Re-raise it with a GraphQL trace.
+      #   potential_context = @__backtrace_last_context
+      #   if potential_context.is_a?(GraphQL::Query::Context) ||
+      #       potential_context.is_a?(Backtrace::Frame)
+      #     raise TracedError.new(err, potential_context)
+      #   else
+      #     raise
+      #   end
       end
 
       private

lib/graphql/execution/interpreter/runtime.rb

@@ -574,7 +574,7 @@ def continue_field(value, owner_type, field, current_type, ast_node, next_select
             r = begin
               current_type.coerce_result(value, context)
             rescue StandardError => err
-              schema.handle_or_reraise(context, err)
+              query.handle_or_reraise(err)
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
@@ -638,31 +638,39 @@ def continue_field(value, owner_type, field, current_type, ast_node, next_select
             set_result(selection_result, result_name, response_list, true, is_non_null)
             idx = nil
             list_value = begin
-              value.each do |inner_value|
-                idx ||= 0
-                this_idx = idx
-                idx += 1
-                if use_dataloader_job
-                  @dataloader.append_job do
+              begin
+                value.each do |inner_value|
+                  idx ||= 0
+                  this_idx = idx
+                  idx += 1
+                  if use_dataloader_job
+                    @dataloader.append_job do
+                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
+                    end
+                  else
                     resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                   end
-                else
-                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                 end
-              end
 
-              response_list
-            rescue NoMethodError => err
-              # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
-              if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
-                # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
-                raise ListResultFailedError.new(value: value, field: field, path: current_path)
-              else
-                # This was some other NoMethodError -- let it bubble to reveal the real error.
-                raise
+                response_list
+              rescue NoMethodError => err
+                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
+                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
+                  # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+                  raise ListResultFailedError.new(value: value, field: field, path: current_path)
+                else
+                  # This was some other NoMethodError -- let it bubble to reveal the real error.
+                  raise
+                end
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                ex_err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
-            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
-              ex_err
             rescue StandardError => err
               begin
                 query.handle_or_reraise(err)

lib/graphql/schema.rb

@@ -1118,8 +1118,14 @@ def error_handlers
         }
       end
 
+      # @api private
+      attr_accessor :using_backtrace
+
       # @api private
       def handle_or_reraise(context, err)
+        if context[:backtrace] || using_backtrace
+          err = GraphQL::Backtrace::TracedError.new(err, context)
+        end
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
           obj = context[:current_object]