graphql 1.10.3 → 1.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe0e22214a3e9457d34ff1cd9aa506abec6431d6dad443f87d297a8c88bbfb0d
-  data.tar.gz: 194b1ce3ee16b95b880f7488ea7cfa44a977330f7d218d591a6a2d076aed049e
+  metadata.gz: abb84b7f4f94ae78b7d23d8726590780465d0018a3b225fb9b0cefbd557e6c1b
+  data.tar.gz: 78222841f7996f8449081d272169e6bd7e120f5937a08ea04a33c04217ff21dd
 SHA512:
-  metadata.gz: 58a7a7149f8f36e42689aa746ecc18d2567ca8fde473dd152c785f26207d750cbc8f1e770d59fa4fdca87cb9d05948afa89a783419fc2accaeacdd29e5a36ab9
-  data.tar.gz: 59baab3d2e8c20050ac3378b5f9749e4989e28086609717c406134e299bf7804ff0207c8d67646e36ac7fd572db1cf6b8b6cca62a88e0133cfd7f5071ab0c046
+  metadata.gz: d935f76873acb5bf0f15f9fa7c6d74a1a8ac5268d4885216698b206c66cda923b5cc269f90cf708ac296bf5d2973f9e45fb52558b5223cc3c345ae2650933e0c
+  data.tar.gz: 601450b86d9d6e9f9445060c24ba0dc74ce88ab2d69b2551b5e8836b4f02d35a0794e75e32c6db60eaefffc22878c87b07162c77a65b8ea1b5e241d6262881ca

data/lib/graphql/execution/interpreter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"

data/lib/graphql/execution/interpreter/arguments_cache.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class ArgumentsCache
+        def initialize(query)
+          @query = query
+          @storage = Hash.new do |h, ast_node|
+            h[ast_node] = Hash.new do |h2, arg_owner|
+              h2[arg_owner] = Hash.new do |h3, parent_object|
+                # First, normalize all AST or Ruby values to a plain Ruby hash
+                args_hash = prepare_args_hash(ast_node)
+                # Then call into the schema to coerce those incoming values
+                arg_owner.coerce_arguments(parent_object, args_hash, query.context)
+              end
+            end
+          end
+        end
+
+        def fetch(ast_node, argument_owner, parent_object)
+          @storage[ast_node][argument_owner][parent_object]
+        end
+
+        private
+
+        NO_VALUE_GIVEN = Object.new
+
+        def prepare_args_hash(ast_arg_or_hash_or_value)
+          case ast_arg_or_hash_or_value
+          when Hash
+            args_hash = {}
+            ast_arg_or_hash_or_value.each do |k, v|
+              args_hash[k] = prepare_args_hash(v)
+            end
+            args_hash
+          when Array
+            ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
+          when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            args_hash = {}
+            ast_arg_or_hash_or_value.arguments.each do |arg|
+              v = prepare_args_hash(arg.value)
+              if v != NO_VALUE_GIVEN
+                args_hash[arg.name] = v
+              end
+            end
+            args_hash
+          when GraphQL::Language::Nodes::VariableIdentifier
+            if @query.variables.key?(ast_arg_or_hash_or_value.name)
+              variable_value = @query.variables[ast_arg_or_hash_or_value.name]
+              prepare_args_hash(variable_value)
+            else
+              NO_VALUE_GIVEN
+            end
+          when GraphQL::Language::Nodes::Enum
+            ast_arg_or_hash_or_value.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
+          else
+            ast_arg_or_hash_or_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -436,48 +436,8 @@ module GraphQL
           end
         end
 
