graphql 2.0.21 → 2.0.32

data/lib/graphql/schema.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/schema/addition"
+require "graphql/schema/always_visible"
 require "graphql/schema/base_64_encoder"
 require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
@@ -157,14 +158,25 @@ module GraphQL
       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
+          case mode
+          when :default
+            superclass_base_class = if superclass.respond_to?(:trace_class_for)
+              superclass.trace_class_for(mode)
+            else
+              GraphQL::Tracing::Trace
+            end
+            Class.new(superclass_base_class)
+          when :default_backtrace
+            schema_base_class = trace_class_for(:default)
+            Class.new(schema_base_class) do
+              include(GraphQL::Backtrace::Trace)
+            end
           else
-            GraphQL::Tracing::Trace
+            mods = trace_modules_for(mode)
+            Class.new(trace_class_for(:default)) do
+              mods.any? && include(*mods)
+            end
           end
-          Class.new(base_class)
         end
       end
 
@@ -179,6 +191,19 @@ module GraphQL
         nil
       end
 
+      def own_trace_modules
+        @own_trace_modules ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Array<Module>] Modules added for tracing in `trace_mode`, including inherited ones
+      def trace_modules_for(trace_mode)
+        modules = own_trace_modules[trace_mode]
+        if superclass.respond_to?(:trace_modules_for)
+          modules += superclass.trace_modules_for(trace_mode)
+        end
+        modules
+      end
+
 
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
@@ -244,11 +269,13 @@ module GraphQL
       end
 
       def default_filter
-        GraphQL::Filter.new(except: default_mask, silence_deprecation_warning: true)
+        GraphQL::Filter.new(except: default_mask)
       end
 
       def default_mask(new_mask = nil)
         if new_mask
+          line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
+          GraphQL::Deprecation.warn("GraphQL::Filter and Schema.mask are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
           @own_default_mask = new_mask
         else
           @own_default_mask || find_inherited_value(:default_mask, Schema::NullMask)
@@ -418,6 +445,18 @@ module GraphQL
         @root_types
       end
 
+      def warden_class
+        if defined?(@warden_class)
+          @warden_class
+        elsif superclass.respond_to?(:warden_class)
+          superclass.warden_class
+        else
+          GraphQL::Schema::Warden
+        end
+      end
+
+      attr_writer :warden_class
+
       # @param type [Module] The type definition whose possible types you want to see
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.
@@ -959,10 +998,8 @@ module GraphQL
       end
 
       def tracer(new_tracer)
-        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."
-        else
-          trace_mode(:default, Class.new(GraphQL::Tracing::LegacyTrace))
+        if !(trace_class_for(:default) < GraphQL::Tracing::CallLegacyTracers)
+          trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
 
         own_tracers << new_tracer
@@ -976,28 +1013,58 @@ module GraphQL
       # will be called at runtime.
       #
       # @param trace_mod [Module] A module that implements tracing methods
+      # @param mode [Symbol] Trace module will only be used for this trade mode
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [void]
-      def trace_with(trace_mod, **options)
-        trace_options.merge!(options)
-        trace_class.include(trace_mod)
+      def trace_with(trace_mod, mode: :default, **options)
+        if mode.is_a?(Array)
+          mode.each { |m| trace_with(trace_mod, mode: m, **options) }
+        else
+          tc = trace_class_for(mode)
+          tc.include(trace_mod)
+          if mode != :default
+            own_trace_modules[mode] << trace_mod
+          end
+          t_opts = trace_options_for(mode)
+          t_opts.merge!(options)
+        end
+        nil
       end
 
-      def trace_options
-        @trace_options ||= superclass.respond_to?(:trace_options) ? superclass.trace_options.dup : {}
+      # The options hash for this trace mode
+      # @return [Hash]
+      def trace_options_for(mode)
+        @trace_options_for_mode ||= {}
+        @trace_options_for_mode[mode] ||= begin
+          if superclass.respond_to?(:trace_options_for)
+            superclass.trace_options_for(mode).dup
+          else
+            {}
+          end
+        end
       end
 
-      def new_trace(**options)
-        if defined?(@trace_options)
-          options = trace_options.merge(options)
-        end
-        trace_mode = if (target = options[:query] || options[:multiplex]) && target.context[:backtrace]
+      # Create a trace instance which will include the trace modules specified for the optional mode.
+      #
+      # @param mode [Symbol] Trace modules for this trade mode will be included
+      # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
+      # @return [Tracing::Trace]
+      def new_trace(mode: nil, **options)
+        target = options[:query] || options[:multiplex]
+        mode ||= target && target.context[:trace_mode]
+
+        trace_mode = if mode
+          mode
+        elsif target && target.context[:backtrace]
           :default_backtrace
         else
           :default
         end
-        trace = trace_class_for(trace_mode).new(**options)
-        trace
+
+        base_trace_options = trace_options_for(trace_mode)
+        trace_options = base_trace_options.merge(options)
+        trace_class_for_mode = trace_class_for(trace_mode)
+        trace_class_for_mode.new(**trace_options)
       end
 
       def query_analyzer(new_analyzer)
@@ -1036,7 +1103,9 @@ module GraphQL
           {
             backtrace: ctx[:backtrace],
             tracers: ctx[:tracers],
+            trace: ctx[:trace],
             dataloader: ctx[:dataloader],
+            trace_mode: ctx[:trace_mode],
           }
         else
           {}

data/lib/graphql/tracing/appoptics_trace.rb

@@ -28,6 +28,8 @@ module GraphQL
         Gem::Version.new('1.0.0')
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       [
         'lex',
         'parse',
@@ -55,20 +57,41 @@ module GraphQL
         RUBY
       end
 
-      def platform_execute_field(platform_key, data)
-        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
-        layer = platform_key
-        kvs = metadata(data, layer)
+      # rubocop:enable Development/NoEvalCop
 
-        ::AppOpticsAPM::SDK.trace(layer, kvs) do
-          kvs.clear # we don't have to send them twice
-          yield
+      def execute_field(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_key_cache[AppOpticsTrace].platform_field_key_cache[field]
+        else
+          nil
+        end
+        if platform_key && trace_field
+          return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+          layer = platform_key
+          kvs = metadata({query: query, field: field, ast_node: ast_node, arguments: arguments, object: object}, layer)
+
+          ::AppOpticsAPM::SDK.trace(layer, kvs) do
+            kvs.clear # we don't have to send them twice
+            super
+          end
+        else
+          super
         end
       end
 
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+        execute_field(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+      end
+
       def authorized(**data)
         return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
-        layer = @platform_authorized_key_cache[data[:type]]
+        layer = @platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
         kvs = metadata(data, layer)
 
         ::AppOpticsAPM::SDK.trace(layer, kvs) do
@@ -79,7 +102,7 @@ module GraphQL
 
       def authorized_lazy(**data)
         return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
-        layer = @platform_authorized_key_cache[data[:type]]
+        layer = @platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
         kvs = metadata(data, layer)
 
         ::AppOpticsAPM::SDK.trace(layer, kvs) do
@@ -90,7 +113,8 @@ module GraphQL
 
       def resolve_type(**data)
         return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
-        layer = @platform_resolve_type_key_cache[data[:type]]
+        layer = @platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
+
         kvs = metadata(data, layer)
 
         ::AppOpticsAPM::SDK.trace(layer, kvs) do
@@ -101,7 +125,7 @@ module GraphQL
 
       def resolve_type_lazy(**data)
         return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
-        layer = @platform_resolve_type_key_cache[data[:type]]
+        layer = @platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
         kvs = metadata(data, layer)
 
         ::AppOpticsAPM::SDK.trace(layer, kvs) do

data/lib/graphql/tracing/appsignal_trace.rb

@@ -13,6 +13,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
@@ -43,6 +45,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key)
         Appsignal.instrument(platform_key) do
           yield

data/lib/graphql/tracing/data_dog_trace.rb

@@ -3,24 +3,25 @@
 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
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         'lex' => 'lex.graphql',
         'parse' => 'parse.graphql',
@@ -33,12 +34,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'
@@ -53,10 +51,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
@@ -66,61 +62,104 @@ module GraphQL
                   RUBY
                 end
               }
-              prepare_span("#{trace_method.sub("platform_", "")}", data, span)
+              if @has_prepare_span
+                prepare_span("#{trace_method.sub("platform_", "")}", data, span)
+              end
               super
             end
           end
         RUBY
       end
 
-      def platform_execute_field(platform_key, data, span_key = "execute_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)
+      # rubocop:enable Development/NoEvalCop
+
+      def execute_field_span(span_key, 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_key_cache[DataDogTrace].platform_field_key_cache[field]
+        else
+          nil
+        end
+        if platform_key && trace_field
+          @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)
+            end
+            yield
           end
-          prepare_span(span_key, data, span)
+        else
           yield
         end
       end
+      def execute_field(query:, field:, ast_node:, arguments:, object:)
+        execute_field_span("execute_field", query, field, ast_node, arguments, object) do
+          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        end
+      end
 
-      def platform_execute_field_lazy(platform_key, data, &block)
-        platform_execute_field(platform_key, data, "execute_field_lazy", &block)
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+        execute_field_span("execute_field_lazy", query, field, ast_node, arguments, object) do
+          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        end
       end
 
-      def authorized(object:, type:, query:, span_key: "authorized")
-        platform_key = @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
-          prepare_span(span_key, {object: object, type: type, query: query}, span)
+      def authorized(query:, type:, object:)
+        authorized_span("authorized", object, type, query) do
           super(query: query, type: type, object: object)
         end
       end
 
-      def authorized_lazy(**kwargs, &block)
-        authorized(span_key: "authorized_lazy", **kwargs, &block)
-      end
+      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, type: 'custom') do |span|
+          span.set_tag('component', 'graphql')
+          span.set_tag('operation', span_key)
 
-      def resolve_type(object:, type:, query:, span_key: "resolve_type")
-        platform_key = @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)
+          if @has_prepare_span
+            prepare_span(span_key, {object: object, type: type, query: query}, span)
           end
-          prepare_span(span_key, {object: object, type: type, query: query}, span)
+          yield
+        end
+      end
+
+      def authorized_lazy(object:, type:, query:)
+        authorized_span("authorized_lazy", object, type, query) do
           super(query: query, type: type, object: object)
         end
       end
 
-      def resolve_type_lazy(**kwargs, &block)
-        resolve_type(span_key: "resolve_type_lazy", **kwargs, &block)
+      def resolve_type(object:, type:, query:)
+        resolve_type_span("resolve_type", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
+      end
+
+      def resolve_type_lazy(object:, type:, query:)
+        resolve_type_span("resolve_type_lazy", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
+      end
+
+      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, 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
+          yield
+        end
       end
 
       include PlatformTrace
@@ -129,8 +168,8 @@ module GraphQL
       # @param key [String] The event being traced
       # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
       # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
-      def prepare_span(key, data, span)
-      end
+      # def prepare_span(key, data, span)
+      # end
 
       def platform_field_key(field)
         field.path

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_trace.rb

@@ -4,7 +4,7 @@ module GraphQL
     # 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
+    module CallLegacyTracers
       def lex(query_string:)
         (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
       end
@@ -61,5 +61,9 @@ module GraphQL
         query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
       end
     end
+
+    class LegacyTrace < Trace
+      include CallLegacyTracers
+    end
   end
 end

data/lib/graphql/tracing/notifications_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     # This implementation forwards events to a notification handler (i.e.
@@ -14,12 +16,15 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
         "validate" => "validate.graphql",
         "analyze_multiplex" => "analyze_multiplex.graphql",
         "analyze_query" => "analyze_query.graphql",
+        "execute_multiplex" => "execute_multiplex.graphql",
         "execute_query" => "execute_query.graphql",
         "execute_query_lazy" => "execute_query_lazy.graphql",
         "execute_field" => "execute_field.graphql",
@@ -36,6 +41,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       include PlatformTrace
     end
   end