graphql 2.0.24 → 2.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c97d63232efb5f7ecdaef0f8102a73ceaa4a4b0a3b06c7ab1f613735efafa59
-  data.tar.gz: aff3df56a3db15d97f457e92fffab33f29440fed5ca84b0515794ad051e5631e
+  metadata.gz: 289b06689b36a3673c053d13d2ce0835a089e92db60e3e24e8af791fdd934d81
+  data.tar.gz: 3c5257c0732d0729b97ac92376427ccba26ef66397f9b9d07c18e9792ea03251
 SHA512:
-  metadata.gz: 3cf33d0ed4df848c57e459f9ee023b0a6b2814d14ef09d7c304120a595cd62e65f25b05b3f16448c89cfb9479d06e550611c42fa76b3fb92a677c788f31f713e
-  data.tar.gz: 28b8d5e3fb2d6cc0bc3ebbdaf6f6d53dc16b0225bcafcc0fe72d4956afb9ff0fdb1ca929093ad466951dc28a30d893e643c8fb68bff69df374e41e1c43e2980b
+  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([key])
-          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)
+      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,13 +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)
+      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
@@ -82,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
 
@@ -98,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
@@ -136,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/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.24"
+  VERSION = "2.0.25"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.24
+  version: 2.0.25
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-27 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.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby