Merge pull request #4437 from rmosolgo/backtrace-trace

Make GraphQL::Backtrace work with module traces

Author: rmosolgo

lib/graphql/backtrace.rb

@@ -3,6 +3,7 @@
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
+require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -23,7 +24,7 @@ class Backtrace
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.tracer(self::Tracer)
+      schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)
@@ -54,5 +55,9 @@ def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_fra
         @parent_frame = parent_frame
       end
     end
+
+    class DefaultBacktraceTrace < GraphQL::Tracing::Trace
+      include GraphQL::Backtrace::Trace
+    end
   end
 end

lib/graphql/backtrace/trace.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module Trace
+      def validate(query:, validate:)
+        if query.multiplex
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def analyze_query(query:)
+        if query.multiplex # missing for stand-alone static validation
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def execute_query(query:)
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        query ||= multiplex.queries.first
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_multiplex(multiplex:)
+        super
+      rescue StandardError => err
+        # This is an unhandled error from execution,
+        # Re-raise it with a GraphQL trace.
+        multiplex_context = multiplex.context
+        potential_context = multiplex_context[:last_graphql_backtrace_context]
+
+        if potential_context.is_a?(GraphQL::Query::Context) ||
+            potential_context.is_a?(Backtrace::Frame)
+          raise TracedError.new(err, potential_context)
+        else
+          raise
+        end
+      ensure
+        multiplex_context = multiplex.context
+        multiplex_context.delete(:graphql_backtrace_contexts)
+        multiplex_context.delete(:last_graphql_backtrace_context)
+      end
+
+      private
+
+      def push_query_backtrace_context(query)
+        push_data = query
+        multiplex = query.multiplex
+        push_key = []
+        push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+        push_storage[push_key] = push_data
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+
+      def push_field_backtrace_context(field, query, ast_node, arguments, object)
+        multiplex = query.multiplex
+        push_key = query.context[:current_path]
+        push_storage = multiplex.context[:graphql_backtrace_contexts]
+        parent_frame = push_storage[push_key[0..-2]]
+
+        if parent_frame.is_a?(GraphQL::Query)
+          parent_frame = parent_frame.context
+        end
+
+        push_data = Frame.new(
+          query: query,
+          path: push_key,
+          ast_node: ast_node,
+          field: field,
+          object: object,
+          arguments: arguments,
+          parent_frame: parent_frame,
+        )
+
+        push_storage[push_key] = push_data
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+    end
+  end
+end

lib/graphql/query.rb

