graphql 2.0.23 → 2.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aade8e5f88eb3dd8e8d6148aa7e8e00b0a351422b090e02a911158f425f1905
-  data.tar.gz: 1ee1e4529f0b1f68596ce73f2b171624637999f0a1d6fc03f377c46fc7756a78
+  metadata.gz: 289b06689b36a3673c053d13d2ce0835a089e92db60e3e24e8af791fdd934d81
+  data.tar.gz: 3c5257c0732d0729b97ac92376427ccba26ef66397f9b9d07c18e9792ea03251
 SHA512:
-  metadata.gz: 8b9cd861e35c529674bdacb6e1a34864bca6852c030022215ecc028d2b36b20da120be4ee45bb5ac5fb906b856e78dc4cfbbcf55609ad47fc47e6d68422a26b1
-  data.tar.gz: b4afc463a0c9058396f274c9224f5a6b0bca73fefc68c1e6f10e53eea24b95b89ef6d9ddd3e22929d90be69b7c46bd81e6ed134ddab2550cbfc4408aee29b8ef
+  metadata.gz: 72ad503ed008aa168a63c1a40ac9e44dbb9b2d6a7871f1cd6191a692d6275506ce17f0df3135ae0a2ef95fe695a457d76239a2623f477cf7cd7f27cc124888c7
+  data.tar.gz: 90976b77a4230bf8a7d3fe5470deae70082e6caac1d3b30c799e958621cd2177283d0f83eb06128081e7e2179e33e718a1ba9353ab388fac83553e0988e7b4bc

data/lib/generators/graphql/mutation_delete_generator.rb

@@ -6,7 +6,7 @@ module Graphql
     # TODO: What other options should be supported?
     #
     # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
-    #     rails g graphql:mutation CreatePostMutation
+    #     rails g graphql:mutation DeletePostMutation
     class MutationDeleteGenerator < OrmMutationsBase
 
       desc "Scaffold a Relay Classic ORM delete mutation for the given model class"

data/lib/generators/graphql/mutation_update_generator.rb

@@ -6,7 +6,7 @@ module Graphql
     # TODO: What other options should be supported?
     #
     # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
-    #     rails g graphql:mutation CreatePostMutation
+    #     rails g graphql:mutation UpdatePostMutation
     class MutationUpdateGenerator < OrmMutationsBase
 
       desc "Scaffold a Relay Classic ORM update mutation for the given model class"

data/lib/graphql/dataloader/source.rb

@@ -7,9 +7,9 @@ module GraphQL
       # @api private
       def setup(dataloader)
         # These keys have been requested but haven't been fetched yet
-        @pending_keys = []
+        @pending = {}
         # These keys have been passed to `fetch` but haven't been finished yet
-        @fetching_keys = []
+        @fetching = {}
         # { key => result }
         @results = {}
         @dataloader = dataloader
@@ -18,42 +18,66 @@ module GraphQL
       attr_reader :dataloader
 
       # @return [Dataloader::Request] a pending request for a value from `key`. Call `.load` on that object to wait for the result.
-      def request(key)
-        if !@results.key?(key)
-          @pending_keys << key
+      def request(value)
+        res_key = result_key_for(value)
+        if !@results.key?(res_key)
+          @pending[res_key] ||= value
         end
-        Dataloader::Request.new(self, key)
+        Dataloader::Request.new(self, value)
+      end
+
+      # Implement this method to return a stable identifier if different
+      # key objects should load the same data value.
+      #
+      # @param value [Object] A value passed to `.request` or `.load`, for which a value will be loaded
+      # @return [Object] The key for tracking this pending data
+      def result_key_for(value)
+        value
       end
 
       # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
-      def request_all(keys)
-        pending_keys = keys.select { |k| !@results.key?(k) }
-        @pending_keys.concat(pending_keys)
-        Dataloader::RequestAll.new(self, keys)
+      def request_all(values)
+        values.each do |v|
+          res_key = result_key_for(v)
+          if !@results.key?(res_key)
+            @pending[res_key] ||= v
+          end
+        end
+        Dataloader::RequestAll.new(self, values)
       end
 
-      # @param key [Object] A loading key which will be passed to {#fetch} if it isn't already in the internal cache.
+      # @param value [Object] A loading value which will be passed to {#fetch} if it isn't already in the internal cache.
       # @return [Object] The result from {#fetch} for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
