graphql 2.2.4 → 2.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87199d36a0f9e158d8892e0e9ca2086f89c321adbbe5dec68b16e662ccb5e912
-  data.tar.gz: 5dde06249941e5ce75bc06613c37bf75cc8d6c110a1e7c39f1fede566bb0d160
+  metadata.gz: ba7d4c9ad987cbae751625aced364d2ace39bfb84ee22e32ab07f33c335f4ebf
+  data.tar.gz: 40773fa35507e6cbeefb468c4ad153e1561e813092187abaf6f246c5e06802d6
 SHA512:
-  metadata.gz: a2da271a3986e6859048054a64021fdb900b71439abec89b3f0b89ef5b2607266c507dae5e3de81b305028c7ba45cde8e7271612fabeda45ac9e8a18be3d9818
-  data.tar.gz: 80a579e0e22967804de66b86fa98a5c0041d45ca1665beba4e50ef5045848364da5b71d115cbe862d308b72919723b121b8a001c9185b664c2394dcc054d5f20
+  metadata.gz: fb0a00a30aec2c81a6a0e239f8f7c3313747e190c06d821395a75868a46d84b65f699e4dbf40342455549b2b1b7f92ab5630dcdd2bebfbe95aef66a574a5bd5d
+  data.tar.gz: 6b1b63f5004336b304adbfb6b946d0b8ba87bd60a5356859f38fae3df92f15f092d07c22f1bd9857fdf04883b8b7d2134f38fb67bf11afe08df009528dd3c0ed

data/lib/graphql/analysis/ast/field_usage.rb

@@ -8,6 +8,7 @@ module GraphQL
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
           @used_deprecated_arguments = Set.new
+          @used_deprecated_enum_values = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -15,7 +16,7 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
-          arguments = visitor.query.arguments_for(node, visitor.field_definition)
+          arguments = visitor.query.arguments_for(node, field_defn)
           # If there was an error when preparing this argument object,
           # then this might be an error or something:
           if arguments.respond_to?(:argument_values)
@@ -28,6 +29,7 @@ module GraphQL
             used_fields: @used_fields.to_a,
             used_deprecated_fields: @used_deprecated_fields.to_a,
             used_deprecated_arguments: @used_deprecated_arguments.to_a,
+            used_deprecated_enum_values: @used_deprecated_enum_values.to_a,
           }
         end
 
@@ -41,16 +43,39 @@ module GraphQL
 
             next if argument.value.nil?
 
-            if argument.definition.type.kind.input_object?
+            argument_type = argument.definition.type
+            if argument_type.non_null?
+              argument_type = argument_type.of_type
+            end
+
+            if argument_type.kind.input_object?
               extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument.definition.type.list?
-              argument
-                .value
-                .select { |value| value.respond_to?(:arguments) }
-                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument_type.kind.enum?
+              extract_deprecated_enum_value(argument_type, argument.value)
+            elsif argument_type.list?
+              inner_type = argument_type.unwrap
+              case inner_type.kind
+              when TypeKinds::INPUT_OBJECT
+                argument.value.each do |value|
+                  extract_deprecated_arguments(value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+                end
+              when TypeKinds::ENUM
+                argument.value.each do |value|
+                  extract_deprecated_enum_value(inner_type, value)
+                end
+              else
+                # Not a kind of input that we track
+              end
             end
           end
         end
+
+        def extract_deprecated_enum_value(enum_type, value)
+          enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
+          if enum_value&.deprecation_reason
+            @used_deprecated_enum_values << enum_value.path
+          end
+        end
       end
     end
   end

data/lib/graphql/analysis/ast.rb

@@ -6,6 +6,7 @@ require "graphql/analysis/ast/query_complexity"
 require "graphql/analysis/ast/max_query_complexity"
 require "graphql/analysis/ast/query_depth"
 require "graphql/analysis/ast/max_query_depth"
+require "timeout"
 
 module GraphQL
   module Analysis
@@ -63,7 +64,10 @@ module GraphQL
                 analyzers: analyzers_to_run
               )
 
-              visitor.visit
+              # `nil` or `0` causes no timeout
+              Timeout::timeout(query.validate_timeout_remaining) do
+                visitor.visit
+              end
 
               if visitor.rescued_errors.any?
                 return visitor.rescued_errors
