graphql 2.4.16 → 2.5.0

data/lib/graphql/tracing/notifications_trace.rb

@@ -1,49 +1,193 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
-
 module GraphQL
   module Tracing
-    # This implementation forwards events to a notification handler (i.e.
-    # ActiveSupport::Notifications or Dry::Monitor::Notifications)
-    # with a `graphql` suffix.
+    # This implementation forwards events to a notification handler
+    # (i.e. ActiveSupport::Notifications or Dry::Monitor::Notifications) with a `graphql` suffix.
+    #
+    # @see ActiveSupportNotificationsTrace ActiveSupport::Notifications integration
     module NotificationsTrace
-      # Initialize a new NotificationsTracing instance
-      #
-      # @param engine [#instrument(key, metadata, block)] The notifications engine to use
-      def initialize(engine:, **rest)
-        @notifications_engine = engine
-        super
-      end
-
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      {
-        "lex" => "lex.graphql",
-        "parse" => "parse.graphql",
-        "validate" => "validate.graphql",
-        "analyze_multiplex" => "analyze_multiplex.graphql",
-        "analyze_query" => "analyze_query.graphql",
-        "execute_multiplex" => "execute_multiplex.graphql",
-        "execute_query" => "execute_query.graphql",
-        "execute_query_lazy" => "execute_query_lazy.graphql",
-        "execute_field" => "execute_field.graphql",
-        "execute_field_lazy" => "execute_field_lazy.graphql",
-        "authorized" => "authorized.graphql",
-        "authorized_lazy" => "authorized_lazy.graphql",
-        "resolve_type" => "resolve_type.graphql",
-        "resolve_type_lazy" => "resolve_type.graphql",
-      }.each do |trace_method, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-          def #{trace_method}(**metadata, &block)
-            @notifications_engine.instrument("#{platform_key}", metadata) { super(**metadata, &block) }
+      # @api private
+      class Adapter
+        def instrument(keyword, payload, &block)
+          raise "Implement #{self.class}#instrument to measure the block"
+        end
+
+        def start_event(keyword, payload)
+          ev = self.class::Event.new(keyword, payload)
+          ev.start
+          ev
+        end
+
+        class Event
+          def initialize(name, payload)
+            @name = name
+            @payload = payload
+          end
+
+          attr_reader :name, :payload
+
+          def start
+            raise "Implement #{self.class}#start to begin a new event (#{inspect})"
           end
-        RUBY
+
+          def finish
+            raise "Implement #{self.class}#finish to end this event (#{inspect})"
+          end
+        end
       end
 
-      # rubocop:enable Development/NoEvalCop
+      # @api private
+      class DryMonitorAdapter < Adapter
+        def instrument(...)
+          Dry::Monitor.instrument(...)
+        end
 
-      include PlatformTrace
+        class Event < Adapter::Event
+          def start
+            Dry::Monitor.start(@name, @payload)
+          end
+
+          def finish
+            Dry::Monitor.stop(@name, @payload)
+          end
+        end
+      end
+
+      # @api private
+      class ActiveSupportNotificationsAdapter < Adapter
+        def instrument(...)
+          ActiveSupport::Notifications.instrument(...)
+        end
+
+        class Event < Adapter::Event
+          def start
+            @asn_event = ActiveSupport::Notifications.instrumenter.new_event(@name, @payload)
+            @asn_event.start!
+          end
+
+          def finish
+            @asn_event.finish!
+            ActiveSupport::Notifications.publish_event(@asn_event)
+          end
+        end
+      end
+
+      # @param engine [Class] The notifications engine to use, eg `Dry::Monitor` or `ActiveSupport::Notifications`
+      def initialize(engine:, **rest)
+        adapter = if defined?(Dry::Monitor) && engine == Dry::Monitor
+          DryMonitoringAdapter
+        elsif defined?(ActiveSupport::Notifications) && engine == ActiveSupport::Notifications
+          ActiveSupportNotificationsAdapter
+        else
+          engine
+        end
+        @notifications = adapter.new
+        super
+      end
+
+      def parse(**payload)
+        @notifications.instrument("parse.graphql", payload) do
+          super
+        end
+      end
+
+      def lex(**payload)
+        @notifications.instrument("lex.graphql", payload) do
+          super
+        end
+      end
+
+      def validate(**payload)
+        @notifications.instrument("validate.graphql", payload) do
+          super
+        end
+      end
+
+      def begin_analyze_multiplex(multiplex, analyzers)
+        begin_notifications_event("analyze.graphql", {multiplex: multiplex, analyzers: analyzers})
+        super
+      end
+
+      def end_analyze_multiplex(_multiplex, _analyzers)
+        finish_notifications_event
+        super
+      end
+
+      def execute_multiplex(**payload)
+        @notifications.instrument("execute.graphql", payload) do
+          super
+        end
+      end
+
+      def begin_execute_field(field, object, arguments, query)
+        begin_notifications_event("execute_field.graphql", {field: field, object: object, arguments: arguments, query: query})
+        super
+      end
+
+      def end_execute_field(_field, _object, _arguments, _query, _result)
+        finish_notifications_event
+        super
+      end
+
+      def dataloader_fiber_yield(source)
+        Fiber[PREVIOUS_EV_KEY] = finish_notifications_event
+        super
+      end
+
+      def dataloader_fiber_resume(source)
+        prev_ev = Fiber[PREVIOUS_EV_KEY]
+        begin_notifications_event(prev_ev.name, prev_ev.payload)
+        super
+      end
+
+      def begin_authorized(type, object, context)
+        begin_notifications_event("authorized.graphql", {type: type, object: object, context: context})
+        super
+      end
+
+      def end_authorized(type, object, context, result)
+        finish_notifications_event
+        super
+      end
+
+      def begin_resolve_type(type, object, context)
+        begin_notifications_event("resolve_type.graphql", {type: type, object: object, context: context})
+        super
+      end
+
+      def end_resolve_type(type, object, context, resolved_type)
+        finish_notifications_event
+        super
+      end
+
+      def begin_dataloader_source(source)
+        begin_notifications_event("dataloader_source.graphql", { source: source })
+        super
+      end
+
+      def end_dataloader_source(source)
+        finish_notifications_event
+        super
+      end
+
+      CURRENT_EV_KEY = :__notifications_graphql_trace_event
+      PREVIOUS_EV_KEY = :__notifications_graphql_trace_previous_event
+
+      private
+
+      def begin_notifications_event(name, payload)
+        Fiber[CURRENT_EV_KEY] = @notifications.start_event(name, payload)
+      end
+
+      def finish_notifications_event
+        if ev = Fiber[CURRENT_EV_KEY]
+          ev.finish
+          # Use `false` to prevent grabbing an event from a parent fiber
+          Fiber[CURRENT_EV_KEY] = false
+          ev
+        end
+      end
     end
   end
 end

data/lib/graphql/tracing/perfetto_trace.rb

@@ -171,36 +171,36 @@ module GraphQL
         )
       end
 
-      def begin_execute_multiplex(m)
+      def execute_multiplex(multiplex:)
         if defined?(ActiveSupport::Notifications) && @active_support_notifications_pattern != false
           subscribe_to_active_support_notifications(@active_support_notifications_pattern)
         end
-        @operation_name = m.queries.map { |q| q.selected_operation_name || "anonymous" }.join(",")
+        @operation_name = multiplex.queries.map { |q| q.selected_operation_name || "anonymous" }.join(",")
         @begin_time = Time.now
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
           name: "Multiplex",
           debug_annotations: [
-            payload_to_debug("query_string", m.queries.map(&:sanitized_query_string).join("\n\n"))
+            payload_to_debug("query_string", multiplex.queries.map(&:sanitized_query_string).join("\n\n"))
           ]
         )
-        super
-      end
+        result = super
 
-      def end_execute_multiplex(m)
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
         )
+
+        result
+      ensure
         unsubscribe_from_active_support_notifications
         if @save_profile
           begin_ts = (@begin_time.to_f * 1000).round
           end_ts = (Time.now.to_f * 1000).round
           duration_ms = end_ts - begin_ts
-          m.schema.detailed_trace.save_trace(@operation_name, duration_ms, begin_ts, Trace.encode(Trace.new(packet: @packets)))
+          multiplex.schema.detailed_trace.save_trace(@operation_name, duration_ms, begin_ts, Trace.encode(Trace.new(packet: @packets)))
         end
-        super
       end
 
       def begin_execute_field(field, object, arguments, query)
@@ -261,7 +261,7 @@ module GraphQL
         super
       end
 
-      def begin_parse(str)
+      def parse(query_string:)
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
@@ -269,17 +269,14 @@ module GraphQL
           extra_counter_values: [count_allocations],
           name: "Parse"
         )
-        super
-      end
-
-      def end_parse(str)
+        result = super
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_END,
           track_uuid: fid,
           extra_counter_track_uuids: [@objects_counter_id],
           extra_counter_values: [count_allocations],
         )
-        super
+        result
       end
 
       def begin_validate(query, validate)

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -26,93 +26,66 @@ module GraphQL
     #
     #    # Then run:
     #    # bundle exec prometheus_exporter -a lib/graphql_collector.rb
+    PrometheusTrace = MonitorTrace.create_module("prometheus")
     module PrometheusTrace
       if defined?(PrometheusExporter::Server)
         autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"
       end
-      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)
+      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
 
-      # 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)
-            instrument_prometheus_execution("#{platform_key}", "#{trace_method}") { super }
+      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
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
-
-      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)
-      end
-
-      def platform_authorized(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized", &block)
-      end
-
-      def platform_authorized_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized_lazy", &block)
-      end
-
-      def platform_resolve_type(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "resolve_type", &block)
-      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/scout_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -10,73 +10,39 @@ module GraphQL
     #   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
-
-      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