graphql 2.5.14 → 2.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: deb0ac3bea401c53909c6880f133ee810f3e0882c7a023ed33b27f7b12a4c82b
-  data.tar.gz: be2d8e55d131a62863d4ecf6665c22c9ba6c9ba467bdd205ec83d96f9b952098
+  metadata.gz: a45427a56efb8b050895ed510b7519a7d6093940220141c5a3853af60cf666b5
+  data.tar.gz: 5d7d99e8b9ceb05b43995cb2095bbf317b379ed659b8df4783716989f0eb2105
 SHA512:
-  metadata.gz: 494296336070a677965ceaaad1e14412f1b8a6589ab3ae3466c5c00071a59f763f2af2df8aacd394c9fd912afd0a5f9df988991411213dbfab285d762d1a6e75
-  data.tar.gz: 8d65056236ddb32eabe498d93bb026f8d7ea145b627d6a4554b2add2d8c00db202f9bbe16cae816e58aeb6dd77f3e8aed99dcaa802af2643f73b03a5d10b0b63
+  metadata.gz: 45080489ddda5c4d9f50eb3cfdc63cb21bfbe8b0f7890ca68e21d9533e8f794ce466eaab8986b1c7356e4f1a1aaf6811baf451ab41a0ee94320a520037e5f442
+  data.tar.gz: 97581b7186279e55ac3465546d99d46f03638be88662b09c6d0423ff238e69d7ff56860f8cea50b1fbb62b7c6a89c9ea344b4d69f71ffc5f36780b956f1e9228

data/lib/graphql/date_encoding_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
     def initialize(value)
       @date_value = value
-      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+      super("Date cannot be parsed: #{value}. \nDate must be able to be parsed as a Ruby Date object.")
     end
   end
 end

data/lib/graphql/execution/interpreter.rb

@@ -80,7 +80,6 @@ module GraphQL
                       end
                     rescue GraphQL::ExecutionError => err
                       query.context.errors << err
-                      NO_OPERATION
                     end
                   end
                   results[idx] = result

data/lib/graphql/language/document_from_schema_definition.rb

@@ -52,8 +52,9 @@ module GraphQL
 
       def build_object_type_node(object_type)
         ints = @types.interfaces(object_type)
+
         if !ints.empty?
