datadog 2.21.0 → 2.38.0

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

@@ -28,6 +28,7 @@ module Datadog
           @propagation = Karafka::Distributed::Propagation.new(
             propagation_style_inject: tracing.propagation_style_inject,
             propagation_style_extract: tracing.propagation_style_extract,
+            propagation_behavior_extract: tracing.propagation_behavior_extract,
             propagation_extract_first: tracing.propagation_extract_first
           )
         end

data/lib/datadog/tracing/contrib/mongodb/parsers.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../utils/quantization/hash'
+require_relative '../utils/quantization/hash_formatter'
 
 module Datadog
   module Tracing
@@ -20,11 +20,11 @@ module Datadog
         # returns a formatted and normalized query
         def query_builder(command_name, database_name, command)
           # always exclude the command name
-          options = Contrib::Utils::Quantization::Hash.merge_options(quantization_options, exclude: [command_name.to_s])
+          options = Contrib::Utils::Quantization::HashFormatter.merge_options(quantization_options, exclude: [command_name.to_s])
 
           # quantized statements keys are strings to avoid leaking Symbols in older Rubies
           # as Symbols are not GC'ed in Rubies prior to 2.2
-          base_info = Contrib::Utils::Quantization::Hash.format(
+          base_info = Contrib::Utils::Quantization::HashFormatter.format(
             {
               'operation' => command_name,
               'database' => database_name,
@@ -33,11 +33,11 @@ module Datadog
             options
           )
 
-          base_info.merge(Contrib::Utils::Quantization::Hash.format(command, options))
+          base_info.merge(Contrib::Utils::Quantization::HashFormatter.format(command, options))
         end
 
         def quantization_options
-          Contrib::Utils::Quantization::Hash.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
+          Contrib::Utils::Quantization::HashFormatter.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
         end
 
         def configuration

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -30,6 +30,8 @@ module Datadog
             span = Tracing.trace(Ext::SPAN_COMMAND, service: service, type: Ext::SPAN_TYPE_COMMAND)
             set_span(event, span)
 
+            span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
+
             # build a quantized Query using the Parser module
             query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
             serialized_query = serialize_query(query)
@@ -41,11 +43,6 @@ module Datadog
               )
             end
 
-            # Tag original global service name if not used
-            if span.service != Datadog.configuration.service
-              span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-            end
-
             span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
 
             span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
@@ -73,7 +70,7 @@ module Datadog
             # set the resource with the quantized query
             span.resource = serialized_query
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e.class}: #{e.message}")
           end
           # rubocop:enable Metrics/AbcSize
 
@@ -85,7 +82,7 @@ module Datadog
             # the framework itself, so we set only the error and the message
             span.set_error(event)
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak
@@ -101,7 +98,7 @@ module Datadog
             rows = event.reply.fetch('n', nil)
             span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak

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

@@ -53,6 +53,12 @@ module Datadog
               o.default false
             end
 
+            option :inject_sql_basehash do |o|
+              o.type :bool
+              o.env Contrib::Propagation::SqlComment::Ext::ENV_DBM_INJECT_SQL_BASEHASH
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE

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

@@ -24,6 +24,7 @@ module Datadog
               on_error = Datadog.configuration_for(self, :on_error) || datadog_configuration[:on_error]
 
               Tracing.trace(Ext::SPAN_QUERY, service: service, on_error: on_error) do |span, trace_op|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.resource = sql
                 span.type = Tracing::Metadata::Ext::SQL::TYPE
 
@@ -34,11 +35,6 @@ module Datadog
                   )
                 end
 
-                # Tag original global service name if not used
-                if span.service != Datadog.configuration.service
-                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-                end
-
                 span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
                 span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
@@ -65,7 +61,8 @@ module Datadog
             def inject_propagation(span, sql, trace_op)
               propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
                 datadog_configuration[:comment_propagation],
