graphql 2.4.15 → 2.5.0

data/lib/graphql/tracing/appsignal_trace.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
-
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -10,80 +9,46 @@ module GraphQL
     #   class MySchema < GraphQL::Schema
     #     trace_with GraphQL::Tracing::AppsignalTrace
     #   end
+    AppsignalTrace = MonitorTrace.create_module("appsignal")
     module AppsignalTrace
-      include PlatformTrace
-
       # @param set_action_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_appsignal_action_name]`.
       def initialize(set_action_name: false, **rest)
-        @set_action_name = set_action_name
+        rest[:set_transaction_name] ||= set_action_name
+        setup_appsignal_monitor(**rest)
         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_appsignal_action_name]
-                if set_this_txn_name == true || (set_this_txn_name.nil? && @set_action_name)
-                  Appsignal::Transaction.current.set_action(transaction_name(data[:query]))
-                end
-                RUBY
-              end
-            }
-
-            Appsignal.instrument("#{platform_key}") do
-              super
+      class AppsignalMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if keyword == :execute
+            query = object.queries.first
+            set_this_txn_name =  query.context[:set_appsignal_action_name]
+            if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+              Appsignal::Transaction.current.set_action(transaction_name(query))
             end
           end
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key)
-        Appsignal.instrument(platform_key) do
-          yield
+          Appsignal.instrument(name_for(keyword, object)) do
+            yield
+          end
         end
-      end
 
-      def platform_authorized(platform_key)
-        Appsignal.instrument(platform_key) do
-          yield
-        end
-      end
+        include MonitorTrace::Monitor::GraphQLSuffixNames
+        class Event < GraphQL::Tracing::MonitorTrace::Monitor::Event
+          def start
+            Appsignal::Transaction.current.start_event
+          end
 
-      def platform_resolve_type(platform_key)
-        Appsignal.instrument(platform_key) do
-          yield
+          def finish
+            Appsignal::Transaction.current.finish_event(
+              @monitor.name_for(@keyword, @object),
+              "",
+              ""
+            )
+          end
         end
       end
-
-      def platform_field_key(field)
-        "#{field.owner.graphql_name}.#{field.graphql_name}.graphql"
-      end
-
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized.graphql"
-      end
-
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type.graphql"
-      end
     end
   end
 end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
-
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -9,186 +8,64 @@ module GraphQL
     #   class MySchema < GraphQL::Schema
     #     trace_with GraphQL::Tracing::DataDogTrace
     #   end
+    # @example Skipping `resolve_type` and `authorized` events
+    #   trace_with GraphQL::Tracing::DataDogTrace, trace_authorized: false, trace_resolve_type: false
+    DataDogTrace = MonitorTrace.create_module("datadog")
     module DataDogTrace
-      # @param tracer [#trace] Deprecated
-      # @param analytics_enabled [Boolean] Deprecated
-      # @param analytics_sample_rate [Float] Deprecated
-      def initialize(tracer: nil, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **rest)
-        if tracer.nil?
-          tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+      class DatadogMonitor < MonitorTrace::Monitor
+        def initialize(set_transaction_name:, service: nil, tracer: nil, **_rest)
+          super
+          if tracer.nil?
+            tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+          end
+          @tracer = tracer
+          @service_name = service
+          @has_prepare_span = @trace.respond_to?(:prepare_span)
         end
-        @tracer = tracer
-
-        @analytics_enabled = analytics_enabled
-        @analytics_sample_rate = analytics_sample_rate
-
-        @service_name = service
-        @has_prepare_span = respond_to?(:prepare_span)
-        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, trace_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-          def #{trace_method}(**data)
-            @tracer.trace("#{trace_key}", service: @service_name, type: 'custom') do |span|
-                span.set_tag('component', 'graphql')
-                span.set_tag('operation', '#{trace_method}')
+        attr_reader :tracer, :service_name
 