-          ints.sort_by!(&:graphql_name)
+          ints = ints.sort_by(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
         end
 

data/lib/graphql/schema/directive.rb

@@ -142,7 +142,14 @@ module GraphQL
                 # However, we're using result coercion here to go from Ruby value
                 # to GraphQL value, so it doesn't have that feature.
                 # Keep the GraphQL-type behavior but implement it manually:
-                coerce_value = [coerce_value]
+                wrap_type = arg_type
+                while wrap_type.list?
+                  if wrap_type.non_null?
+                    wrap_type = wrap_type.of_type
+                  end
+                  wrap_type = wrap_type.of_type
+                  coerce_value = [coerce_value]
+                end
               end
               arg_type.coerce_isolated_result(coerce_value)
             rescue GraphQL::Schema::Enum::UnresolvedValueError

data/lib/graphql/schema/validator/required_validator.rb

@@ -8,6 +8,13 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
+      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # skip validation in this case instead.
+      #
+      # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
+      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      #
       # @example Require exactly one of these arguments
       #
       #   field :update_amount, IngredientAmount, null: false do
@@ -37,15 +44,17 @@ module GraphQL
       class RequiredValidator < Validator
         # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
         # @param argument [Symbol] An argument that is required for this field
+        # @param allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
+        def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
-            [argument]
+            [ argument ]
           else
             raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
           end
+          @allow_all_hidden = allow_all_hidden.nil? ? !!argument : allow_all_hidden
           @message = message
           super(**default_options)
         end
@@ -54,10 +63,17 @@ module GraphQL
           fully_matched_conditions = 0
           partially_matched_conditions = 0
 
+          visible_keywords = context.types.arguments(@validated).map(&:keyword)
+          no_visible_conditions = true
+
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
+                if no_visible_conditions && visible_keywords.include?(one_of_condition)
+                  no_visible_conditions = false
+                end
+
                 if value.key?(one_of_condition)
                   fully_matched_conditions += 1
                 end
@@ -66,6 +82,9 @@ module GraphQL
                 full_match = true
 
                 one_of_condition.each do |k|
+                  if no_visible_conditions && visible_keywords.include?(k)
+                    no_visible_conditions = false
+                  end
                   if value.key?(k)
                     any_match = true
                   else
@@ -88,6 +107,18 @@ module GraphQL
             end
           end
 
+          if no_visible_conditions
+            if @allow_all_hidden
+              return nil
+            else
+              raise GraphQL::Error, <<~ERR
+                #{@validated.path} validates `required: ...` but all required arguments were hidden.
+
+                Update your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`
+              ERR
+            end
+          end
+
           if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else

data/lib/graphql/schema/visibility.rb

@@ -10,9 +10,9 @@ module GraphQL
     class Visibility
       # @param schema [Class<GraphQL::Schema>]
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
-      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
+      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging?) : nil), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze

data/lib/graphql/schema.rb

@@ -1708,7 +1708,7 @@ module GraphQL
       # If you need to support previous, non-spec behavior which allowed selecting union fields
       # but *not* selecting any fields on that union, set this to `true` to continue allowing that behavior.
       #
-      # If this is `true`, then {.legacy_invalid_empty_selections_on_union} will be called with {Query} objects
+      # If this is `true`, then {.legacy_invalid_empty_selections_on_union_with_type} will be called with {Query} objects
       # with that kind of selections. You must implement that method
       # @param new_value [Boolean]
       # @return [true, false, nil]
@@ -1724,6 +1724,22 @@ module GraphQL
         end
       end
 
+      # This method is called during validation when a previously-allowed, but non-spec
+      # query is encountered where a union field has no child selections on it.
+      #
+      # If `legacy_invalid_empty_selections_on_union_with_type` is overridden, this method will not be called.
+      #
+      # You should implement this method or `legacy_invalid_empty_selections_on_union_with_type`
+      # to log the violation so that you can contact clients and notify them about changing their queries.
+      # Then return a suitable value to tell GraphQL-Ruby how to continue.
+      # @param query [GraphQL::Query]
+      # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
+      # @return [String] A validation error to return for this query
+      # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
+      def legacy_invalid_empty_selections_on_union(query)
+        raise "Implement `def self.legacy_invalid_empty_selections_on_union_with_type(query, type)` or `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      end
+
       # This method is called during validation when a previously-allowed, but non-spec
       # query is encountered where a union field has no child selections on it.
       #
@@ -1731,11 +1747,12 @@ module GraphQL
       # and notify them about changing their queries. Then return a suitable value to
       # tell GraphQL-Ruby how to continue.
       # @param query [GraphQL::Query]
+      # @param type1 [Module] A GraphQL type definition
       # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
       # @return [String] A validation error to return for this query
       # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
-      def legacy_invalid_empty_selections_on_union(query)
-        raise "Implement `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      def legacy_invalid_empty_selections_on_union_with_type(query, type)
+        legacy_invalid_empty_selections_on_union(query)
       end
 
       # This setting controls how GraphQL-Ruby handles overlapping selections on scalar types when the types

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

@@ -49,7 +49,7 @@ module GraphQL
           if !resolved_type.kind.fields?
             case @schema.allow_legacy_invalid_empty_selections_on_union
             when true
-              legacy_invalid_empty_selection_result = @schema.legacy_invalid_empty_selections_on_union(@context.query)
+              legacy_invalid_empty_selection_result = @schema.legacy_invalid_empty_selections_on_union_with_type(@context.query, resolved_type)
               case legacy_invalid_empty_selection_result
               when :return_validation_error
                 # keep `return_validation_error = true`
@@ -61,7 +61,7 @@ module GraphQL
                 return_validation_error = false
                 legacy_invalid_empty_selection_result = nil
               else
-                raise GraphQL::InvariantError, "Unexpected return value from legacy_invalid_empty_selections_on_union, must be `:return_validation_error`, String, or nil (got: #{legacy_invalid_empty_selection_result.inspect})"
+                raise GraphQL::InvariantError, "Unexpected return value from legacy_invalid_empty_selections_on_union_with_type, must be `:return_validation_error`, String, or nil (got: #{legacy_invalid_empty_selection_result.inspect})"
               end
             when false
               # pass -- error below

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -81,6 +81,7 @@ module GraphQL
     #       end
     #   end
     #
+    # @see GraphQL::Testing::MockActionCable for test helpers
     class ActionCableSubscriptions < GraphQL::Subscriptions
       SUBSCRIPTION_PREFIX = "graphql-subscription:"
       EVENT_PREFIX = "graphql-event:"

data/lib/graphql/testing/mock_action_cable.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+module GraphQL
+  module Testing
+    # A stub implementation of ActionCable.
+    # Any methods to support the mock backend have `mock` in the name.
+    #
+    # @example Configuring your schema to use MockActionCable in the test environment
+    #   class MySchema < GraphQL::Schema
+    #     # Use MockActionCable in test:
+    #     use GraphQL::Subscriptions::ActionCableSubscriptions,
+    #       action_cable: Rails.env.test? ? GraphQL::Testing::MockActionCable : ActionCable
+    #   end
+    #
+    # @example Clearing old data before each test
+    #   setup do
+    #     GraphQL::Testing::MockActionCable.clear_mocks
+    #   end
+    #
+    # @example Using MockActionCable in a test case
+    #   # Create a channel to use in the test, pass it to GraphQL
+    #   mock_channel = GraphQL::Testing::MockActionCable.get_mock_channel
+    #   ActionCableTestSchema.execute("subscription { newsFlash { text } }", context: { channel: mock_channel })
+    #
+    #   # Trigger a subscription update
+    #   ActionCableTestSchema.subscriptions.trigger(:news_flash, {}, {text: "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"})
+    #
+    #   # Check messages on the channel
+    #   expected_msg = {
+    #     result: {
+    #       "data" => {
+    #         "newsFlash" => {
+    #           "text" => "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"
+    #         }
+    #       }
+    #     },
+    #     more: true,
+    #   }
+    #   assert_equal [expected_msg], mock_channel.mock_broadcasted_messages
+    #
+    class MockActionCable
+      class MockChannel
+        def initialize
+          @mock_broadcasted_messages = []
+        end
+
+        # @return [Array<Hash>] Payloads "sent" to this channel by GraphQL-Ruby
+        attr_reader :mock_broadcasted_messages
+
+        # Called by ActionCableSubscriptions. Implements a Rails API.
+        def stream_from(stream_name, coder: nil, &block)
+          # Rails uses `coder`, we don't
+          block ||= ->(msg) { @mock_broadcasted_messages << msg }
+          MockActionCable.mock_stream_for(stream_name).add_mock_channel(self, block)
+        end
+      end
+
+      # Used by mock code
+      # @api private
+      class MockStream
+        def initialize
+          @mock_channels = {}
+        end
+
+        def add_mock_channel(channel, handler)
+          @mock_channels[channel] = handler
+        end
+
+        def mock_broadcast(message)
+          @mock_channels.each do |channel, handler|
+            handler && handler.call(message)
+          end
+        end
+      end
+
+      class << self
+        # Call this before each test run to make sure that MockActionCable's data is empty
+        def clear_mocks
+          @mock_streams = {}
+        end
+
+        # Implements Rails API
+        def server
+          self
+        end
+
+        # Implements Rails API
+        def broadcast(stream_name, message)
+          stream = @mock_streams[stream_name]
+          stream && stream.mock_broadcast(message)
+        end
+
+        # Used by mock code
+        def mock_stream_for(stream_name)
+          @mock_streams[stream_name] ||= MockStream.new
+        end
+
+        # Use this as `context[:channel]` to simulate an ActionCable channel
+        #
+        # @return [GraphQL::Testing::MockActionCable::MockChannel]
+        def get_mock_channel
+          MockChannel.new
+        end
+
+        # @return [Array<String>] Streams that currently have subscribers
+        def mock_stream_names
+          @mock_streams.keys
+        end
+      end
+    end
+  end
+end

data/lib/graphql/testing.rb

@@ -1,2 +1,3 @@
 # frozen_string_literal: true
 require "graphql/testing/helpers"
+require "graphql/testing/mock_action_cable"

data/lib/graphql/tracing/detailed_trace.rb

@@ -9,8 +9,12 @@ module GraphQL
     # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
     # overriding the one in `context[:trace_mode]`.
     #
+    # By default, the detailed tracer calls `.inspect` on application objects returned from fields. You can customize
+    # this behavior by extending {DetailedTrace} and overriding {#inspect_object}. You can opt out of debug annotations
+    # entirely with `use ..., debug: false` or for a single query with `context: { detailed_trace_debug: false }`.
+    #
     # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
-    # You can configure this database to retail all data (persistent) or to expire data according to your rules.
+    # You can configure this database to retain all data (persistent) or to expire data according to your rules.
     # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
     #
     # @example Adding the sampler to your schema
@@ -27,10 +31,29 @@ module GraphQL
     #   end
     #
     # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
+    #
+    # @example Customizing debug output in traces
+    #   class CustomDetailedTrace < GraphQL::Tracing::DetailedTrace
+    #     def inspect_object(object)
+    #       if object.is_a?(SomeThing)
+    #         # handle it specially ...
+    #       else
+    #         super
+    #        end
+    #     end
+    #   end
+    #
+    # @example disabling debug annotations completely
+    #    use DetailedTrace, debug: false, ...
+    #
+    # @example disabling debug annotations for one query
+    #    MySchema.execute(query_str, context: { detailed_trace_debug: false })
+    #
     class DetailedTrace
       # @param redis [Redis] If provided, profiles will be stored in Redis for later review
       # @param limit [Integer] A maximum number of profiles to store
-      def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
+      # @param debug [Boolean] if `false`, it won't create `debug` annotations in Perfetto traces (reduces overhead)
+      def self.use(schema, trace_mode: :profile_sample, memory: false, debug: debug?, redis: nil, limit: nil)
         storage = if redis
           RedisBackend.new(redis: redis, limit: limit)
         elsif memory
@@ -38,13 +61,15 @@ module GraphQL
         else
           raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
         end
-        schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
+        detailed_trace = self.new(storage: storage, trace_mode: trace_mode, debug: debug)
+        schema.detailed_trace = detailed_trace
         schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
       end
 
-      def initialize(storage:, trace_mode:)
+      def initialize(storage:, trace_mode:, debug:)
         @storage = storage
         @trace_mode = trace_mode
+        @debug = debug
       end
 
       # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true`
@@ -55,6 +80,11 @@ module GraphQL
         @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
       end
 
+      # @return [Boolean]
+      def debug?
+        @debug
+      end
+
       # @param last [Integer]
       # @param before [Integer] Timestamp in milliseconds since epoch
       # @return [Enumerable<StoredTrace>]
@@ -77,6 +107,24 @@ module GraphQL
         @storage.delete_all_traces
       end
 
+      def inspect_object(object)
+        self.class.inspect_object(object)
+      end
+
+      def self.inspect_object(object)
+        if defined?(ActiveRecord::Relation) && object.is_a?(ActiveRecord::Relation)
+          "#{object.class}, .to_sql=#{object.to_sql.inspect}"
+        else
+          object.inspect
+        end
+      end
+
+      # Default debug setting
+      # @return [true]
+      def self.debug?
+        true
+      end
+
       class StoredTrace
         def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:)
           @id = id