-      def load(key)
-        if @results.key?(key)
-          result_for(key)
+      def load(value)
+        result_key = result_key_for(value)
+        if @results.key?(result_key)
+          result_for(result_key)
         else
-          @pending_keys << key
-          sync
-          result_for(key)
+          @pending[result_key] ||= value
+          sync([result_key])
+          result_for(result_key)
         end
       end
 
-      # @param keys [Array<Object>] Loading keys which will be passed to `#fetch` (or read from the internal cache).
+      # @param values [Array<Object>] Loading keys which will be passed to `#fetch` (or read from the internal cache).
       # @return [Object] The result from {#fetch} for `keys`. If `keys` haven't been loaded yet, the Fiber will yield until they're loaded.
-      def load_all(keys)
-        if keys.any? { |k| !@results.key?(k) }
-          pending_keys = keys.select { |k| !@results.key?(k) }
-          @pending_keys.concat(pending_keys)
-          sync
+      def load_all(values)
+        result_keys = []
+        pending_keys = []
+        values.each { |v|
+          k = result_key_for(v)
+          result_keys << k
+          if !@results.key?(k)
+            @pending[k] ||= v
+            pending_keys << k
+          end
+        }
+
+        if pending_keys.any?
+          sync(pending_keys)
         end
 
-        keys.map { |k| result_for(k) }
+        result_keys.map { |k| result_for(k) }
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
@@ -67,14 +91,13 @@ module GraphQL
       # Wait for a batch, if there's anything to batch.
       # Then run the batch and update the cache.
       # @return [void]
-      def sync
-        pending_keys = @pending_keys.dup
+      def sync(pending_result_keys)
         @dataloader.yield
         iterations = 0
-        while pending_keys.any? { |k| !@results.key?(k) }
+        while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
           if iterations > 1000
-            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_keys}), but they still weren't loaded. There is likely a circular dependency."
+            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
           end
           @dataloader.yield
         end
@@ -83,15 +106,18 @@ module GraphQL
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        !@pending_keys.empty?
+        !@pending.empty?
       end
 
       # Add these key-value pairs to this source's cache
       # (future loads will use these merged values).
-      # @param results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @param new_results [Hash<Object => Object>] key-value pairs to cache in this source
       # @return [void]
-      def merge(results)
-        @results.merge!(results)
+      def merge(new_results)
+        new_results.each do |new_k, new_v|
+          key = result_key_for(new_k)
+          @results[key] = new_v
+        end
         nil
       end
 
@@ -99,24 +125,22 @@ module GraphQL
       # @api private
       # @return [void]
       def run_pending_keys
-        if !@fetching_keys.empty?
-          @pending_keys -= @fetching_keys
+        if !@fetching.empty?
+          @fetching.each_key { |k| @pending.delete(k) }
         end
-        return if @pending_keys.empty?
-        fetch_keys = @pending_keys.uniq
-        @fetching_keys.concat(fetch_keys)
-        @pending_keys = []
-        results = fetch(fetch_keys)
-        fetch_keys.each_with_index do |key, idx|
+        return if @pending.empty?
+        fetch_h = @pending
+        @pending = {}
+        @fetching.merge!(fetch_h)
+        results = fetch(fetch_h.values)
+        fetch_h.each_with_index do |(key, _value), idx|
           @results[key] = results[idx]
         end
         nil
       rescue StandardError => error
-        fetch_keys.each { |key| @results[key] = error }
+        fetch_h.each_key { |key| @results[key] = error }
       ensure
-        if fetch_keys
-          @fetching_keys -= fetch_keys
-        end
+        fetch_h && fetch_h.each_key { |k| @fetching.delete(k) }
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -137,7 +161,7 @@ module GraphQL
         [*batch_args, **batch_kwargs]
       end
 
-      attr_reader :pending_keys
+      attr_reader :pending
 
       private
 

data/lib/graphql/dataloader.rb

@@ -111,8 +111,8 @@ module GraphQL
       @source_cache.each do |source_class, batched_sources|
         batched_sources.each do |batch_args, batched_source_instance|
           if batched_source_instance.pending?
-            prev_pending_keys[batched_source_instance] = batched_source_instance.pending_keys.dup
-            batched_source_instance.pending_keys.clear
+            prev_pending_keys[batched_source_instance] = batched_source_instance.pending.dup
+            batched_source_instance.pending.clear
           end
         end
       end
