datadog 2.20.0 → 2.26.0

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

@@ -2,6 +2,8 @@
 
 require_relative '../../tracing/configuration/ext'
 require_relative '../../core/environment/variable_helpers'
+require_relative '../contrib/status_range_matcher'
+require_relative '../contrib/status_range_env_parser'
 require_relative 'http'
 
 module Datadog
@@ -93,9 +95,10 @@ module Datadog
               # @return [Array<String>]
               option :propagation_style do |o|
                 o.type :array
-                o.env [Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE, Configuration::Ext::Distributed::ENV_OTEL_PROPAGATION_STYLE]
+                # Note: Alias (DD_TRACE_PROPAGATION_STYLE) defined in supported-configurations.json
+                o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
                 o.default []
-                o.after_set do |styles|
+                o.after_set do |styles, _, precedence|
                   next if styles.empty?
 
                   # Make values case-insensitive
@@ -109,8 +112,8 @@ module Datadog
                       false
                     end
                   end
-                  set_option(:propagation_style_extract, styles)
-                  set_option(:propagation_style_inject, styles)
+                  set_option(:propagation_style_extract, styles, precedence: precedence)
+                  set_option(:propagation_style_inject, styles, precedence: precedence)
                 end
               end
 
@@ -133,13 +136,16 @@ module Datadog
               # @default `DD_TRACE_ENABLED` environment variable, otherwise `true`
               # @return [Boolean]
               option :enabled do |o|
-                o.env [Tracing::Configuration::Ext::ENV_ENABLED, Tracing::Configuration::Ext::ENV_OTEL_TRACES_EXPORTER]
+                # Note: Alias (OTEL_TRACES_EXPORTER) defined in supported-configurations.json
+                o.env Tracing::Configuration::Ext::ENV_ENABLED
                 o.default true
                 o.type :bool
                 o.env_parser do |value|
                   value = value&.downcase
                   # Tracing is disabled when OTEL_TRACES_EXPORTER is none or
                   # DD_TRACE_ENABLED is 0 or false.
+                  # DEV: The current implementation accepts all of the mentioned values
+                  # for both environment variables, which is incorrect.
                   if ['none', 'false', '0'].include?(value)
                     false
                   # Tracing is enabled when DD_TRACE_ENABLED is true or 1
@@ -268,6 +274,38 @@ module Datadog
                 o.type :bool
               end
 
+              settings :resource_renaming do
+                # Whether resource renaming is enabled. When enabled, http.endpoint tag
+                # containing a route will be reported in traces. If AppSec is enabled,
+                # this feature will be enabled by default.
+                #
+                # For web applications built with instrumented frameworks, http.endpoint tag
+                # will contain the route as it is defined in the application.
+                # For basic Rack applications, or applications that are mounted and are not instrumented,
+                # the route will be inferred from the request path.
+                #
+                # @default `DD_TRACE_RESOURCE_RENAMING_ENABLED` environment variable, otherwise `false`.
+                # @return [Boolean]
+                option :enabled do |o|
+                  o.type :bool, nilable: false
+                  o.env Configuration::Ext::ENV_RESOURCE_RENAMING_ENABLED
+                  o.default false
+                end
+
+                # When set to true, http.endoint is always inferred from path,
+                # instead of using http.route value when it is set.
+                #
+                # This is useful for testing purposes.
+                #
+                # @default false
+                # @return [Boolean]
+                option :always_simplified_endpoint do |o|
+                  o.type :bool, nilable: false
+                  o.env Configuration::Ext::ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT
+                  o.default false
+                end
+              end
+
               # Forces the tracer to always send span events with the native span events format
               # regardless of the agent support. This is useful in agent-less setups.
               #
@@ -302,7 +340,8 @@ module Datadog
                 # @return [Float, nil]
                 option :default_rate do |o|
                   o.type :float, nilable: true