-                datadog_configuration[:append_comment]
+                datadog_configuration[:append_comment],
+                datadog_configuration[:inject_sql_basehash]
               )
 
               Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)

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

@@ -34,6 +34,7 @@ module Datadog
               response = nil
               # rubocop:disable Metrics/BlockLength
               Tracing.trace('opensearch.query', service: datadog_configuration[:service_name]) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 # Set generic tags
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
@@ -62,11 +63,6 @@ module Datadog
                   )
                 end
 
-                # Tag original global service name if not used
-                if span.service != Datadog.configuration.service
-                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-                end
-
                 # Set url tags
                 span.set_tag(OpenSearch::Ext::TAG_URL, url)
                 span.set_tag(OpenSearch::Ext::TAG_HOST, host)
@@ -84,7 +80,7 @@ module Datadog
                 span.resource = "#{method} #{quantized_url}"
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
               rescue => e
-                Datadog.logger.error(e.message)
+                Datadog.logger.error("#{e.class}: #{e.message}")
                 Datadog::Core::Telemetry::Logger.report(e)
                 # TODO: Refactor the code to streamline the execution without ensure
               ensure

data/lib/datadog/tracing/contrib/opensearch/quantize.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../utils/quantization/hash'
+require_relative '../utils/quantization/hash_formatter'
 
 module Datadog
   module Tracing
@@ -41,7 +41,7 @@ module Datadog
             # Parse each statement and quantize them.
             statements.collect do |string|
               reserialize_json(string, options[:placeholder]) do |obj|
-                Contrib::Utils::Quantization::Hash.format(obj, options)
+                Contrib::Utils::Quantization::HashFormatter.format(obj, options)
               end
             end.join("\n")
           end

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

@@ -57,6 +57,12 @@ module Datadog
               o.default false
             end
 
+            option :inject_sql_basehash do |o|
+              o.type :bool
+              o.env Contrib::Propagation::SqlComment::Ext::ENV_DBM_INJECT_SQL_BASEHASH
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE

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

@@ -28,19 +28,19 @@ module Datadog
               end
             end
 
-            def exec_params(sql, params, *args, &block)
+            def exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def exec_prepared(statement_name, params, *args, &block)
+            def exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 
@@ -54,20 +54,20 @@ module Datadog
             end
 
             # async_exec_params is an alias to exec_params
-            def async_exec_params(sql, params, *args, &block)
+            def async_exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
             # async_exec_prepared is an alias to exec_prepared
-            def async_exec_prepared(statement_name, params, *args, &block)
+            def async_exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 
@@ -79,19 +79,19 @@ module Datadog
               end
             end
 
-            def sync_exec_params(sql, params, *args, &block)
+            def sync_exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_prepared(statement_name, params, *args, &block)
+            def sync_exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 
@@ -109,6 +109,7 @@ module Datadog
                 resource: resource,
                 type: Tracing::Metadata::Ext::SQL::TYPE
               ) do |span, trace_op|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 annotate_span_with_query!(span, service)
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
@@ -116,7 +117,8 @@ module Datadog
                 if sql
                   propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
                     comment_propagation,
-                    datadog_configuration[:append_comment]
+                    datadog_configuration[:append_comment],
+                    datadog_configuration[:inject_sql_basehash]
                   )
                   Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
                   propagated_sql_statement = Contrib::Propagation::SqlComment.prepend_comment(
@@ -159,11 +161,6 @@ module Datadog
                 )
               end
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)

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

@@ -23,12 +23,13 @@ module Datadog
                   service: datadog_configuration[:service_name]
                 ) do |span|
                   begin
+                    span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                     decorate!(span, Ext::TAG_OPERATION_QUERY)
                     span.resource = query
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, false)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query)
@@ -41,12 +42,13 @@ module Datadog
                   service: datadog_configuration[:service_name]
                 ) do |span|
                   begin
