graphql 1.8.0 → 1.12.12

data/lib/graphql/tracing/platform_tracing.rb

@@ -26,13 +26,48 @@ module GraphQL
             yield
           end
         when "execute_field", "execute_field_lazy"
-          if (platform_key = data[:context].field.metadata[:platform_key])
+          if data[:context]
+            field = data[:context].field
+            platform_key = field.metadata[:platform_key]
+            trace_field = true # implemented with instrumenter
+          else
+            field = data[:field]
+            return_type = field.type.unwrap
+            trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+              (field.trace.nil? && @trace_scalars) || field.trace
+            else
+              true
+            end
+
+            platform_key = if trace_field
+              context = data.fetch(:query).context
+              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+            else
+              nil
+            end
+          end
+
+          if platform_key && trace_field
             platform_trace(platform_key, key, data) do
               yield
             end
           else
             yield
           end
+        when "authorized", "authorized_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
+        when "resolve_type", "resolve_type_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
         else
           # it's a custom key
           yield
@@ -60,13 +95,45 @@ module GraphQL
       end
 
       def self.use(schema_defn, options = {})
-        tracer = self.new(options)
-        schema_defn.instrument(:field, tracer)
+        tracer = self.new(**options)
+        if !schema_defn.is_a?(Class)
+          schema_defn.instrument(:field, tracer)
+        end
         schema_defn.tracer(tracer)
       end
 
       private
+
+      # Get the transaction name based on the operation type and name
+      def transaction_name(query)
+        selected_op = query.selected_operation
+        if selected_op
+          op_type = selected_op.operation_type
+          op_name = selected_op.name || "anonymous"
+        else
+          op_type = "query"
+          op_name = "anonymous"
+        end
+        "GraphQL/#{op_type}.#{op_name}"
+      end
+
       attr_reader :options
+
+      # Different kind of schema objects have different kinds of keys:
+      #
+      # - Object types: `.authorized`
+      # - Union/Interface types: `.resolve_type`
+      # - Fields: execution
+      #
+      # So, they can all share one cache.
+      #
+      # If the key isn't present, the given block is called and the result is cached for `key`.
+      #
+      # @return [String]
+      def cached_platform_key(ctx, key)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+        cache.fetch(key) { cache[key] = yield }
+      end
     end
   end
 end

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class PrometheusTracing < PlatformTracing
+      class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
+        def initialize
+          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+            'graphql_duration_seconds',
+            'Time spent in GraphQL operations, in seconds'
+          )
+        end
+
+        def type
+          'graphql'
+        end
+
+        def collect(object)
+          default_labels = { key: object['key'], platform_key: object['platform_key'] }
+          custom = object['custom_labels']
+          labels = custom.nil? ? default_labels : default_labels.merge(custom)
+
+          @graphql_gauge.observe object['duration'], labels
+        end
+
+        def metrics
+          [@graphql_gauge]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class PrometheusTracing < PlatformTracing
+      DEFAULT_WHITELIST = ['execute_field', 'execute_field_lazy'].freeze
+      DEFAULT_COLLECTOR_TYPE = 'graphql'.freeze
+
+      self.platform_keys = {
+        'lex' => "graphql.lex",
+        'parse' => "graphql.parse",
+        'validate' => "graphql.validate",
+        'analyze_query' => "graphql.analyze",
+        'analyze_multiplex' => "graphql.analyze",
+        'execute_multiplex' => "graphql.execute",
+        'execute_query' => "graphql.execute",
+        'execute_query_lazy' => "graphql.execute",
+        'execute_field' => "graphql.execute",
+        'execute_field_lazy' => "graphql.execute"
+      }
+
+      def initialize(opts = {})
+        @client = opts[:client] || PrometheusExporter::Client.default
+        @keys_whitelist = opts[:keys_whitelist] || DEFAULT_WHITELIST
+        @collector_type = opts[:collector_type] || DEFAULT_COLLECTOR_TYPE
+
+        super opts
+      end
+
+      def platform_trace(platform_key, key, data, &block)
+        return yield unless @keys_whitelist.include?(key)
+        instrument_execution(platform_key, key, data, &block)
+      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 instrument_execution(platform_key, key, data, &block)
+        start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
+        result = block.call
+        duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
+        observe platform_key, key, duration
+        result
+      end
+
+      def observe(platform_key, key, duration)
+        @client.send_json(
+          type: @collector_type,
+          duration: duration,
+          platform_key: platform_key,
+          key: key
+        )
+      end
+    end
+  end
+end

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,19 +16,38 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_scout_transaction_name]`.
       def initialize(options = {})
         self.class.include ScoutApm::Tracer
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
         super(options)
       end
 
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name = data[:query].context[:set_scout_transaction_name]
+          if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+            ScoutApm::Transaction.rename(transaction_name(data[:query]))
+          end
+        end
+
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
           yield
         end
       end
 
       def platform_field_key(type, field)
-        "#{type.name}.#{field.name}"
+        "#{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

data/lib/graphql/tracing/skylight_tracing.rb

@@ -14,10 +14,33 @@ module GraphQL
         "execute_query_lazy" => "graphql.execute",
       }
 
+      # @param set_endpoint_name [Boolean] If true, the GraphQL operation name will be used as the endpoint name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_skylight_endpoint_name]`.
+      def initialize(options = {})
+        GraphQL::Deprecation.warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
+        @set_endpoint_name = options.fetch(:set_endpoint_name, false)
+        super
+      end
+
       def platform_trace(platform_key, key, data)
