graphql 2.0.17 → 2.0.18

data/lib/graphql/language/parser.rb

@@ -16,22 +16,22 @@ module_eval(<<'...end parser.y/module_eval...', 'parser.y', 448)
 
 EMPTY_ARRAY = [].freeze
 
-def initialize(query_string, filename:, tracer: Tracing::NullTracer)
+def initialize(query_string, filename:, trace: Tracing::NullTrace)
   raise GraphQL::ParseError.new("No query string was present", nil, nil, query_string) if query_string.nil?
   @query_string = query_string
   @filename = filename
-  @tracer = tracer
+  @trace = trace
   @reused_next_token = [nil, nil]
 end
 
 def parse_document
   @document ||= begin
     # Break the string into tokens
-    @tracer.trace("lex", {query_string: @query_string}) do
+    @trace.lex(query_string: @query_string) do
       @tokens ||= GraphQL.scan(@query_string)
     end
     # From the tokens, build an AST
-    @tracer.trace("parse", {query_string: @query_string}) do
+    @trace.parse(query_string: @query_string) do
       if @tokens.empty?
         raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @query_string)
       else
@@ -44,17 +44,17 @@ end
 class << self
   attr_accessor :cache
 
-  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-    new(query_string, filename: filename, tracer: tracer).parse_document
+  def parse(query_string, filename: nil, trace: GraphQL::Tracing::NullTrace)
+    new(query_string, filename: filename, trace: trace).parse_document
   end
 
-  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+  def parse_file(filename, trace: GraphQL::Tracing::NullTrace)
     if cache
       cache.fetch(filename) do
-        parse(File.read(filename), filename: filename, tracer: tracer)
+        parse(File.read(filename), filename: filename, trace: trace)
       end
     else
-      parse(File.read(filename), filename: filename, tracer: tracer)
+      parse(File.read(filename), filename: filename, trace: trace)
     end
   end
 end

data/lib/graphql/language/parser.y

@@ -448,22 +448,22 @@ end
 
 EMPTY_ARRAY = [].freeze
 
-def initialize(query_string, filename:, tracer: Tracing::NullTracer)
+def initialize(query_string, filename:, trace: Tracing::NullTrace)
   raise GraphQL::ParseError.new("No query string was present", nil, nil, query_string) if query_string.nil?
   @query_string = query_string
   @filename = filename
-  @tracer = tracer
+  @trace = trace
   @reused_next_token = [nil, nil]
 end
 
 def parse_document
   @document ||= begin
     # Break the string into tokens
-    @tracer.trace("lex", {query_string: @query_string}) do
+    @trace.lex(query_string: @query_string) do
       @tokens ||= GraphQL.scan(@query_string)
     end
     # From the tokens, build an AST
-    @tracer.trace("parse", {query_string: @query_string}) do
+    @trace.parse(query_string: @query_string) do
       if @tokens.empty?
         raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @query_string)
       else
@@ -476,17 +476,17 @@ end
 class << self
   attr_accessor :cache
 
-  def parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
-    new(query_string, filename: filename, tracer: tracer).parse_document
+  def parse(query_string, filename: nil, trace: GraphQL::Tracing::NullTrace)
+    new(query_string, filename: filename, trace: trace).parse_document
   end
 
-  def parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+  def parse_file(filename, trace: GraphQL::Tracing::NullTrace)
     if cache
       cache.fetch(filename) do
-        parse(File.read(filename), filename: filename, tracer: tracer)
+        parse(File.read(filename), filename: filename, trace: trace)
       end
     else
-      parse(File.read(filename), filename: filename, tracer: tracer)
+      parse(File.read(filename), filename: filename, trace: trace)
     end
   end
 end

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -7,14 +7,6 @@ module GraphQL
     class ActiveRecordRelationConnection < Pagination::RelationConnection
       private
 
-      def relation_larger_than(relation, initial_offset, size)
-        if already_loaded?(relation)
-          (relation.size + initial_offset) > size
-        else
-          set_offset(sliced_nodes, initial_offset + size).exists?
-        end
-      end
-
       def relation_count(relation)
         int_or_hash = if already_loaded?(relation)
           relation.size

data/lib/graphql/query/context.rb

@@ -72,6 +72,18 @@ module GraphQL
       # @return [Array<String, Integer>] The current position in the result
       attr_reader :path
 
+      module EmptyScopedContext
+        EMPTY_HASH = {}.freeze
+
+        def self.key?(k)
+          false
+        end
+
+        def self.merged_context
+          EMPTY_HASH
+        end
+      end
+
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
@@ -87,13 +99,14 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods TODO delete sharedmethods
-        @scoped_context = ScopedContext.new(self)
+        @scoped_context = EmptyScopedContext
       end
 
       class ScopedContext
         def initialize(query_context)
           @query_context = query_context
           @scoped_contexts = {}
