datadog 2.8.0 → 2.39.0

data/lib/datadog/tracing/contrib/grape/instrumentation.rb

@@ -6,27 +6,32 @@ module Datadog
       module Grape
         # Instrumentation for Grape::Endpoint
         module Instrumentation
-          def self.included(base)
-            base.singleton_class.prepend(ClassMethods)
-            base.prepend(InstanceMethods)
-          end
-
-          # ClassMethods - implementing instrumentation
-          module ClassMethods
+          # GenerateApiMethodPatch - class method instrumentation for endpoint render (Grape < 3.0.0)
+          module GenerateApiMethodPatch
             def generate_api_method(*params, &block)
               method_api = super
 
               proc do |*args|
-                ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
+                ::ActiveSupport::Notifications.instrument("endpoint_render.grape.start_render")
                 method_api.call(*args)
               end
             end
           end
 
-          # InstanceMethods - implementing instrumentation
+          # ExecutePatch - instance method instrumentation for endpoint render (Grape >= 3.0.0)
+          module ExecutePatch
+            def execute(*args)
+              return unless @source
+
+              ::ActiveSupport::Notifications.instrument("endpoint_render.grape.start_render")
+              super
+            end
+          end
+
+          # InstanceMethods - instance method instrumentation for endpoint run
           module InstanceMethods
             def run(*args)
-              ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process', endpoint: self, env: env)
+              ::ActiveSupport::Notifications.instrument("endpoint_run.grape.start_process", endpoint: self, env: env)
               super
             end
           end

data/lib/datadog/tracing/contrib/grape/integration.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -12,13 +12,13 @@ module Datadog
         class Integration
           include Contrib::Integration
 
-          MINIMUM_VERSION = Gem::Version.new('1.0')
+          MINIMUM_VERSION = Gem::Version.new("1.0")
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :grape, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['grape'] && Gem.loaded_specs['grape'].version
+            Gem.loaded_specs["grape"]&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/grape/patcher.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'endpoint'
-require_relative 'ext'
-require_relative 'instrumentation'
-require_relative '../patcher'
+require_relative "endpoint"
+require_relative "ext"
+require_relative "instrumentation"
+require_relative "../patcher"
 
 module Datadog
   module Tracing
@@ -21,7 +21,12 @@ module Datadog
 
           def patch
             # Patch endpoints
-            ::Grape::Endpoint.include(Instrumentation)
+            ::Grape::Endpoint.prepend(Instrumentation::InstanceMethods)
+            if target_version < Gem::Version.new("3.0.0")
+              ::Grape::Endpoint.singleton_class.prepend(Instrumentation::GenerateApiMethodPatch)
+            else
+              ::Grape::Endpoint.prepend(Instrumentation::ExecutePatch)
+            end
 
             # Subscribe to ActiveSupport events
             Endpoint.subscribe

data/lib/datadog/tracing/contrib/graphql/configuration/error_extension_env_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GraphQL
+        module Configuration
+          # Parses the environment variable `DD_TRACE_GRAPHQL_ERROR_EXTENSIONS` for error extension names declaration.
+          class ErrorExtensionEnvParser
+            # Parses the environment variable `DD_TRACE_GRAPHQL_ERROR_EXTENSIONS` into an array of error extension names.
+            def self.call(values)
+              # Split by comma, remove leading and trailing whitespaces,
+              # remove empty values, and remove repeated values.
+              values.split(",").each(&:strip!).reject(&:empty?).uniq
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/graphql/configuration/settings.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
+require_relative "error_extension_env_parser"
 
 module Datadog
   module Tracing
@@ -44,6 +45,23 @@ module Datadog
             end
 
             option :with_unified_tracer do |o|
+              o.env Ext::ENV_WITH_UNIFIED_TRACER
+              o.type :bool
+              o.default false
+            end
+
+            # Capture error extensions provided by the user in their GraphQL error responses.
+            # The extensions can be anything, so the user is responsible for ensuring they are safe to capture.
+            option :error_extensions do |o|
+              o.env Ext::ENV_ERROR_EXTENSIONS
+              o.type :array, nilable: false
+              o.default []
+              o.env_parser { |v| ErrorExtensionEnvParser.call(v) }
+            end
+
+            # Surface GraphQL errors in Error Tracking.
+            option :error_tracking do |o|
+              o.env Ext::ENV_ERROR_TRACKING
               o.type :bool
               o.default false
             end

data/lib/datadog/tracing/contrib/graphql/ext.rb

@@ -7,12 +7,18 @@ module Datadog
         # GraphQL integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_GRAPHQL_ENABLED'
+          ENV_ENABLED = "DD_TRACE_GRAPHQL_ENABLED"
           # @!visibility private
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPHQL_ANALYTICS_ENABLED'
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
-          SERVICE_NAME = 'graphql'
-          TAG_COMPONENT = 'graphql'
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_GRAPHQL_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE"
+          ENV_WITH_UNIFIED_TRACER = "DD_TRACE_GRAPHQL_WITH_UNIFIED_TRACER"
+          ENV_ERROR_EXTENSIONS = "DD_TRACE_GRAPHQL_ERROR_EXTENSIONS"
+          ENV_ERROR_TRACKING = "DD_TRACE_GRAPHQL_ERROR_TRACKING"
+          SERVICE_NAME = "graphql"
+          TAG_COMPONENT = "graphql"
+
+          # Span event name for query-level errors
+          EVENT_QUERY_ERROR = "dd.graphql.query.error"
         end
       end
     end

data/lib/datadog/tracing/contrib/graphql/integration.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -16,7 +16,7 @@ module Datadog
           register_as :graphql, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version
+            Gem.loaded_specs["graphql"]&.version
           end
 
           def self.loaded?
@@ -31,15 +31,15 @@ module Datadog
           #
           def self.compatible?
             super && (
-              (version >= Gem::Version.new('1.13.21') && version < Gem::Version.new('2.0')) ||
-              (version >= Gem::Version.new('2.0.28') && version < Gem::Version.new('2.1')) ||
-              (version >= Gem::Version.new('2.1.11') && version < Gem::Version.new('2.2')) ||
-              (version >= Gem::Version.new('2.2.6'))
+              (version >= Gem::Version.new("1.13.21") && version < Gem::Version.new("2.0")) ||
+              (version >= Gem::Version.new("2.0.28") && version < Gem::Version.new("2.1")) ||
+              (version >= Gem::Version.new("2.1.11") && version < Gem::Version.new("2.2")) ||
+              (version >= Gem::Version.new("2.2.6"))
             )
           end
 
           def self.trace_supported?
-            version >= Gem::Version.new('2.0.19')
+            version >= Gem::Version.new("2.0.19")
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/graphql/patcher.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../analytics'
-require_relative '../patcher'
-require_relative 'tracing_patcher'
-require_relative 'trace_patcher'
-require_relative 'unified_trace_patcher'
+require_relative "../analytics"
+require_relative "../patcher"
+require_relative "tracing_patcher"
+require_relative "trace_patcher"
+require_relative "unified_trace_patcher"
 
 module Datadog
   module Tracing
@@ -36,9 +36,9 @@ module Datadog
               end
             else
               Datadog.logger.warn(
-                "GraphQL version (#{target_version}) does not support GraphQL::Tracing::DataDogTrace"\
-                'or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.'\
-                'Falling back to GraphQL::Tracing::DataDogTracing.'
+                "GraphQL version (#{target_version}) does not support GraphQL::Tracing::DataDogTrace" \
+                "or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace." \
+                "Falling back to GraphQL::Tracing::DataDogTracing."
               )
               TracingPatcher.patch!(schemas)
             end

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql'
+require "graphql"
 
 module Datadog
   module Tracing
@@ -11,59 +11,108 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
+          include ::GraphQL::Tracing::PlatformTrace
+
           def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
+
+            # Cache configuration values to avoid repeated lookups
+            config = Datadog.configuration.tracing[:graphql]
+            @service_name = config[:service_name]
+            @analytics_enabled = config[:analytics_enabled]
+            @analytics_sample_rate = config[:analytics_sample_rate]
+            @error_extensions_config = config[:error_extensions]
+
+            load_error_event_attributes(config[:error_tracking])
+
             super
           end
 
+          def load_error_event_attributes(error_tracking)
+            if error_tracking
+              @event_name = Tracing::Metadata::Ext::Errors::EVENT_NAME
+              @message_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_MESSAGE
+              @type_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_TYPE
+              @stacktrace_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_STACKTRACE
+              @locations_key = "graphql.error.locations"
+              @path_key = "graphql.error.path"
+              @extensions_key = "graphql.error.extensions."
+            else
+              @event_name = Ext::EVENT_QUERY_ERROR
+              @message_key = "message"
+              @type_key = "type"
+              @stacktrace_key = "stacktrace"
+              @locations_key = "locations"
+              @path_key = "path"
+              @extensions_key = "extensions."
+            end
+          end
+
+          private :load_error_event_attributes
+
           def lex(*args, query_string:, **kwargs)
-            trace(proc { super }, 'lex', query_string, query_string: query_string)
+            trace(proc { super }, "lex", query_string, query_string: query_string)
           end
 
           def parse(*args, query_string:, **kwargs)
-            trace(proc { super }, 'parse', query_string, query_string: query_string) do |span|
-              span.set_tag('graphql.source', query_string)
+            trace(proc { super }, "parse", query_string, query_string: query_string) do |span|
+              span.set_tag("graphql.source", query_string)
             end
           end
 
           def validate(*args, query:, validate:, **kwargs)