-        NO_VALUE_GIVEN = Object.new
-
-        def prepare_args_hash(ast_arg_or_hash_or_value)
-          case ast_arg_or_hash_or_value
-          when Hash
-            args_hash = {}
-            ast_arg_or_hash_or_value.each do |k, v|
-              args_hash[k] = prepare_args_hash(v)
-            end
-            args_hash
-          when Array
-            ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
-          when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
-            args_hash = {}
-            ast_arg_or_hash_or_value.arguments.each do |arg|
-              v = prepare_args_hash(arg.value)
-              if v != NO_VALUE_GIVEN
-                args_hash[arg.name] = v
-              end
-            end
-            args_hash
-          when GraphQL::Language::Nodes::VariableIdentifier
-            if query.variables.key?(ast_arg_or_hash_or_value.name)
-              variable_value = query.variables[ast_arg_or_hash_or_value.name]
-              prepare_args_hash(variable_value)
-            else
-              NO_VALUE_GIVEN
-            end
-          when GraphQL::Language::Nodes::Enum
-            ast_arg_or_hash_or_value.name
-          when GraphQL::Language::Nodes::NullValue
-            nil
-          else
-            ast_arg_or_hash_or_value
-          end
-        end
-
-        def arguments(graphql_object, arg_owner, ast_node_or_hash)
-          # First, normalize all AST or Ruby values to a plain Ruby hash
-          args_hash = prepare_args_hash(ast_node_or_hash)
-          # Then call into the schema to coerce those incoming values
-          arg_owner.coerce_arguments(graphql_object, args_hash, context)
+        def arguments(graphql_object, arg_owner, ast_node)
+          query.arguments_for(ast_node, arg_owner, parent_object: graphql_object)
         end
 
         def write_invalid_null_in_response(path, invalid_null_error)

data/lib/graphql/language.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
+require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"

data/lib/graphql/language/nodes.rb

@@ -488,6 +488,8 @@ module GraphQL
 
         # @!attribute name
         #   @return [String] The identifier for this variable, _without_ `$`
+
+        self.children_method_name = :variables
       end
 
       # A query, mutation or subscription.

data/lib/graphql/language/printer.rb

@@ -93,7 +93,7 @@ module GraphQL
       end
 
       def print_input_object(input_object)
-        "{#{input_object.arguments.map { |a| "#{a.name}: #{print(a.value)}" }.join(", ")}}"
+        "{#{input_object.arguments.map { |a| print_argument(a) }.join(", ")}}"
       end
 
       def print_list_type(list_type)