+                    span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                     decorate!(span, Ext::TAG_OPERATION_QUERY)
                     span.resource = query
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query, &blk)
@@ -59,13 +61,14 @@ module Datadog
                   service: datadog_configuration[:service_name]
                 ) do |span|
                   begin
+                    span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                     decorate!(span, Ext::TAG_OPERATION_KILL)
                     span.resource = Ext::SPAN_KILL
                     span.type = Tracing::Metadata::Ext::AppTypes::TYPE_DB
                     # ^ not an SQL type span, since there's no SQL query
                     span.set_tag(Ext::TAG_QUERY_ID, query_id)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query_id)
@@ -92,11 +95,6 @@ module Datadog
                   )
                 end
 
-                # Tag original global service name if not used
-                if span.service != Datadog.configuration.service
-                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-                end
-
                 if (host_port = @options[:server])
                   host, port = Core::Utils.extract_host_port(host_port)
                   if host && port

data/lib/datadog/tracing/contrib/propagation/sql_comment/ext.rb

@@ -8,18 +8,28 @@ module Datadog
           module Ext
             ENV_DBM_PROPAGATION_MODE = 'DD_DBM_PROPAGATION_MODE'
 
+            # Determines whether to inject the propagation hash into the SQL comment
+            # TODO: BASEHASH is confusing as a name, so look into better names that can apply cross tracer in the future
+            ENV_DBM_INJECT_SQL_BASEHASH = 'DD_DBM_INJECT_SQL_BASEHASH'
+
             # The default mode for sql comment propagation
             DISABLED = 'disabled'
 
             # The `service` mode propagates service configuration
             SERVICE = 'service'
 
+            # The `dynamic_service` mode propagates service configuration + DBM service hash
+            DYNAMIC_SERVICE = 'dynamic_service'
+
             # The `full` mode propagates service configuration + trace context
             FULL = 'full'
 
             # The value should be `true` when `full` mode
             TAG_DBM_TRACE_INJECTED = '_dd.dbm_trace_injected'
 
+            # Checksum of the agent's container tags and this process' tags
+            TAG_PROPAGATED_HASH = '_dd.propagated_hash'
+
             # Database service/sql span service (i.e. the service executing the actual query)
             #
             # If fake services are disabled:
@@ -52,6 +62,9 @@ module Datadog
             # @see Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
             KEY_PEER_SERVICE = 'ddprs'
 
+            # DBM service hash (ddsh) for propagation
+            KEY_BASE_HASH = 'ddsh'
+
             KEY_TRACEPARENT = 'traceparent'
           end
         end

data/lib/datadog/tracing/contrib/propagation/sql_comment/mode.rb

@@ -8,13 +8,13 @@ module Datadog
       module Propagation
         # Implements sql comment propagation related contracts.
         module SqlComment
-          Mode = Struct.new(:mode, :append) do
+          Mode = Struct.new(:mode, :append, :inject_sql_basehash) do
             def enabled?
               service? || full?
             end
 
             def service?
-              mode == Ext::SERVICE
+              mode == Ext::SERVICE || mode == Ext::DYNAMIC_SERVICE
             end
 
             def full?
@@ -24,6 +24,10 @@ module Datadog
             def append?
               append
             end
+
+            def inject_sql_basehash?
+              inject_sql_basehash || mode == Ext::DYNAMIC_SERVICE
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/propagation/sql_comment.rb

@@ -14,6 +14,16 @@ module Datadog
           def self.annotate!(span_op, mode)
             return unless mode.enabled?
 
+            config = Datadog.configuration
+
+            # Add DBM propagation hash when enabled and available.
+            # This matches the behavior in the Python tracer:
+            # https://github.com/DataDog/dd-trace-py/blob/5e94be5c97b42060e5800e35d8fa41472fb8c569/ddtrace/propagation/_database_monitoring.py#L89
+            if inject_hash?(mode, config)
+              checksum = Datadog.send(:components).agent_info.propagation_checksum
+              span_op.set_tag(Ext::TAG_PROPAGATED_HASH, checksum.to_s) if checksum
+            end
+
             span_op.set_tag(Ext::TAG_DBM_TRACE_INJECTED, true) if mode.full?
           end
 
