graphql 1.9.17 → 1.10.0

data/lib/graphql/static_validation/base_visitor.rb

@@ -71,7 +71,7 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          @object_types.push(object_type)
+          push_type(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
           super
           @object_types.pop
@@ -98,9 +98,9 @@ module GraphQL
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
-            @object_types.push(next_object_type)
+            push_type(next_object_type)
           else
-            @object_types.push(nil)
+            push_type(nil)
           end
           @path.push(node.alias || node.name)
           super
@@ -120,7 +120,7 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.input_fields[node.name]
+              arg_type.arguments[node.name]
             else
               nil
             end
@@ -187,15 +187,19 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @schema.get_type(node.type.name)
           else
             @object_types.last
           end
-          @object_types.push(object_type)
+          push_type(object_type)
           yield(node)
           @object_types.pop
           @path.pop
         end
+
+        def push_type(t)
+          @object_types.push(t)
+        end
       end
 
       private

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

@@ -11,7 +11,7 @@ module GraphQL
             nil
           else
             arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
+            if !arg_ret_type.kind.input_object?
               nil
             else
               arg_ret_type
@@ -54,7 +54,7 @@ module GraphQL
                 node.value.arguments.include?(err.ast_value)
               else
                 # otherwise we just check equality
-                node.value == (err.ast_value)
+                node.value == err.ast_value
               end
               if !matched
                 # This node isn't the node that caused the error,
@@ -67,9 +67,14 @@ module GraphQL
               error ||= begin
                 kind_of_node = node_type(parent)
                 error_arg_name = parent_name(parent, parent_defn)
+                string_value = if node.value == Float::INFINITY
+                  ""
+                else
+                  " (#{GraphQL::Language::Printer.new.print(node.value)})"
+                end
 
                 GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
-                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.",
+                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'.",
                   nodes: parent,
                   type: kind_of_node,
                   argument: node.name
@@ -92,7 +97,7 @@ module GraphQL
         elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
           type_defn.name
         else
-          parent.name
+          parent.graphql_name
         end
       end
 

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

@@ -10,10 +10,10 @@ module GraphQL
             nil
           else
             arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
-              nil
-            else
+            if arg_ret_type.kind.input_object?
               arg_ret_type
+            else
+              nil
             end
           end
         when GraphQL::Language::Nodes::Directive
@@ -45,12 +45,15 @@ module GraphQL
       private
 
       def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
+        case parent
+        when GraphQL::Language::Nodes::Field
           parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
+        when GraphQL::Language::Nodes::InputObject
+          type_defn.graphql_name
+        when GraphQL::Language::Nodes::Argument, GraphQL::Language::Nodes::Directive
           parent.name
+        else
+          raise "Invariant: Unexpected parent #{parent.inspect} (#{parent.class})"
         end
       end
 

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

@@ -56,7 +56,7 @@ module GraphQL
             "'@#{directive_defn.graphql_name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})",
             nodes: directive_ast,
             target: location_name,
-            name: directive_defn.name
+            name: directive_defn.graphql_name
           ))
         end
       end

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

@@ -9,16 +9,16 @@ module GraphQL
         if field.nil?
           if parent_type.kind.union?
             add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
-              "Selections can't be made directly on unions (see selections on #{parent_type.name})",
+              "Selections can't be made directly on unions (see selections on #{parent_type.graphql_name})",
               nodes: parent,
-              node_name: parent_type.name
+              node_name: parent_type.graphql_name
             ))
           else
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
-              "Field '#{node.name}' doesn't exist on type '#{parent_type.name}'",
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
               nodes: node,
               field: node.name,
-              type: parent_type.name
+              type: parent_type.graphql_name
             ))
           end
         else

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

@@ -27,12 +27,12 @@ module GraphQL
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
           if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
           else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
           end
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
-          "Field must have selections (%{node_name} returns #{resolved_type.name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+          "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else
           nil
         end
@@ -55,13 +55,13 @@ module GraphQL
             "name": node_name.to_s
           }
           unless resolved_type.nil?
-            extensions["type"] = resolved_type.to_s
+            extensions["type"] = resolved_type.to_type_signature
           end
           add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
             msg % { node_name: node_name },
             nodes: ast_node,
             node_name: node_name.to_s,
-            type: resolved_type.nil? ? nil : resolved_type.to_s
+            type: resolved_type.nil? ? nil : resolved_type.graphql_name,
           ))
           false
         else

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

@@ -93,8 +93,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.schema.types[fragment1.type.name]
-        fragment_type2 = context.schema.types[fragment2.type.name]
+        fragment_type1 = context.warden.get_type(fragment1.type.name)
+        fragment_type2 = context.warden.get_type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -146,7 +146,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.schema.types[fragment.type.name]
+        fragment_type = context.warden.get_type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -316,7 +316,7 @@ module GraphQL
             definition = context.schema.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = node.type ? context.schema.types[node.type.name] : owner_type
+            fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)

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

@@ -50,12 +50,12 @@ module GraphQL
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
           add_error(GraphQL::StaticValidation::FragmentSpreadsArePossibleError.new(
-            "Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}",
+            "Fragment#{name} on #{child_type.graphql_name} can't be spread inside #{parent_type.graphql_name}",
             nodes: node,
             path: path,
             fragment_name: name.empty? ? "unknown" : name,
-            type: child_type.name,
-            parent: parent_type.name
+            type: child_type.graphql_name,
+            parent: parent_type.graphql_name
           ))
         end
       end

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

@@ -46,10 +46,10 @@ module GraphQL
           path = [*context.path, missing_field]
           missing_field_type = parent_type.arguments[missing_field].type
           add_error(RequiredInputObjectAttributesArePresentError.new(
-            "Argument '#{missing_field}' on InputObject '#{parent_type}' is required. Expected type #{missing_field_type}",
+            "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,
-            argument_type: missing_field_type.to_s,
-            input_object_type: parent_type.to_s,
+            argument_type: missing_field_type.to_type_signature,
+            input_object_type: parent_type.to_type_signature,
             path: path,
             nodes: ast_node,
           ))

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

@@ -13,7 +13,7 @@ module GraphQL
               error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
             ))
           else
-            type = context.schema.type_from_ast(node.type)
+            type = context.schema.type_from_ast(node.type, context: context)
             if type.nil?
               # This is handled by another validator
             else
@@ -26,13 +26,13 @@ module GraphQL
               end
 
               if !valid
-                error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
+                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
                 VariableDefaultValuesAreCorrectlyTypedError
                 add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
                   error_message,
                   nodes: node,
                   name: node.name,
-                  type: type.to_s,
+                  type: type.to_type_signature,
                   error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
                 ))
               end

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

@@ -52,17 +52,16 @@ module GraphQL
       private
 
       def validate_usage(arguments, arg_node, ast_var)
-        var_type = context.schema.type_from_ast(ast_var.type)
+        var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
         end
         if !ast_var.default_value.nil?
-          unless var_type.is_a?(GraphQL::NonNullType)
+          unless var_type.kind.non_null?
             # If the value is required, but the argument is not,
             # and yet there's a non-nil default, then we impliclty
             # make the argument also a required type.
-
-            var_type = GraphQL::NonNullType.new(of_type: var_type)
+            var_type = var_type.to_non_null_type
           end
         end
 
@@ -85,10 +84,10 @@ module GraphQL
 
       def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
         add_error(GraphQL::StaticValidation::VariableUsagesAreAllowedError.new(
-          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})",
+          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_type_signature} / #{arg_defn.type.to_type_signature})",
           nodes: arg_node,
           name: ast_var.name,
-          type: var_type.to_s,
+          type: var_type.to_type_signature,
           argument: arg_node.name,
           error: error_message
         ))

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

@@ -15,7 +15,7 @@ module GraphQL
           ))
         elsif !type.kind.input?
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type.name} isn't a valid input type (on $#{node.name})",
+            "#{type.graphql_name} isn't a valid input type (on $#{node.name})",
             nodes: node,
             name: node.name,
             type: type_name

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

@@ -2,7 +2,7 @@
 module GraphQL
   module StaticValidation
     # The problem is
-    #   - Variable usage must be determined at the OperationDefinition level
+    #   - Variable $usage must be determined at the OperationDefinition level
     #   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
     #
     #  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.

data/lib/graphql/static_validation/type_stack.rb

@@ -55,7 +55,7 @@ module GraphQL
       module FragmentWithTypeStrategy
         def push(stack, node)
           object_type = if node.type
-            stack.schema.types.fetch(node.type.name, nil)
+            stack.schema.get_type(node.type.name)
           else
             stack.object_types.last
           end
@@ -148,7 +148,7 @@ module GraphQL
           if stack.argument_definitions.last
             arg_type = stack.argument_definitions.last.type.unwrap
             if arg_type.kind.input_object?
-              argument_defn = arg_type.input_fields[node.name]
+              argument_defn = arg_type.arguments[node.name]
             else
               argument_defn = nil
             end

data/lib/graphql/static_validation/validator.rb

@@ -23,7 +23,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true)
         query.trace("validate", { validate: validate, query: query }) do
-          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis?
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
             []
           else

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -10,7 +10,7 @@ module GraphQL
     # - Take care to reload context when re-delivering the subscription. (see {Query#subscription_update?})
     #
     # @example Adding ActionCableSubscriptions to your schema
-    #   MySchema = GraphQL::Schema.define do
+    #   class MySchema < GraphQL::Schema
     #     # ...
     #     use GraphQL::Subscriptions::ActionCableSubscriptions
     #   end
@@ -26,7 +26,7 @@ module GraphQL
     #       variables = ensure_hash(data["variables"])
     #       operation_name = data["operationName"]
     #       context = {
-    #         # Re-implement whatever context methods you need 
+    #         # Re-implement whatever context methods you need
     #         # in this channel or ApplicationCable::Channel
     #         # current_user: current_user,
     #         # Make sure the channel is in the context
@@ -41,7 +41,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.subscription? ? { data: nil } : result.to_h,
+    #         result: result.to_h,
     #         more: result.subscription?,
     #       }
     #

data/lib/graphql/subscriptions/event.rb

@@ -49,7 +49,7 @@ module GraphQL
           raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
         end
 
-        sorted_h = normalized_args.to_h.sort.to_h
+        sorted_h = stringify_args(field, normalized_args.to_h)
         Serialize.dump_recursive([scope, name, sorted_h])
       end
 
@@ -71,18 +71,21 @@ module GraphQL
                 arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
               end
 
-              next_args[normalized_arg_name] = stringify_args(arg_defn[1].type, v)
+              next_args[normalized_arg_name] = stringify_args(arg_defn.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) }
+          when GraphQL::Schema::InputObject
+            stringify_args(arg_owner, args.to_h)
           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 }
+          arg_owner.arguments[arg_name] || arg_owner.arguments.each_value.find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -11,7 +11,7 @@ module GraphQL
       end
 
       def instrument(type, field)
-        if type == @schema.subscription
+        if type == @schema.subscription.graphql_definition
           # This is a root field of `subscription`
           subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
           field.redefine(resolve: subscribing_resolve_proc)
@@ -44,7 +44,10 @@ module GraphQL
 
         # 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)
+          result = nil
+          if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
+            result = @inner_proc.call(obj, args, ctx)
+          end
 
           events = ctx.namespace(:subscriptions)[:events]
 
@@ -56,10 +59,12 @@ module GraphQL
               arguments: args,
               context: ctx,
             )
-            ctx.skip
+            result
           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)
+            if !result.nil?
+              result
+            elsif obj.is_a?(GraphQL::Schema::Object)
+              # The root object is _already_ the subscription update:
               obj.object
             else
               obj

data/lib/graphql/subscriptions/subscription_root.rb

@@ -44,7 +44,6 @@ module GraphQL
               context: context,
               field: field,
             )
-            # TODO compat with non-class-based subscriptions?
             value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,

data/lib/graphql/subscriptions.rb

@@ -18,12 +18,17 @@ module GraphQL
 
     # @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)
+      defn.instrument(:field, instrumentation)
+      options[:schema] = schema
+      schema.subscriptions = self.new(**options)
       nil
     end
 
@@ -90,7 +95,7 @@ module GraphQL
       operation_name = query_data.fetch(:operation_name)
       # Re-evaluate the saved query
       result = @schema.execute(
-        {
+        **{
           query: query_string,
           context: context,
           subscription_topic: event.topic,
@@ -188,7 +193,11 @@ module GraphQL
     # @return [Any] normalized arguments value
     def normalize_arguments(event_name, arg_owner, args)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType
+      when GraphQL::Field, GraphQL::InputObjectType, 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|
@@ -202,16 +211,32 @@ module GraphQL
           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)
+            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.each do |name, arg_defn|
+          if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
+            normalized_args[arg_defn.name] = arg_defn.default_value
+          end
+        end
+
         if missing_arg_names.any?
           arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
             "Subscription.#{arg_owner.name}"
+          elsif 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,9 +244,9 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType
+      when GraphQL::ListType, GraphQL::Schema::List
         args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
-      when GraphQL::NonNullType
+      when GraphQL::NonNullType, GraphQL::Schema::NonNull
         normalize_arguments(event_name, arg_owner.of_type, args)
       else
         args

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -8,19 +8,23 @@ module GraphQL
     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",
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
+        "authorized" => "authorized.graphql",
+        "authorized_lazy" => "authorized_lazy.graphql",
+        "resolve_type" => "resolve_type.graphql",
+        "resolve_type_lazy" => "resolve_type.graphql",
       }
 
       def self.trace(key, metadata)
-        prefixed_key = KEYS[key] || "graphql.#{key}"
+        prefixed_key = KEYS[key] || "#{key}.graphql"
         ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
           yield
         end

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -23,6 +23,14 @@ module GraphQL
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}.graphql"
       end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized.graphql"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type.graphql"
+      end
     end
   end
 end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -63,6 +63,14 @@ module GraphQL
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}"
       end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
     end
   end
 end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -49,6 +49,14 @@ module GraphQL
       def platform_field_key(type, field)
         "GraphQL/#{type.graphql_name}/#{field.graphql_name}"
       end
+
+      def platform_authorized_key(type)
+        "GraphQL/Authorize/#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "GraphQL/ResolveType/#{type.graphql_name}"
+      end
     end
   end
 end