@@ -127,8 +127,8 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
-      prev_pending_keys.each do |source_instance, pending_keys|
-        source_instance.pending_keys.concat(pending_keys)
+      prev_pending_keys.each do |source_instance, pending|
+        source_instance.pending.merge!(pending)
       end
     end
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -247,15 +247,15 @@ module GraphQL
           st = get_current_runtime_state
           st.current_object = query.root_value
           st.current_result = @response
-          object_proxy = authorized_new(root_type, query.root_value, context)
-          object_proxy = schema.sync_lazy(object_proxy)
+          runtime_object = root_type.wrap(query.root_value, context)
+          runtime_object = schema.sync_lazy(runtime_object)
 
-          if object_proxy.nil?
+          if runtime_object.nil?
             # Root .authorized? returned false.
             @response = nil
           else
-            call_method_on_directives(:resolve, object_proxy, root_operation.directives) do # execute query level directives
-              gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
+            call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
+              gathered_selections = gather_selections(runtime_object, root_type, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
               # make a new, isolated result hash for writing the result into. (That isolated response
@@ -280,9 +280,9 @@ module GraphQL
                   if (directives = selections[:graphql_directives])
                     selections.delete(:graphql_directives)
                   end
-                  call_method_on_directives(:resolve, object_proxy, directives) do
+                  call_method_on_directives(:resolve, runtime_object, directives) do
                     evaluate_selections(
-                      object_proxy,
+                      runtime_object,
                       root_type,
                       root_op_type == "mutation",
                       selections,
@@ -438,10 +438,8 @@ module GraphQL
           st.current_result = selections_result
           st.current_result_name = result_name
 
-          object = owner_object
-
           if is_introspection
-            object = authorized_new(field_defn.owner, object, context)
+            owner_object = field_defn.owner.wrap(owner_object, context)
           end
 
           total_args_count = field_defn.arguments(context).size
@@ -449,14 +447,14 @@ module GraphQL
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
             end
           else
-            @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+            @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
             end
           end
         end
@@ -774,7 +772,7 @@ module GraphQL
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(current_type, value, context)
+              current_type.wrap(value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
@@ -1047,10 +1045,6 @@ module GraphQL
           end
         end
 
-        def authorized_new(type, value, context)
-          type.authorized_new(value, context)
-        end
-
         def lazy?(object)
           obj_class = object.class
           is_lazy = @lazy_cache[obj_class]

data/lib/graphql/introspection/entry_points.rb

@@ -11,7 +11,7 @@ module GraphQL
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.authorized_new(schema, @context)
+        schema_type.wrap(schema, @context)
       end
 
       def __type(name:)

data/lib/graphql/query/validation_pipeline.rb

@@ -68,7 +68,8 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          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])
 
           if @validation_errors.empty?

data/lib/graphql/query.rb

@@ -45,6 +45,20 @@ module GraphQL
       end
     end
 
+    # @return [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules.
+    attr_reader :static_validator
+
+    # @param new_validate [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules. This can't be reasssigned after validation.
+    def static_validator=(new_validator)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#static_validator= after validation has run, remove this assignment."
+      elsif !new_validator.is_a?(GraphQL::StaticValidation::Validator)
+        raise ArgumentError, "Expected a `GraphQL::StaticValidation::Validator` instance."
+      else
+        @static_validator = new_validator
+      end
+    end
+
     attr_writer :query_string
 
     # @return [GraphQL::Language::Nodes::Document]
@@ -83,7 +97,7 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
@@ -97,6 +111,7 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
+      self.static_validator = static_validator if static_validator
       context_tracers = (context ? context.fetch(:tracers, []) : [])
       @tracers = schema.tracers + context_tracers
 

data/lib/graphql/schema/addition.rb

@@ -40,14 +40,21 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        dirs = owner.directives.map(&:class)
-        @directives.merge(dirs)
-        add_type_and_traverse(dirs)
+        if (dir_instances = owner.directives).any?
+          dirs = dir_instances.map(&:class)
+          @directives.merge(dirs)
+          add_type_and_traverse(dirs)
+        end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        path = []
+        new_types.each do |t|
+          path.push(t.graphql_name)
+          add_type(t, owner: nil, late_types: late_types, path: path)
+          path.pop
+        end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
           type_owner, lt = late_type_vals
@@ -158,7 +165,9 @@ module GraphQL
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
             references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+            path.push(arg.graphql_name)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path)