data/lib/graphql/language/sanitized_printer.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # A custom printer used to print sanitized queries. It inlines provided variables
+    # within the query for facilitate logging and analysis of queries.
+    #
+    # The printer returns `nil` if the query is invalid.
+    #
+    # Since the GraphQL Ruby AST for a GraphQL query doesnt contain any reference
+    # on the type of fields or arguments, we have to track the current object, field
+    # and input type while printing the query.
+    #
+    # @example Printing a scrubbed string
+    #   printer = QueryPrinter.new(query)
+    #   puts printer.sanitized_query_string
+    #
+    # @see {Query#sanitized_query_string}
+    class SanitizedPrinter < GraphQL::Language::Printer
+
+      REDACTED = "\"<REDACTED>\""
+
+      def initialize(query)
+        @query = query
+        @current_type = nil
+        @current_field = nil
+        @current_input_type = nil
+      end
+
+      # @return [String, nil] A scrubbed query string, if the query was valid.
+      def sanitized_query_string
+        if query.valid?
+          print(query.document)
+        else
+          nil
+        end
+      end
+
+      def print_node(node, indent: "")
+        if node.is_a?(String)
+          type = @current_input_type.unwrap
+          # Replace any strings that aren't IDs or Enum values with REDACTED
+          if type.kind.enum? || type.graphql_name == "ID"
+            super
+          else
+            REDACTED
+          end
+        elsif node.is_a?(Array)
+          old_input_type = @current_input_type
+          if @current_input_type && @current_input_type.list?
+            @current_input_type = @current_input_type.of_type
+            @current_input_type = @current_input_type.of_type if @current_input_type.non_null?
+          end
+
+          res = super
+          @current_input_type = old_input_type
+          res
+        else
+          super
+        end
+      end
+
+      def print_argument(argument)
+        arg_owner = @current_input_type || @current_directive || @current_field
+        arg_def = arg_owner.arguments[argument.name]
+
+        old_input_type = @current_input_type
+        @current_input_type = arg_def.type.non_null? ? arg_def.type.of_type : arg_def.type
+        res = super
+        @current_input_type = old_input_type
+        res
+      end
+
+      def print_list_type(list_type)
+        old_input_type = @current_input_type
+        @current_input_type = old_input_type.of_type
+        res = super
+        @current_input_type = old_input_type
+        res
+      end
+
+      def print_variable_identifier(variable_id)
+        variable_value = query.variables[variable_id.name]
+        print_node(value_to_ast(variable_value, @current_input_type))
+      end
+
+      def print_field(field, indent: "")
+        @current_field = query.schema.get_field(@current_type, field.name)
+        old_type = @current_type
+        @current_type = @current_field.type.unwrap
+        res = super
+        @current_type = old_type
+        res
+      end
+
+      def print_inline_fragment(inline_fragment, indent: "")
+        old_type = @current_type
+
+        if inline_fragment.type
+          @current_type = query.schema.types[inline_fragment.type.name]
+        end
+
+        res = super
+
+        @current_type = old_type
+
+        res
+      end
+
+      def print_fragment_definition(fragment_def, indent: "")
+        old_type = @current_type
+        @current_type = query.schema.types[fragment_def.type.name]
+
+        res = super
+
+        @current_type = old_type
+
+        res
+      end
+
+      def print_directive(directive)
+        @current_directive = query.schema.directives[directive.name]
+
+        res = super
+
+        @current_directive = nil
+        res
+      end
+
+      # Print the operation definition but do not include the variable
+      # definitions since we will inline them within the query
+      def print_operation_definition(operation_definition, indent: "")
+        old_type = @current_type
+        @current_type = query.schema.public_send(operation_definition.operation_type)
+
+        out = "#{indent}#{operation_definition.operation_type}".dup
+        out << " #{operation_definition.name}" if operation_definition.name
+        out << print_directives(operation_definition.directives)
+        out << print_selections(operation_definition.selections, indent: indent)
+
+        @current_type = old_type
+        out
+      end
+
+      private
+
+      def value_to_ast(value, type)
+        type = type.of_type if type.non_null?
+
+        if value.nil?
+          return GraphQL::Language::Nodes::NullValue.new(name: "null")
+        end
+
+        case type.kind.name
+        when "INPUT_OBJECT"
+          value = if value.respond_to?(:to_unsafe_h)
+            # for ActionController::Parameters
+            value.to_unsafe_h
+          else
+            value.to_h
+          end
+
+          arguments = value.map do |key, val|
+            sub_type = type.arguments[key.to_s].type
+
+            GraphQL::Language::Nodes::Argument.new(
+              name: key.to_s,
+              value: value_to_ast(val, sub_type)
+            )
+          end
+          GraphQL::Language::Nodes::InputObject.new(
+            arguments: arguments
+          )
+        when "LIST"
+          if value.respond_to?(:each)
+            value.each { |v| value_to_ast(v, type.of_type) }
+          else
+            [value].each { |v| value_to_ast(v, type.of_type) }
+          end
+        when "ENUM"
+          GraphQL::Language::Nodes::Enum.new(name: value)
+        else
+          value
+        end
+      end
+
+      attr_reader :query
+    end
+  end
+end

data/lib/graphql/query.rb

@@ -124,8 +124,6 @@ module GraphQL
         end
       end
 
-      @arguments_cache = ArgumentsCache.build(self)
-
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
@@ -243,10 +241,28 @@ module GraphQL
     end
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @api private
-    # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
-    def arguments_for(irep_or_ast_node, definition)
-      @arguments_cache[irep_or_ast_node][definition]
+    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+    # @param definition [GraphQL::Schema::Field]
+    # @param parent_object [GraphQL::Schema::Object]
+    # @return Hash{Symbol => Object}
+    def arguments_for(ast_node, definition, parent_object: nil)
+      if interpreter?
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+        @arguments_cache.fetch(ast_node, definition, parent_object)
+      else
+        @arguments_cache ||= ArgumentsCache.build(self)
+        @arguments_cache[ast_node][definition]
+      end
+    end
+
+    # A version of the given query string, with:
+    # - Variables inlined to the query
+    # - Strings replaced with `<REDACTED>`
+    # @return [String, nil] Returns nil if the query is invalid.
+    def sanitized_query_string
+      with_prepared_ast {
+        GraphQL::Language::SanitizedPrinter.new(self).sanitized_query_string
+      }
     end
 
     def validation_pipeline

