graphql 2.0.6 → 2.0.9

data/lib/graphql/language/parser.y

@@ -321,13 +321,13 @@ rule
 
   object_type_extension:
       /* TODO - This first one shouldn't be necessary but parser is getting confused */
-      EXTEND TYPE name implements LCURLY field_definition_list RCURLY { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: val[5], position_source: val[0]) }
-    | EXTEND TYPE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], position_source: val[0]) }
+      EXTEND TYPE name implements field_definition_list_opt { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: val[4], position_source: val[0]) }
+    | EXTEND TYPE name implements_opt directives_list_opt field_definition_list_opt { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[5], position_source: val[0]) }
     | EXTEND TYPE name implements_opt directives_list { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: [], position_source: val[0]) }
     | EXTEND TYPE name implements { result = make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: [], position_source: val[0]) }
 
   interface_type_extension:
-      EXTEND INTERFACE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], position_source: val[0]) }
+      EXTEND INTERFACE name implements_opt directives_list_opt field_definition_list_opt { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[5], position_source: val[0]) }
     | EXTEND INTERFACE name implements_opt directives_list { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: [], position_source: val[0]) }
     | EXTEND INTERFACE name implements { result = make_node(:InterfaceTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: [], position_source: val[0]) }
 
@@ -355,8 +355,8 @@ rule
       }
 
   object_type_definition:
