graphql 2.2.5 → 2.3.0

data/lib/graphql/schema.rb

@@ -63,10 +63,6 @@ module GraphQL
   # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
   # (These configurations can be overridden by specific calls to {Schema#execute})
   #
-  # Schemas can specify how queries should be executed against them.
-  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
-  # each apply to corresponding root types.
-  #
   # @example defining a schema
   #   class MySchema < GraphQL::Schema
   #     query QueryType
@@ -162,18 +158,29 @@ module GraphQL
 
       def trace_class(new_class = nil)
         if new_class
+          # If any modules were already added for `:default`,
+          # re-apply them here
+          mods = trace_modules_for(:default)
+          mods.each { |mod| new_class.include(mod) }
           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)
+        trace_class_for(:default, build: true)
       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, build: true)
-        own_trace_modes[mode] ||
-          (superclass.respond_to?(:trace_class_for) ? superclass.trace_class_for(mode, build: build) : (build ? (own_trace_modes[mode] = build_trace_mode(mode)) : nil))
+      def trace_class_for(mode, build: false)
+        if (trace_class = own_trace_modes[mode])
+          trace_class
+        elsif superclass.respond_to?(:trace_class_for) && (trace_class = superclass.trace_class_for(mode, build: false))
+          trace_class
+        elsif build
+          own_trace_modes[mode] = build_trace_mode(mode)
+        else
+          nil
+        end
       end
 
       # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
@@ -211,20 +218,24 @@ module GraphQL
             include DefaultTraceClass
           end
         when :default_backtrace
-          schema_base_class = trace_class_for(:default)
+          schema_base_class = trace_class_for(:default, build: true)
           Class.new(schema_base_class) do
             include(GraphQL::Backtrace::Trace)
           end
         else
           # First, see if the superclass has a custom-defined class for this.
           # Then, if it doesn't, use this class's default trace
-          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode, build: false)) || trace_class_for(:default)
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || trace_class_for(:default, build: true)
           # Prepare the default trace class if it hasn't been initialized yet
           base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
           mods = trace_modules_for(mode)
           if base_class < DefaultTraceClass
             mods = trace_modules_for(:default) + mods
           end
+          # Copy the existing default options into this mode's options
+          default_options = trace_options_for(:default)
+          add_trace_options_for(mode, default_options)
+
           Class.new(base_class) do
             mods.any? && include(*mods)
           end
@@ -640,27 +651,39 @@ module GraphQL
         end
       end
 