+          @all_keys = Set.new
           @no_path = [].freeze
         end
 
@@ -106,6 +119,7 @@ module GraphQL
         end
 
         def merge!(hash)
+          @all_keys.merge(hash.keys)
           ctx = @scoped_contexts
           current_path.each do |path_part|
             ctx = ctx[path_part] ||= { parent: ctx }
@@ -114,15 +128,12 @@ module GraphQL
           this_scoped_ctx.merge!(hash)
         end
 
-        def current_path
-          thread_info = Thread.current[:__graphql_runtime_info]
-          (thread_info && thread_info[:current_path]) || @no_path
-        end
-
         def key?(key)
-          each_present_path_ctx do |path_ctx|
-            if path_ctx.key?(key)
-              return true
+          if @all_keys.include?(key)
+            each_present_path_ctx do |path_ctx|
+              if path_ctx.key?(key)
+                return true
+              end
             end
           end
           false
@@ -137,6 +148,10 @@ module GraphQL
           nil
         end
 
+        def current_path
+          @query_context.current_path || @no_path
+        end
+
         def dig(key, *other_keys)
           each_present_path_ctx do |path_ctx|
             if path_ctx.key?(key)
@@ -209,14 +224,30 @@ module GraphQL
         elsif @provided_values.key?(key)
           @provided_values[key]
         elsif RUNTIME_METADATA_KEYS.include?(key)
-          thread_info = Thread.current[:__graphql_runtime_info]
-          thread_info && thread_info[key]
+          if key == :current_path
+            current_path
+          else
+            thread_info = Thread.current[:__graphql_runtime_info]
+            thread_info && thread_info[key]
+          end
         else
           # not found
           nil
         end
       end
 
+      def current_path
+        thread_info = Thread.current[:__graphql_runtime_info]
+        path = thread_info &&
+          (result = thread_info[:current_result]) &&
+          (result.path)
+        if path && (rn = thread_info[:current_result_name])
+          path = path.dup
+          path.push(rn)
+        end
+        path
+      end
+
       def delete(key)
         if @scoped_context.key?(key)
           @scoped_context.delete(key)
@@ -298,6 +329,9 @@ module GraphQL
       end
 
       def scoped_merge!(hash)
+        if @scoped_context == EmptyScopedContext
+          @scoped_context = ScopedContext.new(self)
+        end
         @scoped_context.merge!(hash)
       end
 

data/lib/graphql/query.rb