+            path.pop
             if arg.default_value?
               @arguments_with_default_values << arg
             end
@@ -179,18 +188,21 @@ module GraphQL
               name = field.graphql_name
               field_type = field.type.unwrap
               references_to(field_type, from: field)
-              field_path = path + [name]
-              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              path.push(name)
+              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg.graphql_name])
+                path.push(arg.graphql_name)
+                add_type(arg_type, owner: arg, late_types: late_types, path: path)
+                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
+              path.pop
             end
           end
           if type.kind.input_object?
@@ -198,7 +210,9 @@ module GraphQL
               add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+              path.push(arg.graphql_name)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path)
+              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
@@ -206,14 +220,18 @@ module GraphQL
           end
           if type.kind.union?
             @possible_types[type.graphql_name] = type.all_possible_types
+            path.push("possible_types")
             type.all_possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.interface?
+            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.object?
             possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
@@ -221,6 +239,7 @@ module GraphQL
           end
 
           if type.kind.object? || type.kind.interface?
+            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
@@ -235,8 +254,9 @@ module GraphQL
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+              add_type(interface_type, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
         end
       end

data/lib/graphql/schema/field.rb

@@ -339,7 +339,7 @@ module GraphQL
           self.validates(validates)
         end
 
-        if definition_block
+        if block_given?
           if definition_block.arity == 1
             yield self
           else

data/lib/graphql/schema/introspection_system.rb

@@ -155,7 +155,7 @@ module GraphQL
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
-          wrapped_object = @object_class.authorized_new(obj, query_ctx)
+          wrapped_object = @object_class.wrap(obj, query_ctx)
           @inner_resolve.call(wrapped_object, args, ctx)
         end
       end

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

@@ -109,7 +109,14 @@ module GraphQL
               to_type_name(something.name)
             end
           when String
-            something.gsub(/\]\[\!/, "").split("::").last
+            if something.include?("]") ||
+                something.include?("[") ||
+                something.include?("!") ||
+                something.include?("::")
+              something.gsub(/\]\[\!/, "").split("::").last
+            else
+              something
+            end
           when GraphQL::Schema::NonNull, GraphQL::Schema::List
             to_type_name(something.unwrap)
           else
@@ -122,7 +129,8 @@ module GraphQL
           return string unless string.include?("_")
           camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
-          if (match_data = string.match(/\A(_+)/))
+          if string.start_with?("_")
+            match_data = string.match(/\A(_+)/)
             camelized = "#{match_data[0]}#{camelized}"
           end
           camelized

data/lib/graphql/schema/object.rb

@@ -30,6 +30,11 @@ module GraphQL
         # @see authorized_new to make instances
         protected :new
 
+        # This is called by the runtime to return an object to call methods on.
+        def wrap(object, context)
+          authorized_new(object, context)
+        end
+
         # Make a new instance of this type _if_ the auth check passes,
         # otherwise, raise an error.
         #

data/lib/graphql/schema.rb

@@ -158,16 +158,24 @@ module GraphQL
       def trace_class_for(mode)
         @trace_modes ||= {}
         @trace_modes[mode] ||= begin
-          if mode == :default_backtrace
+          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
-          elsif superclass.respond_to?(:trace_class_for)
-            superclass_base_class = superclass.trace_class_for(mode)
-            Class.new(superclass_base_class)
           else
-            Class.new(GraphQL::Tracing::Trace)
+            mods = trace_modules_for(mode)
+            Class.new(trace_class_for(:default)) do
+              mods.any? && include(*mods)
+            end
           end
         end
       end
@@ -183,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}
@@ -992,26 +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)
-        options = trace_options.merge(options)
-        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)
@@ -1052,6 +1105,7 @@ module GraphQL
             tracers: ctx[:tracers],
             trace: ctx[:trace],
             dataloader: ctx[:dataloader],
+            trace_mode: ctx[:trace_mode],
           }
         else
           {}

data/lib/graphql/tracing/appoptics_trace.rb

@@ -55,20 +55,39 @@ 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)
-
-        ::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 +98,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 +109,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 +121,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/data_dog_trace.rb