-        if (query = data[:query])
+        if key == "execute_query"
+          query = data[:query]
           title = query.selected_operation_name || "<anonymous>"
           category = platform_key
+          set_endpoint_name_override = query.context[:set_skylight_endpoint_name]
+          if set_endpoint_name_override == true || (set_endpoint_name_override.nil? && @set_endpoint_name)
+            # Assign the endpoint so that queries will be grouped
+            instrumenter = Skylight.instrumenter
+            if instrumenter
+              current_trace = instrumenter.current_trace
+              if current_trace
+                op_type = query.selected_operation ? query.selected_operation.operation_type : "query"
+                endpoint = "GraphQL/#{op_type}.#{title}"
+                current_trace.endpoint = endpoint
+              end
+            end
+          end
         elsif key.start_with?("execute_field")
           title = platform_key
           category = key
@@ -32,7 +55,15 @@ module GraphQL
       end
 
       def platform_field_key(type, field)
-        "graphql.#{type.name}.#{field.name}"
+        "graphql.#{type.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
       end
     end
   end

data/lib/graphql/tracing/statsd_tracing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class StatsdTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => "graphql.lex",
+        'parse' => "graphql.parse",
+        'validate' => "graphql.validate",
+        'analyze_query' => "graphql.analyze_query",
+        'analyze_multiplex' => "graphql.analyze_multiplex",
+        'execute_multiplex' => "graphql.execute_multiplex",
+        'execute_query' => "graphql.execute_query",
+        'execute_query_lazy' => "graphql.execute_query_lazy",
+      }
+
+      # @param statsd [Object] A statsd client
+      def initialize(statsd:, **rest)
+        @statsd = statsd
+        super(**rest)
+      end
+
+      def platform_trace(platform_key, key, data)
+        @statsd.time(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -1,33 +1,33 @@
 # 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"
 require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"
+require "graphql/tracing/statsd_tracing"
+require "graphql/tracing/prometheus_tracing"
+
+if defined?(PrometheusExporter::Server)
+  require "graphql/tracing/prometheus_tracing/graphql_collector"
+end
 
 module GraphQL
   # Library entry point for performance metric reporting.
   #
-  # {ActiveSupportNotificationsTracing} is imported by default
-  # when `ActiveSupport::Notifications` is found.
-  #
-  # You can remove it with `GraphQL::Tracing.uninstall(GraphQL::Tracing::ActiveSupportNotificationsTracing)`.
-  #
-  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
-  #
   # @example Sending custom events
-  #   GraphQL::Tracing.trace("my_custom_event", { ... }) do
+  #   query.trace("my_custom_event", { ... }) do
   #     # do stuff ...
   #   end
   #
   # @example Adding a tracer to a schema
-  #  MySchema = GraphQL::Schema.define do
+  #  class MySchema < GraphQL::Schema
   #    tracer MyTracer # <= responds to .trace(key, data, &block)
   #  end
   #
-  # @example Adding a tracer to a query
+  # @example Adding a tracer to a single query
   #   MySchema.execute(query_str, context: { backtrace: true })
   #
   # Events:
@@ -42,8 +42,17 @@ module GraphQL
   # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
   # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
+  # execute_field | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # execute_field_lazy | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # authorized | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # authorized_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  #
+  # Note that `execute_field` and `execute_field_lazy` receive different data in different settings:
+  #
+  # - When using {GraphQL::Execution::Interpreter}, they receive `{field:, path:, query:}`
+  # - Otherwise, they receive `{context: ...}`
   #
   module Tracing
     # Objects may include traceable to gain a `.trace(...)` method.
@@ -53,8 +62,9 @@ module GraphQL
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
-      def trace(key, metadata)
-        call_tracers(0, key, metadata) { yield }
+      def trace(key, metadata, &block)
+        return yield if @tracers.empty?
+        call_tracers(0, key, metadata, &block)
       end
 
       private
@@ -66,40 +76,15 @@ module GraphQL
       # @param key [String] The current event name
       # @param metadata [Object] The current event object
       # @return Whatever the block returns
-      def call_tracers(idx, key, metadata)
+      def call_tracers(idx, key, metadata, &block)
         if idx == @tracers.length
           yield
         else
-          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         end
       end
     end
 
-    class << self
-      # Install a tracer to receive events.
-      # @param tracer [<#trace(key, metadata)>]
-      # @return [void]
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def install(tracer)
-        warn("GraphQL::Tracing.install is deprecated, add it to the schema with `tracer(my_tracer)` instead.")
-        if !tracers.include?(tracer)
-          @tracers << tracer
-        end
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def uninstall(tracer)
-        @tracers.delete(tracer)
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def tracers
-        @tracers ||= []
-      end
-    end
-    # Initialize the array
-    tracers
-
     module NullTracer
       module_function
       def trace(k, v)

data/lib/graphql/type_kinds.rb

@@ -5,18 +5,21 @@ module GraphQL
     # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
     class TypeKind
       attr_reader :name, :description
-      def initialize(name, resolves: false, fields: false, wraps: false, input: false, description: nil)
+      def initialize(name, abstract: false, fields: false, wraps: false, input: false, description: nil)
         @name = name
-        @resolves = resolves
+        @abstract = abstract
         @fields = fields
         @wraps = wraps
         @input = input
-        @composite = fields? || resolves?
+        @composite = fields? || abstract?
         @description = description
       end
 
       # Does this TypeKind have multiple possible implementors?
-      def resolves?;  @resolves;  end
+      # @deprecated Use `abstract?` instead of `resolves?`.
+      def resolves?;  @abstract;  end
+      # Is this TypeKind abstract?
+      def abstract?; @abstract; end
       # Does this TypeKind have queryable fields?
       def fields?;    @fields;    end
       # Does this TypeKind modify another type?
@@ -26,25 +29,49 @@ module GraphQL
       def to_s;       @name;      end
       # Is this TypeKind composed of many values?
       def composite?; @composite; end
+
+      def scalar?
+        self == TypeKinds::SCALAR
+      end
+
+      def object?
+        self == TypeKinds::OBJECT
+      end
+
+      def interface?
+        self == TypeKinds::INTERFACE
+      end
+
+      def union?
+        self == TypeKinds::UNION
+      end
+
+      def enum?
+        self == TypeKinds::ENUM
+      end
+
+      def input_object?
+        self == TypeKinds::INPUT_OBJECT
+      end
+
+      def list?
+        self == TypeKinds::LIST
+      end
+
+      def non_null?
+        self == TypeKinds::NON_NULL
+      end
     end
 
     TYPE_KINDS = [
       SCALAR =        TypeKind.new("SCALAR", input: true, description: 'Indicates this type is a scalar.'),
       OBJECT =        TypeKind.new("OBJECT", fields: true, description: 'Indicates this type is an object. `fields` and `interfaces` are valid fields.'),
-      INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
-      UNION =         TypeKind.new("UNION", resolves: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
+      INTERFACE =     TypeKind.new("INTERFACE", abstract: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
+      UNION =         TypeKind.new("UNION", abstract: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
       ENUM =          TypeKind.new("ENUM", input: true, description: 'Indicates this type is an enum. `enumValues` is a valid field.'),
       INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true, description: 'Indicates this type is an input object. `inputFields` is a valid field.'),
       LIST =          TypeKind.new("LIST", wraps: true, description: 'Indicates this type is a list. `ofType` is a valid field.'),
       NON_NULL =      TypeKind.new("NON_NULL", wraps: true, description: 'Indicates this type is a non-null. `ofType` is a valid field.'),
     ]
-
-    class TypeKind
-      TYPE_KINDS.map(&:name).each do |kind_name|
-        define_method("#{kind_name.downcase}?") do
-          self.name == kind_name
-        end
-      end
-    end
   end
 end

data/lib/graphql/types/big_int.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class BigInt < GraphQL::Schema::Scalar
+      description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
+
+      def self.coerce_input(value, _ctx)
+        value && Integer(value)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        value.to_i.to_s
+      end
+    end
+  end
+end

data/lib/graphql/types/boolean.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    class Boolean < GraphQL::Schema::Scalar
+      description "Represents `true` or `false` values."
+
+      def self.coerce_input(value, _ctx)
+        (value == true || value == false) ? value : nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        !!value
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types/float.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class Float < GraphQL::Schema::Scalar
+      description "Represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point)."
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(Numeric) ? value.to_f : nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        value.to_f
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types/id.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    class ID < GraphQL::Schema::Scalar
+      graphql_name "ID"
+      description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
+      default_scalar true
+      def self.coerce_result(value, _ctx)
+        value.is_a?(::String) ? value : value.to_s
+      end
+
+      def self.coerce_input(value, _ctx)
+        case value
+        when ::String
+          value
+        when Integer
+          value.to_s
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/int.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    # @see {Types::BigInt} for handling integers outside 32-bit range.
+    class Int < GraphQL::Schema::Scalar
+      description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
+
+      MIN = -(2**31)
+      MAX = (2**31) - 1
+
+      def self.coerce_input(value, ctx)
+        return if !value.is_a?(Integer)
+
+        if value >= MIN && value <= MAX
+          value
+        else
+          err = GraphQL::IntegerDecodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
+      end
+
+      def self.coerce_result(value, ctx)
+        value = value.to_i
+        if value >= MIN && value <= MAX
+          value
+        else
+          err = GraphQL::IntegerEncodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
+      end
+
+      default_scalar true
+    end
+  end
+end