graphql 2.0.32 → 2.5.22

data/lib/graphql/tracing/platform_tracing.rb

@@ -81,10 +81,12 @@ module GraphQL
           trace_name = tracing_name.sub("Tracing", "Trace")
           if GraphQL::Tracing.const_defined?(trace_name, false)
             trace_module = GraphQL::Tracing.const_get(trace_name)
+            warn("`use(#{self.name})` is deprecated, use the equivalent `trace_with(#{trace_module.name})` instead. More info: https://graphql-ruby.org/queries/tracing.html")
             schema_defn.trace_with(trace_module, **options)
           else
+            warn("`use(#{self.name})` and `Tracing::PlatformTracing` are deprecated. Use a `trace_with(...)` module instead. More info: https://graphql-ruby.org/queries/tracing.html. Please open an issue on the GraphQL-Ruby repo if you want to discuss further!")
             tracer = self.new(**options)
-            schema_defn.tracer(tracer)
+          schema_defn.tracer(tracer, silence_deprecation_warning: true)
           end
         end
       end

data/lib/graphql/tracing/{prometheus_tracing → prometheus_trace}/graphql_collector.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "graphql/tracing"
+
 module GraphQL
   module Tracing
-    class PrometheusTracing < PlatformTracing
+    module PrometheusTrace
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
           @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
@@ -28,5 +30,7 @@ module GraphQL
         end
       end
     end
+    # Backwards-compat:
+    PrometheusTracing::GraphQLCollector = PrometheusTrace::GraphQLCollector
   end
 end

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,91 +1,91 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/monitor_trace"
+
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Prometheus.
+    #
+    # The PrometheusExporter server must be run with a custom type collector that extends `GraphQL::Tracing::PrometheusTracing::GraphQLCollector`.
+    #
+    # @example Adding this trace to your schema
+    #   require 'prometheus_exporter/client'
+    #
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::PrometheusTrace
+    #   end
+    #
+    # @example Running a custom type collector
+    #   # lib/graphql_collector.rb
+    #   if defined?(PrometheusExporter::Server)
+    #     require 'graphql/tracing'
+    #
+    #     class GraphQLCollector < GraphQL::Tracing::PrometheusTrace::GraphQLCollector
+    #     end
+    #   end
+    #
+    #    # Then run:
+    #    # bundle exec prometheus_exporter -a lib/graphql_collector.rb
+    PrometheusTrace = MonitorTrace.create_module("prometheus")
     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
-
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      {
-        '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
+      if defined?(PrometheusExporter::Server)
+        autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"
       end
 
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key, &block)
-        instrument_execution(platform_key, "execute_field", &block)
+      def initialize(client: PrometheusExporter::Client.default, keys_whitelist: [:execute_field], collector_type: "graphql", **rest)
+        @prometheus_client = client
+        @prometheus_keys_whitelist = keys_whitelist.map(&:to_sym) # handle previous string keys
+        @prometheus_collector_type = collector_type
+        setup_prometheus_monitor(**rest)
+        super
       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
+      attr_reader :prometheus_collector_type, :prometheus_client, :prometheus_keys_whitelist
+
+      class PrometheusMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if active?(keyword)
+            start = gettime
+            result = yield
+            duration = gettime - start
+            send_json(duration, keyword, object)
+            result
+          else
+            yield
+          end
+        end
 
-      def platform_resolve_type_lazy(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type_lazy", &block)
-      end
+        def active?(keyword)
+          @trace.prometheus_keys_whitelist.include?(keyword)
+        end
 
-      def platform_field_key(field)
-        field.path
-      end
+        def gettime
+          ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        end
 
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized"
-      end
+        def send_json(duration, keyword, object)
+          event_name = name_for(keyword, object)
+          @trace.prometheus_client.send_json(
+            type: @trace.prometheus_collector_type,
+            duration: duration,
+            platform_key: event_name,
+            key: keyword
+          )
+        end
 
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type"
-      end
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      private
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            @start_time = @monitor.gettime
+          end
 
-      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
+          def finish
+            if @monitor.active?(keyword)
+              duration = @monitor.gettime - @start_time
+              @monitor.send_json(duration, keyword, object)
+            end
+          end
         end
       end
     end

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class PrometheusTracing < PlatformTracing

data/lib/graphql/tracing/scout_trace.rb

@@ -1,74 +1,48 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/monitor_trace"
+
 module GraphQL
   module Tracing
+    # A tracer for sending GraphQL-Ruby times to Scout
+    #
+    # @example Adding this tracer to your schema
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::ScoutTrace
+    #   end
+    ScoutTrace = MonitorTrace.create_module("scout")
     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
-
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      {
-        "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
+      class ScoutMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if keyword == :execute
+            query = object.queries.first
+            set_this_txn_name = 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(query))
             end
-          }
+          end
 
-          self.class.instrument("GraphQL", "#{platform_key}", INSTRUMENT_OPTS) do
-            super
+          ScoutApm::Tracer.instrument("GraphQL", name_for(keyword, object), INSTRUMENT_OPTS) do
+            yield
           end
         end
-        RUBY
-      end
-      # rubocop:enable Development/NoEvalCop
 
-      def platform_execute_field(platform_key, &block)
-        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)
-      end
+        INSTRUMENT_OPTS = { scope: true }
 
-      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
+        include MonitorTrace::Monitor::GraphQLSuffixNames
 
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized"
-      end
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            layer = ScoutApm::Layer.new("GraphQL", @monitor.name_for(keyword, object))
+            layer.subscopable!
+            @scout_req = ScoutApm::RequestManager.lookup
+            @scout_req.start_layer(layer)
+          end
 
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type"
+          def finish
+            @scout_req.stop_layer
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/scout_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class ScoutTracing < PlatformTracing

data/lib/graphql/tracing/sentry_trace.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/monitor_trace"
+
+module GraphQL
+  module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Sentry.
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::SentryTrace
+    #   end
+    # @see MonitorTrace Configuration Options in the parent module
+    SentryTrace = MonitorTrace.create_module("sentry")
+    module SentryTrace
+      class SentryMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          return yield unless Sentry.initialized?
+
+          platform_key = name_for(keyword, object)
+
+          Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|
+            result = yield
+            return result unless span
+
+            span.finish
+            if keyword == :execute
+              queries = object.queries
+              operation_names = queries.map{|q| operation_name(q) }
+              span.set_description(operation_names.join(", "))
+
+              if queries.size == 1
+                query = queries.first
+                set_this_txn_name = query.context[:set_sentry_transaction_name]
+                if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+                  Sentry.configure_scope do |scope|
+                    scope.set_transaction_name(transaction_name(query))
+                  end
+                end
+                span.set_data('graphql.document', query.query_string)
+                if query.selected_operation_name
+                  span.set_data('graphql.operation.name', query.selected_operation_name)
+                end
+                if query.selected_operation
+                  span.set_data('graphql.operation.type', query.selected_operation.operation_type)
+                end
+              end
+            end
+
+            result
+          end
+        end
+
+        include MonitorTrace::Monitor::GraphQLPrefixNames
+
+        private
+
+        def operation_name(query)
+          selected_op = query.selected_operation
+          if selected_op
+            [selected_op.operation_type, selected_op.name].compact.join(' ')
+          else
+            'GraphQL Operation'
+          end
+        end
+
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            if Sentry.initialized? && (@span = Sentry.get_current_scope.get_span)
+              span_name = @monitor.name_for(@keyword, @object)
+              @span.start_child(op: span_name)
+            end
+          end
+
+          def finish
+            @span&.finish
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/statsd_trace.rb

@@ -1,59 +1,47 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/monitor_trace"
+
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Statsd.
+    # Passing any Statsd client that implements `.time(name) { ... }`
+    # and `.timing(name, ms)` will work.
+    #
+    # @example Installing this tracer
+    #   # eg:
+    #   # $statsd = Statsd.new 'localhost', 9125
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Tracing::StatsdTrace, statsd: $statsd
+    #   end
+    StatsdTrace = MonitorTrace.create_module("statsd")
     module StatsdTrace
-      include PlatformTrace
-
-      # @param statsd [Object] A statsd client
-      def initialize(statsd:, **rest)
-        @statsd = statsd
-        super(**rest)
-      end
+      class StatsdMonitor < MonitorTrace::Monitor
+        def initialize(statsd:, **_rest)
+          @statsd = statsd
+          super
+        end
 
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+        attr_reader :statsd
 
-      {
-        '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
+        def instrument(keyword, object)
+          @statsd.time(name_for(keyword, object)) do
+            yield
           end
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key, &block)
-        @statsd.time(platform_key, &block)
-      end
+        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
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      def platform_authorized_key(type)
-        "graphql.authorized.#{type.graphql_name}"
-      end
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
 
-      def platform_resolve_type_key(type)
-        "graphql.resolve_type.#{type.graphql_name}"
+          def finish
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+            @monitor.statsd.timing(@monitor.name_for(keyword, object), elapsed)
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/statsd_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class StatsdTracing < PlatformTracing

data/lib/graphql/tracing/trace.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
+
+require "graphql/tracing"
+
 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.
+    # to continue any tracing hooks and call the actual runtime behavior.
     #
     class Trace
       # @param multiplex [GraphQL::Execution::Multiplex, nil]
@@ -15,10 +18,13 @@ module GraphQL
         @query = query
       end
 
+      # The Ruby parser doesn't call this method (`graphql/c_parser` does.)
       def lex(query_string:)
         yield
       end
 
+      # @param query_string [String]
+      # @return [void]
       def parse(query_string:)
         yield
       end
@@ -27,6 +33,22 @@ module GraphQL
         yield
       end
 
+      def begin_validate(query, validate)
+      end
+
+      def end_validate(query, validate, errors)
+      end
+
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @param analyzers [Array<Class>]
+      # @return [void]
+      def begin_analyze_multiplex(multiplex, analyzers); end
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @param analyzers [Array<Class>]
+      # @return [void]
+      def end_analyze_multiplex(multiplex, analyzers); end
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @return [void]
       def analyze_multiplex(multiplex:)
         yield
       end
@@ -35,6 +57,9 @@ module GraphQL
         yield
       end
 
+      # This wraps an entire `.execute` call.
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @return [void]
       def execute_multiplex(multiplex:)
         yield
       end
@@ -47,6 +72,20 @@ module GraphQL
         yield
       end
 
+      # GraphQL is about to resolve this field
+      # @param field [GraphQL::Schema::Field]
+      # @param object [GraphQL::Schema::Object]
+      # @param arguments [Hash]
+      # @param query [GraphQL::Query]
+      def begin_execute_field(field, object, arguments, query); end
+      # GraphQL just finished resolving this field
+      # @param field [GraphQL::Schema::Field]
+      # @param object [GraphQL::Schema::Object]
+      # @param arguments [Hash]
+      # @param query [GraphQL::Query]
+      # @param result [Object]
+      def end_execute_field(field, object, arguments, query, result); end
+
       def execute_field(field:, query:, ast_node:, arguments:, object:)
         yield
       end
@@ -59,6 +98,22 @@ module GraphQL
         yield
       end
 
+      # A call to `.authorized?` is starting
+      # @param type [Class<GraphQL::Schema::Object>]
+      # @param object [Object]
+      # @param context [GraphQL::Query::Context]
+      # @return [void]
+      def begin_authorized(type, object, context)
+      end
+      # A call to `.authorized?` just finished
+      # @param type [Class<GraphQL::Schema::Object>]
+      # @param object [Object]
+      # @param context [GraphQL::Query::Context]
+      # @param authorized_result [Boolean]
+      # @return [void]
+      def end_authorized(type, object, context, authorized_result)
+      end
+
       def authorized_lazy(query:, type:, object:)
         yield
       end
@@ -70,6 +125,62 @@ module GraphQL
       def resolve_type_lazy(query:, type:, object:)
         yield
       end
+
+      # A call to `.resolve_type` is starting
+      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param value [Object]
+      # @param context [GraphQL::Query::Context]
+      # @return [void]
+      def begin_resolve_type(type, value, context)
+      end
+
+      # A call to `.resolve_type` just ended
+      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param value [Object]
+      # @param context [GraphQL::Query::Context]
+      # @param resolved_type [Class<GraphQL::Schema::Object>]
+      # @return [void]
+      def end_resolve_type(type, value, context, resolved_type)
+      end
+
+      # A dataloader run is starting
+      # @param dataloader [GraphQL::Dataloader]
+      # @return [void]
+      def begin_dataloader(dataloader); end
+      # A dataloader run has ended
+      # @param dataloder [GraphQL::Dataloader]
+      # @return [void]
+      def end_dataloader(dataloader); end
+
+      # A source with pending keys is about to fetch
+      # @param source [GraphQL::Dataloader::Source]
+      # @return [void]
+      def begin_dataloader_source(source); end
+      # A fetch call has just ended
+      # @param source [GraphQL::Dataloader::Source]
+      # @return [void]
+      def end_dataloader_source(source); end
+
+      # Called when Dataloader spins up a new fiber for GraphQL execution
+      # @param jobs [Array<#call>] Execution steps to run
+      # @return [void]
+      def dataloader_spawn_execution_fiber(jobs); end
+      # Called when Dataloader spins up a new fiber for fetching data
+      # @param pending_sources [GraphQL::Dataloader::Source] Instances with pending keys
+      # @return [void]
+      def dataloader_spawn_source_fiber(pending_sources); end
+      # Called when an execution or source fiber terminates
+      # @return [void]
+      def dataloader_fiber_exit; end
+
+      # Called when a Dataloader fiber is paused to wait for data
+      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call initiated this `yield`
+      # @return [void]
+      def dataloader_fiber_yield(source); end
+      # Called when a Dataloader fiber is resumed because data has been loaded
+      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call previously caused this Fiber to wait
+      # @return [void]
+      def dataloader_fiber_resume(source); end
     end
   end
 end