data/lib/graphql/schema.rb

@@ -82,6 +82,12 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     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(".")}")
+      end
+    end
+
     class UnresolvedLateBoundTypeError < GraphQL::Error
       attr_reader :type
       def initialize(type:)
@@ -715,14 +721,20 @@ module GraphQL
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
     # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: BuildFromDefinition::DefaultResolve, interpreter: true, parser: BuildFromDefinition::DefaultParser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: BuildFromDefinition::DefaultParser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
       definition = if definition_or_path.end_with?(".graphql")
         File.read(definition_or_path)
       else
         definition_or_path
       end
-      GraphQL::Schema::BuildFromDefinition.from_definition(definition, default_resolve: default_resolve, parser: parser, using: using, interpreter: interpreter)
+      GraphQL::Schema::BuildFromDefinition.from_definition(
+        definition,
+        default_resolve: default_resolve,
+        parser: parser,
+        using: using,
+        interpreter: interpreter,
+      )
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
@@ -1686,7 +1698,7 @@ module GraphQL
         end
         late_types = []
         new_types = Array(t)
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types) }
+        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
           type_owner, lt = late_type_vals
@@ -1695,13 +1707,13 @@ module GraphQL
             # Reset the counter, since we might succeed next go-round
             missed_late_types = 0
             update_type_owner(type_owner, type)
-            add_type(type, owner: type_owner, late_types: late_types)
+            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
           elsif lt.is_a?(LateBoundType)
             if (type = get_type(lt.graphql_name))
               # Reset the counter, since we might succeed next go-round
               missed_late_types = 0
               update_type_owner(type_owner, type)
-              add_type(type, owner: type_owner, late_types: late_types)
+              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
             else
               missed_late_types += 1
               # Add it back to the list, maybe we'll be able to resolve it later.
@@ -1776,7 +1788,7 @@ module GraphQL
         end
       end
 
-      def add_type(type, owner:, late_types:)
+      def add_type(type, owner:, late_types:, path:)
         if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
           type_class = type.metadata[:type_class]
           if type_class.nil?
@@ -1796,46 +1808,52 @@ module GraphQL
 
         if (prev_type = own_types[type.graphql_name])
           if prev_type != type
-            raise ArgumentError, "Conflicting type definitions for `#{type.graphql_name}`: #{prev_type} (#{prev_type.class}), #{type} #{type.class}"
+            raise DuplicateTypeNamesError.new(
+              type_name: type.graphql_name,
+              first_definition: prev_type,
+              second_definition: type,
+              path: path,
+            )
           else
             # This type was already added
           end
         elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
-          type.arguments.each do |_name, arg|
+          type.arguments.each do |name, arg|
             arg_type = arg.type.unwrap
             references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path + [name])
           end
         else
           own_types[type.graphql_name] = type
           if type.kind.fields?
-            type.fields.each do |_name, field|
+            type.fields.each do |name, field|
               field_type = field.type.unwrap
               references_to(field_type, from: field)
-              add_type(field_type, owner: field, late_types: late_types)
-              field.arguments.each do |_name, arg|
+              field_path = path + [name]
+              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              field.arguments.each do |arg_name, arg|
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types)
+                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
               end
             end
           end
           if type.kind.input_object?
-            type.arguments.each do |_name, arg|
+            type.arguments.each do |arg_name, arg|
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
             end
           end
           if type.kind.union?
             own_possible_types[type.graphql_name] = type.possible_types
             type.possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types)