-              #{
-                if trace_method == 'execute_multiplex'
-                  <<-RUBY
-                  operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-
-                  resource = if operations.empty?
-                    first_query = data[:multiplex].queries.first
-                    fallback_transaction_name(first_query && first_query.context)
-                  else
-                    operations
-                  end
-                  span.resource = resource if resource
-
-                  # [Deprecated] will be removed in the future
-                  span.set_metric('_dd1.sr.eausr', @analytics_sample_rate) if @analytics_enabled
-                  RUBY
-                elsif trace_method == 'execute_query'
-                  <<-RUBY
-                  span.set_tag(:selected_operation_name, data[:query].selected_operation_name)
-                  span.set_tag(:selected_operation_type, data[:query].selected_operation.operation_type)
-                  span.set_tag(:query_string, data[:query].query_string)
-                  RUBY
-                end
-              }
-              if @has_prepare_span
-                prepare_span("#{trace_method.sub("platform_", "")}", data, span)
+        def instrument(keyword, object)
+          trace_key = name_for(keyword, object)
+          @tracer.trace(trace_key, service: @service_name, type: 'custom') do |span|
+            span.set_tag('component', 'graphql')
+            op_name = keyword.respond_to?(:name) ? keyword.name : keyword.to_s
+            span.set_tag('operation', op_name)
+
+            if keyword == :execute
+              operations = object.queries.map(&:selected_operation_name).join(', ')
+              first_query = object.queries.first
+              resource = if operations.empty?
+                fallback_transaction_name(first_query && first_query.context)
+              else
+                operations
               end
-              super
-            end
-          end
-        RUBY
-      end
+              span.resource = resource if resource
 
-      # rubocop:enable Development/NoEvalCop
-
-      def execute_field_span(span_key, query, field, ast_node, arguments, object)
-        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
-        platform_key = if trace_field
-          @platform_key_cache[DataDogTrace].platform_field_key_cache[field]
-        else
-          nil
-        end
-        if platform_key && trace_field
-          @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-            span.set_tag('component', 'graphql')
-            span.set_tag('operation', span_key)
+              span.set_tag("selected_operation_name", first_query.selected_operation_name)
+              span.set_tag("selected_operation_type", first_query.selected_operation&.operation_type)
+              span.set_tag("query_string", first_query.query_string)
+            end
 
             if @has_prepare_span
-              prepare_span_data = { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }
-              prepare_span(span_key, prepare_span_data, span)
+              @trace.prepare_span(keyword, object, span)
             end
             yield
           end
-        else
-          yield
-        end
-      end
-      def execute_field(query:, field:, ast_node:, arguments:, object:)
-        execute_field_span("execute_field", query, field, ast_node, arguments, object) do
-          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
-        end
-      end
-
-      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
-        execute_field_span("execute_field_lazy", query, field, ast_node, arguments, object) do
-          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
         end
-      end
 
-      def authorized(query:, type:, object:)
-        authorized_span("authorized", object, type, query) do
-          super(query: query, type: type, object: object)
-        end
-      end
-
-      def authorized_span(span_key, object, type, query)
-        platform_key = @platform_key_cache[DataDogTrace].platform_authorized_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-          span.set_tag('component', 'graphql')
-          span.set_tag('operation', span_key)
-
-          if @has_prepare_span
-            prepare_span(span_key, {object: object, type: type, query: query}, span)
+        include MonitorTrace::Monitor::GraphQLSuffixNames
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            name = @monitor.name_for(keyword, object)
+            @dd_span = @monitor.tracer.trace(name, service: @monitor.service_name, type: 'custom')
           end
-          yield
-        end
-      end
-
-      def authorized_lazy(object:, type:, query:)
-        authorized_span("authorized_lazy", object, type, query) do
-          super(query: query, type: type, object: object)
-        end
-      end
-
-      def resolve_type(object:, type:, query:)
-        resolve_type_span("resolve_type", object, type, query) do
-          super(object: object, query: query, type: type)
-        end
-      end
 
-      def resolve_type_lazy(object:, type:, query:)
-        resolve_type_span("resolve_type_lazy", object, type, query) do
-          super(object: object, query: query, type: type)
-        end
-      end
-
-      def resolve_type_span(span_key, object, type, query)
-        platform_key = @platform_key_cache[DataDogTrace].platform_resolve_type_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-          span.set_tag('component', 'graphql')
-          span.set_tag('operation', span_key)
-
-          if @has_prepare_span
-            prepare_span(span_key, {object: object, type: type, query: query}, span)
+          def finish
+            @dd_span.finish
           end
-          yield
         end
       end
-
-      include PlatformTrace
-
-      # Implement this method in a subclass to apply custom tags to datadog spans
-      # @param key [String] The event being traced
-      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
-      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
-      # def prepare_span(key, data, span)
-      # 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
     end
   end
 end

data/lib/graphql/tracing/monitor_trace.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This module is the basis for Ruby-level integration with third-party monitoring platforms.
+    # Platform-specific traces include this module and implement an adapter.
+    #
+    # @see ActiveSupportNotificationsTrace Integration via ActiveSupport::Notifications, an alternative approach.
+    module MonitorTrace
+      class Monitor
+        def initialize(trace:, set_transaction_name:, **_rest)
+          @trace = trace
+          @set_transaction_name = set_transaction_name
+          @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }.compare_by_identity
+          @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }.compare_by_identity
+          @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }.compare_by_identity
+          @platform_source_class_key_cache = Hash.new { |h, source_cls| h[source_cls] = platform_source_class_key(source_cls) }.compare_by_identity
+        end
+
+        def instrument(keyword, object, &block)
+          raise "Implement #{self.class}#instrument to measure the block"
+        end
+
+        def start_event(keyword, object)
+          ev = self.class::Event.new(self, keyword, object)
+          ev.start
+          ev
+        end
+
+        # 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 fallback_transaction_name(context)
+          context[:tracing_fallback_transaction_name]
+        end
+
+        def name_for(keyword, object)
+          case keyword
+          when :execute_field
+            @platform_field_key_cache[object]
+          when :authorized
+            @platform_authorized_key_cache[object]
+          when :resolve_type
+            @platform_resolve_type_key_cache[object]
+          when :dataloader_source
+            @platform_source_class_key_cache[object.class]
+          when :parse then self.class::PARSE_NAME
+          when :lex then self.class::LEX_NAME
+          when :execute then self.class::EXECUTE_NAME
+          when :analyze then self.class::ANALYZE_NAME
+          when :validate then self.class::VALIDATE_NAME
+          else
+            raise "No name for #{keyword.inspect}"
+          end
+        end
+
+        class Event
+          def initialize(monitor, keyword, object)
+            @monitor = monitor
+            @keyword = keyword
+            @object = object
+          end
+
+          attr_reader :keyword, :object
+
+          def start
+            raise "Implement #{self.class}#start to begin a new event (#{inspect})"
+          end
+
+          def finish
+            raise "Implement #{self.class}#finish to end this event (#{inspect})"
+          end
+        end
+
+        module GraphQLSuffixNames
+          PARSE_NAME = "parse.graphql"
+          LEX_NAME = "lex.graphql"
+          VALIDATE_NAME = "validate.graphql"
+          EXECUTE_NAME = "execute.graphql"
+          ANALYZE_NAME = "analyze.graphql"
+
+          private
+
+          def platform_field_key(field)
+            "#{field.path}.graphql"
+          end
+
+          def platform_authorized_key(type)
+            "#{type.graphql_name}.authorized.graphql"
+          end
+
+          def platform_resolve_type_key(type)
+            "#{type.graphql_name}.resolve_type.graphql"
+          end
+
+          def platform_source_key(source_class)
+            "#{source_class.name.gsub("::", "_").name.underscore}.fetch.graphql"
+          end
+        end
+
+        module GraphQLPrefixNames
+          PARSE_NAME = "graphql.parse"
+          LEX_NAME = "graphql.lex"
+          VALIDATE_NAME = "graphql.validate"
+          EXECUTE_NAME = "graphql.execute"
+          ANALYZE_NAME = "graphql.analyze"
+
+          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
+
+          def platform_source_class_key(source_class)
+            "graphql.fetch.#{source_class.name.gsub("::", "_")}"
+          end
+        end
+      end
+
+      def self.create_module(monitor_name)
+        if !monitor_name.match?(/[a-z]+/)
+          raise ArgumentError, "monitor name must be [a-z]+, not: #{monitor_name.inspect}"
+        end
+
+        trace_module = Module.new
+        code = MODULE_TEMPLATE % {
+          monitor: monitor_name,
+          monitor_class: monitor_name.capitalize + "Monitor",
+        }
+        trace_module.module_eval(code, __FILE__, __LINE__ + 5) # rubocop:disable Development/NoEvalCop This is build-time with a validated string
+        trace_module
+      end
+
+      MODULE_TEMPLATE = <<~RUBY
+        # @param set_transaction_name [Boolean] If `true`, use the GraphQL operation name as the request name on the monitoring platform
+        # @param trace_scalars [Boolean] If `true`, leaf fields will be traced too (Scalars _and_ Enums)
+        # @param trace_authorized [Boolean] If `false`, skip tracing `authorized?` calls
+        # @param trace_resolve_type [Boolean] If `false`, skip tracing `resolve_type?` calls
+        def initialize(...)
+          setup_%{monitor}_monitor(...)
+          super
+        end
+
+        def setup_%{monitor}_monitor(trace_scalars: false, trace_authorized: true, trace_resolve_type: true, set_transaction_name: false, **kwargs)
+          @trace_scalars = trace_scalars
+          @trace_authorized = trace_authorized
+          @trace_resolve_type = trace_resolve_type
+          @set_transaction_name = set_transaction_name
+          @%{monitor} = %{monitor_class}.new(trace: self, set_transaction_name: @set_transaction_name, **kwargs)
+        end
+
+        def parse(query_string:)
+          @%{monitor}.instrument(:parse, query_string) do
+            super
+          end
+        end
+
+        def lex(query_string:)
+          @%{monitor}.instrument(:lex, query_string) do
+            super
+          end
+        end
+
+        def validate(query:, validate:)
+          @%{monitor}.instrument(:validate, query) do
+            super
+          end
+        end
+
+        def begin_analyze_multiplex(multiplex, analyzers)
+          begin_%{monitor}_event(:analyze, nil)
+          super
+        end
+
+        def end_analyze_multiplex(multiplex, analyzers)
+          finish_%{monitor}_event
+          super
+        end
+
+        def execute_multiplex(multiplex:)
+          @%{monitor}.instrument(:execute, multiplex) do
+            super
+          end
+        end
+
+        def begin_execute_field(field, object, arguments, query)
+          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
+
+          if trace_field
+            begin_%{monitor}_event(:execute_field, field)
+          end
+          super
+        end
+
+        def end_execute_field(field, object, arguments, query, result)
+          finish_%{monitor}_event
+          super
+        end
+
+        def dataloader_fiber_yield(source)
+          Fiber[PREVIOUS_EV_KEY] = finish_%{monitor}_event
+          super
+        end
+
+        def dataloader_fiber_resume(source)
+          prev_ev = Fiber[PREVIOUS_EV_KEY]
+          if prev_ev
+            begin_%{monitor}_event(prev_ev.keyword, prev_ev.object)
+          end
+          super
+        end
+
+        def begin_authorized(type, object, context)
+          @trace_authorized && begin_%{monitor}_event(:authorized, type)
+          super
+        end
+
+        def end_authorized(type, object, context, result)
+          finish_%{monitor}_event
+          super
+        end
+
+        def begin_resolve_type(type, value, context)
+          @trace_resolve_type && begin_%{monitor}_event(:resolve_type, type)
+          super
+        end
+
+        def end_resolve_type(type, value, context, resolved_type)
+          finish_%{monitor}_event
+          super
+        end
+
+        def begin_dataloader_source(source)
+          begin_%{monitor}_event(:dataloader_source, source)
+          super
+        end
+
+        def end_dataloader_source(source)
+          finish_%{monitor}_event
+          super
+        end
+
+        CURRENT_EV_KEY = :__graphql_%{monitor}_trace_event
+        PREVIOUS_EV_KEY = :__graphql_%{monitor}_trace_previous_event
+
+        private
+
+        def begin_%{monitor}_event(keyword, object)
+          Fiber[CURRENT_EV_KEY] = @%{monitor}.start_event(keyword, object)
+        end
+
+        def finish_%{monitor}_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
+      RUBY
+    end
+  end
+end