@@ -100,12 +100,16 @@ def initialize(schema, query_string = nil, query: nil, document: nil, context: n
 
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        context_tracers += [GraphQL::Backtrace::Tracer]
-        @tracers << GraphQL::Backtrace::Tracer
+        if schema.trace_class <= GraphQL::Tracing::LegacyTrace
+          context_tracers += [GraphQL::Backtrace::Tracer]
+          @tracers << GraphQL::Backtrace::Tracer
+        elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
+          raise "Invariant: `backtrace: true` should have provided a trace class with Backtrace mixed in, but it didnt. (Found: #{current_trace.class.ancestors}). This is a bug in GraphQL-Ruby, please report it on GitHub."
+        end
       end
 
       if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
-        raise ArgumentError, "context[:tracers] and context[:backtrace] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+        raise ArgumentError, "context[:tracers] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
       end
 
 

lib/graphql/schema.rb

@@ -145,18 +145,41 @@ def subscriptions=(new_implementation)
 
       def trace_class(new_class = nil)
         if new_class
-          @trace_class = new_class
-        elsif !defined?(@trace_class)
-          parent_trace_class = if superclass.respond_to?(:trace_class)
-            superclass.trace_class
+          trace_mode(:default, new_class)
+          backtrace_class = Class.new(new_class)
+          backtrace_class.include(GraphQL::Backtrace::Trace)
+          trace_mode(:default_backtrace, backtrace_class)
+        end
+        trace_class_for(:default)
+      end
+
+      # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
+      def trace_class_for(mode)
+        @trace_modes ||= {}
+        @trace_modes[mode] ||= begin
+          base_class = if superclass.respond_to?(:trace_class_for)
+            superclass.trace_class_for(mode)
+          elsif mode == :default_backtrace
+            GraphQL::Backtrace::DefaultBacktraceTrace
           else
             GraphQL::Tracing::Trace
           end
-          @trace_class = Class.new(parent_trace_class)
+          Class.new(base_class)
         end
-        @trace_class
       end
 
+      # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
+      # `:default` is used when no `trace_mode: ...` is requested.
+      # @param mode_name [Symbol]
+      # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
+      # @return void
+      def trace_mode(mode_name, trace_class)
+        @trace_modes ||= {}
+        @trace_modes[mode_name] = trace_class
+        nil
+      end
+
+
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
@@ -936,10 +959,10 @@ def default_directives
       end
 
       def tracer(new_tracer)
-        if defined?(@trace_class) && !(@trace_class < GraphQL::Tracing::LegacyTrace)
+        if defined?(@trace_modes) && !(trace_class_for(:default) < GraphQL::Tracing::LegacyTrace)
           raise ArgumentError, "Can't add tracer after configuring a `trace_class`, use GraphQL::Tracing::LegacyTrace to merge legacy tracers into a trace class instead."
-        elsif !defined?(@trace_class)
-          @trace_class = Class.new(GraphQL::Tracing::LegacyTrace)
+        else
+          trace_mode(:default, Class.new(GraphQL::Tracing::LegacyTrace))
         end
 
         own_tracers << new_tracer
@@ -968,7 +991,13 @@ def new_trace(**options)
         if defined?(@trace_options)
           options = trace_options.merge(options)
         end
-        trace_class.new(**options)
+        trace_mode = if (target = options[:query] || options[:multiplex]) && target.context[:backtrace]
+          :default_backtrace
+        else
+          :default
+        end
+        trace = trace_class_for(trace_mode).new(**options)
+        trace
       end
 
       def query_analyzer(new_analyzer)

lib/graphql/tracing.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+require "graphql/tracing/trace"
+require "graphql/tracing/legacy_trace"
+
 # Legacy tracing:
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
@@ -26,131 +29,8 @@
 
 module GraphQL
   module Tracing
-    class Trace
-      # @param multiplex [GraphQL::Execution::Multiplex, nil]
-      # @param query [GraphQL::Query, nil]
-      def initialize(multiplex: nil, query: nil, **_options)
-        @multiplex = multiplex
-        @query = query
-      end
-
-      def lex(query_string:)
-        yield
-      end
-
-      def parse(query_string:)
-        yield
-      end
-
-      def validate(query:, validate:)
-        yield
-      end
-
-      def analyze_multiplex(multiplex:)
-        yield
-      end
-
-      def analyze_query(query:)
-        yield
-      end
-
-      def execute_multiplex(multiplex:)
-        yield
-      end
-
-      def execute_query(query:)
-        yield
-      end
-
-      def execute_query_lazy(query:, multiplex:)
-        yield
-      end
-
-      def execute_field(field:, query:, ast_node:, arguments:, object:)
-        yield
-      end
-
-      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
-        yield
-      end
-
-      def authorized(query:, type:, object:)
-        yield
-      end
-
-      def authorized_lazy(query:, type:, object:)
-        yield
-      end
-
-      def resolve_type(query:, type:, object:)
-        yield
-      end
-
-      def resolve_type_lazy(query:, type:, object:)
-        yield
-      end
-    end
-
     NullTrace = Trace.new
 
-    class LegacyTrace < Trace
-      def lex(query_string:, &block)
-        (@multiplex || @query).trace("lex", { query_string: query_string }, &block)
-      end
-
-      def parse(query_string:, &block)
-        (@multiplex || @query).trace("parse", { query_string: query_string }, &block)
-      end
-
-      def validate(query:, validate:, &block)
-        query.trace("validate", { validate: validate, query: query }, &block)
-      end
-
-      def analyze_multiplex(multiplex:, &block)
-        multiplex.trace("analyze_multiplex", { multiplex: multiplex }, &block)
-      end
-
-      def analyze_query(query:, &block)
-        query.trace("analyze_query", { query: query }, &block)
-      end
-
-      def execute_multiplex(multiplex:, &block)
-        multiplex.trace("execute_multiplex", { multiplex: multiplex }, &block)
-      end
-
-      def execute_query(query:, &block)
-        query.trace("execute_query", { query: query }, &block)
-      end
-
-      def execute_query_lazy(query:, multiplex:, &block)
-        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }, &block)
-      end
-
-      def execute_field(field:, query:, ast_node:, arguments:, object:, &block)
-        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }, &block)
-      end
-
-      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:, &block)
-        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }, &block)
-      end
-
-      def authorized(query:, type:, object:, &block)
-        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }, &block)
-      end
-
-      def authorized_lazy(query:, type:, object:, &block)
-        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }, &block)
-      end
-
-      def resolve_type(query:, type:, object:, &block)
-        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }, &block)
-      end
-
-      def resolve_type_lazy(query:, type:, object:, &block)
-        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }, &block)
-      end
-    end
-
     # Objects may include traceable to gain a `.trace(...)` method.
     # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.
     # @api private