-      def query_execution_strategy(new_query_execution_strategy = nil)
+      def query_execution_strategy(new_query_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.query_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
         else
-          @query_execution_strategy || find_inherited_value(:query_execution_strategy, self.default_execution_strategy)
+          @query_execution_strategy || (superclass.respond_to?(:query_execution_strategy) ? superclass.query_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def mutation_execution_strategy(new_mutation_execution_strategy = nil)
+      def mutation_execution_strategy(new_mutation_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.mutation_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+            warn "  #{caller(1, 1).first}"
+        end
         if new_mutation_execution_strategy
           @mutation_execution_strategy = new_mutation_execution_strategy
         else
-          @mutation_execution_strategy || find_inherited_value(:mutation_execution_strategy, self.default_execution_strategy)
+          @mutation_execution_strategy || (superclass.respond_to?(:mutation_execution_strategy) ? superclass.mutation_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def subscription_execution_strategy(new_subscription_execution_strategy = nil)
+      def subscription_execution_strategy(new_subscription_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.subscription_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_subscription_execution_strategy
           @subscription_execution_strategy = new_subscription_execution_strategy
         else
-          @subscription_execution_strategy || find_inherited_value(:subscription_execution_strategy, self.default_execution_strategy)
+          @subscription_execution_strategy || (superclass.respond_to?(:subscription_execution_strategy) ? superclass.subscription_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
@@ -743,6 +766,7 @@ module GraphQL
 
       def error_bubbling(new_error_bubbling = nil)
         if !new_error_bubbling.nil?
+          warn("error_bubbling(#{new_error_bubbling.inspect}) is deprecated; the default value of `false` will be the only option in GraphQL-Ruby 3.0")
           @error_bubbling = new_error_bubbling
         else
           @error_bubbling.nil? ? find_inherited_value(:error_bubbling) : @error_bubbling
@@ -814,9 +838,40 @@ module GraphQL
         end
       end
 
+      # @param new_extra_types [Module] Type definitions to include in printing and introspection, even though they aren't referenced in the schema
+      # @return [Array<Module>] Type definitions added to this schema
+      def extra_types(*new_extra_types)
+        if new_extra_types.any?
+          new_extra_types = new_extra_types.flatten
+          @own_extra_types ||= []
+          @own_extra_types.concat(new_extra_types)
+        end
+        inherited_et = find_inherited_value(:extra_types, nil)
+        if inherited_et
+          if @own_extra_types
+            inherited_et + @own_extra_types
+          else
+            inherited_et
+          end
+        else
+          @own_extra_types || EMPTY_ARRAY
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
+          non_object_types = new_orphan_types.reject { |ot| ot.is_a?(Class) && ot < GraphQL::Schema::Object }
+          if non_object_types.any?
+            raise ArgumentError, <<~ERR
+              Only object type classes should be added as `orphan_types(...)`.
+
+              - Remove these no-op types from `orphan_types`: #{non_object_types.map { |t| "#{t.inspect} (#{t.kind.name})"}.join(", ")}
+              - See https://graphql-ruby.org/type_definitions/interfaces.html#orphan-types
+
+              To add other types to your schema, you might want `extra_types`: https://graphql-ruby.org/schema/definition.html#extra-types
+            ERR
+          end
           add_type_and_traverse(new_orphan_types, root: false)
           own_orphan_types.concat(new_orphan_types.flatten)
         end
@@ -1044,6 +1099,12 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        warn <<~WARN
+        Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
+          (From `#{self}.instrument(#{instrument_step}, #{instrumenter})` at #{caller(1, 1).first})
+
+        WARN
+        trace_with(Tracing::LegacyHooksTrace)
         own_instrumenters[instrument_step] << instrumenter
       end
 
@@ -1079,8 +1140,12 @@ module GraphQL
         }.freeze
       end
 
-      def tracer(new_tracer)
-        default_trace = trace_class_for(:default)
+      def tracer(new_tracer, silence_deprecation_warning: false)
+        if !silence_deprecation_warning
+          warn("`Schema.tracer(#{new_tracer.inspect})` is deprecated; use module-based `trace_with` instead. See: https://graphql-ruby.org/queries/tracing.html")
+          warn "  #{caller(1, 1).first}"
+        end
+        default_trace = trace_class_for(:default, build: true)
         if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
           trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
@@ -1106,20 +1171,23 @@ module GraphQL
           tc = own_trace_modes[mode] ||= build_trace_mode(mode)
           tc.include(trace_mod)
           own_trace_modules[mode] << trace_mod
-
+          add_trace_options_for(mode, options)
           if mode == :default
             # This module is being added as a default tracer. If any other mode classes
             # have already been created, but get their default behavior from a superclass,
             # Then mix this into this schema's subclass.
             # (But don't mix it into mode classes that aren't default-based.)
             own_trace_modes.each do |other_mode_name, other_mode_class|
-              if other_mode_class < DefaultTraceClass && !(other_mode_class < trace_mod)
-                other_mode_class.include(trace_mod)
+              if other_mode_class < DefaultTraceClass
+                # Don't add it back to the inheritance tree if it's already there
+                if !(other_mode_class < trace_mod)
+                  other_mode_class.include(trace_mod)
+                end
+                # Add any options so they'll be available
+                add_trace_options_for(other_mode_name, options)
               end
             end
           end
-          t_opts = trace_options_for(mode)
-          t_opts.merge!(options)
         end
         nil
       end
@@ -1129,10 +1197,14 @@ module GraphQL
       def trace_options_for(mode)
         @trace_options_for_mode ||= {}
         @trace_options_for_mode[mode] ||= begin
+          # It may be time to create an options hash for a mode that wasn't registered yet.
+          # Mix in the default options in that case.
+          default_options = mode == :default ? EMPTY_HASH : trace_options_for(:default)
+          # Make sure this returns a new object so that other hashes aren't modified later
           if superclass.respond_to?(:trace_options_for)
-            superclass.trace_options_for(mode).dup
+            superclass.trace_options_for(mode).merge(default_options)
           else
-            {}
+            default_options.dup
           end
         end
       end
@@ -1155,15 +1227,17 @@ module GraphQL
             raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
           else
             own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
+            options_trace_mode = :default
             :default_backtrace
           end
         else
           default_trace_mode
         end
 
-        base_trace_options = trace_options_for(trace_mode)
+        options_trace_mode ||= trace_mode
+        base_trace_options = trace_options_for(options_trace_mode)
         trace_options = base_trace_options.merge(options)
-        trace_class_for_mode = trace_class_for(trace_mode) || raise(ArgumentError, "#{self} has no trace class for mode: #{trace_mode.inspect}")
+        trace_class_for_mode = trace_class_for(trace_mode, build: true)
         trace_class_for_mode.new(**trace_options)
       end
 
@@ -1317,6 +1391,12 @@ module GraphQL
 
       private
 
+      def add_trace_options_for(mode, new_options)
+        t_opts = trace_options_for(mode)
+        t_opts.merge!(new_options)
+        nil
+      end
+
       # @param t [Module, Array<Module>]
       # @return [void]
       def add_type_and_traverse(t, root:)
@@ -1378,7 +1458,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
-            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load_with_deprecation_warning)
           end
         end
         @lazy_methods

data/lib/graphql/static_validation/literal_validator.rb

@@ -110,7 +110,7 @@ module GraphQL
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
         required_field_names = @warden.arguments(type)
-          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
+          .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
           .map!(&:name)
 
         present_field_names = ast_node.arguments.map(&:name)
@@ -122,7 +122,6 @@ module GraphQL
             arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
-
           if type.one_of? && ast_node.arguments.size != 1
             results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
           end

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -35,7 +35,7 @@ module GraphQL
         return unless parent_type && parent_type.kind.input_object?
 
         required_fields = context.warden.arguments(parent_type)
-          .select{|arg| arg.type.kind.non_null?}
+          .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
           .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)

data/lib/graphql/static_validation/validator.rb

@@ -28,6 +28,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
           errors = if validate == false
             []
           else
@@ -52,11 +53,13 @@ module GraphQL
           end
 
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
+          remaining_timeout: nil,
           errors: [e],
         }
       end

data/lib/graphql/subscriptions/serialize.rb

@@ -148,6 +148,8 @@ module GraphQL
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
           elsif obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
+          elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
+            dump_value(obj.to_a)
           else
             obj
           end

data/lib/graphql/subscriptions.rb

@@ -2,7 +2,6 @@
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
-require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/default_subscription_resolve_extension"
@@ -30,8 +29,6 @@ module GraphQL
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
-      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:query, instrumentation)
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary

data/lib/graphql/testing/helpers.rb

@@ -5,10 +5,7 @@ module GraphQL
       # @param schema_class [Class<GraphQL::Schema>]
       # @return [Module] A helpers module which always uses the given schema
       def self.for(schema_class)
-        Module.new do
-          include SchemaHelpers
-          @@schema_class_for_helpers = schema_class
-        end
+        SchemaHelpers.for(schema_class)
       end
 
       class Error < GraphQL::Error
@@ -119,6 +116,13 @@ module GraphQL
           # schema will be added later
           super(nil, *args, **kwargs, &block)
         end
+
+        def self.for(schema_class)
+          Module.new do
+            include SchemaHelpers
+            @@schema_class_for_helpers = schema_class
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -3,20 +3,18 @@
 module GraphQL
   module Tracing
     module DataDogTrace
+      # @param tracer [#trace] Deprecated
       # @param analytics_enabled [Boolean] Deprecated
       # @param analytics_sample_rate [Float] Deprecated
-      def initialize(tracer: nil, analytics_enabled: false, analytics_sample_rate: 1.0, service: "ruby-graphql", **rest)
+      def initialize(tracer: nil, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **rest)
         if tracer.nil?
           tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
         end
         @tracer = tracer
 
-        analytics_available = defined?(Datadog::Contrib::Analytics) \
-            && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
-            && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
-
-        @analytics_enabled = analytics_available && Datadog::Contrib::Analytics.enabled?(analytics_enabled)
+        @analytics_enabled = analytics_enabled
         @analytics_sample_rate = analytics_sample_rate
+
         @service_name = service
         @has_prepare_span = respond_to?(:prepare_span)
         super
@@ -34,12 +32,9 @@ module GraphQL
       }.each do |trace_method, trace_key|
         module_eval <<-RUBY, __FILE__, __LINE__
           def #{trace_method}(**data)
-            @tracer.trace("#{trace_key}", service: @service_name) do |span|
-              span.span_type = 'custom'
-              if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, '#{trace_method}')
-              end
+            @tracer.trace("#{trace_key}", service: @service_name, type: 'custom') do |span|
+                span.set_tag('component', 'graphql')
+                span.set_tag('operation', '#{trace_method}')
 
               #{
                 if trace_method == 'execute_multiplex'