-      description_opt TYPE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY {
-        result = make_node(:ObjectTypeDefinition, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
+      description_opt TYPE name implements_opt directives_list_opt field_definition_list_opt {
+        result = make_node(:ObjectTypeDefinition, name: val[2], interfaces: val[3], directives: val[4], fields: val[5], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
       }
 
   implements_opt:
@@ -394,14 +394,18 @@ rule
         result = make_node(:FieldDefinition, name: val[1], arguments: val[2], type: val[4], directives: val[5], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
       }
 
-  field_definition_list:
+  field_definition_list_opt:
     /* none */ { result = EMPTY_ARRAY }
+    | LCURLY field_definition_list RCURLY { result = val[1] }
+
+  field_definition_list:
+    /* none - this is not actually valid but graphql-ruby used to print this */ { result = EMPTY_ARRAY }
     | field_definition                       { result = [val[0]] }
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:
-      description_opt INTERFACE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY {
-        result = make_node(:InterfaceTypeDefinition, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
+      description_opt INTERFACE name implements_opt directives_list_opt field_definition_list_opt {
+        result = make_node(:InterfaceTypeDefinition, name: val[2], interfaces: val[3], directives: val[4], fields: val[5], description: val[0] || get_description(val[1]), definition_line: val[1].line, position_source: val[0] || val[1])
       }
 
   union_members:

data/lib/graphql/language/printer.rb

@@ -267,12 +267,16 @@ module GraphQL
       end
 
       def print_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_field_definition(field)}\n"
+        if fields.empty?
+          ""
+        else
+          out = " {\n".dup
+          fields.each.with_index do |field, i|
+            out << print_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{print_field_definition(field)}\n"
+          end
+          out << "}"
         end
-        out << "}"
       end
 
       def print_directives(directives)

data/lib/graphql/pagination/connection.rb

@@ -56,8 +56,9 @@ module GraphQL
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
-      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
+      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given and no `default_page_size` is set.
+      # @param default_page_size [Integer, nil] A configured value to determine the result size when neither first or last are given.
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, default_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -76,6 +77,12 @@ module GraphQL
         else
           max_page_size
         end
+        @has_default_page_size_override = default_page_size != :not_given
+        @default_page_size = if default_page_size == :not_given
+          nil
+        else
+          default_page_size
+        end
       end
 
       def max_page_size=(new_value)
@@ -95,16 +102,36 @@ module GraphQL
         @has_max_page_size_override
       end
 
+      def default_page_size=(new_value)
+        @has_default_page_size_override = true
+        @default_page_size = new_value
+      end
+
+      def default_page_size
+        if @has_default_page_size_override
+          @default_page_size
+        else
+          context.schema.default_page_size
+        end
+      end
+
+      def has_default_page_size_override?
+        @has_default_page_size_override
+      end
+
       attr_writer :first
       # @return [Integer, nil]
       #   A clamped `first` value.
       #   (The underlying instance variable doesn't have limits on it.)
-      #   If neither `first` nor `last` is given, but `max_page_size` is present, max_page_size is used for first.
+      #   If neither `first` nor `last` is given, but `default_page_size` is
+      #   present, default_page_size is used for first. If `default_page_size`
+      #   is greater than `max_page_size``, it'll be clamped down to
+      #   `max_page_size`. If `default_page_size` is nil, use `max_page_size`.
       def first
         @first ||= begin
           capped = limit_pagination_argument(@first_value, max_page_size)
           if capped.nil? && last.nil?
-            capped = max_page_size
+            capped = limit_pagination_argument(default_page_size, max_page_size) || max_page_size
           end
           capped
         end

data/lib/graphql/pagination/connections.rb

@@ -70,6 +70,7 @@ module GraphQL
             parent: parent,
             field: field,
             max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            default_page_size: field.has_default_page_size? ? field.default_page_size : context.schema.default_page_size,
             first: arguments[:first],
             after: arguments[:after],
             last: arguments[:last],

data/lib/graphql/schema/field/connection_extension.rb

@@ -47,6 +47,9 @@ module GraphQL
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size
               end
+              if field.has_default_page_size? && !value.has_default_page_size_override?
+                value.default_page_size = field.default_page_size
+              end
               if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
                 value.edge_class = custom_t
               end
@@ -64,6 +67,7 @@ module GraphQL
                 original_arguments,
                 field: field,
                 max_page_size: field.max_page_size,
+                default_page_size: field.default_page_size,
                 parent: object,
                 context: context,
               )

data/lib/graphql/schema/field.rb

@@ -200,6 +200,7 @@ module GraphQL
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
+      # @param default_page_size [Integer, nil] For connections, the default number of items to return from this field, or `nil` to return unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver.
       # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
@@ -214,7 +215,8 @@ module GraphQL
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, &definition_block)
+      # @fallback_value [Object] A fallback value if the method is not defined
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, default_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -246,9 +248,12 @@ module GraphQL
           end
         end
 
-        method_name = method || name_s
+        method_name = method || hash_key || name_s
         @dig_keys = dig
-        @hash_key = hash_key
+        if hash_key
+          @hash_key = hash_key
+          @hash_key_str = hash_key.to_s
+        end
 
         @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
@@ -265,6 +270,8 @@ module GraphQL
         @connection = connection
         @has_max_page_size = max_page_size != :not_given
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
+        @has_default_page_size = default_page_size != :not_given
+        @default_page_size = default_page_size == :not_given ? nil : default_page_size
         @introspection = introspection
         @extras = extras
         if !broadcastable.nil?
@@ -277,6 +284,7 @@ module GraphQL
         @relay_nodes_field = relay_nodes_field
         @ast_node = ast_node
         @method_conflict_warning = method_conflict_warning
+        @fallback_value = fallback_value
 
         arguments.each do |name, arg|
           case arg
@@ -459,11 +467,11 @@ module GraphQL
           end
 
           if max_possible_page_size.nil?
-            max_possible_page_size = max_page_size || query.schema.default_max_page_size
+            max_possible_page_size = default_page_size || query.schema.default_page_size || max_page_size || query.schema.default_max_page_size
           end
 
           if max_possible_page_size.nil?
-            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `max_page_size` or `default_max_page_size`"
+            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `default_page_size`, `max_page_size` or `default_max_page_size`"
           else
             metadata_complexity = 0
             lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
@@ -491,7 +499,13 @@ module GraphQL
           case defined_complexity
           when Proc
             arguments = query.arguments_for(nodes.first, self)
-            defined_complexity.call(query.context, arguments.keyword_arguments, child_complexity)
+            if arguments.is_a?(GraphQL::ExecutionError)
+              return child_complexity
+            elsif arguments.respond_to?(:keyword_arguments)
+              arguments = arguments.keyword_arguments
+            end
+
+            defined_complexity.call(query.context, arguments, child_complexity)
           when Numeric
             defined_complexity + child_complexity
           else
@@ -534,6 +548,16 @@ module GraphQL
         @max_page_size || (@resolver_class && @resolver_class.max_page_size)
       end
 
+      # @return [Boolean] True if this field's {#default_page_size} should override the schema default.
+      def has_default_page_size?
+        @has_default_page_size || (@resolver_class && @resolver_class.has_default_page_size?)
+      end
+
+      # @return [Integer, nil] Applied to connections if {#has_default_page_size?}
+      def default_page_size
+        @default_page_size || (@resolver_class && @resolver_class.default_page_size)
+      end
+
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 
@@ -639,10 +663,8 @@ module GraphQL
 
               inner_object = obj.object
 
-              if @hash_key
-                inner_object[@hash_key]
-              elsif @dig_keys
-                inner_object.dig(*@dig_keys)
+              if defined?(@hash_key)
+                inner_object[@hash_key] || inner_object[@hash_key_str] || (@fallback_value != :not_given ? @fallback_value : nil)
               elsif obj.respond_to?(resolver_method)
                 method_to_call = resolver_method
                 method_receiver = obj
@@ -653,10 +675,26 @@ module GraphQL
                   obj.public_send(resolver_method)
                 end
               elsif inner_object.is_a?(Hash)
-                if inner_object.key?(@method_sym)
+                if @dig_keys
+                  inner_object.dig(*@dig_keys)
+                elsif defined?(@hash_key)
+                  if inner_object.key?(@hash_key)
+                    inner_object[@hash_key]
+                  elsif inner_object.key?(@hash_key_str)
+                    inner_object[@hash_key_str]
+                  elsif @fallback_value != :not_given
+                    @fallback_value
+                  else
+                    nil
+                  end
+                elsif inner_object.key?(@method_sym)
                   inner_object[@method_sym]
-                else
+                elsif inner_object.key?(@method_str)
                   inner_object[@method_str]
+                elsif @fallback_value != :not_given
+                  @fallback_value
+                else
+                  nil
                 end
               elsif inner_object.respond_to?(@method_sym)
                 method_to_call = @method_sym
@@ -666,6 +704,8 @@ module GraphQL
                 else
                   inner_object.public_send(@method_sym)
                 end
+              elsif @fallback_value != :not_given
+                @fallback_value
               else
                 raise <<-ERR
               Failed to implement #{@owner.graphql_name}.#{@name}, tried:
@@ -674,7 +714,7 @@ module GraphQL
               - `#{inner_object.class}##{@method_sym}`, which did not exist
               - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{inner_object}`, but it wasn't a Hash
 
-              To implement this field, define one of the methods above (and check for typos)
+              To implement this field, define one of the methods above (and check for typos), or supply a `fallback_value`.
               ERR
               end
             end
@@ -746,7 +786,7 @@ module GraphQL
 
         if unsatisfied_ruby_kwargs.any? || unsatisfied_method_params.any?
           raise FieldImplementationFailed.new, <<-ERR
-Failed to call #{method_name} on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
+Failed to call `#{method_name.inspect}` on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
 
 #{ unsatisfied_ruby_kwargs
     .map { |key, value| "- `#{key}: #{value}` was given by GraphQL but not defined in the Ruby method. Add `#{key}:` to the method parameters." }

data/lib/graphql/schema/resolver.rb

@@ -328,6 +328,27 @@ module GraphQL
           (!!defined?(@max_page_size)) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
         end
 
+        # Get or set the `default_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited default page size".)
+        # @param default_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `default_page_size` assigned to fields that use this resolver
+        def default_page_size(new_default_page_size = :not_given)
+          if new_default_page_size != :not_given
+            @default_page_size = new_default_page_size
+          elsif defined?(@default_page_size)
+            @default_page_size
+          elsif superclass.respond_to?(:default_page_size)
+            superclass.default_page_size
+          else
+            nil
+          end
+        end
+
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `default_page_size`
+        def has_default_page_size?
+          (!!defined?(@default_page_size)) || (superclass.respond_to?(:has_default_page_size?) && superclass.has_default_page_size?)
+        end
+
         # A non-normalized type configuration, without `null` applied
         def type_expr
           @type_expr || (superclass.respond_to?(:type_expr) ? superclass.type_expr : nil)

data/lib/graphql/schema/warden.rb

@@ -55,7 +55,9 @@ module GraphQL
               if visible_item.nil?
                 visible_item = item
               else
-                raise Schema::DuplicateNamesError, "Found two visible definitions for `#{item.path}`: #{visible_item.inspect}, #{item.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: item.path, duplicated_definition_1: visible_item.inspect, duplicated_definition_2: item.inspect
+                )
               end
             end
           end
@@ -362,7 +364,9 @@ module GraphQL
           if @reachable_type_set.add?(type)
             type_by_name = rt_hash[type.graphql_name] ||= type
             if type_by_name != type
-              raise DuplicateNamesError, "Found two visible type definitions for `#{type.graphql_name}`: #{type.inspect}, #{type_by_name.inspect}"
+              raise DuplicateNamesError.new(
+                duplicated_name: type.graphql_name, duplicated_definition_1: type.inspect, duplicated_definition_2: type_by_name.inspect
+              )
             end
             if type.kind.input_object?
               # recurse into visible arguments

data/lib/graphql/schema.rb

@@ -73,14 +73,16 @@ module GraphQL
     extend GraphQL::Schema::Member::HasAstNode
     extend GraphQL::Schema::FindInheritedValue
 
-    class DuplicateTypeNamesError < GraphQL::Error
-      def initialize(type_name:, first_definition:, second_definition:, path:)
-        super("Multiple definitions for `#{type_name}`. Previously found #{first_definition.inspect} (#{first_definition.class}), then found #{second_definition.inspect} (#{second_definition.class}) at #{path.join(".")}")
+    class DuplicateNamesError < GraphQL::Error
+      attr_reader :duplicated_name
+      def initialize(duplicated_name:, duplicated_definition_1:, duplicated_definition_2:)
+        @duplicated_name = duplicated_name
+        super(
+          "Found two visible definitions for `#{duplicated_name}`: #{duplicated_definition_1}, #{duplicated_definition_2}"
+        )
       end
     end
 
-    class DuplicateNamesError < GraphQL::Error; end
-
     class UnresolvedLateBoundTypeError < GraphQL::Error
       attr_reader :type
       def initialize(type:)
@@ -225,7 +227,9 @@ module GraphQL
                 if visible_t.nil?
                   visible_t = t
                 else
-                  raise DuplicateNamesError, "Found two visible type definitions for `#{k}`: #{visible_t.inspect}, #{t.inspect}"
+                  raise DuplicateNamesError.new(
+                    duplicated_name: k, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                  )
                 end
               end
             end
@@ -252,7 +256,9 @@ module GraphQL
               if visible_t.nil?
                 visible_t = t
               else
-                raise DuplicateNamesError, "Found two visible type definitions for `#{type_name}`: #{visible_t.inspect}, #{t.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: type_name, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                )
               end
             end
           end
@@ -500,6 +506,14 @@ module GraphQL
         end
       end
 
+      def default_page_size(new_default_page_size = nil)
+        if new_default_page_size
+          @default_page_size = new_default_page_size
+        else
+          @default_page_size || find_inherited_value(:default_page_size)
+        end
+      end
+
       def query_execution_strategy(new_query_execution_strategy = nil)
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
@@ -977,7 +991,9 @@ module GraphQL
         if !defined?(@subscription_extension_added) && subscription && self.subscriptions
           @subscription_extension_added = true
           subscription.all_field_definitions.each do |field|
-            field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            if !field.extensions.any? { |ext| ext.is_a?(Subscriptions::DefaultSubscriptionResolveExtension) }
+              field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            end
           end
         end
       end

data/lib/graphql/subscriptions.rb

@@ -39,12 +39,14 @@ module GraphQL
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+    # @param validate_update [Boolean] If false, then validation is skipped when executing updates
+    def initialize(schema:, validate_update: true, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
       end
       @default_broadcastable = default_broadcastable
       @schema = schema
+      @validate_update = validate_update
     end
 
     # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
@@ -117,14 +119,16 @@ module GraphQL
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      result = @schema.execute(
+      execute_options = {
         query: query_string,
         context: context,
         subscription_topic: event.topic,
         operation_name: operation_name,
         variables: variables,
         root_value: object,
-      )
+      }
+      execute_options[:validate] = validate_update?(**execute_options)
+      result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)
       if subscriptions_context[:no_update]
         result = nil
@@ -142,6 +146,14 @@ module GraphQL
       result
     end
 
+    # Define this method to customize whether to validate
+    # this subscription when executing an update.
+    #
+    # @return [Boolean] defaults to `true`, or false if `validate: false` is provided.
+    def validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:)
+      @validate_update
+    end
+
     # Run the update query for this subscription and deliver it
     # @see {#execute_update}
     # @see {#deliver}

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,15 +17,21 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         tracer.trace(platform_key, service: service_name) do |span|
           span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