-            trace(proc { super }, 'validate', query.selected_operation_name, query: query, validate: validate) do |span|
-              span.set_tag('graphql.source', query.query_string)
+            trace(proc { super }, "validate", query.selected_operation_name, query: query, validate: validate) do |span|
+              span.set_tag("graphql.source", query.query_string)
             end
           end
 
           def analyze_multiplex(*args, multiplex:, **kwargs)
-            trace(proc { super }, 'analyze_multiplex', multiplex_resource(multiplex), multiplex: multiplex)
+            trace(proc { super }, "analyze_multiplex", multiplex_resource(multiplex), multiplex: multiplex)
           end
 
           def analyze_query(*args, query:, **kwargs)
-            trace(proc { super }, 'analyze', query.query_string, query: query)
+            trace(proc { super }, "analyze", query.query_string, query: query)
           end
 
           def execute_multiplex(*args, multiplex:, **kwargs)
-            trace(proc { super }, 'execute_multiplex', multiplex_resource(multiplex), multiplex: multiplex) do |span|
-              span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(', ')}]")
+            trace(proc { super }, "execute_multiplex", multiplex_resource(multiplex), multiplex: multiplex) do |span|
+              span.set_tag("graphql.source", "Multiplex[#{multiplex.queries.map(&:query_string).join(", ")}]")
             end
           end
 
           def execute_query(*args, query:, **kwargs)
-            trace(proc { super }, 'execute', query.selected_operation_name, query: query) do |span|
-              span.set_tag('graphql.source', query.query_string)
-              span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
-              span.set_tag('graphql.operation.name', query.selected_operation_name) if query.selected_operation_name
-              query.variables.instance_variable_get(:@storage).each do |key, value|
-                span.set_tag("graphql.variables.#{key}", value)
-              end
-            end
+            trace(
+              proc { super },
+              "execute",
+              operation_resource(query.selected_operation),
+              lambda { |span|
+                # Ensure this span can be aggregated by in the Datadog App, and generates RED metrics.
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
+                span.set_tag("graphql.source", query.query_string)
+                span.set_tag("graphql.operation.type", query.selected_operation&.operation_type)
+                if query.selected_operation_name
+                  span.set_tag(
+                    "graphql.operation.name",
+                    query.selected_operation_name
+                  )
+                end
+                query.variables.instance_variable_get(:@storage).each do |key, value|
+                  span.set_tag("graphql.variables.#{key}", value)
+                end
+              },
+              ->(span) { add_query_error_events(span, query.context.errors) },
+              query: query,
+            )
           end
 
           def execute_query_lazy(*args, query:, multiplex:, **kwargs)
             resource = if query
-                         query.selected_operation_name || fallback_transaction_name(query.context)
-                       else
-                         multiplex_resource(multiplex)
-                       end
-            trace(proc { super }, 'execute_lazy', resource, query: query, multiplex: multiplex)
+              query.selected_operation_name || fallback_transaction_name(query.context)
+            else
+              multiplex_resource(multiplex)
+            end
+            trace(proc { super }, "execute_lazy", resource, query: query, multiplex: multiplex)
           end
 
           def execute_field_span(callable, span_key, **kwargs)
@@ -82,11 +131,11 @@ module Datadog
           end
 
           def execute_field(*args, **kwargs)
-            execute_field_span(proc { super }, 'resolve', **kwargs)
+            execute_field_span(proc { super }, "resolve", **kwargs)
           end
 
           def execute_field_lazy(*args, **kwargs)
-            execute_field_span(proc { super }, 'resolve_lazy', **kwargs)
+            execute_field_span(proc { super }, "resolve_lazy", **kwargs)
           end
 
           def authorized_span(callable, span_key, **kwargs)
@@ -95,11 +144,11 @@ module Datadog
           end
 
           def authorized(*args, **kwargs)
-            authorized_span(proc { super }, 'authorized', **kwargs)
+            authorized_span(proc { super }, "authorized", **kwargs)
           end
 
           def authorized_lazy(*args, **kwargs)
-            authorized_span(proc { super }, 'authorized_lazy', **kwargs)
+            authorized_span(proc { super }, "authorized_lazy", **kwargs)
           end
 
           def resolve_type_span(callable, span_key, **kwargs)
@@ -108,15 +157,13 @@ module Datadog
           end
 
           def resolve_type(*args, **kwargs)
-            resolve_type_span(proc { super }, 'resolve_type', **kwargs)
+            resolve_type_span(proc { super }, "resolve_type", **kwargs)
           end
 
           def resolve_type_lazy(*args, **kwargs)
-            resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
+            resolve_type_span(proc { super }, "resolve_type_lazy", **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -129,33 +176,70 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
-          private
+          # Serialize error's `locations` array as an array of Strings, given
+          # Span Events do not support hashes nested inside arrays.
+          #
+          # Here's an example in which `locations`:
+          #   [
+          #    {"line" => 3, "column" => 10},
+          #    {"line" => 7, "column" => 8},
+          #   ]
+          # is serialized as:
+          #   ["3:10", "7:8"]
+          def self.serialize_error_locations(locations)
+            # locations are only provided by the `graphql` library when the error can
+            # be associated to a particular point in the query.
+            return [] if locations.nil?
+
+            locations.map do |location|
+              "#{location["line"]}:#{location["column"]}"
+            end
+          end
 
-          def trace(callable, trace_key, resource, **kwargs)
-            config = Datadog.configuration.tracing[:graphql]
+          private
 
+          # Traces the given callable with the given trace key, resource, and kwargs.
+          #
+          # @param callable [Proc] the original method call
+          # @param trace_key [String] the sub-operation name (`"graphql.#{trace_key}"`)
+          # @param resource [String] the resource name for the trace
+          # @param before [Proc, nil] a callable to run before the trace, same as the block parameter
+          # @param after [Proc, nil] a callable to run after the trace, which has access to query values after execution
+          # @param kwargs [Hash] the arguments to pass to `prepare_span`
+          # @yield [Span] the block to run before the trace, same as the `before` parameter
+          def trace(callable, trace_key, resource, before = nil, after = nil, **kwargs, &before_block)
             Tracing.trace(
               "graphql.#{trace_key}",
-              type: 'graphql',
+              type: "graphql",
               resource: resource,
-              service: config[:service_name]
+              service: @service_name
             ) do |span|
-              if Contrib::Analytics.enabled?(config[:analytics_enabled])
-                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
+              if Contrib::Analytics.enabled?(@analytics_enabled)
+                Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
               end
 
-              yield(span) if block_given?
+              # A sanity check for us.
+              raise "Please provide either `before` or a block, but not both" if before && before_block
+
+              if (before_callable = before || before_block)
+                before_callable.call(span)
+              end
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span
 
-              callable.call
+              ret = callable.call
+
+              after&.call(span)
+
+              ret
             end
           end
 
           def multiplex_resource(multiplex)
             return nil unless multiplex
 
-            operations = multiplex.queries.map(&:selected_operation_name).compact.join(', ')
+            operations = multiplex.queries.map(&:selected_operation_name).compact.join(", ")
             if operations.empty?
               first_query = multiplex.queries.first
               fallback_transaction_name(first_query && first_query.context)
@@ -163,6 +247,55 @@ module Datadog
               operations
             end
           end
+
+          def operation_resource(operation)
+            if operation&.name
+              "#{operation.operation_type} #{operation.name}"
+            else
+              "anonymous"
+            end
+          end
+
+          # Create a Span Event for each error that occurs at query level.
+          def add_query_error_events(span, errors)
+            errors.each do |error|
+              attributes = if !@error_extensions_config.empty? && (extensions = error.extensions)
+                # Capture extensions, ensuring all values are primitives
+                extensions.each_with_object({}) do |(key, value), hash|
+                  next unless @error_extensions_config.include?(key.to_s)
+
+                  value = case value
+                  when TrueClass, FalseClass, Integer, Float
+                    value
+                  else
+                    value.to_s
+                  end
+
+                  hash[@extensions_key + key.to_s] = value
+                end
+              else
+                {}
+              end
+
+              # {::GraphQL::Error#to_h} returns the error formatted in compliance with the GraphQL spec.
+              # This is an unwritten contract in the `graphql` library.
+              # See for an example: https://github.com/rmosolgo/graphql-ruby/blob/0afa241775e5a113863766cce126214dee093464/lib/graphql/execution_error.rb#L32
+              graphql_error = error.to_h
+              parsed_error = Core::Error.build_from(error)
+
+              span.span_events << SpanEvent.new(
+                @event_name,
+                attributes: attributes.merge!(
+                  @type_key => parsed_error.type,
+                  @stacktrace_key => parsed_error.backtrace,
+                  @message_key => graphql_error["message"],
+                  @locations_key =>
+                    Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.serialize_error_locations(graphql_error["locations"]),
+                  @path_key => graphql_error["path"],
+                )
+              )
+            end
+          end
         end
       end
     end

data/lib/datadog/tracing/contrib/graphql/unified_trace_patcher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('2.0.19')
-  require_relative 'unified_trace'
+if Gem.loaded_specs["graphql"] && Gem.loaded_specs["graphql"].version >= Gem::Version.new("2.0.19")
+  require_relative "unified_trace"
 end
 
 module Datadog

data/lib/datadog/tracing/contrib/grpc/configuration/settings.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
 
 module Datadog
   module Tracing
@@ -30,8 +30,11 @@ module Datadog
               o.default 1.0
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :service_name do |o|
               o.type :string, nilable: true
               o.default do