data/lib/graphql/tracing/perfetto_trace.rb

@@ -60,11 +60,37 @@ module GraphQL
       DA_FETCH_KEYS_IID = 13
       DA_STR_VAL_NIL_IID = 14
 
+      REVERSE_DEBUG_NAME_LOOKUP = {
+        DA_OBJECT_IID => "object",
+        DA_RESULT_IID => "result",
+        DA_ARGUMENTS_IID => "arguments",
+        DA_FETCH_KEYS_IID => "fetch keys",
+      }
+
+      DEBUG_INSPECT_CATEGORY_IIDS = [15]
+      DA_DEBUG_INSPECT_CLASS_IID = 16
+      DEBUG_INSPECT_EVENT_NAME_IID = 17
+      DA_DEBUG_INSPECT_FOR_IID = 18
+
       # @param active_support_notifications_pattern [String, RegExp, false] A filter for `ActiveSupport::Notifications`, if it's present. Or `false` to skip subscribing.
       def initialize(active_support_notifications_pattern: nil, save_profile: false, **_rest)
         super
         @active_support_notifications_pattern = active_support_notifications_pattern
         @save_profile = save_profile
+
+        query = if @multiplex
+          @multiplex.queries.first
+        else
+          @query # could still be nil in some initializations
+        end
+
+        @detailed_trace = query&.schema&.detailed_trace || DetailedTrace
+        @create_debug_annotations = if (ctx = query&.context).nil? || (ctx_debug = ctx[:detailed_trace_debug]).nil?
+          @detailed_trace.debug?
+        else
+          ctx_debug
+        end
+
         Fiber[:graphql_flow_stack] = nil
         @sequence_id = object_id
         @pid = Process.pid