-                  o.env [Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE, Tracing::Configuration::Ext::Sampling::ENV_OTEL_TRACES_SAMPLER]
+                  # Note: Alias (OTEL_TRACES_SAMPLER) defined in supported-configurations.json
+                  o.env Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE
                   o.env_parser do |value|
                     # Parse the value as a float
                     next if value.nil?
@@ -321,7 +360,7 @@ module Datadog
                     when 'parentbased_always_off'
                       0.0
                     when 'parentbased_traceidratio'
-                      ENV.fetch(Tracing::Configuration::Ext::Sampling::OTEL_TRACES_SAMPLER_ARG, 1.0).to_f
+                      DATADOG_ENV.fetch(Configuration::Ext::Sampling::OTEL_TRACES_SAMPLER_ARG, 1.0).to_f
                     else
                       value.to_f
                     end
@@ -355,7 +394,7 @@ module Datadog
                 # @public_api
                 option :rules do |o|
                   o.type :string, nilable: true
-                  o.default { ENV.fetch(Configuration::Ext::Sampling::ENV_RULES, nil) }
+                  o.default { DATADOG_ENV.fetch(Configuration::Ext::Sampling::ENV_RULES, nil) }
                 end
 
                 # Single span sampling rules.
@@ -372,8 +411,8 @@ module Datadog
                 option :span_rules do |o|
                   o.type :string, nilable: true
                   o.default do
-                    rules = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES]
-                    rules_file = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES_FILE]
+                    rules = DATADOG_ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES]
+                    rules_file = DATADOG_ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES_FILE]
 
                     if rules
                       if rules_file
@@ -485,6 +524,46 @@ module Datadog
                 o.env Tracing::Configuration::Ext::Distributed::ENV_X_DATADOG_TAGS_MAX_LENGTH
                 o.default 512
               end
+
+              # HTTP error statuses configuration
+              # @public_api
+              settings :http_error_statuses do
+                # Defines the range of status codes to be considered errors on http.server span kinds.
+                # Once set, only the values within the specified range are considered errors.
+                #
+                # Format of env var: comma-separated list of values like 500,501,502 or ranges like 500-599 (e.g. `500,502,504-510`)
+                #
+                # @default `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` environment variable, otherwise `500..599`.
+                # @return [Tracing::Contrib::StatusRangeMatcher]
+                option :server do |o|
+                  o.env Tracing::Configuration::Ext::HTTPErrorStatuses::ENV_SERVER_ERROR_STATUSES
+                  o.default 500..599
+                  o.setter do |v|
+                    Tracing::Contrib::StatusRangeMatcher.new(v) if v
+                  end
+                  o.env_parser do |values|
+                    Tracing::Contrib::StatusRangeEnvParser.call(values)
+                  end
+                end
+
+                # Defines the range of status codes to be considered errors on http.client span kinds.
+                # Once set, only the values within the specified range are considered errors.
+                #
+                # Format of env var: comma-separated list of values like 400,401,402 or ranges like 400-499 (e.g. `400,402,404-410`)
+                #
+                # @default `DD_TRACE_HTTP_CLIENT_ERROR_STATUSES` environment variable, otherwise `400..499`.
+                # @return [Tracing::Contrib::StatusRangeMatcher]
+                option :client do |o|
+                  o.env Tracing::Configuration::Ext::HTTPErrorStatuses::ENV_CLIENT_ERROR_STATUSES
+                  o.default 400..499
+                  o.setter do |v|
+                    Tracing::Contrib::StatusRangeMatcher.new(v) if v
+                  end
+                  o.env_parser do |values|
+                    Tracing::Contrib::StatusRangeEnvParser.call(values)
+                  end
+                end
+              end
             end
           end
         end

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -77,10 +77,10 @@ module Datadog
 
                 exception = payload[:exception_object]
                 if exception.nil?
-                  # [christian] in some cases :status is not defined,
-                  # rather than firing an error, simply acknowledge we don't know it.
-                  status = payload.fetch(:status, '?').to_s
-                  span.status = 1 if status.start_with?('5')
+                  status = payload[:status]
+                  if status && Datadog.configuration.tracing.http_error_statuses.server.include?(status)
+                    span.status = Tracing::Metadata::Ext::Errors::STATUS
+                  end
                 elsif Utils.exception_is_error?(exception)
                   span.set_error(exception)
                 end

data/lib/datadog/tracing/contrib/action_pack/utils.rb

@@ -13,8 +13,7 @@ module Datadog
               # Gets the equivalent status code for the exception (not all are 5XX)
               # You can add custom errors via `config.action_dispatch.rescue_responses`
               status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
-              # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-              status.to_s.start_with?('5')
+              Datadog.configuration.tracing.http_error_statuses.server.include?(status)
             else
               true
             end

data/lib/datadog/tracing/contrib/active_job/log_injection.rb

@@ -6,17 +6,31 @@ module Datadog
       module ActiveJob
         # Active Job log injection wrapped around job execution
         module LogInjection
-          def self.included(base)
-            base.class_eval do
-              around_perform do |_, block|
-                if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
-                  logger.tagged(Tracing.log_correlation, &block)
-                else
-                  block.call
+          # Active Job 4 / 5 don't execute `perform_now` at the right point, so we do best effort log correlation tagging
+          module AroundPerformPatch
+            def self.included(base)
+              base.class_eval do
+                around_perform do |_, block|
+                  if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                    logger.tagged(Tracing.log_correlation, &block)
+                  else
+                    block.call
+                  end
                 end
               end
             end
           end
+
+          # Active Job 6+ executes `perform_now` at the right point, so we can provide better log correlation tagging
+          module PerformNowPatch
+            def perform_now
+              if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                logger.tagged(Tracing.log_correlation) { super }
+              else
+                super
+              end
+            end
+          end
         end
       end
     end

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

@@ -26,7 +26,11 @@ module Datadog
 
           def inject_log_correlation
             ::ActiveSupport.on_load(:active_job) do
-              include LogInjection
+              if ::ActiveJob.gem_version < Gem::Version.new('6.0.0')
+                include LogInjection::AroundPerformPatch
+              else
+                include LogInjection::PerformNowPatch
+              end
             end
           end
         end

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

@@ -36,8 +36,10 @@ module Datadog
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
 
-            # Set error on the span if the Response Status Code is in error range
-            if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(context.safely(:status_code))
+            # DEV-3.0: This was previously checking against a 500..599 range.
+            # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+            # but `aws` is a client library, this check should use `http_error_statuses.client` instead.
+            if Datadog.configuration.tracing.http_error_statuses.server.include?(context.safely(:status_code))
               # At this point we do not have any additional diagnostics
               # besides the HTTP status code which is recorded in the span tags
               # later in this method.

data/lib/datadog/tracing/contrib/component.rb

@@ -9,13 +9,13 @@ module Datadog
           # Register a callback to be invoked when components are reconfigured.
           # @param name [String] the name of the integration
           # @param callback [Proc] the callback to invoke
-          # @yieldparam config [Datadog::Configuration] the configuration to pass to callbacks
+          # @yieldparam config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def register(name, &callback)
             @registry[name] = callback
           end
 
           # Invoke all registered callbacks with the given configuration.
-          # @param config [Datadog::Configuration] the configuration to pass to callbacks
+          # @param config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def configure(config)
             @registry.each do |name, callback|
               callback.call(config)

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -57,7 +57,10 @@ module Datadog
                   set_span_error_message("Request has failed: #{message}")
                 else
                   @datadog_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response_code)
-                  if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(response_code)
+                  # DEV-3.0: This was previously checking against a 500..599 range.
+                  # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+                  # but `ethon` is a client library, this check should use `http_error_statuses.client` instead.
+                  if Datadog.configuration.tracing.http_error_statuses.server.include?(response_code)
                     set_span_error_message("Request has failed with HTTP error: #{response_code}")
                   end
                 end

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

@@ -41,9 +41,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `excon` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

data/lib/datadog/tracing/contrib/extensions.rb

@@ -220,12 +220,20 @@ module Datadog
             # `@instrumented_integrations` hash.
             # @!visibility private
             def instrumented_integrations
-              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize { (@instrumented_integrations&.dup || {}).freeze }
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                (if defined?(@instrumented_integrations)
+                   @instrumented_integrations&.dup
+                 end || {}).freeze
+              end
             end
 
             # @!visibility private
             def reset!
-              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize { @instrumented_integrations&.clear }
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                if defined?(@instrumented_integrations)
+                  @instrumented_integrations&.clear
+                end
+              end
               super
             end
 

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

@@ -13,10 +13,6 @@ module Datadog
           # Custom settings for the Faraday integration
           # @public_api
           class Settings < Contrib::Configuration::Settings
-            DEFAULT_ERROR_HANDLER = lambda do |env|
-              Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-            end
-
             option :enabled do |o|
               o.type :bool
               o.env Ext::ENV_ENABLED
@@ -44,9 +40,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `faraday` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -39,9 +39,13 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 500...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to server (500..599)
+                  Datadog.configuration.tracing.http_error_statuses.server
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -58,6 +58,13 @@ module Datadog
               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
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
           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'
 

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

@@ -11,11 +11,45 @@ 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)
           end
@@ -50,10 +84,13 @@ module Datadog
             trace(
               proc { super },
               'execute',
-              query.selected_operation_name,
+              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)
+                span.set_tag('graphql.operation.type', query.selected_operation&.operation_type)
                 if query.selected_operation_name
                   span.set_tag(
                     'graphql.operation.name',
@@ -127,8 +164,6 @@ module Datadog
             resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -141,6 +176,26 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
+          # 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
+
           private
 
           # Traces the given callable with the given trace key, resource, and kwargs.
@@ -153,16 +208,14 @@ module Datadog
           # @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)
-            config = Datadog.configuration.tracing[:graphql]
-
             Tracing.trace(
               "graphql.#{trace_key}",
               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])
+              if Contrib::Analytics.enabled?(@analytics_enabled)
+                Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
               end
 
               # A sanity check for us.
@@ -194,27 +247,30 @@ module Datadog
             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.
-          #
-          # These are represented in the Datadog App as special GraphQL errors,
-          # given their event name `dd.graphql.query.error`.
           def add_query_error_events(span, errors)
-            capture_extensions = Datadog.configuration.tracing[:graphql][:error_extensions]
             errors.each do |error|
-              extensions = if !capture_extensions.empty? && (extensions = error.extensions)
+              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 capture_extensions.include?(key.to_s)
+                  next unless @error_extensions_config.include?(key.to_s)
 
                   value = case value
                   when TrueClass, FalseClass, Integer, Float
                     value
                   else
-                    # Stringify anything that is not a boolean or a number
                     value.to_s
                   end
 
-                  hash["extensions.#{key}"] = value
+                  hash[@extensions_key + key.to_s] = value
                 end
               else
                 {}
@@ -224,36 +280,21 @@ module Datadog
               # 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
-              error = Core::Error.build_from(error)
-
-              span.span_events << Datadog::Tracing::SpanEvent.new(
-                Ext::EVENT_QUERY_ERROR,
-                attributes: extensions.merge!(
-                  message: graphql_error['message'],
-                  type: error.type,
-                  stacktrace: error.backtrace,
-                  locations: serialize_error_locations(graphql_error['locations']),
-                  path: graphql_error['path'],
+              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
-
-          # 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 serialize_error_locations(locations)
-            locations.map do |location|
-              "#{location["line"]}:#{location["column"]}"
-            end
-          end
         end
       end
     end

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

@@ -46,9 +46,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `http` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v