graphql 1.13.24 → 2.5.11

data/lib/graphql/tracing/detailed_trace.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require "graphql/tracing/detailed_trace/memory_backend"
+require "graphql/tracing/detailed_trace/redis_backend"
+
+module GraphQL
+  module Tracing
+    # `DetailedTrace` can make detailed profiles for a subset of production traffic.
+    #
+    # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
+    # overriding the one in `context[:trace_mode]`.
+    #
+    # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
+    # You can configure this database to retail all data (persistent) or to expire data according to your rules.
+    # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
+    #
+    # @example Adding the sampler to your schema
+    #   class MySchema < GraphQL::Schema
+    #     # Add the sampler:
+    #     use GraphQL::Tracing::DetailedTrace, redis: Redis.new(...), limit: 100
+    #
+    #     # And implement this hook to tell it when to take a sample:
+    #     def self.detailed_trace?(query)
+    #       # Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+    #       # Could call out to Flipper, etc
+    #       rand <= 0.000_1 # one in ten thousand
+    #     end
+    #   end
+    #
+    # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
+    class DetailedTrace
+      # @param redis [Redis] If provided, profiles will be stored in Redis for later review
+      # @param limit [Integer] A maximum number of profiles to store
+      def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
+        storage = if redis
+          RedisBackend.new(redis: redis, limit: limit)
+        elsif memory
+          MemoryBackend.new(limit: limit)
+        else
+          raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
+        end
+        schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
+        schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
+      end
+
+      def initialize(storage:, trace_mode:)
+        @storage = storage
+        @trace_mode = trace_mode
+      end
+
+      # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true`
+      attr_reader :trace_mode
+
+      # @return [String] ID of saved trace
+      def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+        @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
+      end
+
+      # @param last [Integer]
+      # @param before [Integer] Timestamp in milliseconds since epoch
+      # @return [Enumerable<StoredTrace>]
+      def traces(last: nil, before: nil)
+        @storage.traces(last: last, before: before)
+      end
+
+      # @return [StoredTrace, nil]
+      def find_trace(id)
+        @storage.find_trace(id)
+      end
+
+      # @return [void]
+      def delete_trace(id)
+        @storage.delete_trace(id)
+      end
+
+      # @return [void]
+      def delete_all_traces
+        @storage.delete_all_traces
+      end
+
+      class StoredTrace
+        def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:)
+          @id = id
+          @operation_name = operation_name
+          @duration_ms = duration_ms
+          @begin_ms = begin_ms
+          @trace_data = trace_data
+        end
+
+        attr_reader :id, :operation_name, :duration_ms, :begin_ms, :trace_data
+      end
+    end
+  end
+end

data/lib/graphql/{execution/instrumentation.rb → tracing/legacy_hooks_trace.rb}

@@ -1,38 +1,21 @@
 # frozen_string_literal: true
-module GraphQL
-  module Execution
-    module Instrumentation
-      # This function implements the instrumentation policy:
-      #
-      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
-      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
-      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
-      #
-      # When errors are raised from `after_` hooks:
-      #   - Subsequent `after_` hooks _are_ called
-      #   - The first raised error is captured; later errors are ignored
-      #   - If an error was capture, it's re-raised after all hooks are finished
-      #
-      # Partial runs of instrumentation are possible:
-      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
-      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
-      def self.apply_instrumenters(multiplex)
-        schema = multiplex.schema
-        queries = multiplex.queries
-        query_instrumenters = schema.instrumenters[:query]
-        multiplex_instrumenters = schema.instrumenters[:multiplex]
 
+module GraphQL
+  module Tracing
+    module LegacyHooksTrace
+      def execute_multiplex(multiplex:)
+        multiplex_instrumenters = multiplex.schema.instrumenters[:multiplex]
+        query_instrumenters = multiplex.schema.instrumenters[:query]
         # First, run multiplex instrumentation, then query instrumentation for each query
-        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-          each_query_call_hooks(query_instrumenters, queries) do
-            # Let them be executed
-            yield
+        RunHooks.call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+          RunHooks.each_query_call_hooks(query_instrumenters, multiplex.queries) do
+            super
           end
         end
       end
 
-      class << self
-        private
+      module RunHooks
+        module_function
         # Call the before_ hooks of each query,
         # Then yield if no errors.
         # `call_hooks` takes care of appropriate cleanup.

data/lib/graphql/tracing/legacy_trace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/trace"
+require "graphql/tracing/call_legacy_tracers"
+
+module GraphQL
+  module Tracing
+    class LegacyTrace < Trace
+      include CallLegacyTracers
+    end
+  end
+end

data/lib/graphql/tracing/monitor_trace.rb

@@ -0,0 +1,283 @@
+# 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"
+
+          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_class_key(source_class)
+            "#{source_class.name.gsub("::", "_")}.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

data/lib/graphql/tracing/new_relic_trace.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/monitor_trace"
+
+module GraphQL
+  module Tracing
+    # A tracer for reporting GraphQL-Ruby time to New Relic
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::NewRelicTrace
+    #
+    #     # Optional, use the operation name to set the new relic transaction name:
+    #     # trace_with GraphQL::Tracing::NewRelicTrace, set_transaction_name: true
+    #   end
+    #
+    # @example Installing without trace events for `authorized?` or `resolve_type` calls
+    #   trace_with GraphQL::Tracing::NewRelicTrace, trace_authorized: false, trace_resolve_type: false
+    NewRelicTrace = MonitorTrace.create_module("newrelic")
+    module NewRelicTrace
+      class NewrelicMonitor < MonitorTrace::Monitor
+        PARSE_NAME = "GraphQL/parse"
+        LEX_NAME = "GraphQL/lex"
+        VALIDATE_NAME = "GraphQL/validate"
+        EXECUTE_NAME = "GraphQL/execute"
+        ANALYZE_NAME = "GraphQL/analyze"
+
+        def instrument(keyword, payload, &block)
+          if keyword == :execute
+            query = payload.queries.first
+            set_this_txn_name = query.context[:set_new_relic_transaction_name]
+            if set_this_txn_name || (set_this_txn_name.nil? && @set_transaction_name)
+              NewRelic::Agent.set_transaction_name(transaction_name(query))
+            end
+          end
+          ::NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(name_for(keyword, payload), &block)
+        end
+
+        def platform_source_class_key(source_class)
+          "GraphQL/Source/#{source_class.name}"
+        end
+
+        def platform_field_key(field)
+          "GraphQL/#{field.owner.graphql_name}/#{field.graphql_name}"
+        end
+
+        def platform_authorized_key(type)
+          "GraphQL/Authorized/#{type.graphql_name}"
+        end
+
+        def platform_resolve_type_key(type)
+          "GraphQL/ResolveType/#{type.graphql_name}"
+        end
+
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            name = @monitor.name_for(keyword, object)
+            @nr_ev = NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: name, category: :web)
+          end
+
+          def finish
+            @nr_ev.finish
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_tracing.rb

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