@@ -110,6 +136,10 @@ module GraphQL
         @objects_counter_id = :objects_counter.object_id
         @fibers_counter_id = :fibers_counter.object_id
         @fields_counter_id = :fields_counter.object_id
+        @counts_objects = [@objects_counter_id]
+        @counts_objects_and_fields = [@objects_counter_id, @fields_counter_id]
+        @counts_fibers = [@fibers_counter_id]
+        @counts_fibers_and_objects = [@fibers_counter_id, @objects_counter_id]
         @begin_validate = nil
         @begin_time = nil
         @packets = []
@@ -132,16 +162,19 @@ module GraphQL
               EventCategory.new(name: "ActiveSupport::Notifications", iid: ACTIVE_SUPPORT_NOTIFICATIONS_CATEGORY_IIDS.first),
               EventCategory.new(name: "Authorized", iid: AUTHORIZED_CATEGORY_IIDS.first),
               EventCategory.new(name: "Resolve Type", iid: RESOLVE_TYPE_CATEGORY_IIDS.first),
+              EventCategory.new(name: "Debug Inspect", iid: DEBUG_INSPECT_CATEGORY_IIDS.first),
             ],
             debug_annotation_names: [
-              DebugAnnotationName.new(name: "object", iid: DA_OBJECT_IID),
-              DebugAnnotationName.new(name: "arguments", iid: DA_ARGUMENTS_IID),
-              DebugAnnotationName.new(name: "result", iid: DA_RESULT_IID),
-              DebugAnnotationName.new(name: "fetch keys", iid: DA_FETCH_KEYS_IID),
+              *REVERSE_DEBUG_NAME_LOOKUP.map { |(iid, name)| DebugAnnotationName.new(name: name, iid: iid) },
+              DebugAnnotationName.new(name: "inspect instance of", iid: DA_DEBUG_INSPECT_CLASS_IID),
+              DebugAnnotationName.new(name: "inspecting for", iid: DA_DEBUG_INSPECT_FOR_IID)
             ],
             debug_annotation_string_values: [
               InternedString.new(str: "(nil)", iid: DA_STR_VAL_NIL_IID),
             ],
+            event_names: [
+              EventName.new(name: "#{(@detailed_trace.is_a?(Class) ? @detailed_trace : @detailed_trace.class).name}#inspect_object", iid: DEBUG_INSPECT_EVENT_NAME_IID)
+            ],
           ),
           trusted_packet_sequence_id: @sequence_id,
           sequence_flags: 2,
@@ -180,11 +213,9 @@ module GraphQL
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
-          name: "Multiplex",
-          debug_annotations: [
-            payload_to_debug("query_string", multiplex.queries.map(&:sanitized_query_string).join("\n\n"))
-          ]
-        )
+          name: "Multiplex"
+        ) { [ payload_to_debug("query_string", multiplex.queries.map(&:sanitized_query_string).join("\n\n")) ] }
+
         result = super
 
         @packets << trace_packet(
@@ -209,7 +240,7 @@ module GraphQL
           track_uuid: fid,
           name: query.context.current_path.join("."),
           category_iids: FIELD_EXECUTE_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         @packets << packet
@@ -218,19 +249,23 @@ module GraphQL
       end
 
       def end_execute_field(field, object, arguments, query, app_result)
+        end_ts = ts
         start_field = fiber_flow_stack.pop
-        start_field.track_event = dup_with(start_field.track_event, {
-          debug_annotations: [
-            payload_to_debug(nil, object.object, iid: DA_OBJECT_IID, intern_value: true),
-            payload_to_debug(nil, arguments, iid: DA_ARGUMENTS_IID),
-            payload_to_debug(nil, app_result, iid: DA_RESULT_IID, intern_value: true)
-          ]
-        })
+        if @create_debug_annotations
+          start_field.track_event = dup_with(start_field.track_event,{
+            debug_annotations: [
+                payload_to_debug(nil, object.object, iid: DA_OBJECT_IID, intern_value: true),
+                payload_to_debug(nil, arguments, iid: DA_ARGUMENTS_IID),
+                payload_to_debug(nil, app_result, iid: DA_RESULT_IID, intern_value: true)
+              ]
+            })
+        end
 
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id, @fields_counter_id],
+          extra_counter_track_uuids: @counts_objects_and_fields,
           extra_counter_values: [count_allocations, count_fields],
         )
         super
@@ -240,22 +275,24 @@ module GraphQL
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
-          name: "Analysis",
-          debug_annotations: [
-            payload_to_debug("analyzers_count", analyzers.size),
-            payload_to_debug("analyzers", analyzers),
-          ]
-        )
+          name: "Analysis") {
+            [
+              payload_to_debug("analyzers_count", analyzers.size),
+              payload_to_debug("analyzers", analyzers),
+            ]
+          }
         super
       end
 
       def end_analyze_multiplex(m, analyzers)
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         super
@@ -265,50 +302,57 @@ module GraphQL
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
           name: "Parse"
         )
         result = super
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         result
       end
 
       def begin_validate(query, validate)
-        @packets << @begin_validate = trace_packet(
+        @begin_validate = trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
-          name: "Validate",
-          debug_annotations: [
-            payload_to_debug("validate?", validate),
-          ]
-        )
+          name: "Validate") {
+            [payload_to_debug("validate?", validate)]
+          }
+
+        @packets << @begin_validate
         super
       end
 
       def end_validate(query, validate, validation_errors)
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
-        @begin_validate.track_event = dup_with(
-          @begin_validate.track_event,
-          {
-            debug_annotations: [
-              @begin_validate.track_event.debug_annotations.first,
-              payload_to_debug("valid?", validation_errors.empty?)
-            ]
-          }
-        )
+
+        if @create_debug_annotations
+          new_bv_track_event = dup_with(
+            @begin_validate.track_event, {
+              debug_annotations: [
+                @begin_validate.track_event.debug_annotations.first,
+                payload_to_debug("valid?", validation_errors.empty?)
+              ]
+            }
+          )
+          @begin_validate.track_event = new_bv_track_event
+        end
         super
       end
 
@@ -318,7 +362,7 @@ module GraphQL
           track_uuid: fid,
           name: "Create Execution Fiber",
           category_iids: DATALOADER_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@fibers_counter_id, @objects_counter_id],
+          extra_counter_track_uuids: @counts_fibers_and_objects,
           extra_counter_values: [count_fibers(1), count_allocations]
         )
         @packets << track_descriptor_packet(@did, fid, "Exec Fiber ##{fid}")
@@ -331,7 +375,7 @@ module GraphQL
           track_uuid: fid,
           name: "Create Source Fiber",
           category_iids: DATALOADER_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@fibers_counter_id, @objects_counter_id],
+          extra_counter_track_uuids: @counts_fibers_and_objects,
           extra_counter_values: [count_fibers(1), count_allocations]
         )
         @packets << track_descriptor_packet(@did, fid, "Source Fiber ##{fid}")
@@ -385,7 +429,7 @@ module GraphQL
           track_uuid: fid,
           name: "Fiber Exit",
           category_iids: DATALOADER_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@fibers_counter_id],
+          extra_counter_track_uuids: @counts_fibers,
           extra_counter_values: [count_fibers(-1)],
         )
         super
@@ -415,31 +459,34 @@ module GraphQL
         fds = @flow_ids[source]
         fds_copy = fds.dup
         fds.clear
+
         packet = trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
           name_iid: @source_name_iids[source.class],
           category_iids: DATALOADER_CATEGORY_IIDS,
           flow_ids: fds_copy,