@@ -95,12 +95,20 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
-      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
+      context_tracers = (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + context_tracers
+
       # 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
       end
 
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
+        raise ArgumentError, "context[:tracers] and context[:backtrace] are not supported without `tracer_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+      end
+
+
       @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
@@ -157,6 +165,11 @@ module GraphQL
 
     attr_accessor :multiplex
 
+    # @return [GraphQL::Tracing::Trace]
+    def current_trace
+      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+    end
+
     def subscription_update?
       @subscription_topic && subscription?
     end
@@ -362,7 +375,7 @@ module GraphQL
       parse_error = nil
       @document ||= begin
         if query_string
-          GraphQL.parse(query_string, tracer: self)
+          GraphQL.parse(query_string, trace: self.current_trace)
         end
       rescue GraphQL::ParseError => err
         parse_error = err

data/lib/graphql/schema/field.rb

@@ -219,7 +219,7 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, default_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -233,9 +233,10 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-        if description != :not_given
-          @description = description
-        end
+
+        @description = description
+        @type = @owner_type = @own_validators = @own_directives = @own_arguments = nil # these will be prepared later if necessary
+
         self.deprecation_reason = deprecation_reason
 
         if method && hash_key && dig
@@ -257,6 +258,9 @@ module GraphQL
         if hash_key
           @hash_key = hash_key
           @hash_key_str = hash_key.to_s
+        else
+          @hash_key = NOT_CONFIGURED
+          @hash_key_str = NOT_CONFIGURED
         end
 
         @method_str = -method_name.to_s
@@ -272,15 +276,11 @@ module GraphQL
           true
         end
         @connection = connection
-        @has_max_page_size = max_page_size != :not_given
-        @max_page_size = max_page_size == :not_given ? nil : max_page_size
-        @has_default_page_size = default_page_size != :not_given
-        @default_page_size = default_page_size == :not_given ? nil : default_page_size
+        @max_page_size = max_page_size
+        @default_page_size = default_page_size
         @introspection = introspection
         @extras = extras
-        if !broadcastable.nil?
-          @broadcastable = broadcastable
-        end
+        @broadcastable = broadcastable
         @resolver_class = resolver_class
         @scope = scope
         @trace = trace
@@ -355,7 +355,7 @@ module GraphQL
       # @return [Boolean, nil]
       # @see GraphQL::Subscriptions::BroadcastAnalyzer
       def broadcastable?
-        if defined?(@broadcastable)
+        if !NOT_CONFIGURED.equal?(@broadcastable)
           @broadcastable
         elsif @resolver_class
           @resolver_class.broadcastable?
@@ -369,10 +369,10 @@ module GraphQL
       def description(text = nil)
         if text
           @description = text
-        elsif defined?(@description)
+        elsif !NOT_CONFIGURED.equal?(@description)
           @description
         elsif @resolver_class
-          @description || @resolver_class.description
+          @resolver_class.description
         else
           nil
         end
@@ -544,22 +544,34 @@ module GraphQL
 
       # @return [Boolean] True if this field's {#max_page_size} should override the schema default.
       def has_max_page_size?
-        @has_max_page_size || (@resolver_class && @resolver_class.has_max_page_size?)
+        !NOT_CONFIGURED.equal?(@max_page_size) || (@resolver_class && @resolver_class.has_max_page_size?)
       end
 
       # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       def max_page_size
-        @max_page_size || (@resolver_class && @resolver_class.max_page_size)
+        if !NOT_CONFIGURED.equal?(@max_page_size)
+          @max_page_size
+        elsif @resolver_class && @resolver_class.has_max_page_size?
+          @resolver_class.max_page_size
+        else
+          nil
+        end
       end
 
       # @return [Boolean] True if this field's {#default_page_size} should override the schema default.
       def has_default_page_size?
-        @has_default_page_size || (@resolver_class && @resolver_class.has_default_page_size?)
+        !NOT_CONFIGURED.equal?(@default_page_size) || (@resolver_class && @resolver_class.has_default_page_size?)
       end
 
       # @return [Integer, nil] Applied to connections if {#has_default_page_size?}
       def default_page_size
-        @default_page_size || (@resolver_class && @resolver_class.default_page_size)
+        if !NOT_CONFIGURED.equal?(@default_page_size)
+          @default_page_size
+        elsif @resolver_class && @resolver_class.has_default_page_size?
+          @resolver_class.default_page_size
+        else
+          nil
+        end
       end
 
       class MissingReturnTypeError < GraphQL::Error; end
@@ -661,7 +673,7 @@ module GraphQL
 
               inner_object = obj.object
 
-              if defined?(@hash_key)
+              if !NOT_CONFIGURED.equal?(@hash_key)
                 hash_value = if inner_object.is_a?(Hash)
                   inner_object.key?(@hash_key) ? inner_object[@hash_key] : inner_object[@hash_key_str]
                 elsif inner_object.respond_to?(:[])

data/lib/graphql/schema/member/has_deprecation_reason.rb

@@ -5,17 +5,16 @@ module GraphQL
     class Member
       module HasDeprecationReason
         # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
-        def deprecation_reason
-          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
-          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
-        end
+        attr_reader :deprecation_reason
 
         # Set the deprecation reason for this member, or remove it by assigning `nil`
         # @param text [String, nil]
         def deprecation_reason=(text)
+          @deprecation_reason = text
           if text.nil?
             remove_directive(GraphQL::Schema::Directive::Deprecated)
           else
+            # This removes a previously-attached directive, if there is one:
             directive(GraphQL::Schema::Directive::Deprecated, reason: text)
           end
         end

data/lib/graphql/schema/member/has_fields.rb

@@ -72,7 +72,12 @@ module GraphQL
         def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
           # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
           # that shows that no override value was given manually.
-          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym && field_defn.hash_key.nil? && field_defn.dig_keys.nil?
+          if method_conflict_warning &&
+              CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) &&
+              field_defn.original_name == field_defn.resolver_method &&
+              field_defn.original_name == field_defn.method_sym &&
+              field_defn.hash_key == NOT_CONFIGURED &&
+              field_defn.dig_keys.nil?
             warn(conflict_field_name_warning(field_defn))
           end
           prev_defn = own_fields[field_defn.name]

data/lib/graphql/schema/object.rb

@@ -48,9 +48,7 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
-
-          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+          maybe_lazy_auth_val = context.query.current_trace.authorized(query: context.query, type: self, object: object) do
             begin
               authorized?(object, context)
             rescue GraphQL::UnauthorizedError => err
@@ -62,7 +60,7 @@ module GraphQL
 
           auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
             GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
+              context.query.current_trace.authorized_lazy(query: context.query, type: self, object: object) do
                 context.schema.sync_lazy(maybe_lazy_auth_val)
               end
             end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -89,16 +89,16 @@ module GraphQL
         def generate_payload_type
           resolver_name = graphql_name
           resolver_fields = all_field_definitions
