datadog 2.21.0 → 2.23.0

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
@@ -56,7 +90,7 @@ module Datadog
                 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',
@@ -130,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
@@ -144,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.
@@ -156,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.
@@ -198,34 +248,29 @@ module Datadog
           end
 
           def operation_resource(operation)
-            if operation.name
+            if operation&.name
               "#{operation.operation_type} #{operation.name}"
             else
-              "anonymous"
+              '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
                 {}
@@ -235,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

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

@@ -45,9 +45,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: `httpclient` 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/httprb/configuration/settings.rb

@@ -45,9 +45,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: `httprb` 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/kafka/instrumentation/consumer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Consumer
+          module Consumer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance methods for consumer instrumentation
+            module InstanceMethods
+              def each_message(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |message|
+                  Datadog.logger.debug { "Kafka each_message: DSM enabled for topic #{message.topic}" }
+
+                  begin
+                    headers = message.headers || {}
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: message.topic,
+                      auto_instrumentation: true
+                    ) { |key| headers[key] }
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+
+                  yield(message) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+
+              def each_batch(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |batch|
+                  Datadog.logger.debug { "Kafka each_batch: DSM enabled for topic #{batch.topic}" }
+
+                  begin
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: batch.topic,
+                      auto_instrumentation: true
+                    )
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+
+                  yield(batch) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/instrumentation/producer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Producer
+          module Producer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            module InstanceMethods
+              def deliver_messages(**kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    pending_messages = instance_variable_get(:@pending_message_queue)
+
+                    if pending_messages && !pending_messages.empty?
+                      pending_messages.each do |message|
+                        message.headers ||= {}
+                        Datadog::DataStreams.set_produce_checkpoint(
+                          type: 'kafka',
+                          destination: message.topic,
+                          auto_instrumentation: true
+                        ) do |key, value|
+                          message.headers[key] = value
+                        end
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+                end
+
+                super
+              end
+
+              def send_messages(messages, **kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    messages.each do |message|
+                      message[:headers] ||= {}
+                      Datadog::DataStreams.set_produce_checkpoint(
+                        type: 'kafka',
+                        destination: message[:topic],
+                        auto_instrumentation: true
+                      ) do |key, value|
+                        message[:headers][key] = value
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,20 @@ module Datadog
           def patch
             # Subscribe to Kafka events
             Events.subscribe!
+
+            # Apply monkey patches for additional instrumentation (e.g., DSM)
+            patch_producer if defined?(::Kafka::Producer)
+            patch_consumer if defined?(::Kafka::Consumer)
+          end
+
+          def patch_producer
+            require_relative 'instrumentation/producer'
+            ::Kafka::Producer.prepend(Instrumentation::Producer)
+          end
+
+          def patch_consumer
+            require_relative 'instrumentation/consumer'
+            ::Kafka::Consumer.prepend(Instrumentation::Consumer)
           end
         end
       end

data/lib/datadog/tracing/contrib/karafka/framework.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Karafka framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          def self.setup
+            Datadog.configure do |datadog_config|
+              karafka_config = datadog_config.tracing[:karafka]
+              activate_waterdrop!(datadog_config, karafka_config)
+            end
+          end
+
+          # Apply relevant configuration from Karafka to WaterDrop
+          def self.activate_waterdrop!(datadog_config, karafka_config)
+            datadog_config.tracing.instrument(
+              :waterdrop,
+              service_name: karafka_config[:service_name],
+              distributed_tracing: karafka_config[:distributed_tracing],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/monitor.rb

@@ -47,6 +47,17 @@ module Datadog
                 span.set_tag(Ext::TAG_CONSUMER, consumer)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, job.executor.topic.name)
                 span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                # DSM: Track consumer offset stats for batch processing
+                if Datadog.configuration.data_streams.enabled
+                  job.messages.each do |message|
+                    Datadog::DataStreams.track_kafka_consume(
+                      job.executor.topic.name,
+                      job.executor.partition,
+                      message.metadata.offset
+                    )
+                  end
+                end
               end
 
               super

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

@@ -35,6 +35,24 @@ module Datadog
                 Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
               end
 
+              if Datadog::DataStreams.enabled?
+                begin
+                  headers = if message.metadata.respond_to?(:raw_headers)
+                    message.metadata.raw_headers
+                  else
+                    message.metadata.headers
+                  end
+
+                  Datadog::DataStreams.set_consume_checkpoint(
+                    type: 'kafka',
+                    source: message.topic,
+                    auto_instrumentation: true
+                  ) { |key| headers[key] }
+                rescue => e
+                  Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                end
+              end
+
               Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
                 span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
@@ -48,6 +66,18 @@ module Datadog
           end
         end
 
+        module AppPatch
+          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          def initialized!
+            ONLY_ONCE_PER_APP[self].run do
+              # Activate tracing on components related to Karafka (e.g. WaterDrop)
+              Contrib::Karafka::Framework.setup
+            end
+            super
+          end
+        end
+
         # Patcher enables patching of 'karafka' module.
         module Patcher
           include Contrib::Patcher
@@ -60,9 +90,11 @@ module Datadog
 
           def patch
             require_relative 'monitor'
+            require_relative 'framework'
 
             ::Karafka::Instrumentation::Monitor.prepend(Monitor)
             ::Karafka::Messages::Messages.prepend(MessagesPatch)
+            ::Karafka::App.singleton_class.prepend(AppPatch)
           end
         end
       end

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -13,6 +13,7 @@ require_relative 'ext'
 require_relative 'header_collection'
 require_relative 'header_tagging'
 require_relative 'request_queue'
+require_relative 'route_inference'
 require_relative 'trace_proxy_middleware'
 
 module Datadog
@@ -138,28 +139,7 @@ module Datadog
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
-            if status != 404 && (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
-              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
-
-              # If the last_script_name is empty but the env['SCRIPT_NAME'] is NOT empty
-              # then the current rack request was not routed and must be accounted for
-              # which only happens in pure nested rack requests i.e /rack/rack/hello/world
-              #
-              # To account for the unaccounted nested rack requests of /rack/hello/world,
-              # we use 'PATH_INFO knowing that rack cannot have named parameters
-              if last_script_name == '' && env['SCRIPT_NAME'] && env['SCRIPT_NAME'] != ''
-                last_script_name = last_route
-                last_route = env['PATH_INFO']
-              end
-
-              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
-              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
-              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
-
-              # Ensure tags are placed in rack.request span as desired
-              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
-              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
-            end
+            set_route_and_endpoint_tags(trace: trace, request_span: request_span, status: status, env: env)
 
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
@@ -218,16 +198,14 @@ module Datadog
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
-            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil? && status != 404
-              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, env['PATH_INFO'])
-            end
-
             HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
             HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
 
             # detect if the status code is a 5xx and flag the request span as an error
             # unless it has been already set by the underlying framework
-            request_span.status = 1 if status.to_s.start_with?('5') && request_span.status.zero?
+            if request_span.status.zero? && Datadog.configuration.tracing.http_error_statuses.server.include?(status)
+              request_span.status = Tracing::Metadata::Ext::Errors::STATUS
+            end
           end
           # rubocop:enable Metrics/AbcSize
           # rubocop:enable Metrics/CyclomaticComplexity
@@ -240,6 +218,60 @@ module Datadog
             Datadog.configuration.tracing[:rack]
           end
 
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          def set_route_and_endpoint_tags(trace:, request_span:, status:, env:)
+            return if status == 404
+
+            if (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # This happens when processing requests to a nested rack application,
+              # when parent app is instrumented, and the nested app is not instrumented
+              #
+              # When resource_renaming.always_simplified_endpoint is set to true,
+              # we infer the route from the full request path.
+              if last_script_name == '' && env['SCRIPT_NAME'] != '' &&
+                  !Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint &&
+                  (inferred_route = RouteInference.infer(env['PATH_INFO']))
+                set_endpoint_tag(request_span, last_route + inferred_route)
+              end
+
+              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+
+              # Ensure tags are placed in rack.request span as desired
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
+              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+            end
+
+            if Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint ||
+                request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil?
+              if (inferred_route = RouteInference.read_or_infer(env))
+                set_endpoint_tag(request_span, inferred_route) if inferred_route
+              end
+            elsif !request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT)
+              set_endpoint_tag(request_span, request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def set_endpoint_tag(request_span, value)
+            # In the first iteration, http.endpoint must be reported in 2 cases:
+            #   1. resource renaming is enabled
+            #   2. AppSec is enabled and resource renaming is disabled (by default, not explicitly)
+            if Datadog.configuration.tracing.resource_renaming.enabled ||
+                Datadog.configuration.appsec.enabled && Datadog.configuration.tracing.resource_renaming.options[:enabled].default_precedence?
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT, value)
+            end
+          end
+
           # rubocop:disable Metrics/AbcSize
           # rubocop:disable Metrics/MethodLength
           def parse_url(env, original_env)