@@ -75,6 +79,8 @@ module GraphQL
             []
           end
         end
+      rescue Timeout::Error
+        [GraphQL::AnalysisError.new("Timeout on validation of query")]
       end
 
       def analysis_errors(results)

data/lib/graphql/coercion_error.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 module GraphQL
-  class CoercionError < GraphQL::Error
-    # @return [Hash] Optional custom data for error objects which will be added
-    # under the `extensions` key.
-    attr_accessor :extensions
-
-    def initialize(message, extensions: nil)
-      @extensions = extensions
-      super(message)
-    end
+  class CoercionError < GraphQL::ExecutionError
   end
 end

data/lib/graphql/execution/interpreter.rb

@@ -37,173 +37,113 @@ module GraphQL
           multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            query_instrumenters = schema.instrumenters[:query]
-            multiplex_instrumenters = schema.instrumenters[:multiplex]
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
+            multiplex_analyzers = schema.multiplex_analyzers
+            if multiplex.max_complexity
+              multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+            end
 
-            # First, run multiplex instrumentation, then query instrumentation for each query
-            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-              each_query_call_hooks(query_instrumenters, queries) do
-                schema = multiplex.schema
-                multiplex_analyzers = schema.multiplex_analyzers
-                queries = multiplex.queries
-                if multiplex.max_complexity
-                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            begin
+              # Since this is basically the batching context,
+              # share it for a whole multiplex
+              multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
+              # Do as much eager evaluation of the query as possible
+              results = []
+              queries.each_with_index do |query, idx|
+                if query.subscription? && !query.subscription_update?
+                  query.context.namespace(:subscriptions)[:events] = []
                 end
-
-                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-                begin
-                  # Since this is basically the batching context,
-                  # share it for a whole multiplex
-                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
-                  # Do as much eager evaluation of the query as possible
-                  results = []
-                  queries.each_with_index do |query, idx|
-                    multiplex.dataloader.append_job {
-                      operation = query.selected_operation
-                      result = if operation.nil? || !query.valid? || query.context.errors.any?
-                        NO_OPERATION
-                      else
-                        begin
-                          # Although queries in a multiplex _share_ an Interpreter instance,
-                          # they also have another item of state, which is private to that query
-                          # in particular, assign it here:
-                          runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
-                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
-                          query.current_trace.execute_query(query: query) do
-                            runtime.run_eager
-                          end
-                        rescue GraphQL::ExecutionError => err
-                          query.context.errors << err
-                          NO_OPERATION
-                        end
+                multiplex.dataloader.append_job {
+                  operation = query.selected_operation
+                  result = if operation.nil? || !query.valid? || query.context.errors.any?
+                    NO_OPERATION
+                  else
+                    begin
+                      # Although queries in a multiplex _share_ an Interpreter instance,
+                      # they also have another item of state, which is private to that query
+                      # in particular, assign it here:
+                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      query.context.namespace(:interpreter_runtime)[:runtime] = runtime
+
+                      query.current_trace.execute_query(query: query) do
+                        runtime.run_eager
                       end
-                      results[idx] = result
-                    }
+                    rescue GraphQL::ExecutionError => err
+                      query.context.errors << err
+                      NO_OPERATION
+                    end
                   end
+                  results[idx] = result
+                }
+              end
 
-                  multiplex.dataloader.run
-
-                  # Then, work through lazy results in a breadth-first way
-                  multiplex.dataloader.append_job {
-                    query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                    queries = multiplex ? multiplex.queries : [query]
-                    final_values = queries.map do |query|
-                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                      # it might not be present if the query has an error
-                      runtime ? runtime.final_result : nil
-                    end
-                    final_values.compact!
-                    multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                      Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                    end
-                  }
-                  multiplex.dataloader.run
+              multiplex.dataloader.run
 
-                  # Then, find all errors and assign the result to the query object
-                  results.each_with_index do |data_result, idx|
-                    query = queries[idx]
-                    # Assign the result so that it can be accessed in instrumentation
-                    query.result_values = if data_result.equal?(NO_OPERATION)
-                      if !query.valid? || query.context.errors.any?
-                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
-                        { "errors" => query.static_errors.map(&:to_h) }
-                      else
-                        data_result
-                      end
-                    else
-                      result = {
-                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
-                      }
+              # Then, work through lazy results in a breadth-first way
+              multiplex.dataloader.append_job {
+                query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+                queries = multiplex ? multiplex.queries : [query]
+                final_values = queries.map do |query|
+                  runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                  # it might not be present if the query has an error
+                  runtime ? runtime.final_result : nil
+                end
+                final_values.compact!
+                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
+                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
+                end
+              }
+              multiplex.dataloader.run
 
-                      if query.context.errors.any?
-                        error_result = query.context.errors.map(&:to_h)
-                        result["errors"] = error_result
-                      end
+              # Then, find all errors and assign the result to the query object
+              results.each_with_index do |data_result, idx|
+                query = queries[idx]
+                if (events = query.context.namespace(:subscriptions)[:events]) && events.any?
+                  schema.subscriptions.write_subscription(query, events)
+                end
+                # Assign the result so that it can be accessed in instrumentation
+                query.result_values = if data_result.equal?(NO_OPERATION)
+                  if !query.valid? || query.context.errors.any?
+                    # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                    { "errors" => query.static_errors.map(&:to_h) }
+                  else
+                    data_result
+                  end
+                else
+                  result = {
+                    "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
+                  }
 
-                      result
-                    end
-                    if query.context.namespace?(:__query_result_extensions__)
-                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
-                    end
-                    # Get the Query::Result, not the Hash
-                    results[idx] = query.result
+                  if query.context.errors.any?
+                    error_result = query.context.errors.map(&:to_h)
+                    result["errors"] = error_result
                   end
 
-                  results
-                rescue Exception
-                  # TODO rescue at a higher level so it will catch errors in analysis, too
-                  # Assign values here so that the query's `@executed` becomes true
-                  queries.map { |q| q.result_values ||= {} }
-                  raise
-                ensure
-                  queries.map { |query|
-                    runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                    if runtime
-                      runtime.delete_all_interpreter_context
-                    end
-                  }
+                  result
+                end
+                if query.context.namespace?(:__query_result_extensions__)
+                  query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
                 end
+                # Get the Query::Result, not the Hash
+                results[idx] = query.result
               end
-            end
-          end
-        end
-
-        private
 
-        # 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
+              results
+            rescue Exception
+              # TODO rescue at a higher level so it will catch errors in analysis, too
+              # Assign values here so that the query's `@executed` becomes true
+              queries.map { |q| q.result_values ||= {} }
+              raise
+            ensure
+              queries.map { |query|
+                runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                if runtime
+                  runtime.delete_all_interpreter_context
+                end
               }
-            }
-          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
 

data/lib/graphql/introspection/entry_points.rb

@@ -9,13 +9,19 @@ module GraphQL
 
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
-        schema = @context.query.schema
+        schema = context.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.wrap(schema, @context)
+        schema_type.wrap(schema, context)
       end
 
       def __type(name:)
-        context.warden.reachable_type?(name) ? context.warden.get_type(name) : nil
+        if context.warden.reachable_type?(name)
+          context.warden.get_type(name)
+        elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
+          type
+        else
+          nil
+        end
       end
     end
   end

data/lib/graphql/introspection/schema_type.rb

@@ -20,7 +20,9 @@ module GraphQL
       end
 
       def types
-        @context.warden.reachable_types.sort_by(&:graphql_name)
+        types = context.warden.reachable_types + context.schema.extra_types
+        types.sort_by!(&:graphql_name)
+        types
       end
 
       def query_type

data/lib/graphql/language/document_from_schema_definition.rb

@@ -266,8 +266,7 @@ module GraphQL
         end
         definitions = build_directive_nodes(dirs_to_build)
 
-        type_nodes = build_type_definition_nodes(warden.reachable_types)
-
+        type_nodes = build_type_definition_nodes(warden.reachable_types + schema.extra_types)
         if @include_one_of
           # This may have been set to true when iterating over all types
           definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))

data/lib/graphql/language/parser.rb

@@ -333,7 +333,7 @@ module GraphQL
             v_loc = pos
             description = if at?(:STRING); string_value; end
             defn_loc = pos
-            enum_value = expect_token_value(:IDENTIFIER)
+            enum_value = parse_enum_name
             v_directives = parse_directives
             list << EnumValueDefinition.new(pos: v_loc, definition_pos: defn_loc, description: description, name: enum_value, directives: v_directives, filename: @filename, source_string: @graphql_str)
           end

data/lib/graphql/pagination/array_connection.rb

@@ -35,10 +35,10 @@ module GraphQL
       def load_nodes
         @nodes ||= begin
           sliced_nodes = if before && after
-            end_idx = index_from_cursor(before)-1
+            end_idx = index_from_cursor(before) - 2
             end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
           elsif before
-            end_idx = index_from_cursor(before)-2
+            end_idx = index_from_cursor(before) - 2
             end_idx < 0 ? [] : items[0..end_idx] || []
           elsif after
             items[index_from_cursor(after)..-1] || []
@@ -56,7 +56,7 @@ module GraphQL
             false
           end
 
-          @has_next_page = if first
+          @has_next_page = if first_value && first
             # There are more items after these items
             sliced_nodes.count > first
           elsif before

data/lib/graphql/pagination/relation_connection.rb

@@ -29,14 +29,14 @@ module GraphQL
 
       def has_next_page
         if @has_next_page.nil?
-          @has_next_page = if before_offset && before_offset > 0
-            true
-          elsif first
+          @has_next_page = if first && first_value
             if @nodes && @nodes.count < first
               false
             else
               relation_larger_than(sliced_nodes, @sliced_nodes_offset, first)
             end
+          elsif before_offset && before_offset > 0
+            true
           else
             false
           end

data/lib/graphql/query/validation_pipeline.rb

@@ -14,7 +14,7 @@ module GraphQL
     #
     # @api private
     class ValidationPipeline
-      attr_reader :max_depth, :max_complexity
+      attr_reader :max_depth, :max_complexity, :validate_timeout_remaining
 
       def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
@@ -71,7 +71,7 @@ module GraphQL
           validator = @query.static_validator || @schema.static_validator
           validation_result = validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-
+          @validate_timeout_remaining = validation_result[:remaining_timeout]
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
           end

data/lib/graphql/query/variables.rb

@@ -26,7 +26,7 @@ module GraphQL
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
           variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
-          if variable_type.nil?
+          if variable_type.nil? || !variable_type.unwrap.kind.input?
             # Pass -- it will get handled by a validator
           else
             variable_name = ast_variable.name
@@ -80,12 +80,12 @@ module GraphQL
         else
           val
         end
-      end    
+      end
 
       def add_max_errors_reached_message
         message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
         validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message) 
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
       end
     end
   end

data/lib/graphql/query.rb

@@ -317,7 +317,7 @@ module GraphQL
     end
 
     def_delegators :validation_pipeline, :validation_errors,
-                   :analyzers, :ast_analyzers, :max_depth, :max_complexity
+                   :analyzers, :ast_analyzers, :max_depth, :max_complexity, :validate_timeout_remaining
 
     attr_accessor :analysis_errors
     def valid?

data/lib/graphql/schema/enum.rb

@@ -14,7 +14,7 @@ module GraphQL
     #   #   ONIONS
     #   #   PEPPERS
     #   # }
-    #   class PizzaTopping < GraphQL::Enum
+    #   class PizzaTopping < GraphQL::Schema::Enum
     #     value :MUSHROOMS
     #     value :ONIONS
     #     value :PEPPERS

data/lib/graphql/schema.rb

@@ -814,6 +814,26 @@ 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
@@ -1044,6 +1064,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
 

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.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/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,8 +81,10 @@ 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)
           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

data/lib/graphql/tracing/sentry_trace.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module SentryTrace
+      include PlatformTrace
+
+      {
+        "lex" => "graphql.lex",
+        "parse" => "graphql.parse",
+        "validate" => "graphql.validate",
+        "analyze_query" => "graphql.analyze",
+        "analyze_multiplex" => "graphql.analyze_multiplex",
+        "execute_multiplex" => "graphql.execute_multiplex",
+        "execute_query" => "graphql.execute",
+        "execute_query_lazy" => "graphql.execute"
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+        def #{trace_method}(**data, &block)
+          instrument_execution("#{platform_key}", "#{trace_method}", data, &block)
+        end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, &block)
+        instrument_execution(platform_key, "execute_field", &block)
+      end
+
+      def platform_execute_field_lazy(platform_key, &block)
+        instrument_execution(platform_key, "execute_field_lazy", &block)
+      end
+
+      def platform_authorized(platform_key, &block)
+        instrument_execution(platform_key, "authorized", &block)
+      end
+
+      def platform_authorized_lazy(platform_key, &block)
+        instrument_execution(platform_key, "authorized_lazy", &block)
+      end
+
+      def platform_resolve_type(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type", &block)
+      end
+
+      def platform_resolve_type_lazy(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type_lazy", &block)
+      end
+
+      def platform_field_key(field)
+        "graphql.field.#{field.path}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
+
+      private
+
+      def instrument_execution(platform_key, trace_method, data=nil, &block)
+        return yield unless Sentry.initialized?
+
+        Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|
+          result = block.call
+          span.finish
+
+          if trace_method == "execute_multiplex" && data.key?(:multiplex)
+            operation_names = data[:multiplex].queries.map{|q| operation_name(q) }
+            span.set_description(operation_names.join(", "))
+          elsif trace_method == "execute_query" && data.key?(:query)
+            span.set_description(operation_name(data[:query]))
+            span.set_data('graphql.document', data[:query].query_string)
+            span.set_data('graphql.operation.name', data[:query].selected_operation_name) if data[:query].selected_operation_name
+            span.set_data('graphql.operation.type', data[:query].selected_operation.operation_type)
+          end
+
+          result
+        end
+      end
+
+      def operation_name(query)
+        selected_op = query.selected_operation
+        if selected_op
+          [selected_op.operation_type, selected_op.name].compact.join(' ')
+        else
+          'GraphQL Operation'
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/tracing/trace"
 require "graphql/tracing/legacy_trace"
+require "graphql/tracing/legacy_hooks_trace"
 
 # Legacy tracing:
 require "graphql/tracing/active_support_notifications_tracing"
@@ -21,11 +22,12 @@ require "graphql/tracing/appsignal_trace"
 require "graphql/tracing/data_dog_trace"
 require "graphql/tracing/new_relic_trace"
 require "graphql/tracing/notifications_trace"
+require "graphql/tracing/sentry_trace"
 require "graphql/tracing/scout_trace"
 require "graphql/tracing/statsd_trace"
 require "graphql/tracing/prometheus_trace"
 if defined?(PrometheusExporter::Server)
-  require "graphql/tracing/prometheus_tracing/graphql_collector"
+  require "graphql/tracing/prometheus_trace/graphql_collector"
 end
 
 module GraphQL

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.2.4"
+  VERSION = "2.2.6"
 end

data/lib/graphql.rb

@@ -120,5 +120,4 @@ require "graphql/backtrace"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
-require "graphql/deprecation"
 require "graphql/testing"

data/readme.md

@@ -7,7 +7,7 @@ A Ruby implementation of [GraphQL](https://graphql.org/).
 
 - [Website](https://graphql-ruby.org/)
 - [API Documentation](https://www.rubydoc.info/github/rmosolgo/graphql-ruby)
-- [Newsletter](https://tinyletter.com/graphql-ruby)
+- [Newsletter](https://buttondown.email/graphql-ruby)
 
 ## Installation
 
@@ -34,7 +34,17 @@ Or, see ["Getting Started"](https://graphql-ruby.org/getting_started.html).
 
 ## Upgrade
 
-I also sell [GraphQL::Pro](https://graphql.pro) which provides several features on top of the GraphQL runtime, including [Pundit authorization](https://graphql-ruby.org/authorization/pundit_integration), [CanCan authorization](https://graphql-ruby.org/authorization/can_can_integration), [Pusher-based subscriptions](https://graphql-ruby.org/subscriptions/pusher_implementation) and [persisted queries](https://graphql-ruby.org/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
+I also sell [GraphQL::Pro](https://graphql.pro) which provides several features on top of the GraphQL runtime, including:
+
+- [Persisted queries](https://graphql-ruby.org/operation_store/overview)
+- [API versioning](https://graphql-ruby.org/changesets/overview)
+- [Streaming payloads](https://graphql-ruby.org/defer/overview)
+- [Server-side caching](https://graphql-ruby.org/object_cache/overview)
+- [Rate limiters](https://graphql-ruby.org/limiters/overview)
+- Subscriptions backends for [Pusher](https://graphql-ruby.org/subscriptions/pusher_implementation) and [Ably](https://graphql-ruby.org/subscriptions/ably_implementation)
+- Authorization plugins for [Pundit](https://graphql-ruby.org/authorization/pundit_integration) and  [CanCan](https://graphql-ruby.org/authorization/can_can_integration)
+
+Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
 
 ## Goals
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 2.2.6
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-03 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc
@@ -315,7 +315,6 @@ files:
 - lib/graphql/dataloader/request_all.rb
 - lib/graphql/dataloader/source.rb
 - lib/graphql/date_encoding_error.rb
-- lib/graphql/deprecation.rb
 - lib/graphql/dig.rb
 - lib/graphql/duration_encoding_error.rb
 - lib/graphql/execution.rb
@@ -551,7 +550,6 @@ files:
 - lib/graphql/subscriptions/broadcast_analyzer.rb
 - lib/graphql/subscriptions/default_subscription_resolve_extension.rb
 - lib/graphql/subscriptions/event.rb
-- lib/graphql/subscriptions/instrumentation.rb
 - lib/graphql/subscriptions/serialize.rb
 - lib/graphql/testing.rb
 - lib/graphql/testing/helpers.rb
@@ -564,6 +562,7 @@ files:
 - lib/graphql/tracing/appsignal_tracing.rb
 - lib/graphql/tracing/data_dog_trace.rb
 - lib/graphql/tracing/data_dog_tracing.rb
+- lib/graphql/tracing/legacy_hooks_trace.rb
 - lib/graphql/tracing/legacy_trace.rb
 - lib/graphql/tracing/new_relic_trace.rb
 - lib/graphql/tracing/new_relic_tracing.rb
@@ -572,10 +571,11 @@ files:
 - lib/graphql/tracing/platform_trace.rb
 - lib/graphql/tracing/platform_tracing.rb
 - lib/graphql/tracing/prometheus_trace.rb
+- lib/graphql/tracing/prometheus_trace/graphql_collector.rb
 - lib/graphql/tracing/prometheus_tracing.rb
-- lib/graphql/tracing/prometheus_tracing/graphql_collector.rb
 - lib/graphql/tracing/scout_trace.rb
 - lib/graphql/tracing/scout_tracing.rb
+- lib/graphql/tracing/sentry_trace.rb
 - lib/graphql/tracing/statsd_trace.rb
 - lib/graphql/tracing/statsd_tracing.rb
 - lib/graphql/tracing/trace.rb
@@ -615,7 +615,7 @@ metadata:
   changelog_uri: https://github.com/rmosolgo/graphql-ruby/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
-  mailing_list_uri: https://tinyletter.com/graphql-ruby
+  mailing_list_uri: https://buttondown.email/graphql-ruby
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -631,7 +631,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby

data/lib/graphql/deprecation.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Deprecation
-    def self.warn(message)
-      Kernel.warn(message)
-    end
-  end
-end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Subscriptions
-    # Wrap the root fields of the subscription type with special logic for:
-    # - Registering the subscription during the first execution
-    # - Evaluating the triggered portion(s) of the subscription during later execution
-    class Instrumentation
-      def initialize(schema:)
-        @schema = schema
-      end
-
-      # If needed, prepare to gather events which this query subscribes to
-      def before_query(query)
-        if query.subscription? && !query.subscription_update?
-          query.context.namespace(:subscriptions)[:events] = []
-        end
-      end
-
-      # After checking the root fields, pass the gathered events to the store
-      def after_query(query)
-        events = query.context.namespace(:subscriptions)[:events]
-        if events && events.any?
-          @schema.subscriptions.write_subscription(query, events)
-        end
-      end
-    end
-  end
-end