+          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = if operations.empty?
+
+            resource = if operations.empty?
               first_query = data[:multiplex].queries.first
               fallback_transaction_name(first_query && first_query.context)
             else
               operations
             end
+            span.resource = resource if resource
 
             # For top span of query, set the analytics sample rate tag, if available.
             if analytics_enabled?
@@ -39,6 +45,8 @@ module GraphQL
             span.set_tag(:query_string, data[:query].query_string)
           end
 
+          prepare_span(key, data, span)
+
           yield
         end
       end
@@ -47,6 +55,13 @@ module GraphQL
         options.fetch(:service, 'ruby-graphql')
       end
 
+      # Implement this method in a subclass to apply custom tags to datadog spans
+      # @param key [String] The event being traced
+      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
+      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
+      def prepare_span(key, data, span)
+      end
+
       def tracer
         default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
 

data/lib/graphql/tracing/opentelemetry_tracing.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class OpenTelemetryTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => 'graphql.lex',
+        'parse' => 'graphql.parse',
+        'validate' => 'graphql.validate',
+        'analyze_query' => 'graphql.analyze_query',
+        'analyze_multiplex' => 'graphql.analyze_multiplex',
+        'execute_query' => 'graphql.execute_query',
+        'execute_query_lazy' => 'graphql.execute_query_lazy',
+        'execute_multiplex' => 'graphql.execute_multiplex'
+      }
+
+      def platform_trace(platform_key, key, data)
+        return yield if platform_key.nil?
+
+        tracer.in_span(platform_key, attributes: attributes_for(key, data)) do |span, _context|
+          yield.tap do |response|
+            errors = response[:errors]&.compact&.map { |e| e.to_h }&.to_json if key == 'validate'
+            unless errors.nil?
+              span.add_event(
+                'graphql.validation.error',
+                attributes: {
+                  'message' => errors
+                }
+              )
+            end
+          end
+        end
+      end
+
+      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
+
+      private
+
+      def tracer
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.tracer
+      end
+
+      def config
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.config
+      end
+
+      def platform_key_enabled?(ctx, key)
+        return false unless config[key]
+
+        ns = ctx.namespace(:opentelemetry)
+        return true if ns.empty? # restores original behavior so that keys are returned if tracing is not set in context.
+        return false unless ns.key?(key) && ns[key]
+
+        return true
+      end
+
+      def attributes_for(key, data)
+        attributes = {}
+        case key
+        when 'execute_query'
+          attributes['selected_operation_name'] = data[:query].selected_operation_name if data[:query].selected_operation_name
+          attributes['selected_operation_type'] = data[:query].selected_operation.operation_type
+          attributes['query_string'] = data[:query].query_string
+        end
+        attributes
+      end
+
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+
+        cache.fetch(key) do
+          cache[key] = if trace_phase == :field
+            return unless platform_key_enabled?(ctx, :enable_platform_field)
+
+            yield
+          elsif trace_phase == :authorized
+            return unless platform_key_enabled?(ctx, :enable_platform_authorized)
+
+            yield
+          elsif trace_phase == :resolve_type
+            return unless platform_key_enabled?(ctx, :enable_platform_resolve_type)
+
+            yield
+          else
+            raise "Unknown trace phase"
+          end
+        end
+      end
+    end
+  end
+end