graphql 2.0.13 → 2.3.10

data/lib/graphql/tracing/legacy_trace.rb

@@ -0,0 +1,69 @@
+# 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
+
+    class LegacyTrace < Trace
+      include CallLegacyTracers
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_trace.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module NewRelicTrace
+      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_new_relic_transaction_name]`.
+      def initialize(set_transaction_name: false, **_rest)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+
+      def execute_query(query:)
+        set_this_txn_name =  query.context[:set_new_relic_transaction_name]
+        if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+          NewRelic::Agent.set_transaction_name(transaction_name(query))
+        end
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped("GraphQL/execute") do
+          super
+        end
+      end
+
+      {
+        "lex" => "GraphQL/lex",
+        "parse" => "GraphQL/parse",
+        "validate" => "GraphQL/validate",
+        "analyze_query" => "GraphQL/analyze",
+        "analyze_multiplex" => "GraphQL/analyze",
+        "execute_multiplex" => "GraphQL/execute",
+        "execute_query_lazy" => "GraphQL/execute",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**_keys)
+            NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped("#{platform_key}") do
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_authorized(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_resolve_type(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(field)
+        "GraphQL/#{field.owner.graphql_name}/#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "GraphQL/Authorize/#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "GraphQL/ResolveType/#{type.graphql_name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/notifications_trace.rb

@@ -0,0 +1,45 @@
+# 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.
+    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
+
+      {
+        "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, &blk)
+            @notifications_engine.instrument("#{platform_key}", metadata, &blk)
+          end
+        RUBY
+      end
+
+      include PlatformTrace
+    end
+  end
+end

data/lib/graphql/tracing/platform_trace.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module PlatformTrace
+      def initialize(trace_scalars: false, **_options)
+        @trace_scalars = trace_scalars
+
+        @platform_key_cache = Hash.new { |h, mod| h[mod] = mod::KeyCache.new }
+        super
+      end
+
+      module BaseKeyCache
+        def initialize
+          @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }
+          @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }
+          @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }
+        end
+
+        attr_reader :platform_field_key_cache, :platform_authorized_key_cache, :platform_resolve_type_key_cache
+      end
+
+
+      def platform_execute_field_lazy(*args, &block)
+        platform_execute_field(*args, &block)
+      end
+
+      def platform_authorized_lazy(key, &block)
+        platform_authorized(key, &block)
+      end
+
+      def platform_resolve_type_lazy(key, &block)
+        platform_resolve_type(key, &block)
+      end
+
+      def self.included(child_class)
+        key_methods_class = Class.new {
+          include(child_class)
+          include(BaseKeyCache)
+        }
+        child_class.const_set(:KeyCache, key_methods_class)
+        [: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__
+              def #{field_trace_method}(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[#{child_class}].platform_field_key_cache[field]
+                else
+                  nil
+                end
+                if platform_key && trace_field
+                  platform_#{field_trace_method}(platform_key) do
+                    super
+                  end
+                else
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+
+
+        [:authorized, :authorized_lazy].each do |auth_trace_method|
+          if !child_class.method_defined?(auth_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{auth_trace_method}(type:, query:, object:)
+                platform_key = @platform_key_cache[#{child_class}].platform_authorized_key_cache[type]
+                platform_#{auth_trace_method}(platform_key) do
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+
+        [:resolve_type, :resolve_type_lazy].each do |rt_trace_method|
+          if !child_class.method_defined?(rt_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{rt_trace_method}(query:, type:, object:)
+                platform_key = @platform_key_cache[#{child_class}].platform_resolve_type_key_cache[type]
+                platform_#{rt_trace_method}(platform_key) do
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+      end
+
+      private
+
+      # 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
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -40,7 +40,7 @@ module GraphQL
 
           platform_key = if trace_field
             context = data.fetch(:query).context
-            cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
+            cached_platform_key(context, field, :field) { platform_field_key(field.owner, field) }
           else
             nil
           end
@@ -73,8 +73,22 @@ module GraphQL
       end
 
       def self.use(schema_defn, options = {})
-        tracer = self.new(**options)
-        schema_defn.tracer(tracer)
+        if options[:legacy_tracing]
+          tracer = self.new(**options)
+          schema_defn.tracer(tracer)
+        else
+          tracing_name = self.name.split("::").last
+          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, silence_deprecation_warning: true)
+          end
+        end
       end
 
       private

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

@@ -2,10 +2,10 @@
 
 module GraphQL
   module Tracing
-    class PrometheusTracing < PlatformTracing
+    module PrometheusTrace
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
-          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+          @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
             'graphql_duration_seconds',
             'Time spent in GraphQL operations, in seconds'
           )
@@ -28,5 +28,7 @@ module GraphQL
         end
       end
     end
+    # Backwards-compat:
+    PrometheusTracing::GraphQLCollector = PrometheusTrace::GraphQLCollector
   end
 end

data/lib/graphql/tracing/prometheus_trace.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    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)
+      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
+
+      def platform_resolve_type_lazy(platform_key, &block)
+        instrument_prometheus_execution(platform_key, "resolve_type_lazy", &block)
+      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
+
+      private
+
+      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
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -27,9 +27,9 @@ module GraphQL
         super opts
       end
 
-      def platform_trace(platform_key, key, data, &block)
+      def platform_trace(platform_key, key, _data, &block)
         return yield unless @keys_whitelist.include?(key)
-        instrument_execution(platform_key, key, data, &block)
+        instrument_execution(platform_key, key, &block)
       end
 
       def platform_field_key(type, field)
@@ -46,7 +46,7 @@ module GraphQL
 
       private
 
-      def instrument_execution(platform_key, key, data, &block)
+      def instrument_execution(platform_key, key, &block)
         start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
         result = block.call
         duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start

data/lib/graphql/tracing/scout_trace.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    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
+            end
+          }
+
+          self.class.instrument("GraphQL", "#{platform_key}", INSTRUMENT_OPTS) do
+            super
+          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
+
+      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/sentry_trace.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    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]))
+          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
+
+      def instrument_sentry_execution(platform_key, trace_method, data=nil, &block)
+        return yield unless Sentry.initialized?
+
+        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)
+          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'
+        end
+      end
+    end
+  end
+end