graphql 2.4.5 → 2.5.21

data/lib/graphql/tracing/platform_trace.rb

@@ -39,6 +39,9 @@ module GraphQL
           include(BaseKeyCache)
         }
         child_class.const_set(:KeyCache, key_methods_class)
+
+        # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
         [:execute_field, :execute_field_lazy].each do |field_trace_method|
           if !child_class.method_defined?(field_trace_method)
             child_class.module_eval <<-RUBY, __FILE__, __LINE__
@@ -91,6 +94,8 @@ module GraphQL
               end
             RUBY
           end
+
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing"
+
 module GraphQL
   module Tracing
     module PrometheusTrace

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,87 +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
-
-      {
-        '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)
-            instrument_prometheus_execution("#{platform_key}", "#{trace_method}") { super }
-          end
-        RUBY
-      end
-
-      def platform_execute_field(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "execute_field", &block)
-      end
-
-      def platform_execute_field_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "execute_field_lazy", &block)
+      if defined?(PrometheusExporter::Server)
+        autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"
       end
 
-      def platform_authorized(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized", &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_authorized_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized_lazy", &block)
-      end
+      attr_reader :prometheus_collector_type, :prometheus_client, :prometheus_keys_whitelist
 
-      def platform_resolve_type(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "resolve_type", &block)
-      end
+      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_prometheus_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_prometheus_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,71 +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
-
-      {
-        "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
-
-      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
+        INSTRUMENT_OPTS = { scope: true }
 
-      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

@@ -1,110 +1,80 @@
 # 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
-      include PlatformTrace
-
-      # @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_sentry_transaction_name]`.
-      def initialize(set_transaction_name: false, **_rest)
-        @set_transaction_name = set_transaction_name
-        super
-      end
-
-      def execute_query(**data)
-        set_this_txn_name = data[: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(data[:query]))
+      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
-        instrument_sentry_execution("graphql.execute", "execute_query", data) { super }
-      end
-
-      {
-        "lex" => "graphql.lex",
-        "parse" => "graphql.parse",
-        "validate" => "graphql.validate",
-        "analyze_query" => "graphql.analyze",
-        "analyze_multiplex" => "graphql.analyze_multiplex",
-        "execute_multiplex" => "graphql.execute_multiplex",
-        "execute_query_lazy" => "graphql.execute"
-      }.each do |trace_method, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-        def #{trace_method}(**data)
-          instrument_sentry_execution("#{platform_key}", "#{trace_method}", data) { super }
-        end
-        RUBY
-      end
-
-      def platform_execute_field(platform_key, &block)
-        instrument_sentry_execution(platform_key, "execute_field", &block)
-      end
-
-      def platform_execute_field_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "execute_field_lazy", &block)
-      end
-
-      def platform_authorized(platform_key, &block)
-        instrument_sentry_execution(platform_key, "authorized", &block)
-      end
-
-      def platform_authorized_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "authorized_lazy", &block)
-      end
 
-      def platform_resolve_type(platform_key, &block)
-        instrument_sentry_execution(platform_key, "resolve_type", &block)
-      end
-
-      def platform_resolve_type_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "resolve_type_lazy", &block)
-      end
-
-      def platform_field_key(field)
-        "graphql.field.#{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
-
-      private
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      def instrument_sentry_execution(platform_key, trace_method, data=nil, &block)
-        return yield unless Sentry.initialized?
+        private
 
-        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 trace_method == "execute_multiplex" && data.key?(:multiplex)
-            operation_names = data[:multiplex].queries.map{|q| operation_name(q) }
-            span.set_description(operation_names.join(", "))
-          elsif trace_method == "execute_query" && data.key?(:query)
-            span.set_description(operation_name(data[:query]))
-            span.set_data('graphql.document', data[:query].query_string)
-            span.set_data('graphql.operation.name', data[:query].selected_operation_name) if data[:query].selected_operation_name
-            span.set_data('graphql.operation.type', data[:query].selected_operation.operation_type)
+        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
-
-          result
         end
-      end
 
-      def operation_name(query)
-        selected_op = query.selected_operation
-        if selected_op
-          [selected_op.operation_type, selected_op.name].compact.join(' ')
-        else
-          'GraphQL Operation'
+        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

data/lib/graphql/tracing/statsd_trace.rb

@@ -1,55 +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
+      class StatsdMonitor < MonitorTrace::Monitor
+        def initialize(statsd:, **_rest)
+          @statsd = statsd
+          super
+        end
 
-      # @param statsd [Object] A statsd client
-      def initialize(statsd:, **rest)
-        @statsd = statsd
-        super(**rest)
-      end
+        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
-
-      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
+        end
 
-      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