graphql 0.16.0 → 2.0.15

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class AppsignalTracing < PlatformTracing
+      self.platform_keys = {
+        "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",
+      }
+
+      # @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(options = {})
+        @set_action_name = options.fetch(:set_action_name, false)
+        super
+      end
+
+      def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          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
+        end
+
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.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_tracing.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DataDogTracing < PlatformTracing
+      self.platform_keys = {
+        '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',
+      }
+
+      def platform_trace(platform_key, key, data)
+        tracer.trace(platform_key, service: service_name) do |span|
+          span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
+          end
+
+          if key == 'execute_multiplex'
+            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
+
+            # For top span of query, set the analytics sample rate tag, if available.
+            if analytics_enabled?
+              Datadog::Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+            end
+          end
+
+          if key == 'execute_query'
+            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)
+          end
+
+          prepare_span(key, data, span)
+
+          yield
+        end
+      end
+
+      def service_name
+        options.fetch(:service, 'ruby-graphql')
+      end
+
+      # 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 tracer
+        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+
+        options.fetch(:tracer, default_tracer)
+      end
+
+      def analytics_available?
+        defined?(Datadog::Contrib::Analytics) \
+          && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
+          && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
+      end
+
+      def analytics_enabled?
+        # [Deprecated] options[:analytics_enabled] will be removed in the future
+        analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
+      end
+
+      def analytics_sample_rate
+        # [Deprecated] options[:analytics_sample_rate] will be removed in the future
+        options.fetch(:analytics_sample_rate, 1.0)
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      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/instrumentation_tracing.rb

