graphql 1.9.0 → 2.1.1

data/lib/graphql/tracing/platform_tracing.rb

@@ -10,6 +10,10 @@ module GraphQL
     class PlatformTracing
       class << self
         attr_accessor :platform_keys
+
+        def inherited(child_class)
+          child_class.platform_keys = self.platform_keys
+        end
       end
 
       def initialize(options = {})
@@ -26,20 +30,19 @@ module GraphQL
             yield
           end
         when "execute_field", "execute_field_lazy"
-          if data[:context]
-            field = data[:context].field
-            platform_key = field.metadata[:platform_key]
-            trace_field = true # implemented with instrumenter
+          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
-            field = data[:field]
-            # Lots of duplicated work here, can this be done ahead of time?
-            platform_key = platform_field_key(field.owner, 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
+            true
+          end
+
+          platform_key = if trace_field
+            context = data.fetch(:query).context
+            cached_platform_key(context, field, :field) { platform_field_key(field.owner, field) }
+          else
+            nil
           end
 
           if platform_key && trace_field
@@ -49,40 +52,83 @@ module GraphQL
           else
             yield
           end
+        when "authorized", "authorized_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type, :authorized) { 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, :resolve_type) { platform_resolve_type_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
         else
           # it's a custom key
           yield
         end
       end
 
-      def instrument(type, field)
-        return_type = field.type.unwrap
-        case return_type
-        when GraphQL::ScalarType, GraphQL::EnumType
-          if field.trace || (field.trace.nil? && @trace_scalars)
-            trace_field(type, field)
+      def self.use(schema_defn, options = {})
+        if options[:legacy_tracing]
+          tracer = self.new(**options)
+          schema_defn.tracer(tracer)
+        else
+          tracing_name = self.name.split("::").last
+          trace_name = tracing_name.sub("Tracing", "Trace")
+          if GraphQL::Tracing.const_defined?(trace_name, false)
+            trace_module = GraphQL::Tracing.const_get(trace_name)
+            schema_defn.trace_with(trace_module, **options)
           else
-            field
+            tracer = self.new(**options)
+            schema_defn.tracer(tracer)
           end
-        else
-          trace_field(type, field)
         end
       end
 
-      def trace_field(type, field)
-        new_f = field.redefine
-        new_f.metadata[:platform_key] = platform_field_key(type, field)
-        new_f
+      private
+
+      # Get the transaction name based on the operation type and name if possible, or fall back to a user provided
+      # one. Useful for anonymous queries.
+      def transaction_name(query)
+        selected_op = query.selected_operation
+        txn_name = if selected_op
+          op_type = selected_op.operation_type
+          op_name = selected_op.name || fallback_transaction_name(query.context) || "anonymous"
+          "#{op_type}.#{op_name}"
+        else
+          "query.anonymous"
+        end
+        "GraphQL/#{txn_name}"
       end
 
-      def self.use(schema_defn, options = {})
-        tracer = self.new(options)
-        schema_defn.instrument(:field, tracer)
-        schema_defn.tracer(tracer)
+      def fallback_transaction_name(context)
+        context[:tracing_fallback_transaction_name]
       end
 
-      private
       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`.
+      #
+      # @param ctx [GraphQL::Query::Context]
+      # @param key [Class, GraphQL::Field] A part of the schema
+      # @param trace_phase [Symbol] The stage of execution being traced (used by OpenTelementry tracing)
+      # @return [String]
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+        cache.fetch(key) { cache[key] = yield }
+      end
     end
   end
 end

data/lib/graphql/tracing/prometheus_trace.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module PrometheusTrace
+      include PlatformTrace
+
+      def initialize(client: PrometheusExporter::Client.default, keys_whitelist: ["execute_field", "execute_field_lazy"], collector_type: "graphql", **rest)
+        @client = client
+        @keys_whitelist = keys_whitelist
+        @collector_type = collector_type
+
+        super(**rest)
+      end
+
+      {
+        '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",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data, &block)
+            instrument_execution("#{platform_key}", "#{trace_method}", &block)
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, &block)
+        instrument_execution(platform_key, "execute_field", &block)
+      end
+
+      def platform_execute_field_lazy(platform_key, &block)
+        instrument_execution(platform_key, "execute_field_lazy", &block)
+      end
+
+      def platform_authorized(platform_key, &block)
+        instrument_execution(platform_key, "authorized", &block)
+      end
+
+      def platform_authorized_lazy(platform_key, &block)
+        instrument_execution(platform_key, "authorized_lazy", &block)
+      end
+
+      def platform_resolve_type(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type", &block)
+      end
+
+      def platform_resolve_type_lazy(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type_lazy", &block)
+      end
+
+      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
+
+      private
+
+      def instrument_execution(platform_key, key, &block)
+        if @keys_whitelist.include?(key)
+          start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
+          result = block.call
+          duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
+          @client.send_json(
+            type: @collector_type,
+            duration: duration,
+            platform_key: platform_key,
+            key: key
+          )
+          result
+        else
+          yield
+        end
+      end
+    end
+  end
+end

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,18 +27,26 @@ 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)
         "#{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)
+      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
@@ -30,6 +41,14 @@ module GraphQL
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}"
       end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
     end
   end
 end

data/lib/graphql/tracing/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