graphql 1.9.21 → 2.0.0

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+
+    # This class uses the AppopticsAPM SDK from the appoptics_apm gem to create
+    # traces for GraphQL.
+    #
+    # There are 4 configurations available. They can be set in the
+    # appoptics_apm config file or in code. Please see:
+    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    #
+    #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
+    #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false
+    #     AppOpticsAPM::Config[:graphql][:sanitize_query] = true|false
+    #     AppOpticsAPM::Config[:graphql][:remove_comments] = true|false
+    class AppOpticsTracing < GraphQL::Tracing::PlatformTracing
+      # These GraphQL events will show up as 'graphql.prep' spans
+      PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+      # 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
+
+      self.platform_keys = {
+        'lex' => 'lex',
+        'parse' => 'parse',
+        'validate' => 'validate',
+        'analyze_query' => 'analyze_query',
+        'analyze_multiplex' => 'analyze_multiplex',
+        'execute_multiplex' => 'execute_multiplex',
+        'execute_query' => 'execute_query',
+        'execute_query_lazy' => 'execute_query_lazy'
+      }
+
+      def platform_trace(platform_key, _key, data)
+        return yield if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+
+        layer = span_name(platform_key)
+        kvs = metadata(data, layer)
+        kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+        transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          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
+
+      private
+
+      def gql_config
+        ::AppOpticsAPM::Config[:graphql] ||= {}
+      end
+
+      def transaction_name(query)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        split_query = query.strip.split(/\W+/, 3)
+        split_query[0] = 'query' if split_query[0].empty?
+        name = "graphql.#{split_query[0..1].join('.')}"
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def multiplex_transaction_name(names)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        name = "graphql.multiplex.#{names.join('.')}"
+        name = "#{name[0..251]}..." if name.length > 254
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def span_name(key)
+        return 'graphql.prep' if PREP_KEYS.include?(key)
+        return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+        key[/^graphql\./] ? key : "graphql.#{key}"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def metadata(data, layer)
+        data.keys.map do |key|
+          case key
+          when :context
+            graphql_context(data[key], layer)
+          when :query
+            graphql_query(data[key])
+          when :query_string
+            graphql_query_string(data[key])
+          when :multiplex
+            graphql_multiplex(data[key])
+          when :path
+            [key, data[key].join(".")]
+          else
+            [key, data[key]]
+          end
+        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def graphql_context(context, layer)
+        context.errors && context.errors.each do |err|
+          AppOpticsAPM::API.log_exception(layer, err)
+        end
+
+        [[:Path, context.path.join('.')]]
+      end
+
+      def graphql_query(query)
+        return [] unless query
+
+        query_string = query.query_string
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [[:InboundQuery, query_string],
+         [:Operation, query.selected_operation_name]]
+      end
+
+      def graphql_query_string(query_string)
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [:InboundQuery, query_string]
+      end
+
+      def graphql_multiplex(data)
+        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        multiplex_transaction_name(names) if names.size > 1
+
+        [:Operations, names.join(', ')]
+      end
+
+      def sanitize(query)
+        return unless query
+
+        # remove arguments
+        query.gsub(/"[^"]*"/, '"?"')                 # strings
+          .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+          .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+      end
+
+      def remove_comments(query)
+        return unless query
+
+        query.gsub(/#[^\n\r]*/, '')
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -14,7 +14,22 @@ module 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
@@ -23,6 +38,14 @@ module GraphQL
       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

@@ -20,7 +20,12 @@ module GraphQL
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = operations unless operations.empty?
+            span.resource = if operations.empty?
+              first_query = data[:multiplex].queries.first
+              fallback_transaction_name(first_query && first_query.context)
+            else
+              operations
+            end
 
             # For top span of query, set the analytics sample rate tag, if available.
             if analytics_enabled?
@@ -63,6 +68,14 @@ module GraphQL
       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/new_relic_tracing.rb

@@ -26,18 +26,7 @@ module GraphQL
         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)
-            query = data[:query]
-            # Set the transaction name based on the operation type and name
-            selected_op = query.selected_operation
-            if selected_op
-              op_type = selected_op.operation_type
-              op_name = selected_op.name || "anonymous"
-            else
-              op_type = "query"
-              op_name = "anonymous"
-            end
-
-            NewRelic::Agent.set_transaction_name("GraphQL/#{op_type}.#{op_name}")
+            NewRelic::Agent.set_transaction_name(transaction_name(data[:query]))
           end
         end
 
@@ -49,6 +38,14 @@ module GraphQL
       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

@@ -21,7 +21,6 @@ module GraphQL
       def trace(key, data)
         case key
         when "lex", "parse", "validate", "analyze_query", "analyze_multiplex", "execute_query", "execute_query_lazy", "execute_multiplex"
-          data.fetch(:query).context.namespace(self.class)[:platform_key_cache] = {} if key == "execute_query"
           platform_key = @platform_keys.fetch(key)
           platform_trace(platform_key, key, data) do
             yield