@@ -0,0 +1,83 @@
+module GraphQL
+  module Tracing
+    class InstrumentationTracing
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def trace(event, data)
+        instrumenters = nil
+        query_instrumenters = nil
+        case event
+        when "execute_multiplex"
+          instrumenters = @schema.instrumenters
+          multiplex_instrumenters = instrumenters[:multiplex]
+          query_instrumenters = instrumenters[:query]
+          call_hooks(multiplex_instrumenters, data[:multiplex], :before_multiplex, :after_multiplex) {
+            each_query_call_hooks(query_instrumenters, data[:multiplex].queries) {
+              yield
+            }
+          }
+        else
+          yield
+        end
+      end
+
+      private
+
+      # Call the before_ hooks of each query,
+      # Then yield if no errors.
+      # `call_hooks` takes care of appropriate cleanup.
+      def each_query_call_hooks(instrumenters, queries, i = 0)
+        if i >= queries.length
+          yield
+        else
+          query = queries[i]
+          call_hooks(instrumenters, query, :before_query, :after_query) {
+            each_query_call_hooks(instrumenters, queries, i + 1) {
+              yield
+            }
+          }
+        end
+      end
+
+      # Call each before hook, and if they all succeed, yield.
+      # If they don't all succeed, call after_ for each one that succeeded.
+      def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+        begin
+          successful = []
+          instrumenters.each do |instrumenter|
+            instrumenter.public_send(before_hook_name, object)
+            successful << instrumenter
+          end
+
+          # if any before hooks raise an exception, quit calling before hooks,
+          # but call the after hooks on anything that succeeded but also
+          # raise the exception that came from the before hook.
+        rescue GraphQL::ExecutionError => err
+          object.context.errors << err
+        rescue => e
+          raise call_after_hooks(successful, object, after_hook_name, e)
+        end
+
+        begin
+          yield # Call the user code
+        ensure
+          ex = call_after_hooks(successful, object, after_hook_name, nil)
+          raise ex if ex
+        end
+      end
+
+      def call_after_hooks(instrumenters, object, after_hook_name, ex)
+        instrumenters.reverse_each do |instrumenter|
+          begin
+            instrumenter.public_send(after_hook_name, object)
+          rescue => e
+            ex = e
+          end
+        end
+        ex
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class NewRelicTracing < PlatformTracing
+      self.platform_keys = {
+        "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",
+      }
+
+      # @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(options = {})
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
+        super
+      end
+
+      def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name =  data[: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(data[:query]))
+          end
+        end
+
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "GraphQL/#{type.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_tracing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to a notification handler (i.e.
+    # ActiveSupport::Notifications or Dry::Monitor::Notifications)
+    # with a `graphql` suffix.
+    #
+    # @see KEYS for event names
+    class NotificationsTracing
+      # A cache of frequently-used keys to avoid needless string allocations
+      KEYS = {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.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",
+      }
+
+      MAX_KEYS_SIZE = 100
+
+      # Initialize a new NotificationsTracing instance
+      #
+      # @param [Object] notifications_engine The notifications engine to use
+      def initialize(notifications_engine)
+        @notifications_engine = notifications_engine
+      end
+
+      # Sends a GraphQL tracing event to the notification handler
+      #
+      # @example
+      # . notifications_engine = Dry::Monitor::Notifications.new(:graphql)
+      # . tracer = GraphQL::Tracing::NotificationsTracing.new(notifications_engine)
+      # . tracer.trace("lex") { ... }
+      #
+      # @param [string] key The key for the event
+      # @param [Hash] metadata The metadata for the event
+      # @yield The block to execute for the event
+      def trace(key, metadata, &blk)
+        prefixed_key = KEYS[key] || "#{key}.graphql"
+
+        # Cache the new keys while making sure not to induce a memory leak
+        if KEYS.size < MAX_KEYS_SIZE
+          KEYS[key] ||= prefixed_key
+        end
+
+        @notifications_engine.instrument(prefixed_key, metadata, &blk)
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # Each platform provides:
+    # - `.platform_keys`
+    # - `#platform_trace`
+    # - `#platform_field_key(type, field)`
+    # @api private
+    class PlatformTracing
+      class << self
+        attr_accessor :platform_keys
+
+        def inherited(child_class)
+          child_class.platform_keys = self.platform_keys
+        end
+      end
+
+      def initialize(options = {})
+        @options = options
+        @platform_keys = self.class.platform_keys
+        @trace_scalars = options.fetch(:trace_scalars, false)
+      end
+
+      def trace(key, data)
+        case key
+        when "lex", "parse", "validate", "analyze_query", "analyze_multiplex", "execute_query", "execute_query_lazy", "execute_multiplex"
+          platform_key = @platform_keys.fetch(key)
+          platform_trace(platform_key, key, data) do
+            yield
+          end
+        when "execute_field", "execute_field_lazy"
+          field = data[:field]
+          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
+            context = data.fetch(:query).context
+            cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
+          else
+            nil
+          end
+
+          if platform_key && trace_field
+            platform_trace(platform_key, key, data) do
+              yield
+            end
+          else
+            yield
+          end
+        when "authorized", "authorized_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type, :authorized) { platform_authorized_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
+        when "resolve_type", "resolve_type_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type, :resolve_type) { platform_resolve_type_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
+        else
+          # it's a custom key
+          yield
+        end
+      end
+
+      def self.use(schema_defn, options = {})
+        tracer = self.new(**options)
+        schema_defn.tracer(tracer)
+      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
+
+      attr_reader :options
+
+      # Different kind of schema objects have different kinds of keys:
+      #
+      # - Object types: `.authorized`
+      # - Union/Interface types: `.resolve_type`
+      # - Fields: execution
+      #
+      # So, they can all share one cache.
+      #
+      # If the key isn't present, the given block is called and the result is cached for `key`.
+      #
+      # @param ctx [GraphQL::Query::Context]
+      # @param key [Class, GraphQL::Field] A part of the schema
+      # @param trace_phase [Symbol] The stage of execution being traced (used by OpenTelementry tracing)
+      # @return [String]
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+        cache.fetch(key) { cache[key] = yield }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class PrometheusTracing < PlatformTracing
+      class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
+        def initialize
+          @graphql_gauge = PrometheusExporter::Metric::Summary.new(
+            'graphql_duration_seconds',
+            'Time spent in GraphQL operations, in seconds'
+          )
+        end
+
+        def type
+          'graphql'
+        end
+
+        def collect(object)
+          default_labels = { key: object['key'], platform_key: object['platform_key'] }
+          custom = object['custom_labels']
+          labels = custom.nil? ? default_labels : default_labels.merge(custom)
+
+          @graphql_gauge.observe object['duration'], labels
+        end
+
+        def metrics
+          [@graphql_gauge]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class PrometheusTracing < PlatformTracing
+      DEFAULT_WHITELIST = ['execute_field', 'execute_field_lazy'].freeze
+      DEFAULT_COLLECTOR_TYPE = 'graphql'.freeze
+
+      self.platform_keys = {
+        '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",
+        'execute_field' => "graphql.execute",
+        'execute_field_lazy' => "graphql.execute"
+      }
+
+      def initialize(opts = {})
+        @client = opts[:client] || PrometheusExporter::Client.default
+        @keys_whitelist = opts[:keys_whitelist] || DEFAULT_WHITELIST
+        @collector_type = opts[:collector_type] || DEFAULT_COLLECTOR_TYPE
+
+        super opts
+      end
+
+      def platform_trace(platform_key, key, data, &block)
+        return yield unless @keys_whitelist.include?(key)
+        instrument_execution(platform_key, key, data, &block)
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      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_execution(platform_key, key, data, &block)
+        start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
+        result = block.call
+        duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
+        observe platform_key, key, duration
+        result
+      end
+
+      def observe(platform_key, key, duration)
+        @client.send_json(
+          type: @collector_type,
+          duration: duration,
+          platform_key: platform_key,
+          key: key
+        )
+      end
+    end
+  end
+end

data/lib/graphql/tracing/scout_tracing.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class ScoutTracing < PlatformTracing
+      INSTRUMENT_OPTS = { scope: true }
+
+      self.platform_keys = {
+        "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",
+      }
+
+      # @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(options = {})
+        self.class.include ScoutApm::Tracer
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
+        super(options)
+      end
+
+      def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          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
+        end
+
+        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      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/statsd_tracing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class StatsdTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => "graphql.lex",
+        'parse' => "graphql.parse",
+        'validate' => "graphql.validate",
+        'analyze_query' => "graphql.analyze_query",
+        'analyze_multiplex' => "graphql.analyze_multiplex",
+        'execute_multiplex' => "graphql.execute_multiplex",
+        'execute_query' => "graphql.execute_query",
+        'execute_query_lazy' => "graphql.execute_query_lazy",
+      }
+
+      # @param statsd [Object] A statsd client
+      def initialize(statsd:, **rest)
+        @statsd = statsd
+        super(**rest)
+      end
+
+      def platform_trace(platform_key, key, data)
+        @statsd.time(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.graphql_name}.#{field.graphql_name}"
+      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
+    end
+  end
+end