graphql 1.10.2 → 2.0.21

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

@@ -5,7 +5,7 @@ module GraphQL
     class PrometheusTracing < PlatformTracing
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
-          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+          @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
             'graphql_duration_seconds',
             'Time spent in GraphQL operations, in seconds'
           )
@@ -16,7 +16,10 @@ module GraphQL
         end
 
         def collect(object)
-          labels = { key: object['key'], platform_key: object['platform_key'] }
+          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
 

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -27,9 +27,9 @@ module GraphQL
         super opts
       end
 
-      def platform_trace(platform_key, key, data, &block)
+      def platform_trace(platform_key, key, _data, &block)
         return yield unless @keys_whitelist.include?(key)
-        instrument_execution(platform_key, key, data, &block)
+        instrument_execution(platform_key, key, &block)
       end
 
       def platform_field_key(type, field)
@@ -46,7 +46,7 @@ module GraphQL
 
       private
 
-      def instrument_execution(platform_key, key, data, &block)
+      def instrument_execution(platform_key, key, &block)
         start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
         result = block.call
         duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start

data/lib/graphql/tracing/scout_trace.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module ScoutTrace
+      include PlatformTrace
+
+      INSTRUMENT_OPTS = { scope: true }
+
+      # @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(set_transaction_name: false, **_rest)
+        self.class.include(ScoutApm::Tracer)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+
+      {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_query" => "analyze.graphql",
+        "analyze_multiplex" => "analyze.graphql",
+        "execute_multiplex" => "execute.graphql",
+        "execute_query" => "execute.graphql",
+        "execute_query_lazy" => "execute.graphql",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+        def #{trace_method}(**data)
+          #{
+            if trace_method == "execute_query"
+              <<-RUBY
+              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
+              RUBY
+            end
+          }
+
+          self.class.instrument("GraphQL", "#{platform_key}", INSTRUMENT_OPTS) do
+            super
+          end
+        end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, &block)
+        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)
+      end
+
+      def platform_authorized(platform_key, &block)
+        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)
+      end
+
+      alias :platform_resolve_type :platform_authorized
+
+      def platform_field_key(field)
+        field.path
+      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/scout_tracing.rb

@@ -16,12 +16,23 @@ 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

data/lib/graphql/tracing/statsd_trace.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module StatsdTrace
+      include PlatformTrace
+
+      # @param statsd [Object] A statsd client
+      def initialize(statsd:, **rest)
+        @statsd = statsd
+        super(**rest)
+      end
+
+      {
+        '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",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            @statsd.time("#{platform_key}") do
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, &block)
+        @statsd.time(platform_key, &block)
+      end
+
+      def platform_authorized(key, &block)
+        @statsd.time(key, &block)
+      end
+
+      alias :platform_resolve_type :platform_authorized
+
+      def platform_field_key(field)
+        "graphql.#{field.path}"
+      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/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/trace.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This is the base class for a `trace` instance whose methods are called during query execution.
+    # "Trace modes" are subclasses of this with custom tracing modules mixed in.
+    #
+    # A trace module may implement any of the methods on `Trace`, being sure to call `super`
+    # to continue any tracing hooks and call the actual runtime behavior. See {GraphQL::Backtrace::Trace} for example.
+    #
+    class Trace
+      # @param multiplex [GraphQL::Execution::Multiplex, nil]
+      # @param query [GraphQL::Query, nil]
+      def initialize(multiplex: nil, query: nil, **_options)
+        @multiplex = multiplex
+        @query = query
+      end
+
+      def lex(query_string:)
+        yield
+      end
+
+      def parse(query_string:)
+        yield
+      end
+
+      def validate(query:, validate:)
+        yield
+      end
+
+      def analyze_multiplex(multiplex:)
+        yield
+      end
+
+      def analyze_query(query:)
+        yield
+      end
+
+      def execute_multiplex(multiplex:)
+        yield
+      end
+
+      def execute_query(query:)
+        yield
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        yield
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def authorized(query:, type:, object:)
+        yield
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        yield
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -1,60 +1,36 @@
 # frozen_string_literal: true
+require "graphql/tracing/trace"
+require "graphql/tracing/legacy_trace"
+
+# Legacy tracing:
 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"
 
+# New Tracing:
+require "graphql/tracing/platform_trace"
+require "graphql/tracing/appoptics_trace"
+require "graphql/tracing/appsignal_trace"
+require "graphql/tracing/data_dog_trace"
+require "graphql/tracing/new_relic_trace"
+require "graphql/tracing/notifications_trace"
+require "graphql/tracing/scout_trace"
+require "graphql/tracing/statsd_trace"
+require "graphql/tracing/prometheus_trace"
 if defined?(PrometheusExporter::Server)
   require "graphql/tracing/prometheus_tracing/graphql_collector"
 end
 
 module GraphQL
-  # Library entry point for performance metric reporting.
-  #
-  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
-  #
-  # @example Sending custom events
-  #   query.trace("my_custom_event", { ... }) do
-  #     # do stuff ...
-  #   end
-  #
-  # @example Adding a tracer to a schema
-  #  class MySchema < GraphQL::Schema
-  #    tracer MyTracer # <= responds to .trace(key, data, &block)
-  #  end
-  #
-  # @example Adding a tracer to a single query
-  #   MySchema.execute(query_str, context: { backtrace: true })
-  #
-  # Events:
-  #
-  # Key | Metadata
-  # ----|---------
-  # lex | `{ query_string: String }`
-  # parse | `{ query_string: String }`
-  # validate | `{ query: GraphQL::Query, validate: Boolean }`
-  # analyze_multiplex |  `{ multiplex: GraphQL::Execution::Multiplex }`
-  # analyze_query | `{ query: GraphQL::Query }`
-  # 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?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
-  # 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
+    NullTrace = Trace.new
+
     # Objects may include traceable to gain a `.trace(...)` method.
     # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.
     # @api private
@@ -62,8 +38,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
@@ -75,39 +52,14 @@ 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 } }
-        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
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         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

data/lib/graphql/type_kinds.rb

@@ -5,12 +5,13 @@ module GraphQL
     # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
     class TypeKind
       attr_reader :name, :description
-      def initialize(name, abstract: false, fields: false, wraps: false, input: false, description: nil)
+      def initialize(name, abstract: false, leaf: false, fields: false, wraps: false, input: false, description: nil)
         @name = name
         @abstract = abstract
         @fields = fields
         @wraps = wraps
         @input = input
+        @leaf = leaf
         @composite = fields? || abstract?
         @description = description
       end
@@ -27,6 +28,8 @@ module GraphQL
       # Is this TypeKind a valid query input?
       def input?;     @input;     end
       def to_s;       @name;      end
+      # Is this TypeKind a primitive value?
+      def leaf?; @leaf; end
       # Is this TypeKind composed of many values?
       def composite?; @composite; end
 
@@ -64,11 +67,11 @@ module GraphQL
     end
 
     TYPE_KINDS = [
-      SCALAR =        TypeKind.new("SCALAR", input: true, description: 'Indicates this type is a scalar.'),
+      SCALAR =        TypeKind.new("SCALAR", input: true, leaf: 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", 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.'),
+      ENUM =          TypeKind.new("ENUM", input: true, leaf: 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.'),

data/lib/graphql/types/big_int.rb

@@ -6,7 +6,7 @@ module GraphQL
       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)
-        Integer(value)
+        value && parse_int(value)
       rescue ArgumentError
         nil
       end
@@ -14,6 +14,10 @@ module GraphQL
       def self.coerce_result(value, _ctx)
         value.to_i.to_s
       end
+
+      def self.parse_int(value)
+        value.is_a?(Numeric) ? value : Integer(value, 10)
+      end
     end
   end
 end

data/lib/graphql/types/int.rb

@@ -9,8 +9,15 @@ module GraphQL
       MIN = -(2**31)
       MAX = (2**31) - 1
 
-      def self.coerce_input(value, _ctx)
-        value.is_a?(Integer) ? value : nil
+      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)
@@ -18,7 +25,7 @@ module GraphQL
         if value >= MIN && value <= MAX
           value
         else
-          err = GraphQL::IntegerEncodingError.new(value)
+          err = GraphQL::IntegerEncodingError.new(value, context: ctx)
           ctx.schema.type_error(err, ctx)
         end
       end

data/lib/graphql/types/iso_8601_date.rb

@@ -14,20 +14,31 @@ module GraphQL
     # own Date type.
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
-      # @param value [Date]
+      # @param value [Date,Time,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
-        value.iso8601
+        Date.parse(value.to_s).iso8601
       end
 
-      # @param str_value [String]
-      # @return [Date]
-      def self.coerce_input(str_value, _ctx)
-        Date.iso8601(str_value)
-      rescue ArgumentError
-        # Invalid input
-        nil
+      # @param str_value [String, Date, DateTime, Time]
+      # @return [Date, nil]
+      def self.coerce_input(value, ctx)
+        if value.is_a?(::Date)
+          value
+        elsif value.is_a?(::DateTime)
+          value.to_date
+        elsif value.is_a?(::Time)
+          value.to_date
+        elsif value.nil?
+          nil
+        else
+          Date.iso8601(value)
+        end
+      rescue ArgumentError, TypeError
+        err = GraphQL::DateEncodingError.new(value)
+        ctx.schema.type_error(err, ctx)
       end
     end
   end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
+
+require 'time'
+
 module GraphQL
   module Types
-    # This scalar takes `DateTime`s and transmits them as strings,
+    # This scalar takes `Time`s and transmits them as strings,
     # using ISO 8601 format.
     #
     # Use it for fields or arguments as follows:
@@ -14,6 +17,7 @@ module GraphQL
     # own DateTime type.
     class ISO8601DateTime < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded datetime"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
       # It's not compatible with Rails' default,
       # i.e. ActiveSupport::JSON::Encoder.time_precision (3 by default)
@@ -29,21 +33,43 @@ module GraphQL
         @time_precision = value
       end
 
-      # @param value [DateTime]
+      # @param value [Time,Date,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
-        value.iso8601(time_precision)
-      rescue ArgumentError
-        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only DateTimes are used with this type."
+        case value
+        when Date
+          return value.to_time.iso8601(time_precision)
+        when ::String
+          return Time.parse(value).iso8601(time_precision)
+        else
+          # Time, DateTime or compatible is given:
+          return value.iso8601(time_precision)
+        end
+      rescue StandardError => error
+        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Times, Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
       end
 
       # @param str_value [String]
-      # @return [DateTime]
+      # @return [Time]
       def self.coerce_input(str_value, _ctx)
-        DateTime.iso8601(str_value)
-      rescue ArgumentError
-        # Invalid input
-        nil
+        Time.iso8601(str_value)
+      rescue ArgumentError, TypeError
+        begin
+          dt = Date.iso8601(str_value).to_time
+          # For compatibility, continue accepting dates given without times
+          # But without this, it would zero out given any time part of `str_value` (hours and/or minutes)
+          if dt.iso8601.start_with?(str_value)
+            dt
+          elsif str_value.length == 8 && str_value.match?(/\A\d{8}\Z/)
+            # Allow dates that are missing the "-". eg. "20220404"
+            dt
+          else
+            nil
+          end
+        rescue ArgumentError, TypeError
+          # Invalid input
+          nil
+        end
       end
     end
   end