graphql 2.4.5 → 2.5.21

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -1,11 +1,22 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_trace'
+require "graphql/tracing/notifications_trace"
 
 module GraphQL
   module Tracing
-    # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql` suffix.
+    # This implementation forwards events to ActiveSupport::Notifications with a `graphql` suffix.
+    #
+    # @example Sending execution events to ActiveSupport::Notifications
+    #   class MySchema < GraphQL::Schema
+    #     trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
+    #   end
+    #
+    # @example Subscribing to GraphQL events with ActiveSupport::Notifications
+    #   ActiveSupport::Notifications.subscribe(/graphql/) do |event|
+    #     pp event.name
+    #     pp event.payload
+    #   end
+    #
     module ActiveSupportNotificationsTrace
       include NotificationsTrace
       def initialize(engine: ActiveSupport::Notifications, **rest)

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_tracing'
+require "graphql/tracing/notifications_tracing"
 
 module GraphQL
   module Tracing

data/lib/graphql/tracing/appoptics_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
 
@@ -20,14 +22,18 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used
 
+
       def self.version
         Gem::Version.new('1.0.0')
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       [
         'lex',
         'parse',
@@ -55,6 +61,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field(query:, field:, ast_node:, arguments:, object:)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?
@@ -81,7 +89,7 @@ module GraphQL
         end
       end
 
-      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)  # rubocop:disable Development/TraceCallsSuperCop
         execute_field(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
       end
 

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
 
@@ -20,6 +22,11 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+      def initialize(...)
+        warn "GraphQL::Tracing::AppOptics tracing is deprecated; update to SolarWindsAPM instead, which uses OpenTelemetry."
+        super
+      end
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used

data/lib/graphql/tracing/appsignal_trace.rb

@@ -1,77 +1,54 @@
 # frozen_string_literal: true
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
+    # Instrumentation for reporting GraphQL-Ruby times to Appsignal.
+    #
+    # @example Installing the tracer
+    #   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
 
-      {
-        "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
-
-      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/appsignal_tracing.rb

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

data/lib/graphql/tracing/call_legacy_tracers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    module CallLegacyTracers
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -1,183 +1,71 @@
 # frozen_string_literal: true
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting to DataDog
+    # @example Adding this tracer to your schema
+    #   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
-
-      {
-        '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}')
-
-              #{
-                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
+        attr_reader :tracer, :service_name
 
-                  # [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
 
-      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/data_dog_tracing.rb

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

data/lib/graphql/tracing/detailed_trace/active_record_backend.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class ActiveRecordBackend
+        class GraphqlDetailedTrace < ActiveRecord::Base
+        end
+
+        def initialize(limit: nil, model_class: nil)
+          @limit = limit
+          @model_class = model_class || GraphqlDetailedTrace
+        end
+
+        def traces(last:, before:)
+          gdts = @model_class.all.order("begin_ms DESC")
+          if before
+            gdts = gdts.where("begin_ms < ?", before)
+          end
+          if last
+            gdts = gdts.limit(last)
+          end
+          gdts.map { |gdt| record_to_stored_trace(gdt) }
+        end
+
+        def delete_trace(id)
+          @model_class.where(id: id).destroy_all
+          nil
+        end
+
+        def delete_all_traces
+          @model_class.all.destroy_all
+        end
+
+        def find_trace(id)
+          gdt = @model_class.find_by(id: id)
+          if gdt
+            record_to_stored_trace(gdt)
+          else
+            nil
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          gdt = @model_class.create!(
+            begin_ms: begin_ms,
+            operation_name: operation_name,
+            duration_ms: duration_ms,
+            trace_data: trace_data,
+          )
+          if @limit
+            @model_class
+              .where("id NOT IN(SELECT id FROM graphql_detailed_traces ORDER BY begin_ms DESC LIMIT ?)", @limit)
+              .delete_all
+          end
+          gdt.id
+        end
+
+        private
+
+        def record_to_stored_trace(gdt)
+          StoredTrace.new(
+            id: gdt.id,
+            begin_ms: gdt.begin_ms,
+            operation_name: gdt.operation_name,
+            duration_ms: gdt.duration_ms,
+            trace_data: gdt.trace_data
+          )
+
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace/memory_backend.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      # An in-memory trace storage backend. Suitable for testing and development only.
+      # It won't work for multi-process deployments and everything is erased when the app is restarted.
+      class MemoryBackend
+        def initialize(limit: nil)
+          @limit = limit
+          @traces = {}
+          @next_id = 0
+        end
+
+        def traces(last:, before:)
+          page = []
+          @traces.values.reverse_each do |trace|
+            if page.size == last
+              break
+            elsif before.nil? || trace.begin_ms < before
+              page << trace
+            end
+          end
+          page
+        end
+
+        def find_trace(id)
+          @traces[id]
+        end
+
+        def delete_trace(id)
+          @traces.delete(id.to_i)
+          nil
+        end
+
+        def delete_all_traces
+          @traces.clear
+          nil
+        end
+
+        def save_trace(operation_name, duration, begin_ms, trace_data)
+          id = @next_id
+          @next_id += 1
+          @traces[id] = DetailedTrace::StoredTrace.new(
+            id: id,
+            operation_name: operation_name,
+            duration_ms: duration,
+            begin_ms: begin_ms,
+            trace_data: trace_data
+          )
+          if @limit && @traces.size > @limit
+            del_keys = @traces.keys[0...-@limit]
+            del_keys.each { |k| @traces.delete(k) }
+          end
+          id
+        end
+      end
+    end
+  end
+end