@@ -54,10 +49,8 @@ module GraphQL
                   end
                   span.resource = resource if resource
 
-                  # For top span of query, set the analytics sample rate tag, if available.
-                  if @analytics_enabled
-                    Datadog::Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
-                  end
+                  # [Deprecated] will be removed in the future
+                  span.set_metric('_dd1.sr.eausr', @analytics_sample_rate) if @analytics_enabled
                   RUBY
                 elsif trace_method == 'execute_query'
                   <<-RUBY
@@ -89,12 +82,10 @@ module GraphQL
           nil
         end
         if platform_key && trace_field
-          @tracer.trace(platform_key, service: @service_name) do |span|
-            span.span_type = 'custom'
-            if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
-            end
+          @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
+            span.set_tag('component', 'graphql')
+            span.set_tag('operation', span_key)
+
             if @has_prepare_span
               prepare_span_data = { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }
               prepare_span(span_key, prepare_span_data, span)
@@ -125,12 +116,10 @@ module GraphQL
 
       def authorized_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_authorized_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name) do |span|
-          span.span_type = 'custom'
-          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
-          end
+        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
+          span.set_tag('component', 'graphql')
+          span.set_tag('operation', span_key)
+
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end
@@ -158,12 +147,10 @@ module GraphQL
 
       def resolve_type_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_resolve_type_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name) do |span|