@@ -18,6 +18,7 @@ module GraphQL
         @analytics_enabled = analytics_available && Datadog::Contrib::Analytics.enabled?(analytics_enabled)
         @analytics_sample_rate = analytics_sample_rate
         @service_name = service
+        @has_prepare_span = respond_to?(:prepare_span)
         super
       end
 
@@ -66,38 +67,60 @@ 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)
+      def execute_field(span_key = "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[DataDogTrace].platform_field_key_cache[field]
+        else
+          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
+            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
+            super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
           end
-          prepare_span(span_key, data, span)
-          yield
+        else
+          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("execute_field_lazy", query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
       end
 
       def authorized(object:, type:, query:, span_key: "authorized")
-        platform_key = @platform_authorized_key_cache[type]
+        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
-          prepare_span(span_key, {object: object, type: type, query: query}, span)
+          if @has_prepare_span
+            prepare_span(span_key, {object: object, type: type, query: query}, span)
+          end
           super(query: query, type: type, object: object)
         end
       end
@@ -107,14 +130,16 @@ module GraphQL
       end
 
       def resolve_type(object:, type:, query:, span_key: "resolve_type")
-        platform_key = @platform_resolve_type_key_cache[type]
+        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
-          prepare_span(span_key, {object: object, type: type, query: query}, span)
+          if @has_prepare_span
+            prepare_span(span_key, {object: object, type: type, query: query}, span)
+          end
           super(query: query, type: type, object: object)
         end
       end
@@ -129,8 +154,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/platform_trace.rb

@@ -5,12 +5,22 @@ module GraphQL
     module PlatformTrace
       def initialize(trace_scalars: false, **_options)
         @trace_scalars = trace_scalars
-        @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }
-        @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }
-        @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }
+
+        @platform_key_cache = Hash.new { |h, mod| h[mod] = mod::KeyCache.new }
         super
       end
 
+      module BaseKeyCache
+        def initialize
+          @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }
+          @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }
+          @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }
+        end
+
+        attr_reader :platform_field_key_cache, :platform_authorized_key_cache, :platform_resolve_type_key_cache
+      end
+
+
       def platform_execute_field_lazy(*args, &block)
         platform_execute_field(*args, &block)
       end
@@ -24,10 +34,11 @@ module GraphQL
       end
 
       def self.included(child_class)
-        # Don't gather this unless necessary
-        pass_data_to_execute_field = child_class.method_defined?(:platform_execute_field) &&
-          child_class.instance_method(:platform_execute_field).arity != 1
-
+        key_methods_class = Class.new {
+          include(child_class)
+          include(BaseKeyCache)
+        }
+        child_class.const_set(:KeyCache, key_methods_class)
         [:execute_field, :execute_field_lazy].each do |field_trace_method|
           if !child_class.method_defined?(field_trace_method)
             child_class.module_eval <<-RUBY, __FILE__, __LINE__
@@ -39,12 +50,12 @@ module GraphQL
                   true
                 end
                 platform_key = if trace_field
-                  @platform_field_key_cache[field]
+                  @platform_key_cache[#{child_class}].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
+                  platform_#{field_trace_method}(platform_key) do
                     super
                   end
                 else
@@ -60,7 +71,7 @@ module GraphQL
           if !child_class.method_defined?(auth_trace_method)
             child_class.module_eval <<-RUBY, __FILE__, __LINE__
               def #{auth_trace_method}(type:, query:, object:)
-                platform_key = @platform_authorized_key_cache[type]
+                platform_key = @platform_key_cache[#{child_class}].platform_authorized_key_cache[type]
                 platform_#{auth_trace_method}(platform_key) do
                   super
                 end
@@ -73,7 +84,7 @@ module GraphQL
           if !child_class.method_defined?(rt_trace_method)
             child_class.module_eval <<-RUBY, __FILE__, __LINE__
               def #{rt_trace_method}(query:, type:, object:)
-                platform_key = @platform_resolve_type_key_cache[type]
+                platform_key = @platform_key_cache[#{child_class}].platform_resolve_type_key_cache[type]
                 platform_#{rt_trace_method}(platform_key) do
                   super
                 end
@@ -83,8 +94,6 @@ module GraphQL
         end
       end
 
-
-
       private
 
       # Get the transaction name based on the operation type and name if possible, or fall back to a user provided

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.23
+  version: 2.0.25
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -623,7 +623,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby