graphql 1.9.21 → 2.0.0

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module GraphQL
+  class Subscriptions
+    class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
+      def resolve(context:, object:, arguments:)
+        has_override_implementation = @field.resolver ||
+          object.respond_to?(@field.resolver_method)
+
+        if !has_override_implementation
+          if context.query.subscription_update?
+            object.object
+          else
+            context.skip
+          end
+        else
+          yield(object, arguments)
+        end
+      end
+
+      def after_resolve(value:, context:, object:, arguments:, **rest)
+        if value.is_a?(GraphQL::ExecutionError)
+          value
+        elsif (events = context.namespace(:subscriptions)[:events])
+          # This is the first execution, so gather an Event
+          # for the backend to register:
+          event = Subscriptions::Event.new(
+            name: field.name,
+            arguments: arguments_without_field_extras(arguments: arguments),
+            context: context,
+            field: field,
+          )
+          events << event
+          value
+        elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+            field.name,
+            arguments_without_field_extras(arguments: arguments),
+            field,
+            scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
+          )
+          # This is a subscription update. The resolver returned `skip` if it should be skipped,
+          # or else it returned an object to resolve the update.
+          value
+        else
+          # This is a subscription update, but this event wasn't triggered.
+          context.skip
+        end
+      end
+
+      private
+
+      def arguments_without_field_extras(arguments:)
+        arguments.dup.tap do |event_args|
+          field.extras.each { |k| event_args.delete(k) }
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/event.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # This thing can be:
     # - Subscribed to by `subscription { ... }`
     # - Triggered by `MySchema.subscriber.trigger(name, arguments, obj)`
     #
-    # An array of `Event`s are passed to `store.register(query, events)`.
     class Event
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
 
-      # @return [GraphQL::Query::Arguments]
+      # @return [GraphQL::Execution::Interpreter::Arguments]
       attr_reader :arguments
 
       # @return [GraphQL::Query::Context]
@@ -25,64 +23,120 @@ module GraphQL
         @arguments = arguments
         @context = context
         field ||= context.field
-        scope_val = scope || (context && field.subscription_scope && context[field.subscription_scope])
+        scope_key = field.subscription_scope
+        scope_val = scope || (context && scope_key && context[scope_key])
+        if scope_key &&
+            (subscription = field.resolver) &&
+            (subscription.respond_to?(:subscription_scope_optional?)) &&
+            !subscription.subscription_scope_optional? &&
+            scope_val.nil?
+          raise Subscriptions::SubscriptionScopeMissingError, "#{field.path} (#{subscription}) requires a `scope:` value to trigger updates (Set `subscription_scope ..., optional: true` to disable this requirement)"
+        end
 
-        @topic = self.class.serialize(name, arguments, field, scope: scope_val)
+        @topic = self.class.serialize(name, arguments, field, scope: scope_val, context: context)
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(name, arguments, field, scope:)
-        normalized_args = case arguments
-        when GraphQL::Query::Arguments
-          arguments
-        when Hash
-          if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(field, arguments)
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext)
+        subscription = field.resolver || GraphQL::Schema::Subscription
+        normalized_args = stringify_args(field, arguments.to_h, context)
+        subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
+      end
+
+      # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)
+      def fingerprint
+        @fingerprint ||= begin
+          # When this query has been flagged as broadcastable,
+          # use a generalized, stable fingerprint so that
+          # duplicate subscriptions can be evaluated and distributed in bulk.
+          # (`@topic` includes field, args, and subscription scope already.)
+          if @context.namespace(:subscriptions)[:subscription_broadcastable]
+            "#{@topic}/#{@context.query.fingerprint}"
           else
-            GraphQL::Query::LiteralInput.from_arguments(
-              arguments,
-              field,
-              nil,
-            )
+            # not broadcastable, build a unique ID for this event
+            @context.schema.subscriptions.build_id
           end
-        else
-          raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
         end
-
-        sorted_h = normalized_args.to_h.sort.to_h
-        Serialize.dump_recursive([scope, name, sorted_h])
       end
 
       class << self
         private