-          span.span_type = 'custom'
-          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
-          end
+        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
+          span.set_tag('component', 'graphql')
+          span.set_tag('operation', span_key)
+
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -15,12 +15,9 @@ module GraphQL
       }
 
       def platform_trace(platform_key, key, data)
-        tracer.trace(platform_key, service: service_name) do |span|
-          span.span_type = 'custom'
-          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
-          end
+        tracer.trace(platform_key, service: options[:service], type: 'custom') do |span|
+          span.set_tag('component', 'graphql')
+          span.set_tag('operation', key)
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
@@ -33,10 +30,8 @@ module GraphQL
             end
             span.resource = resource if resource
 
-            # For top span of query, set the analytics sample rate tag, if available.
-            if analytics_enabled?
-              Datadog::Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-            end
+            # [Deprecated] will be removed in the future
+            span.set_metric('_dd1.sr.eausr', analytics_sample_rate) if analytics_enabled?
           end
 
           if key == 'execute_query'
@@ -51,10 +46,6 @@ module GraphQL
         end
       end
 
-      def service_name
-        options.fetch(:service, 'ruby-graphql')
-      end
-
       # Implement this method in a subclass to apply custom tags to datadog spans
       # @param key [String] The event being traced
       # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
@@ -65,18 +56,13 @@ module GraphQL
       def tracer
         default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
 
+        # [Deprecated] options[:tracer] will be removed in the future
         options.fetch(:tracer, default_tracer)
       end
 
-      def analytics_available?
-        defined?(Datadog::Contrib::Analytics) \
-          && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
-          && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
-      end
-
       def analytics_enabled?
         # [Deprecated] options[:analytics_enabled] will be removed in the future
-        analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
+        options.fetch(:analytics_enabled, false)
       end
 
       def analytics_sample_rate

data/lib/graphql/tracing/legacy_hooks_trace.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    module LegacyHooksTrace
+      def execute_multiplex(multiplex:)
+        multiplex_instrumenters = multiplex.schema.instrumenters[:multiplex]
+        query_instrumenters = multiplex.schema.instrumenters[:query]
+        # First, run multiplex instrumentation, then query instrumentation for each query
+        RunHooks.call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+          RunHooks.each_query_call_hooks(query_instrumenters, multiplex.queries) do
+            super
+          end
+        end
+      end
+
+      module RunHooks
+        module_function
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
+        end
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+          begin
+            successful = []
+            instrumenters.each do |instrumenter|
+              instrumenter.public_send(before_hook_name, object)
+              successful << instrumenter
+            end
+
+            # if any before hooks raise an exception, quit calling before hooks,
+            # but call the after hooks on anything that succeeded but also
+            # raise the exception that came from the before hook.
+          rescue GraphQL::ExecutionError => err
+            object.context.errors << err
+          rescue => e
+            raise call_after_hooks(successful, object, after_hook_name, e)
+          end
+
+          begin
+            yield # Call the user code
+          ensure
+            ex = call_after_hooks(successful, object, after_hook_name, nil)
+            raise ex if ex
+          end
+        end
+
+        def call_after_hooks(instrumenters, object, after_hook_name, ex)
+          instrumenters.reverse_each do |instrumenter|
+            begin
+              instrumenter.public_send(after_hook_name, object)
+            rescue => e
+              ex = e
+            end
+          end
+          ex
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -81,10 +81,12 @@ module GraphQL
           trace_name = tracing_name.sub("Tracing", "Trace")
           if GraphQL::Tracing.const_defined?(trace_name, false)
             trace_module = GraphQL::Tracing.const_get(trace_name)
+            warn("`use(#{self.name})` is deprecated, use the equivalent `trace_with(#{trace_module.name})` instead. More info: https://graphql-ruby.org/queries/tracing.html")
             schema_defn.trace_with(trace_module, **options)
           else
+            warn("`use(#{self.name})` and `Tracing::PlatformTracing` are deprecated. Use a `trace_with(...)` module instead. More info: https://graphql-ruby.org/queries/tracing.html. Please open an issue on the GraphQL-Ruby repo if you want to discuss further!")
             tracer = self.new(**options)
-            schema_defn.tracer(tracer)
+          schema_defn.tracer(tracer, silence_deprecation_warning: true)
           end
         end
       end

data/lib/graphql/tracing/{prometheus_tracing → prometheus_trace}/graphql_collector.rb

@@ -2,7 +2,7 @@
 
 module GraphQL
   module Tracing
-    class PrometheusTracing < PlatformTracing
+    module PrometheusTrace
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
           @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
@@ -28,5 +28,7 @@ module GraphQL
         end
       end
     end
+    # Backwards-compat:
+    PrometheusTracing::GraphQLCollector = PrometheusTrace::GraphQLCollector
   end
 end