@@ -36,6 +46,14 @@ module Datadog
               Ext::KEY_PEER_SERVICE => peer_service,
             }
 
+            # Add DBM propagation hash to SQL comment when enabled and available.
+            # This matches the behavior in the Python tracer:
+            # https://github.com/DataDog/dd-trace-py/blob/5e94be5c97b42060e5800e35d8fa41472fb8c569/ddtrace/propagation/_database_monitoring.py#L139
+            if inject_hash?(mode, config)
+              checksum = Datadog.send(:components).agent_info.propagation_checksum
+              tags[Ext::KEY_BASE_HASH] = checksum.to_s if checksum
+            end
+
             db_service = peer_service || span_op.service
             if parent_service != db_service # Only set if it's different from parent_service; otherwise it's redundant
               tags[Ext::KEY_DATABASE_SERVICE] = db_service
@@ -60,6 +78,12 @@ module Datadog
               "#{Comment.new(tags)} #{sql}"
             end
           end
+
+          # @return [Boolean] whether to inject the propagation checksum (basehash)
+          def self.inject_hash?(mode, config)
+            mode.inject_sql_basehash? && config.experimental_propagate_process_tags_enabled
+          end
+          private_class_method :inject_hash?
         end
       end
     end

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

@@ -11,8 +11,11 @@ module Datadog
           # Default settings for the Que integration
           class Settings < Contrib::Configuration::Settings
             option :service_name
-            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 :enabled do |o|
               o.type :bool
               o.env Ext::ENV_ENABLED

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

@@ -11,6 +11,7 @@ module Datadog
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_QUE_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_QUE_ANALYTICS_SAMPLE_RATE'
           ENV_ENABLED = 'DD_TRACE_QUE_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_QUE_DISTRIBUTED_TRACING'
           ENV_TAG_ARGS_ENABLED = 'DD_TRACE_QUE_TAG_ARGS_ENABLED'
           ENV_TAG_DATA_ENABLED = 'DD_TRACE_QUE_TAG_DATA_ENABLED'
           SERVICE_NAME = 'que'

data/lib/datadog/tracing/contrib/que/tracer.rb

@@ -16,6 +16,7 @@ module Datadog
             }
 
             Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               request_span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
 
               request_span.resource = job.class.name.to_s

data/lib/datadog/tracing/contrib/racecar/event.rb

@@ -35,6 +35,7 @@ module Datadog
 
             def on_start(span, event, _id, payload)
               span.service = configuration[:service_name]
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.resource = payload[:consumer_class]
 
               span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
@@ -48,11 +49,6 @@ module Datadog
               # Measure service stats
               Contrib::Analytics.set_measured(span)
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Ext::TAG_TOPIC, payload[:topic])
               span.set_tag(Ext::TAG_CONSUMER, payload[:consumer_class])
               span.set_tag(Ext::TAG_PARTITION, payload[:partition])

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

@@ -37,7 +37,11 @@ module Datadog
             end
 
             option :application
-            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 :headers, default: DEFAULT_HEADERS, type: :hash
             option :middleware_names, default: false, type: :bool
             option :quantize, default: {}, type: :hash
@@ -50,6 +54,12 @@ module Datadog
               o.type :string, nilable: true
             end
 
+            option :inferred_proxy_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_INFERRED_PROXY_ENABLED
+              o.default false
+            end
+
             option :web_service_name, default: Ext::DEFAULT_PEER_WEBSERVER_SERVICE_NAME, type: :string
           end
         end

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