-        def stringify_args(arg_owner, args)
+
+        # This method does not support cyclic references in the Hash,
+        # nor does it support Hashes whose keys are not sortable
+        # with respect to their peers ( cases where a <=> b might throw an error )
+        def deep_sort_hash_keys(hash_to_sort)
+          raise ArgumentError.new("Argument must be a Hash") unless hash_to_sort.is_a?(Hash)
+          hash_to_sort.keys.sort.map do |k|
+            if hash_to_sort[k].is_a?(Hash)
+              [k, deep_sort_hash_keys(hash_to_sort[k])]
+            elsif hash_to_sort[k].is_a?(Array)
+              [k, deep_sort_array_hashes(hash_to_sort[k])]
+            else
+              [k, hash_to_sort[k]]
+            end
+          end.to_h
+        end
+
+        def deep_sort_array_hashes(array_to_inspect)
+          raise ArgumentError.new("Argument must be an Array") unless array_to_inspect.is_a?(Array)
+          array_to_inspect.map do |v|
+            if v.is_a?(Hash)
+              deep_sort_hash_keys(v)
+            elsif v.is_a?(Array)
+              deep_sort_array_hashes(v)
+            else
+              v
+            end
+          end
+        end
+
+        def stringify_args(arg_owner, args, context)
+          arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
           when Hash
             next_args = {}
             args.each do |k, v|
               arg_name = k.to_s
               camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
-              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
 
               if arg_defn
                 normalized_arg_name = camelized_arg_name
               else
                 normalized_arg_name = arg_name
-                arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
+                arg_defn = get_arg_definition(arg_owner, normalized_arg_name, context)
+              end
+              arg_base_type = arg_defn.type.unwrap
+              # In the case where the value being emitted is seen as a "JSON"
+              # type, treat the value as one atomic unit of serialization
+              is_json_definition = arg_base_type && arg_base_type <= GraphQL::Types::JSON
+              if is_json_definition
+                sorted_value = if v.is_a?(Hash)
+                  deep_sort_hash_keys(v)
+                elsif v.is_a?(Array)
+                  deep_sort_array_hashes(v)
+                else
+                  v
+                end
+                next_args[normalized_arg_name] = sorted_value.respond_to?(:to_json) ? sorted_value.to_json : sorted_value
+              else
+                next_args[normalized_arg_name] = stringify_args(arg_base_type, v, context)
               end
-
-              next_args[normalized_arg_name] = stringify_args(arg_defn[1].type, v)
             end
-            next_args
+            # Make sure they're deeply sorted
+            next_args.sort.to_h
           when Array
-            args.map { |a| stringify_args(arg_owner, a) }
+            args.map { |a| stringify_args(arg_owner, a, context) }
+          when GraphQL::Schema::InputObject
+            stringify_args(arg_owner, args.to_h, context)
           else
             args
           end
         end
 
-        def get_arg_definition(arg_owner, arg_name)
-          arg_owner.arguments.find { |k, v| k == arg_name || v.keyword.to_s == arg_name }
+        def get_arg_definition(arg_owner, arg_name, context)
+          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # Wrap the root fields of the subscription type with special logic for:
@@ -10,16 +9,6 @@ module GraphQL
         @schema = schema
       end
 
-      def instrument(type, field)
-        if type == @schema.subscription
-          # This is a root field of `subscription`
-          subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
-          field.redefine(resolve: subscribing_resolve_proc)
-        else
-          field
-        end
-      end
-
       # If needed, prepare to gather events which this query subscribes to
       def before_query(query)
         if query.subscription? && !query.subscription_update?
@@ -34,42 +23,6 @@ module GraphQL
           @schema.subscriptions.write_subscription(query, events)
         end
       end
-
-      private
-
-      class SubscriptionRegistrationResolve
-        def initialize(inner_proc)
-          @inner_proc = inner_proc
-        end
-
-        # Wrap the proc with subscription registration logic
-        def call(obj, args, ctx)
-          @inner_proc.call(obj, args, ctx) if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
-
-          events = ctx.namespace(:subscriptions)[:events]
-
-          if events
-            # This is the first execution, so gather an Event
-            # for the backend to register:
-            events << Subscriptions::Event.new(
-              name: ctx.field.name,
-              arguments: args,
-              context: ctx,
-            )
-            ctx.skip
-          elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
-            # The root object is _already_ the subscription update:
-            if obj.is_a?(GraphQL::Schema::Object)
-              obj.object
-            else
-              obj
-            end
-          else
-            # This is a subscription update, but this event wasn't triggered.
-            ctx.skip
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/subscriptions/serialize.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../subscriptions.rb
 require "set"
 module GraphQL
   class Subscriptions
@@ -9,6 +8,9 @@ module GraphQL
       GLOBALID_KEY = "__gid__"
       SYMBOL_KEY = "__sym__"
       SYMBOL_KEYS_KEY = "__sym_keys__"
+      TIMESTAMP_KEY = "__timestamp__"
+      TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%z" # eg '2020-01-01 23:59:59.123456789+05:00'
+      OPEN_STRUCT_KEY = "__ostruct__"
 
       module_function
 
@@ -53,12 +55,40 @@ module GraphQL
         # @return [Object] An object that load Global::Identification recursive
         def load_value(value)
           if value.is_a?(Array)
-            value.map{|item| load_value(item)}
+            is_gids = (v1 = value[0]).is_a?(Hash) && v1.size == 1 && v1[GLOBALID_KEY]
+            if is_gids
+              # Assume it's an array of global IDs
+              ids = value.map { |v| v[GLOBALID_KEY] }
+              GlobalID::Locator.locate_many(ids)
+            else
+              value.map { |item| load_value(item) }
+            end
           elsif value.is_a?(Hash)
-            if value.size == 1 && value.key?(GLOBALID_KEY)
-              GlobalID::Locator.locate(value[GLOBALID_KEY])
-            elsif value.size == 1 && value.key?(SYMBOL_KEY)
-              value[SYMBOL_KEY].to_sym
+            if value.size == 1
+              case value.keys.first # there's only 1 key
+              when GLOBALID_KEY
+                GlobalID::Locator.locate(value[GLOBALID_KEY])
+              when SYMBOL_KEY
+                value[SYMBOL_KEY].to_sym
+              when TIMESTAMP_KEY
+                timestamp_class_name, *timestamp_args = value[TIMESTAMP_KEY]
+                timestamp_class = Object.const_get(timestamp_class_name)
+                if defined?(ActiveSupport::TimeWithZone) && timestamp_class <= ActiveSupport::TimeWithZone
+                  zone_name, timestamp_s = timestamp_args
+                  zone = ActiveSupport::TimeZone[zone_name]
+                  raise "Zone #{zone_name} not found, unable to deserialize" unless zone
+                  zone.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                else
+                  timestamp_s = timestamp_args.first
+                  timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                end
+              when OPEN_STRUCT_KEY
+                ostruct_values = load_value(value[OPEN_STRUCT_KEY])
+                OpenStruct.new(ostruct_values)
+              else
+                key = value.keys.first
+                { key => load_value(value[key]) }
+              end
             else
               loaded_h = {}
               sym_keys = value.fetch(SYMBOL_KEYS_KEY, [])
@@ -101,6 +131,23 @@ module GraphQL
             { SYMBOL_KEY => obj.to_s }
           elsif obj.respond_to?(:to_gid_param)
             {GLOBALID_KEY => obj.to_gid_param}
+          elsif defined?(ActiveSupport::TimeWithZone) && obj.is_a?(ActiveSupport::TimeWithZone) && obj.class.name != Time.name
+            # This handles a case where Rails prior to 7 would
+            # make the class ActiveSupport::TimeWithZone return "Time" for
+            # its name. In Rails 7, it will now return "ActiveSupport::TimeWithZone",
+            # which happens to be incompatible with expectations we have
+            # with what a Time class supports ( notably, strptime in `load_value` ).
+            #
+            # This now passes along the name of the zone, such that a future deserialization
+            # of this string will use the correct time zone from the ActiveSupport TimeZone
+            # list to produce the time.
+            #
+            { TIMESTAMP_KEY => [obj.class.name, obj.time_zone.name, obj.strftime(TIMESTAMP_FORMAT)] }
+          elsif obj.is_a?(Date) || obj.is_a?(Time)
+            # DateTime extends Date; for TimeWithZone, call `.utc` first.
+            { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
+          elsif obj.is_a?(OpenStruct)
+            { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           else
             obj
           end

data/lib/graphql/subscriptions.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 require "securerandom"
+require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
-if defined?(ActionCable)
-  require "graphql/subscriptions/action_cable_subscriptions"
-end
-require "graphql/subscriptions/subscription_root"
+require "graphql/subscriptions/action_cable_subscriptions"
+require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
   class Subscriptions
@@ -16,22 +15,41 @@ module GraphQL
     class InvalidTriggerError < GraphQL::Error
     end
 
+    # Raised when either:
+    # - An initial subscription didn't have a value for `context[subscription_scope]`
+    # - Or, an update didn't pass `.trigger(..., scope:)`
+    # When raised, the initial subscription or update fails completely.
+    class SubscriptionScopeMissingError < GraphQL::Error
+    end
+
     # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
-      schema = defn.target
-      options[:schema] = schema
-      schema.subscriptions = self.new(**options)
+      schema = defn.is_a?(Class) ? defn : defn.target
+
+      if schema.subscriptions
+        raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
+      end
+
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:field, instrumentation)
       defn.instrument(:query, instrumentation)
+      options[:schema] = schema
+      schema.subscriptions = self.new(**options)
+      schema.add_subscription_extension_if_necessary
       nil
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, **rest)
+    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+      if broadcast
+        schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
+      end
+      @default_broadcastable = default_broadcastable
       @schema = schema
     end
 
+    # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
+    attr_reader :default_broadcastable
+
     # Fetch subscriptions matching this field + arguments pair
     # And pass them off to the queue.
     # @param event_name [String]
@@ -58,7 +76,8 @@ module GraphQL
       end
 
       # Normalize symbol-keyed args to strings, try camelizing them
-      normalized_args = normalize_arguments(normalized_event_name, field, args)
+      # Should this accept a real context somehow?
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
@@ -72,40 +91,59 @@ module GraphQL
     # `event` was triggered on `object`, and `subscription_id` was subscribed,
     # so it should be updated.
     #
-    # Load `subscription_id`'s GraphQL data, re-evaluate the query, and deliver the result.
-    #
-    # This is where a queue may be inserted to push updates in the background.
+    # Load `subscription_id`'s GraphQL data, re-evaluate the query and return the result.
     #
     # @param subscription_id [String]
     # @param event [GraphQL::Subscriptions::Event] The event which was triggered
     # @param object [Object] The value for the subscription field
-    # @return [void]
-    def execute(subscription_id, event, object)
+    # @return [GraphQL::Query::Result]
+    def execute_update(subscription_id, event, object)
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
+      if query_data.nil?
+        delete_subscription(subscription_id)
+        return nil
+      end
+
       # Fetch the required keys from the saved data
       query_string = query_data.fetch(:query_string)
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      # Re-evaluate the saved query
       result = @schema.execute(
-        **{
-          query: query_string,
-          context: context,
-          subscription_topic: event.topic,
-          operation_name: operation_name,
-          variables: variables,
-          root_value: object,
-        }
+        query: query_string,
+        context: context,
+        subscription_topic: event.topic,
+        operation_name: operation_name,
+        variables: variables,
+        root_value: object,
       )
-      deliver(subscription_id, result)
-    rescue GraphQL::Schema::Subscription::NoUpdateError
-      # This update was skipped in user code; do nothing.
-    rescue GraphQL::Schema::Subscription::UnsubscribedError
-      # `unsubscribe` was called, clean up on our side
-      # TODO also send `{more: false}` to client?
-      delete_subscription(subscription_id)
+      subscriptions_context = result.context.namespace(:subscriptions)
+      if subscriptions_context[:no_update]
+        result = nil
+      end
+
+      unsubscribed = subscriptions_context[:unsubscribed]
+
+      if unsubscribed
+        # `unsubscribe` was called, clean up on our side
+        # TODO also send `{more: false}` to client?
+        delete_subscription(subscription_id)
+        result = nil
+      end
+
+      result
+    end
+
+    # Run the update query for this subscription and deliver it
+    # @see {#execute_update}
+    # @see {#deliver}
+    # @return [void]
+    def execute(subscription_id, event, object)
+      res = execute_update(subscription_id, event, object)
+      if !res.nil?
+        deliver(subscription_id, res)
+      end
     end
 
     # Event `event` occurred on `object`,
@@ -114,16 +152,6 @@ module GraphQL
     # @param object [Object]
     # @return [void]
     def execute_all(event, object)
-      each_subscription_id(event) do |subscription_id|
-        execute(subscription_id, event, object)
-      end
-    end
-
-    # Get each `subscription_id` subscribed to `event.topic` and yield them
-    # @param event [GraphQL::Subscriptions::Event]
-    # @yieldparam subscription_id [String]
-    # @return [void]
-    def each_subscription_id(event)
       raise GraphQL::RequiredImplementationMissingError
     end
 
@@ -178,6 +206,16 @@ module GraphQL
       Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
     end
 
+    # @return [Boolean] if true, then a query like this one would be broadcasted
+    def broadcastable?(query_str, **query_options)
+      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      if !query.valid?
+        raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
+      end
+      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      query.context.namespace(:subscriptions)[:subscription_broadcastable]
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:
@@ -186,32 +224,53 @@ module GraphQL
     # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
     # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
     # @return [Any] normalized arguments value
-    def normalize_arguments(event_name, arg_owner, args)
+    def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType
+      when GraphQL::Schema::Field, Class
+        if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
+          # it's a type, but not an input object
+          return args
+        end
         normalized_args = {}
         missing_arg_names = []
         args.each do |k, v|
           arg_name = k.to_s
-          arg_defn = arg_owner.arguments[arg_name]
+          arg_defn = arg_owner.get_argument(arg_name, context)
           if arg_defn
             normalized_arg_name = arg_name
           else
             normalized_arg_name = normalize_name(arg_name)
-            arg_defn = arg_owner.arguments[normalized_arg_name]
+            arg_defn = arg_owner.get_argument(normalized_arg_name, context)
           end
 
           if arg_defn
-            normalized_args[normalized_arg_name] = normalize_arguments(event_name, arg_defn.type, v)
+            if arg_defn.loads
+              normalized_arg_name = arg_defn.keyword.to_s
+            end
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
+            normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
             missing_arg_names << arg_name
           end
         end
 
+        # Backfill default values so that trigger arguments
+        # match query arguments.
+        arg_owner.arguments(context).each do |_name, arg_defn|
+          if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
+            default_value = arg_defn.default_value
+            # We don't have an underlying "object" here, so it can't call methods.
+            # This is broken.
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
+          end
+        end
+
         if missing_arg_names.any?
-          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
-            "Subscription.#{arg_owner.name}"
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
+            arg_owner.path
+          elsif arg_owner.is_a?(Class)
+            arg_owner.graphql_name
           else
             arg_owner.to_s
           end
@@ -219,10 +278,10 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
-      when GraphQL::NonNullType
-        normalize_arguments(event_name, arg_owner.of_type, args)
+      when GraphQL::Schema::List
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
+      when GraphQL::Schema::NonNull
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args
       end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,29 +1,20 @@
 # frozen_string_literal: true
 
+require 'graphql/tracing/notifications_tracing'
+
 module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql.` prefix.
+    # with a `graphql` suffix.
     #
+    # @see KEYS for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
-      KEYS = {
-        "lex" => "graphql.lex",
-        "parse" => "graphql.parse",
-        "validate" => "graphql.validate",
-        "analyze_multiplex" => "graphql.analyze_multiplex",
-        "analyze_query" => "graphql.analyze_query",
-        "execute_query" => "graphql.execute_query",
-        "execute_query_lazy" => "graphql.execute_query_lazy",
-        "execute_field" => "graphql.execute_field",
-        "execute_field_lazy" => "graphql.execute_field_lazy",
-      }
+      KEYS = NotificationsTracing::KEYS
+      NOTIFICATIONS_ENGINE = NotificationsTracing.new(ActiveSupport::Notifications) if defined?(ActiveSupport::Notifications)
 
-      def self.trace(key, metadata)
-        prefixed_key = KEYS[key] || "graphql.#{key}"
-        ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
-          yield
-        end
+      def self.trace(key, metadata, &blk)
+        NOTIFICATIONS_ENGINE.trace(key, metadata, &blk)
       end
     end
   end