graphql 2.0.20 → 2.0.21

data/lib/graphql/schema.rb

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

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

@@ -26,11 +26,19 @@ module GraphQL
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
-          else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          selection_strs = ast_node.selections.map do |n|
+            case n
+            when GraphQL::Language::Nodes::InlineFragment
+              "\"... on #{n.type.name} { ... }\""
+            when GraphQL::Language::Nodes::Field
+              "\"#{n.name}\""
+            when GraphQL::Language::Nodes::FragmentSpread
+              "\"#{n.name}\""
+            else
+              raise "Invariant: unexpected selection node: #{n}"
+            end
           end
+          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else

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

@@ -9,7 +9,7 @@ module GraphQL
       # without ambiguity.
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
-      NO_ARGS = {}.freeze
+      NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
@@ -323,7 +323,7 @@ module GraphQL
         end
       end
 
-      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+      NO_SELECTIONS = [GraphQL::EmptyObjects::EMPTY_HASH, GraphQL::EmptyObjects::EMPTY_ARRAY].freeze
 
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
         if node.selections.empty?

data/lib/graphql/tracing/appsignal_trace.rb

@@ -55,6 +55,12 @@ module GraphQL
         end
       end
 
+      def platform_resolve_type(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
       def platform_field_key(field)
         "#{field.owner.graphql_name}.#{field.graphql_name}.graphql"
       end

data/lib/graphql/tracing/legacy_trace.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    class LegacyTrace < Trace
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/notifications_trace.rb

@@ -6,7 +6,6 @@ module GraphQL
     # ActiveSupport::Notifications or Dry::Monitor::Notifications)
     # with a `graphql` suffix.
     module NotificationsTrace
-      include PlatformTrace
       # Initialize a new NotificationsTracing instance
       #
       # @param engine [#instrument(key, metadata, block)] The notifications engine to use
@@ -36,6 +35,8 @@ module GraphQL
           end
         RUBY
       end
+
+      include PlatformTrace
     end
   end
 end

data/lib/graphql/tracing/platform_trace.rb

@@ -29,28 +29,30 @@ module GraphQL
           child_class.instance_method(:platform_execute_field).arity != 1
 
         [:execute_field, :execute_field_lazy].each do |field_trace_method|
-          child_class.module_eval <<-RUBY, __FILE__, __LINE__
-            def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
-              return_type = field.type.unwrap
-              trace_field = if return_type.kind.scalar? || return_type.kind.enum?
-                (field.trace.nil? && @trace_scalars) || field.trace
-              else
-                true
-              end
-              platform_key = if trace_field
-                @platform_field_key_cache[field]
-              else
-                nil
-              end
-              if platform_key && trace_field
-                platform_#{field_trace_method}(platform_key#{pass_data_to_execute_field ? ", { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }" : ""}) do
+          if !child_class.method_defined?(field_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
+                return_type = field.type.unwrap
+                trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+                  (field.trace.nil? && @trace_scalars) || field.trace
+                else
+                  true
+                end
+                platform_key = if trace_field
+                  @platform_field_key_cache[field]
+                else
+                  nil
+                end
+                if platform_key && trace_field
+                  platform_#{field_trace_method}(platform_key#{pass_data_to_execute_field ? ", { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }" : ""}) do
+                    super
+                  end
+                else
                   super
                 end
-              else
-                super
               end
-            end
-          RUBY
+            RUBY
+          end
         end
 
 

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -5,7 +5,7 @@ module GraphQL
     class PrometheusTracing < PlatformTracing
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
-          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+          @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
             'graphql_duration_seconds',
             'Time spent in GraphQL operations, in seconds'
           )

data/lib/graphql/tracing/trace.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This is the base class for a `trace` instance whose methods are called during query execution.
+    # "Trace modes" are subclasses of this with custom tracing modules mixed in.
+    #
+    # A trace module may implement any of the methods on `Trace`, being sure to call `super`
+    # to continue any tracing hooks and call the actual runtime behavior. See {GraphQL::Backtrace::Trace} for example.
+    #
+    class Trace
+      # @param multiplex [GraphQL::Execution::Multiplex, nil]
+      # @param query [GraphQL::Query, nil]
+      def initialize(multiplex: nil, query: nil, **_options)
+        @multiplex = multiplex
+        @query = query
+      end
+
+      def lex(query_string:)
+        yield
+      end
+
+      def parse(query_string:)
+        yield
+      end
+
+      def validate(query:, validate:)
+        yield
+      end
+
+      def analyze_multiplex(multiplex:)
+        yield
+      end
+
+      def analyze_query(query:)
+        yield
+      end
+
+      def execute_multiplex(multiplex:)
+        yield
+      end
+
+      def execute_query(query:)
+        yield
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        yield
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def authorized(query:, type:, object:)
+        yield
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        yield
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

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

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -69,6 +69,10 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
 
   NOT_CONFIGURED = Object.new
   private_constant :NOT_CONFIGURED
+  module EmptyObjects
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+  end
 end
 
 # Order matters for these:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.20
+  version: 2.0.21
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-30 00:00:00.000000000 Z
+date: 2023-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -303,6 +303,7 @@ files:
 - lib/graphql/backtrace.rb
 - lib/graphql/backtrace/inspect_result.rb
 - lib/graphql/backtrace/table.rb
+- lib/graphql/backtrace/trace.rb
 - lib/graphql/backtrace/traced_error.rb
 - lib/graphql/backtrace/tracer.rb
 - lib/graphql/coercion_error.rb
@@ -555,6 +556,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_trace.rb
 - lib/graphql/tracing/new_relic_trace.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_trace.rb
@@ -568,6 +570,7 @@ files:
 - lib/graphql/tracing/scout_tracing.rb
 - lib/graphql/tracing/statsd_trace.rb
 - lib/graphql/tracing/statsd_tracing.rb
+- lib/graphql/tracing/trace.rb
 - lib/graphql/type_kinds.rb
 - lib/graphql/types.rb
 - lib/graphql/types/big_int.rb