+              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
             end
           end
           if type.kind.interface?
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types)
+              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
             end
           end
           if type.kind.object?
@@ -1843,7 +1861,7 @@ module GraphQL
             type.interfaces.each do |i|
               implementers = own_possible_types[i.graphql_name] ||= []
               implementers << type
-              add_type(i, owner: type, late_types: late_types)
+              add_type(i, owner: type, late_types: late_types, path: path + ["implements"])
             end
           end
         end

data/lib/graphql/schema/argument.rb

@@ -55,7 +55,7 @@ module GraphQL
         @owner = owner
         @as = as
         @loads = loads
-        @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
+        @keyword = as || (arg_name.is_a?(Symbol) ? arg_name : Schema::Member::BuildType.underscore(@name).to_sym)
         @prepare = prepare
         @ast_node = ast_node
         @from_resolver = from_resolver

data/lib/graphql/schema/build_from_definition.rb

@@ -5,31 +5,22 @@ module GraphQL
   class Schema
     module BuildFromDefinition
       class << self
-        def from_definition(definition_string, default_resolve:, using: {}, interpreter: true, parser: DefaultParser)
+        # @see {Schema.from_definition}
+        def from_definition(definition_string, default_resolve:, using: {}, relay: false, interpreter: true, parser: DefaultParser)
           document = parser.parse(definition_string)
-          Builder.build(document, default_resolve: default_resolve, using: using, interpreter: interpreter)
+          default_resolve ||= {}
+          Builder.build(document, default_resolve: default_resolve, relay: relay, using: using, interpreter: interpreter)
         end
       end
 
       # @api private
       DefaultParser = GraphQL::Language::Parser
 
-      # @api private
-      module DefaultResolve
-        def self.call(type, field, obj, args, ctx)
-          if field.arguments.any?
-            obj.public_send(field.name, args, ctx)
-          else
-            obj.public_send(field.name)
-          end
-        end
-      end
-
       # @api private
       module Builder
         extend self
 
-        def build(document, default_resolve: DefaultResolve, using: {}, interpreter: true)
+        def build(document, default_resolve:, using: {}, interpreter: true, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
           if default_resolve.is_a?(Hash)
@@ -316,6 +307,7 @@ module GraphQL
               type: type_resolver.call(field_definition.type),
               null: true,
               connection: type_name.end_with?("Connection"),
+              connection_extension: nil,
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
               method_conflict_warning: false,

data/lib/graphql/schema/field.rb

@@ -172,6 +172,7 @@ module GraphQL
       # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @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] For connections, the maximum number of items to return from this field
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
@@ -187,7 +188,7 @@ module GraphQL
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
       # @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
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: EMPTY_HASH, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], 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, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -275,8 +276,8 @@ module GraphQL
         end
         # The problem with putting this after the definition_block
         # is that it would override arguments
-        if connection?
-          self.extension(self.class.connection_extension)
+        if connection? && connection_extension
+          self.extension(connection_extension)
         end
 
         if definition_block

data/lib/graphql/tracing.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
+require "graphql/tracing/appoptics_tracing"
 require "graphql/tracing/appsignal_tracing"
 require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+
+    # This class uses the AppopticsAPM SDK from the appoptics_apm gem to create
+    # traces for GraphQL.
+    #
+    # There are 4 configurations available. They can be set in the
+    # appoptics_apm config file or in code. Please see:
+    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    #
+    #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
+    #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false
+    #     AppOpticsAPM::Config[:graphql][:sanitize_query] = true|false
+    #     AppOpticsAPM::Config[:graphql][:remove_comments] = true|false
+    class AppOpticsTracing < GraphQL::Tracing::PlatformTracing
+      # These GraphQL events will show up as 'graphql.prep' spans
+      PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+      # These GraphQL events will show up as 'graphql.execute' spans
+      EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+      # During auto-instrumentation this version of AppOpticsTracing is compared
+      # with the version provided in the appoptics_apm gem, so that the newer
+      # version of the class can be used
+
+      def self.version
+        Gem::Version.new('1.0.0')
+      end
+
+      self.platform_keys = {
+        'lex' => 'lex',
+        'parse' => 'parse',
+        'validate' => 'validate',
+        'analyze_query' => 'analyze_query',
+        'analyze_multiplex' => 'analyze_multiplex',
+        'execute_multiplex' => 'execute_multiplex',
+        'execute_query' => 'execute_query',
+        'execute_query_lazy' => 'execute_query_lazy'
+      }
+
+      def platform_trace(platform_key, _key, data)
+        return yield if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+
+        layer = span_name(platform_key)
+        kvs = metadata(data, layer)
+        kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+        transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.name}.#{field.name}"
+      end
+
+      private
+
+      def gql_config
+        ::AppOpticsAPM::Config[:graphql] ||= {}
+      end
+
+      def transaction_name(query)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        split_query = query.strip.split(/\W+/, 3)
+        split_query[0] = 'query' if split_query[0].empty?
+        name = "graphql.#{split_query[0..1].join('.')}"
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def multiplex_transaction_name(names)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        name = "graphql.multiplex.#{names.join('.')}"
+        name = "#{name[0..251]}..." if name.length > 254
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def span_name(key)
+        return 'graphql.prep' if PREP_KEYS.include?(key)
+        return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+        key[/^graphql\./] ? key : "graphql.#{key}"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def metadata(data, layer)
+        data.keys.map do |key|
+          case key
+          when :context
+            graphql_context(data[key], layer)
+          when :query
+            graphql_query(data[key])
+          when :query_string
+            graphql_query_string(data[key])
+          when :multiplex
+            graphql_multiplex(data[key])
+          else
+            [key, data[key]]
+          end
+        end.flatten.each_slice(2).to_h.merge(Spec: 'graphql')
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def graphql_context(context, layer)
+        context.errors && context.errors.each do |err|
+          AppOpticsAPM::API.log_exception(layer, err)
+        end
+
+        [[:Path, context.path.join('.')]]
+      end
+
+      def graphql_query(query)
+        return [] unless query
+
+        query_string = query.query_string
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [[:InboundQuery, query_string],
+         [:Operation, query.selected_operation_name]]
+      end
+
+      def graphql_query_string(query_string)
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [:InboundQuery, query_string]
+      end
+
+      def graphql_multiplex(data)
+        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        multiplex_transaction_name(names) if names.size > 1
+
+        [:Operations, names.join(', ')]
+      end
+
+      def sanitize(query)
+        return unless query
+
+        # remove arguments
+        query.gsub(/"[^"]*"/, '"?"')                 # strings
+          .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+          .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+      end
+
+      def remove_comments(query)
+        return unless query
+
+        query.gsub(/#[^\n\r]*/, '')
+      end
+    end
+  end
+end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.3
+  version: 1.10.4
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-17 00:00:00.000000000 Z
+date: 2020-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -422,6 +422,7 @@ files:
 - lib/graphql/execution/flatten.rb
 - lib/graphql/execution/instrumentation.rb
 - lib/graphql/execution/interpreter.rb
+- lib/graphql/execution/interpreter/arguments_cache.rb
 - lib/graphql/execution/interpreter/execution_errors.rb
 - lib/graphql/execution/interpreter/handles_raw_value.rb
 - lib/graphql/execution/interpreter/hash_response.rb
@@ -477,6 +478,7 @@ files:
 - lib/graphql/language/parser.rb
 - lib/graphql/language/parser.y
 - lib/graphql/language/printer.rb
+- lib/graphql/language/sanitized_printer.rb
 - lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/list_type.rb
@@ -682,6 +684,7 @@ files:
 - lib/graphql/subscriptions/subscription_root.rb
 - lib/graphql/tracing.rb
 - lib/graphql/tracing/active_support_notifications_tracing.rb
+- lib/graphql/tracing/appoptics_tracing.rb
 - lib/graphql/tracing/appsignal_tracing.rb
 - lib/graphql/tracing/data_dog_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
@@ -743,7 +746,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby