datadog 2.30.0 → 2.45.0

data/lib/datadog/tracing/distributed/b3_multi.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
-require_relative '../trace_digest'
-require_relative '../utils'
+require_relative "helpers"
+require_relative "../trace_digest"
+require_relative "../utils"
 
 module Datadog
   module Tracing
@@ -10,9 +10,9 @@ module Datadog
       # B3 multi header-style trace propagation.
       # @see https://github.com/openzipkin/b3-propagation#multiple-headers
       class B3Multi
-        B3_TRACE_ID_KEY = 'x-b3-traceid'
-        B3_SPAN_ID_KEY = 'x-b3-spanid'
-        B3_SAMPLED_KEY = 'x-b3-sampled'
+        B3_TRACE_ID_KEY = "x-b3-traceid"
+        B3_SPAN_ID_KEY = "x-b3-spanid"
+        B3_SAMPLED_KEY = "x-b3-sampled"
 
         def initialize(
           fetcher:,
@@ -30,8 +30,8 @@ module Datadog
           return if digest.nil?
 
           # DEV: We need these to be hex encoded
-          data[@trace_id_key] = format('%032x', digest.trace_id)
-          data[@span_id_key] = format('%016x', digest.span_id || 0) # # Fall back to zero (invalid) if not present
+          data[@trace_id_key] = format("%032x", digest.trace_id)
+          data[@span_id_key] = format("%016x", digest.span_id || 0) # # Fall back to zero (invalid) if not present
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(

data/lib/datadog/tracing/distributed/b3_single.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
-require_relative '../trace_digest'
+require_relative "helpers"
+require_relative "../trace_digest"
 
 module Datadog
   module Tracing
@@ -15,7 +15,7 @@ module Datadog
       #
       # @see https://github.com/openzipkin/b3-propagation#single-header
       class B3Single
-        B3_SINGLE_HEADER_KEY = 'b3'
+        B3_SINGLE_HEADER_KEY = "b3"
 
         def initialize(fetcher:, key: B3_SINGLE_HEADER_KEY)
           @key = key
@@ -47,7 +47,7 @@ module Datadog
 
           return unless value
 
-          parts = value.split('-')
+          parts = value.split("-")
           trace_id = Helpers.parse_hex_id(parts[0]) unless parts.empty?
           # Return early if this propagation is not valid
           return if trace_id.nil? || trace_id <= 0 || trace_id > Tracing::Utils::TraceId::MAX

data/lib/datadog/tracing/distributed/baggage.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../metadata/ext'
-require_relative '../trace_digest'
-require_relative 'datadog_tags_codec'
-require_relative '../utils'
-require_relative 'helpers'
-require 'uri'
+require_relative "../ext"
+require_relative "../metadata/ext"
+require_relative "../trace_digest"
+require_relative "../utils"
+require_relative "helpers"
+require "uri"
 
 module Datadog
   module Tracing
@@ -14,10 +14,10 @@ module Datadog
       # The baggage header is propagated through `baggage`.
       # @see https://www.w3.org/TR/baggage/
       class Baggage
-        BAGGAGE_KEY = 'baggage'
+        BAGGAGE_KEY = "baggage"
         DD_TRACE_BAGGAGE_MAX_ITEMS = 64
         DD_TRACE_BAGGAGE_MAX_BYTES = 8192
-        BAGGAGE_TAG_KEYS_MATCH_ALL = ['*'].freeze
+        BAGGAGE_TAG_KEYS_MATCH_ALL = ["*"].freeze
         SAFE_CHARACTERS_KEY = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'*+-.^_`|~"
         SAFE_CHARACTERS_VALUE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'()*+-./:<>?@[]^_`{|}~"
 
@@ -42,9 +42,9 @@ module Datadog
               ::Datadog.logger.warn("Baggage item limit (#{DD_TRACE_BAGGAGE_MAX_ITEMS}) exceeded, dropping excess items")
               # Record telemetry for item count truncation
               record_telemetry_metric(
-                'context_header.truncated',
+                "context_header.truncated",
                 1,
-                {'header_style' => 'baggage', 'truncation_reason' => 'baggage_item_count_exceeded'}
+                {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"}
               )
               baggage_items = baggage_items.first(DD_TRACE_BAGGAGE_MAX_ITEMS)
             end
@@ -59,9 +59,9 @@ module Datadog
                 ::Datadog.logger.warn("Baggage header size (#{DD_TRACE_BAGGAGE_MAX_BYTES}) exceeded, dropping excess items")
                 # Record telemetry for byte count truncation
                 record_telemetry_metric(
-                  'context_header.truncated',
+                  "context_header.truncated",
                   1,
-                  {'header_style' => 'baggage', 'truncation_reason' => 'baggage_byte_count_exceeded'}
+                  {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"}
                 )
                 break # stop adding items when size limit is reached
               end
@@ -72,12 +72,12 @@ module Datadog
             # edge case where a single item is too large
             return if encoded_items.empty?
 
-            data[@baggage_key] = encoded_items.join(',')
+            data[@baggage_key] = encoded_items.join(",")
 
             # Record telemetry for successful injection
-            record_telemetry_metric('context_header_style.injected', 1, {'header_style' => 'baggage'})
+            record_telemetry_metric("context_header_style.injected", 1, {"header_style" => "baggage"})
           rescue => e
-            ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.class}: #{e}")
+            ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.class}: #{e.message}")
           end
         end
 
@@ -94,7 +94,7 @@ module Datadog
 
           # Record telemetry for successful extraction only if baggage is not empty
           unless baggage.empty?
-            record_telemetry_metric('context_header_style.extracted', 1, {'header_style' => 'baggage'})
+            record_telemetry_metric("context_header_style.extracted", 1, {"header_style" => "baggage"})
           end
 
           TraceDigest.new(
@@ -109,7 +109,7 @@ module Datadog
           # Strip whitespace and URL-encode the item
           result = URI.encode_www_form_component(item.strip)
           # Replace '+' with '%20' for space encoding consistency with W3C spec
-          result = result.gsub('+', '%20')
+          result = result.gsub("+", "%20")
           # Selectively decode percent-encoded characters that are considered "safe" in W3C Baggage spec
           result.gsub(/%[0-9A-F]{2}/) do |encoded|
             if encoded.size >= 3 && encoded[1..2] =~ /\A[0-9A-F]{2}\z/
@@ -117,7 +117,7 @@ module Datadog
               next encoded unless hex_str && !hex_str.empty?
 
               # Convert hex representation back to character
-              char = [hex_str.hex].pack('C')
+              char = [hex_str.hex].pack("C")
               # Keep the character as-is if it's in the safe character set, otherwise keep it encoded
               safe_characters.include?(char) ? char : encoded
             else
@@ -133,30 +133,84 @@ module Datadog
         # - Keys and values are URL-encoded
         # - Returns an empty hash if the baggage header is malformed
         #
+        # For entries with duplicate keys, only last one is preserved:
+        # https://www.w3.org/TR/2024/CR-baggage-20240530/#mutating-baggage
+        #
         # @param baggage_header [String] The W3C Baggage header string to parse
         # @return [Hash<String, String>] A hash of decoded baggage items
         def parse_baggage_header(baggage_header)
+          # Reject inputs that would cause String operations below to raise.
+          # `valid_encoding?` is true for ASCII-8BIT regardless of byte values, so
+          # the typical Rack path is unaffected; only UTF-8-tagged-but-actually-invalid
+          # input (e.g. headers re-encoded upstream) is short-circuited here.
+          unless baggage_header.valid_encoding?
+            record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
+            return {}
+          end
+
+          if baggage_header.bytesize > DD_TRACE_BAGGAGE_MAX_BYTES
+            record_telemetry_metric("context_header.truncated", 1, {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"})
+
+            # We MUST NOT propagate partial entries, but we SHOULD try
+            # to parse as much of the baggage as possible:
+            # https://www.w3.org/TR/2024/CR-baggage-20240530/#limits
+
+            # We parse 1 byte over the limit to detect if the last entry
+            # is a partial entry (toss) or ends exactly at the limit (keep).
+            remove_last_entry = baggage_header.byteslice(DD_TRACE_BAGGAGE_MAX_BYTES, 1) != ","
+
+            # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
+            # and safely remove it with `#chop`.
+            # `#chops` walks back the string until it finds a valid character boundary and deletes
+            # from there.
+            baggage_header = baggage_header.byteslice(0, DD_TRACE_BAGGAGE_MAX_BYTES + 1) #: String
+            baggage_header = baggage_header.chop
+          end
+
           baggage = {}
-          baggages = baggage_header.split(',')
-          baggages.each do |key_value|
-            key, value = key_value.split('=', 2)
+          # DEV: To avoid unnecessary eager string allocation, replace with
+          # DEV: `split(',') { |s| ... }` when Ruby 2.5 is no longer supported.
+          baggages = baggage_header.split(",", DD_TRACE_BAGGAGE_MAX_ITEMS + 1) # Stop splitting if we've reached max size
+          baggages.each_with_index do |key_value, index|
+            if index >= DD_TRACE_BAGGAGE_MAX_ITEMS
+              record_telemetry_metric("context_header.truncated", 1, {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"})
+              break
+            end
+
+            # On truncation, remove incomplete trailing partial entry
+            next if remove_last_entry && index == baggages.size - 1
+
+            # Empty items are skipped
+            next if key_value.strip.empty?
+
+            key, value = key_value.split("=", 2)
             # If baggage is malformed, return an empty hash
             if key.nil? || value.nil?
               # Record telemetry for malformed header
-              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
+              return {}
+            end
+
+            begin
+              key = URI.decode_www_form_component(key.strip)
+              value = URI.decode_www_form_component(value.strip)
+            rescue ArgumentError
+              # `URI.decode_www_form_component` raises on malformed percent encoding
+              # (e.g. `%XX`, lone `%`). Treat as malformed rather than letting it
+              # propagate to `Propagation#extract`'s caller.
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
               return {}
             end
 
-            key = URI.decode_www_form_component(key.strip)
-            value = URI.decode_www_form_component(value.strip)
             if key.empty? || value.empty?
               # Record telemetry for malformed header
-              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
               return {}
             end
 
             baggage[key] = value
           end
+
           baggage
         end
 
@@ -176,8 +230,7 @@ module Datadog
           tags = {}
 
           baggage_tag_keys.each do |key, _|
-            # Steep: https://github.com/soutaro/steep/issues/2031
-            value = baggage[key] # steep:ignore ArgumentTypeMismatch
+            value = baggage[key]
             next if value.nil? || value.empty?
 
             tags["baggage.#{key}"] = value
@@ -189,7 +242,7 @@ module Datadog
         # Record telemetry metrics for baggage operations
         def record_telemetry_metric(metric_name, value, tags)
           telemetry = ::Datadog.send(:components).telemetry
-          telemetry.inc('instrumentation_telemetry_data.tracers', metric_name, value, tags: tags)
+          telemetry.inc(Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: tags)
         end
       end
     end

data/lib/datadog/tracing/distributed/datadog.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require_relative '../metadata/ext'
-require_relative '../trace_digest'
-require_relative 'datadog_tags_codec'
-require_relative '../utils'
-require_relative 'helpers'
+require_relative "../metadata/ext"
+require_relative "../trace_digest"
+require_relative "trace_state/datadog"
+require_relative "../utils"
+require_relative "helpers"
 
 module Datadog
   module Tracing
     module Distributed
       # Datadog-style trace propagation.
       class Datadog
-        TRACE_ID_KEY = 'x-datadog-trace-id'
-        PARENT_ID_KEY = 'x-datadog-parent-id'
-        SAMPLING_PRIORITY_KEY = 'x-datadog-sampling-priority'
-        ORIGIN_KEY = 'x-datadog-origin'
+        TRACE_ID_KEY = "x-datadog-trace-id"
+        PARENT_ID_KEY = "x-datadog-parent-id"
+        SAMPLING_PRIORITY_KEY = "x-datadog-sampling-priority"
+        ORIGIN_KEY = "x-datadog-origin"
         # Distributed trace-level tags
-        TAGS_KEY = 'x-datadog-tags'
+        TAGS_KEY = "x-datadog-tags"
 
         # Prefix used by all Datadog-specific distributed tags
-        TAGS_PREFIX = 'x-datadog-'
+        TAGS_PREFIX = "x-datadog-"
 
         def initialize(
           fetcher:,
@@ -108,7 +108,7 @@ module Datadog
 
           return tags if high_order == 0
 
-          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => format('%016x', high_order))
+          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => format("%016x", high_order))
         end
 
         # Side effect: Remove high order 64 bit hex-encoded `tid` tag from distributed tags
@@ -127,21 +127,19 @@ module Datadog
         # DEV: This means errors cannot be reported if there's not active span.
         # DEV: Ideally, we'd have a dedicated error reporting stream for all of datadog.
         def inject_tags!(tags, data)
-          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
+          return set_tags_propagation_error(reason: "disabled") if tags_disabled?
 
-          encoded_tags = DatadogTagsCodec.encode(tags)
+          encoded_tags = TraceState::Datadog.encode(tags)
 
-          return set_tags_propagation_error(reason: 'inject_max_size') if tags_too_large?(
-            encoded_tags.size,
-            scenario: 'inject'
-          )
+          return set_tags_propagation_error(reason: "inject_max_size") if tags_too_large?(encoded_tags, scenario: "inject")
 
           data[@tags_key] = encoded_tags
         rescue => e
-          set_tags_propagation_error(reason: 'encoding_error')
+          set_tags_propagation_error(reason: "encoding_error")
           ::Datadog.logger.warn(
-            "Failed to inject x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to inject x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
+          nil
         end
 
         # Import `x-datadog-tags` tags as trace distributed tags.
@@ -154,25 +152,26 @@ module Datadog
           tags = fetcher[@tags_key]
 
           return if !tags || tags.empty?
-          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
-          return set_tags_propagation_error(reason: 'extract_max_size') if tags_too_large?(tags.size, scenario: 'extract')
+          return set_tags_propagation_error(reason: "disabled") if tags_disabled?
+          return set_tags_propagation_error(reason: "extract_max_size") if tags_too_large?(tags, scenario: "extract")
 
-          tags_hash = DatadogTagsCodec.decode(tags)
+          tags_hash = TraceState::Datadog.decode(tags)
           # Only extract keys with the expected Datadog prefix
           tags_hash.select! do |key, _|
             key.start_with?(Tracing::Metadata::Ext::Distributed::TAGS_PREFIX) && key != EXCLUDED_TAG
           end
           tags_hash
         rescue => e
-          set_tags_propagation_error(reason: 'decoding_error')
+          set_tags_propagation_error(reason: "decoding_error")
           ::Datadog.logger.warn(
-            "Failed to extract x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to extract x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
+          nil
         end
 
         def set_tags_propagation_error(reason:)
           active_trace = Tracing.active_trace
-          active_trace&.set_tag('_dd.propagation_error', reason)
+          active_trace&.set_tag("_dd.propagation_error", reason)
           nil
         end
 
@@ -180,20 +179,23 @@ module Datadog
           ::Datadog.configuration.tracing.x_datadog_tags_max_length <= 0
         end
 
-        def tags_too_large?(size, scenario:)
-          return false if size <= ::Datadog.configuration.tracing.x_datadog_tags_max_length
+        def tags_too_large?(tags, scenario:)
+          size = tags.bytesize
+          max_length = ::Datadog.configuration.tracing.x_datadog_tags_max_length
+
+          return false if size <= max_length
 
           ::Datadog.logger.warn(
-            "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (size:#{size} >= " \
-              "limit:#{::Datadog.configuration.tracing.x_datadog_tags_max_length}). This limit can be configured " \
-              'through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable.'
+            "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (bytesize:#{size} >= " \
+              "limit:#{max_length}). This limit can be configured " \
+              "through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable."
           )
 
           true
         end
 
         # We want to exclude tags that we don't want to propagate downstream.
-        EXCLUDED_TAG = '_dd.p.upstream_services'
+        EXCLUDED_TAG = "_dd.p.upstream_services"
         private_constant :EXCLUDED_TAG
       end
     end

data/lib/datadog/tracing/distributed/fetcher.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
+require_relative "helpers"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/distributed/helpers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../sampling/ext'
-require_relative '../utils'
+require_relative "../sampling/ext"
+require_relative "../utils"
 
 module Datadog
   module Tracing
@@ -47,7 +47,7 @@ module Datadog
           #      for us so we want to make sure the comparision will work as expected
           # DEV: regex, remove all leading zeros up until we find the last 0 in the string
           #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
-          value = value.sub(/^0*(?=(0$)|[^0])/, '')
+          value = value.sub(/^0*(?=(0$)|[^0])/, "")
 
           # Convert value to an integer
           # DEV: Ruby `.to_i` will return `0` if a number could not be parsed

data/lib/datadog/tracing/distributed/propagation.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../configuration/ext'
-require_relative '../trace_digest'
-require_relative '../trace_operation'
-require_relative '../../core/telemetry/logger'
-require_relative 'baggage'
+require_relative "../configuration/ext"
+require_relative "../trace_digest"
+require_relative "../trace_operation"
+require_relative "../span_link"
+require_relative "../../core/telemetry/logger"
+require_relative "baggage"
 
 module Datadog
   module Tracing
@@ -13,6 +14,8 @@ module Datadog
       class Propagation
         # @param propagation_styles [Hash<String,Object>]
         #  a map of propagation styles to their corresponding implementations
+        # @param propagation_behavior_extract [String]
+        #   the behavior to apply when extracting distributed trace data
         # @param propagation_style_inject [Array<String>]
         #   a list of styles to use when injecting distributed trace data
         # @param propagation_style_extract [Array<String>]
@@ -23,9 +26,11 @@ module Datadog
           propagation_styles:,
           propagation_style_inject:,
           propagation_style_extract:,
+          propagation_behavior_extract:,
           propagation_extract_first:
         )
           @propagation_styles = propagation_styles
+          @propagation_behavior_extract = propagation_behavior_extract
           @propagation_extract_first = propagation_extract_first
           @propagation_style_inject = propagation_style_inject.map { |style| propagation_styles[style] }
           @propagation_style_extract = propagation_style_extract.map { |style| propagation_styles[style] }
@@ -57,13 +62,13 @@ module Datadog
         # @return [nil] in case of unrecoverable errors, see `Datadog.logger` output for details.
         def inject!(digest, data)
           if digest.nil?
-            ::Datadog.logger.debug('Cannot inject distributed trace data: digest is nil.')
+            ::Datadog.logger.debug("Cannot inject distributed trace data: digest is nil.")
             return nil
           end
 
           digest = digest.to_digest if digest.respond_to?(:to_digest)
           if digest.trace_id.nil? && digest.baggage.nil?
-            ::Datadog.logger.debug('Cannot inject distributed trace data: digest.trace_id and digest.baggage are both nil.')
+            ::Datadog.logger.debug("Cannot inject distributed trace data: digest.trace_id and digest.baggage are both nil.")
             return nil
           end
 
@@ -76,7 +81,7 @@ module Datadog
           rescue => e
             result = nil
             ::Datadog.logger.error(
-              "Error injecting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
+              "Error injecting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
             )
             ::Datadog::Core::Telemetry::Logger.report(
               e,
@@ -97,12 +102,20 @@ module Datadog
           return unless data
           return if data.empty?
 
+          if @propagation_behavior_extract == Tracing::Configuration::Ext::Distributed::PROPAGATION_BEHAVIOR_EXTRACT_IGNORE
+            return nil
+          end
+
           extracted_trace_digest = nil
+          # Name of the propagation style that first produced a trace context.
+          # Used as the `context_headers` span-link attribute when restarting a trace.
+          extracted_style_name = nil
 
           @propagation_style_extract.each do |propagator|
             # First extraction?
             unless extracted_trace_digest
               extracted_trace_digest = propagator.extract(data)
+              extracted_style_name = @propagation_styles.key(propagator) if extracted_trace_digest
               next
             end
 
@@ -133,19 +146,41 @@ module Datadog
                 span_id: parent_id,
                 trace_state: tracecontext_digest.trace_state,
                 trace_state_unknown_fields: tracecontext_digest.trace_state_unknown_fields,
+                trace_otel_random_value: tracecontext_digest.trace_otel_random_value,
+                trace_otel_threshold: tracecontext_digest.trace_otel_threshold,
+                trace_otel_unknown_fields: tracecontext_digest.trace_otel_unknown_fields,
                 trace_distributed_tags: distributed_tags
               )
             end
           rescue => e
             # TODO: Not to report Telemetry logs for now
             ::Datadog.logger.error(
-              "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
+              "Error extracting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
             )
           end
           # Handle baggage after all other styles if present
           extracted_trace_digest = propagate_baggage(data, extracted_trace_digest) if @baggage_propagator
 
-          extracted_trace_digest
+          # Default mode: Current digest continues the upstream trace.
+          return extracted_trace_digest if @propagation_behavior_extract != Tracing::Configuration::Ext::Distributed::PROPAGATION_BEHAVIOR_EXTRACT_RESTART || extracted_trace_digest&.trace_id.nil?
+
+          # Restart mode: start a new local digest and create a Span Link on
+          # the service-entry span with the original propagation data.
+          link = SpanLink.new(
+            extracted_trace_digest,
+            attributes: {
+              "reason" => "propagation_behavior_extract",
+              "context_headers" => extracted_style_name,
+            }
+          )
+          baggage_tags = extracted_trace_digest.trace_distributed_tags&.select { |k, _| k.start_with?("baggage.") }
+          baggage_tags = nil if baggage_tags&.empty?
+          TraceDigest.new(
+            span_links: [link],
+            baggage: extracted_trace_digest.baggage,
+            trace_distributed_tags: baggage_tags,
+            span_remote: false,
+          )
         end
 
         private
@@ -178,7 +213,7 @@ module Datadog
             tracecontext_tags[Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID]
           elsif dd_propagator && (dd_digest = dd_propagator.extract(headers))
             # if p value is not present in tracestate, use the parent id from the datadog headers
-            format('%016x', dd_digest.span_id)
+            format("%016x", dd_digest.span_id)
           end
         end
       end

data/lib/datadog/tracing/distributed/propagation_policy.rb

@@ -28,6 +28,11 @@ module Datadog
               return true
             end
 
+            if ::Datadog.configuration.respond_to?(:ai_guard) && ::Datadog.configuration.ai_guard.enabled &&
+                (trace_source & ::Datadog::AIGuard::Ext::PRODUCT_BIT) != 0
+              return true
+            end
+
             return false
           end