@@ -33,18 +32,19 @@ module GraphQL
             trace_field = true # implemented with instrumenter
           else
             field = data[:field]
-            platform_key_cache = data.fetch(:query).context.namespace(self.class).fetch(:platform_key_cache)
-            platform_key = platform_key_cache.fetch(field) do
-              platform_key_cache[field] = platform_field_key(data[:owner], field)
-            end
-
             return_type = field.type.unwrap
-            # Handle LateBoundTypes, which don't have `#kind`
-            trace_field = if return_type.respond_to?(:kind) && (return_type.kind.scalar? || return_type.kind.enum?)
+            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) { platform_field_key(data[:owner], field) }
+            else
+              nil
+            end
           end
 
           if platform_key && trace_field
@@ -54,40 +54,68 @@ module GraphQL
           else
             yield
           end
+        when "authorized", "authorized_lazy"
+          type = data.fetch(:type)
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { 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) { platform_resolve_type_key(type) }
+          platform_trace(platform_key, key, data) do
+            yield
+          end
         else
           # it's a custom key
           yield
         end
       end
 
-      def instrument(type, field)
-        return_type = field.type.unwrap
-        case return_type
-        when GraphQL::ScalarType, GraphQL::EnumType
-          if field.trace || (field.trace.nil? && @trace_scalars)
-            trace_field(type, field)
-          else
-            field
-          end
-        else
-          trace_field(type, field)
-        end
+      def self.use(schema_defn, options = {})
+        tracer = self.new(**options)
+        schema_defn.tracer(tracer)
       end
 
-      def trace_field(type, field)
-        new_f = field.redefine
-        new_f.metadata[:platform_key] = platform_field_key(type, field)
-        new_f
+      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 self.use(schema_defn, options = {})
-        tracer = self.new(options)
-        schema_defn.instrument(:field, tracer)
-        schema_defn.tracer(tracer)
+      def fallback_transaction_name(context)
+        context[:tracing_fallback_transaction_name]
       end
 
-      private
       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`.
+      #
+      # @return [String]
+      def cached_platform_key(ctx, key)
+        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

@@ -16,7 +16,10 @@ module GraphQL
         end
 
         def collect(object)
-          labels = { key: object['key'], platform_key: object['platform_key'] }
+          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
 

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -36,6 +36,14 @@ module GraphQL
         "#{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)

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,12 +16,23 @@ module 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
@@ -30,6 +41,14 @@ module GraphQL
       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

data/lib/graphql/tracing.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
+require "graphql/tracing/appoptics_tracing"
 require "graphql/tracing/appsignal_tracing"
 require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
-require "graphql/tracing/skylight_tracing"
+require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
 
 if defined?(PrometheusExporter::Server)
@@ -15,15 +16,13 @@ end
 module GraphQL
   # Library entry point for performance metric reporting.
   #
-  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
-  #
   # @example Sending custom events
-  #   GraphQL::Tracing.trace("my_custom_event", { ... }) do
+  #   query.trace("my_custom_event", { ... }) do
   #     # do stuff ...
   #   end
   #
   # @example Adding a tracer to a schema
-  #  MySchema = GraphQL::Schema.define do
+  #  class MySchema < GraphQL::Schema
   #    tracer MyTracer # <= responds to .trace(key, data, &block)
   #  end
   #
@@ -42,8 +41,12 @@ module GraphQL
   # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
   # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphQL::Query?, path: Array<String, Integer>?}`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, query: GraphqL::Query?, path: Array<String, Integer>?}`
+  # execute_field | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # execute_field_lazy | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
+  # authorized | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # authorized_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
+  # resolve_type_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
   #
   # Note that `execute_field` and `execute_field_lazy` receive different data in different settings:
   #
@@ -58,8 +61,9 @@ module GraphQL
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
-      def trace(key, metadata)
-        call_tracers(0, key, metadata) { yield }
+      def trace(key, metadata, &block)
+        return yield if @tracers.empty?
+        call_tracers(0, key, metadata, &block)
       end
 
       private
@@ -71,39 +75,14 @@ module GraphQL
       # @param key [String] The current event name
       # @param metadata [Object] The current event object
       # @return Whatever the block returns
-      def call_tracers(idx, key, metadata)
+      def call_tracers(idx, key, metadata, &block)
         if idx == @tracers.length
           yield
         else
-          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
-        end
-      end
-    end
-
-    class << self
-      # Install a tracer to receive events.
-      # @param tracer [<#trace(key, metadata)>]
-      # @return [void]
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def install(tracer)
-        warn("GraphQL::Tracing.install is deprecated, add it to the schema with `tracer(my_tracer)` instead.")
-        if !tracers.include?(tracer)
-          @tracers << tracer
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         end
       end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def uninstall(tracer)
-        @tracers.delete(tracer)
-      end
-
-      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
-      def tracers
-        @tracers ||= []
-      end
     end
-    # Initialize the array
-    tracers
 
     module NullTracer
       module_function