@@ -8,6 +8,8 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_RACK_DISTRIBUTED_TRACING'
+          ENV_INFERRED_PROXY_ENABLED = 'DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'
@@ -23,6 +25,32 @@ module Datadog
           TAG_OPERATION_HTTP_SERVER_QUEUE = 'queue'
           WEBSERVER_APP = 'webserver'
           DEFAULT_PEER_WEBSERVER_SERVICE_NAME = 'web-server'
+
+          # @!visibility private
+          HEADER_X_DD_PROXY = 'HTTP_X_DD_PROXY'
+          HEADER_X_DD_PROXY_REQUEST_TIME_MS = 'HTTP_X_DD_PROXY_REQUEST_TIME_MS'
+          HEADER_X_DD_PROXY_PATH = 'HTTP_X_DD_PROXY_PATH'
+          HEADER_X_DD_PROXY_RESOURCE_PATH = 'HTTP_X_DD_PROXY_RESOURCE_PATH'
+          HEADER_X_DD_PROXY_HTTPMETHOD = 'HTTP_X_DD_PROXY_HTTPMETHOD'
+          HEADER_X_DD_PROXY_DOMAIN_NAME = 'HTTP_X_DD_PROXY_DOMAIN_NAME'
+          HEADER_X_DD_PROXY_STAGE = 'HTTP_X_DD_PROXY_STAGE'
+          HEADER_X_DD_PROXY_ACCOUNT_ID = 'HTTP_X_DD_PROXY_ACCOUNT_ID'
+          HEADER_X_DD_PROXY_API_ID = 'HTTP_X_DD_PROXY_API_ID'
+          HEADER_X_DD_PROXY_REGION = 'HTTP_X_DD_PROXY_REGION'
+          HEADER_X_DD_PROXY_USER = 'HTTP_X_DD_PROXY_USER'
+
+          PROXY_AWS_APIGATEWAY = 'aws-apigateway'
+          PROXY_AWS_HTTPAPI = 'aws-httpapi'
+
+          SPAN_AWS_APIGATEWAY = 'aws.apigateway'
+          SPAN_AWS_HTTPAPI = 'aws.httpapi'
+
+          PROXY_SPAN_NAMES = {
+            PROXY_AWS_APIGATEWAY => SPAN_AWS_APIGATEWAY,
+            PROXY_AWS_HTTPAPI => SPAN_AWS_HTTPAPI,
+          }.freeze
+
+          TAG_INFERRED_SPAN = '_dd.inferred_span'
         end
       end
     end

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

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
+require_relative 'header_collection'
+
 module Datadog
   module Tracing
     module Contrib
       module Rack
         # Matches Rack-style headers with a matcher and sets matching headers into a span.
         module HeaderTagging
+          DATADOG_REQUEST_ATTRIBUTION_HEADERS = [
+            'x-datadog-endpoint-scan',
+            'x-datadog-security-test'
+          ].freeze
+
           def self.tag_request_headers(span, env, configuration)
             # Wrap env in a case-insensitive Rack-style accessor.
             headers = env.is_a?(Header::RequestHeaderCollection) ? env : Header::RequestHeaderCollection.new(env)
@@ -25,6 +32,7 @@ module Datadog
             end
 
             span.set_tags(tags)
+            tag_datadog_request_attribution_headers(span, headers)
           end
 
           def self.tag_response_headers(span, headers, configuration)
@@ -56,6 +64,21 @@ module Datadog
 
             span.set_tags(tags)
           end
+
+          # Datadog-originated requests use these headers for request attribution.
+          # They are tagged independently of user-configured header tagging so
+          # downstream systems can distinguish them from regular application traffic.
+          #
+          # @api private
+          private_class_method def self.tag_datadog_request_attribution_headers(span, headers)
+            DATADOG_REQUEST_ATTRIBUTION_HEADERS.each do |header|
+              header_value = headers.get(header)
+              next unless header_value
+
+              header_tag = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
+              span.set_tag(header_tag, header_value)
+            end
+          end
         end
       end
     end