-          extra_counter_track_uuids: [@objects_counter_id],
-          extra_counter_values: [count_allocations],
-          debug_annotations: [
-            payload_to_debug(nil, source.pending.values, iid: DA_FETCH_KEYS_IID, intern_value: true),
-            *(source.instance_variables - [:@pending, :@fetching, :@results, :@dataloader]).map { |iv|
-              payload_to_debug(iv.to_s, source.instance_variable_get(iv), intern_value: true)
-            }
-          ]
-        )
+          extra_counter_track_uuids: @counts_objects,
+          extra_counter_values: [count_allocations]) {
+            [
+              payload_to_debug(nil, source.pending.values, iid: DA_FETCH_KEYS_IID, intern_value: true),
+              *(source.instance_variables - [:@pending, :@fetching, :@results, :@dataloader]).map { |iv|
+                payload_to_debug(iv.to_s, source.instance_variable_get(iv), intern_value: true)
+              }
+            ]
+          }
         @packets << packet
         fiber_flow_stack << packet
         super
       end
 
       def end_dataloader_source(source)
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         fiber_flow_stack.pop
@@ -451,7 +498,7 @@ module GraphQL
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
           category_iids: AUTHORIZED_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
           name_iid: @auth_name_iids[type],
         )
@@ -461,14 +508,18 @@ module GraphQL
       end
 
       def end_authorized(type, obj, ctx, is_authorized)
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         beg_auth = fiber_flow_stack.pop
-        beg_auth.track_event = dup_with(beg_auth.track_event, { debug_annotations: [payload_to_debug("authorized?", is_authorized)] })
+        if @create_debug_annotations
+          beg_auth.track_event = dup_with(beg_auth.track_event, { debug_annotations: [payload_to_debug("authorized?", is_authorized)] })
+        end
         super
       end
 
@@ -477,7 +528,7 @@ module GraphQL
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
           category_iids: RESOLVE_TYPE_CATEGORY_IIDS,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
           name_iid: @resolve_type_name_iids[type],
         )
@@ -487,14 +538,18 @@ module GraphQL
       end
 
       def end_resolve_type(type, value, context, resolved_type)
+        end_ts = ts
         @packets << trace_packet(
+          timestamp: end_ts,
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
-          extra_counter_track_uuids: [@objects_counter_id],
+          extra_counter_track_uuids: @counts_objects,
           extra_counter_values: [count_allocations],
         )
         rt_begin = fiber_flow_stack.pop
-        rt_begin.track_event = dup_with(rt_begin.track_event, { debug_annotations: [payload_to_debug("resolved_type", resolved_type, intern_value: true)] })
+        if @create_debug_annotations
+          rt_begin.track_event = dup_with(rt_begin.track_event, { debug_annotations: [payload_to_debug("resolved_type", resolved_type, intern_value: true)] })
+        end
         super
       end
 
@@ -546,7 +601,6 @@ module GraphQL
       def payload_to_debug(k, v, iid: nil, intern_value: false)
         if iid.nil?
           iid = @interned_da_name_ids[k]
-          k = nil
         end
         case v
         when String
@@ -578,15 +632,41 @@ module GraphQL
         when Symbol
           debug_annotation(iid, :string_value, v.inspect)
         when Array
-          debug_annotation(iid, :array_values, v.map { |v2| payload_to_debug(nil, v2, intern_value: intern_value) }.compact)
+          debug_annotation(iid, :array_values, v.each_with_index.map { |v2, idx| payload_to_debug((k ? "#{k}.#{idx}" : String(idx)), v2, intern_value: intern_value) }.compact)
         when Hash
           debug_annotation(iid, :dict_entries, v.map { |k2, v2| payload_to_debug(k2, v2, intern_value: intern_value) }.compact)
         else
-          debug_str = if defined?(ActiveRecord::Relation) && v.is_a?(ActiveRecord::Relation)
-            "#{v.class}, .to_sql=#{v.to_sql.inspect}"
-          else
-            v.inspect
+          class_name_iid = @interned_da_string_values[v.class.name]
+          da = [
+            debug_annotation(DA_DEBUG_INSPECT_CLASS_IID, :string_value_iid, class_name_iid),
+          ]
+          if k
+            k_str_value_iid = @interned_da_string_values[k]
+            da << debug_annotation(DA_DEBUG_INSPECT_FOR_IID, :string_value_iid, k_str_value_iid)
+          elsif iid
+            k = REVERSE_DEBUG_NAME_LOOKUP[iid] || @interned_da_name_ids.key(iid)
+            if k.nil?
+              da << debug_annotation(DA_DEBUG_INSPECT_FOR_IID, :string_value_iid, DA_STR_VAL_NIL_IID)
+            else
+              k_str_value_iid = @interned_da_string_values[k]
+              da << debug_annotation(DA_DEBUG_INSPECT_FOR_IID, :string_value_iid, k_str_value_iid)
+            end
           end
+
+          @packets << trace_packet(
+            type: TrackEvent::Type::TYPE_SLICE_BEGIN,
+            track_uuid: fid,
+            name_iid: DEBUG_INSPECT_EVENT_NAME_IID,
+            category_iids: DEBUG_INSPECT_CATEGORY_IIDS,
+            extra_counter_track_uuids: @counts_objects,
+            extra_counter_values: [count_allocations],
+            debug_annotations: da,
+          )
+          debug_str = @detailed_trace.inspect_object(v)
+          @packets << trace_packet(
+            type: TrackEvent::Type::TYPE_SLICE_END,
+            track_uuid: fid,
+          )
           if intern_value
             str_iid = @interned_da_string_values[debug_str]
             debug_annotation(iid, :string_value_iid, str_iid)
@@ -622,10 +702,14 @@ module GraphQL
         Fiber[:graphql_flow_stack] ||= []
       end
 
-      def trace_packet(event_attrs)
+      def trace_packet(timestamp: ts, **event_attrs)
+        if @create_debug_annotations && block_given?
+          event_attrs[:debug_annotations] = yield
+        end
+        track_event = TrackEvent.new(event_attrs)
         TracePacket.new(
-          timestamp: ts,
-          track_event: TrackEvent.new(event_attrs),
+          timestamp: timestamp,
+          track_event: track_event,
           trusted_packet_sequence_id: @sequence_id,
           sequence_flags: 2,
           interned_data: new_interned_data
@@ -690,9 +774,9 @@ module GraphQL
 
       def subscribe_to_active_support_notifications(pattern)
         @as_subscriber = ActiveSupport::Notifications.monotonic_subscribe(pattern) do |name, start, finish, id, payload|
-          metadata = payload.map { |k, v| payload_to_debug(k, v, intern_value: true) }
-          metadata.compact!
-          te = if metadata.empty?
+          metadata = @create_debug_annotations ? payload.map { |k, v| payload_to_debug(String(k), v, intern_value: true) } : nil
+          metadata&.compact!
+          te = if metadata.nil? || metadata.empty?
             TrackEvent.new(
               type: TrackEvent::Type::TYPE_SLICE_BEGIN,
               track_uuid: fid,
@@ -721,7 +805,7 @@ module GraphQL
               type: TrackEvent::Type::TYPE_SLICE_END,
               track_uuid: fid,
               name: name,
-              extra_counter_track_uuids: [@objects_counter_id],
+              extra_counter_track_uuids: @counts_objects,
               extra_counter_values: [count_allocations]
             ),
             trusted_packet_sequence_id: @sequence_id,

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -4,7 +4,7 @@ require "json"
 require "set"
 require "singleton"
 require "forwardable"
-require "fiber/storage"
+require "fiber/storage" if RUBY_VERSION < "3.2.0"
 require "graphql/autoload"
 
 module GraphQL

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.14
+  version: 2.5.15
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-10-08 00:00:00.000000000 Z
+date: 2025-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: fiber-storage
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -729,6 +715,7 @@ files:
 - lib/graphql/subscriptions/serialize.rb
 - lib/graphql/testing.rb
 - lib/graphql/testing/helpers.rb
+- lib/graphql/testing/mock_action_cable.rb
 - lib/graphql/tracing.rb
 - lib/graphql/tracing/active_support_notifications_trace.rb
 - lib/graphql/tracing/active_support_notifications_tracing.rb