-          Class.new(object_class) do
-            graphql_name("#{resolver_name}Payload")
-            description("Autogenerated return type of #{resolver_name}.")
-            resolver_fields.each do |f|
-              # Reattach the already-defined field here
-              # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
-              add_field(f, method_conflict_warning: false)
-            end
+          pt = Class.new(object_class)
+          pt.graphql_name("#{resolver_name}Payload")
+          pt.description("Autogenerated return type of #{resolver_name}.")
+          resolver_fields.each do |f|
+            # Reattach the already-defined field here
+            # (The field's `.owner` will still point to the mutation, not the object type, I think)
+            # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+            pt.add_field(f, method_conflict_warning: false)
           end
+          pt
         end
       end
     end

data/lib/graphql/schema/timeout.rb

@@ -33,60 +33,56 @@ module GraphQL
     #   end
     #
     class Timeout
-      def self.use(schema, **options)
-        tracer = new(**options)
-        schema.tracer(tracer)
+      def self.use(schema, max_seconds: nil)
+        timeout = self.new(max_seconds: max_seconds)
+        schema.trace_with(self::Trace, timeout: timeout)
       end
 
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
-      def trace(key, data)
-        case key
-        when 'execute_multiplex'
-          data.fetch(:multiplex).queries.each do |query|
-            timeout_duration_s = max_seconds(query)
+      module Trace
+        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        def initialize(timeout:, **rest)
+          @timeout = timeout
+          super
+        end
+
+        def execute_multiplex(multiplex:)
+          multiplex.queries.each do |query|
+            timeout_duration_s = @timeout.max_seconds(query)
             timeout_state = if timeout_duration_s == false
               # if the method returns `false`, don't apply a timeout
               false
             else
               now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-              timeout_at = now + (max_seconds(query) * 1000)
+              timeout_at = now + (timeout_duration_s * 1000)
               {
                 timeout_at: timeout_at,
                 timed_out: false
               }
             end
-            query.context.namespace(self.class)[:state] = timeout_state
+            query.context.namespace(@timeout)[:state] = timeout_state
           end
+          super
+        end
 
-          yield
-        when 'execute_field', 'execute_field_lazy'
-          query_context = data[:context] || data[:query].context
-          timeout_state = query_context.namespace(self.class).fetch(:state)
+        def execute_field(query:, field:, **_rest)
+          timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
-            error = if data[:context]
-              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
-            else
-              field = data.fetch(:field)
-              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
-            end
-
+            error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query_context.query)
+              @timeout.handle_timeout(error, query)
             end
 
             error
           else
             yield
           end
-        else
-          yield
         end
       end
 
@@ -114,8 +110,8 @@ module GraphQL
       # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field)
-          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        def initialize(field)
+          super("Timeout on #{field.path}")
         end
       end
     end

data/lib/graphql/schema/warden.rb

@@ -96,6 +96,13 @@ module GraphQL
         @subscription = @schema.subscription
         @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
+        # Initialize all ivars to improve object shape consistency:
+        @types = @visible_types = @reachable_types = @visible_parent_fields =
+          @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
+          @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @reachable_type_set =
+            nil
       end
 
       # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
@@ -347,7 +354,7 @@ module GraphQL
       end
 
       def reachable_type_set
-        return @reachable_type_set if defined?(@reachable_type_set)
+        return @reachable_type_set if @reachable_type_set
 
         @reachable_type_set = Set.new
         rt_hash = {}

data/lib/graphql/schema.rb

@@ -143,6 +143,15 @@ module GraphQL
         @subscriptions = new_implementation
       end
 
+      def trace_class(new_class = nil)
+        if new_class
+          @trace_class = new_class
+        elsif !defined?(@trace_class)
+          @trace_class = Class.new(GraphQL::Tracing::Trace)
+        end
+        @trace_class
+      end
+
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
@@ -926,6 +935,12 @@ module GraphQL
       end
 
       def tracer(new_tracer)
+        if defined?(@trace_class) && !(@trace_class < 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)
+        end
+
         own_tracers << new_tracer
       end
 
@@ -933,6 +948,25 @@ module GraphQL
         find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
+      # Mix `trace_mod` into this schema's `Trace` class so that its methods
+      # will be called at runtime.
+      #
+      # @param trace_mod [Module] A module that implements tracing methods
+      # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
+      # @return [void]
+      def trace_with(trace_mod, **options)
+        @trace_options ||= {}
+        @trace_options.merge!(options)
+        trace_class.include(trace_mod)
+      end
+
+      def new_trace(**options)
+        if defined?(@trace_options)
+          options = @trace_options.merge(options)
+        end
+        trace_class.new(**options)
+      end
+
       def query_analyzer(new_analyzer)
         own_query_analyzers << new_analyzer
       end

data/lib/graphql/static_validation/validator.rb

@@ -27,7 +27,7 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
-        query.trace("validate", { validate: validate, query: query }) do
+        query.current_trace.validate(validate: validate, query: query) do
           errors = if validate == false
             []
           else