datadog 2.17.0 → 2.37.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../ext'
 require_relative '../metadata/ext'
 require_relative '../trace_digest'
 require_relative 'datadog_tags_codec'
@@ -17,15 +18,18 @@ module Datadog
         BAGGAGE_KEY = 'baggage'
         DD_TRACE_BAGGAGE_MAX_ITEMS = 64
         DD_TRACE_BAGGAGE_MAX_BYTES = 8192
+        BAGGAGE_TAG_KEYS_MATCH_ALL = ['*'].freeze
         SAFE_CHARACTERS_KEY = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'*+-.^_`|~"
         SAFE_CHARACTERS_VALUE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'()*+-./:<>?@[]^_`{|}~"
 
         def initialize(
           fetcher:,
-          baggage_key: BAGGAGE_KEY
+          baggage_key: BAGGAGE_KEY,
+          baggage_tag_keys: ::Datadog.configuration.tracing.baggage_tag_keys
         )
           @baggage_key = baggage_key
           @fetcher = fetcher
+          @baggage_tag_keys = baggage_tag_keys
         end
 
         def inject!(digest, data)
@@ -36,7 +40,13 @@ module Datadog
 
           begin
             if baggage_items.size > DD_TRACE_BAGGAGE_MAX_ITEMS
-              ::Datadog.logger.warn('Baggage item limit exceeded, dropping excess items')
+              ::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',
+                1,
+                {'header_style' => 'baggage', 'truncation_reason' => 'baggage_item_count_exceeded'}
+              )
               baggage_items = baggage_items.first(DD_TRACE_BAGGAGE_MAX_ITEMS)
             end
 
@@ -47,7 +57,13 @@ module Datadog
               item = "#{encode_item(key, SAFE_CHARACTERS_KEY)}=#{encode_item(value, SAFE_CHARACTERS_VALUE)}"
               item_size = item.bytesize + (encoded_items.empty? ? 0 : 1) # +1 for comma if not first item
               if total_size + item_size > DD_TRACE_BAGGAGE_MAX_BYTES
-                ::Datadog.logger.warn('Baggage header size exceeded, dropping excess items')
+                ::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',
+                  1,
+                  {'header_style' => 'baggage', 'truncation_reason' => 'baggage_byte_count_exceeded'}
+                )
                 break # stop adding items when size limit is reached
               end
               encoded_items << item
@@ -57,10 +73,12 @@ module Datadog
             # edge case where a single item is too large
             return if encoded_items.empty?
 
-            header_value = encoded_items.join(',')
-            data[@baggage_key] = header_value
+            data[@baggage_key] = encoded_items.join(',')
+
+            # Record telemetry for successful injection
+            record_telemetry_metric('context_header_style.injected', 1, {'header_style' => 'baggage'})
           rescue => e
-            ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.message}")
+            ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.class}: #{e.message}")
           end
         end
 
@@ -72,8 +90,17 @@ module Datadog
           baggage = parse_baggage_header(fetcher[@baggage_key])
           return unless baggage
 
+          # Convert selected baggage items to span tags based on configuration
+          baggage_tags = build_baggage_tags(baggage)
+
+          # 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'})
+          end
+
           TraceDigest.new(
             baggage: baggage,
+            trace_distributed_tags: baggage_tags
           )
         end
 
@@ -107,24 +134,118 @@ 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|
+          # 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
-            return {} unless key && value
+            if key.nil? || value.nil?
+              # Record telemetry for malformed header
+              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)
-            return {} if key.empty? || value.empty?
+            if key.empty? || value.empty?
+              # Record telemetry for malformed header
+              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              return {}
+            end
 
             baggage[key] = value
           end
+
           baggage
         end
+
+        # Convert selected baggage items to span tags
+        # Baggage carries important contextual information (like user.id, session.id) across distributed services,
+        # but isn't searchable by default.
+        def build_baggage_tags(baggage)
+          return {} if baggage.empty?
+
+          # Get the configuration for which baggage keys should become span tags
+          baggage_tag_keys = @baggage_tag_keys
+          return {} if baggage_tag_keys.empty?
+
+          # If wildcard is specified, use all baggage keys
+          baggage_tag_keys = baggage if baggage_tag_keys == BAGGAGE_TAG_KEYS_MATCH_ALL
+
+          tags = {}
+
+          baggage_tag_keys.each do |key, _|
+            # Steep: https://github.com/soutaro/steep/issues/2031
+            value = baggage[key] # steep:ignore ArgumentTypeMismatch
+            next if value.nil? || value.empty?
+
+            tags["baggage.#{key}"] = value
+          end
+
+          tags
+        end
+
+        # Record telemetry metrics for baggage operations
+        def record_telemetry_metric(metric_name, value, tags)
+          telemetry = ::Datadog.send(:components).telemetry
+          telemetry.inc(Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: tags)
+        end
       end
     end
   end

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

@@ -55,17 +55,16 @@ module Datadog
         def extract(data)
           fetcher = @fetcher.new(data)
 
-          trace_id  = parse_trace_id(fetcher)
+          trace_id = parse_trace_id(fetcher)
           parent_id = parse_parent_id(fetcher)
 
           sampling_priority = Helpers.parse_decimal_id(fetcher[@sampling_priority_key])
           origin = fetcher[@origin_key]
 
           # Return early if this propagation is not valid
-          # DEV: To be valid we need to have a trace id and a parent id
-          #      or when it is a synthetics trace, just the trace id.
+          # DEV: To be valid we need to have a trace id and a parent id or an origin id.
           # DEV: `Fetcher#id` will not return 0
-          return unless (trace_id && parent_id) || (origin && trace_id)
+          return if trace_id.nil? || parent_id.nil? && origin.nil?
 
           trace_distributed_tags = extract_tags(fetcher)
 
@@ -132,17 +131,15 @@ module Datadog
 
           encoded_tags = DatadogTagsCodec.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')
           ::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.
@@ -156,7 +153,7 @@ module Datadog
 
           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: 'extract_max_size') if tags_too_large?(tags, scenario: 'extract')
 
           tags_hash = DatadogTagsCodec.decode(tags)
           # Only extract keys with the expected Datadog prefix
@@ -167,13 +164,14 @@ module Datadog
         rescue => e
           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) if active_trace
+          active_trace&.set_tag('_dd.propagation_error', reason)
           nil
         end
 
@@ -181,12 +179,15 @@ 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 " \
+            "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.'
           )
 

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

@@ -6,19 +6,6 @@ module Datadog
       # Encodes and decodes distributed 'x-datadog-tags' tags for transport
       # to and from external processes.
       module DatadogTagsCodec
-        # Backport `Regexp::match?` because it is measurably the most performant
-        # way to check if a string matches a regular expression.
-        module RefineRegexp
-          unless Regexp.method_defined?(:match?)
-            refine ::Regexp do
-              def match?(*args)
-                !match(*args).nil?
-              end
-            end
-          end
-        end
-        using RefineRegexp
-
         # ASCII characters 32-126, except `,`, `=`, and ` `. At least one character.
         VALID_KEY_CHARS = /\A(?:(?![,= ])[\u0020-\u007E])+\Z/.freeze
         # ASCII characters 32-126, except `,`. At least one character.
@@ -31,19 +18,17 @@ module Datadog
         # @return [String] serialized tags hash
         # @raise [EncodingError] if tags cannot be serialized to the `x-datadog-tags` format
         def self.encode(tags)
-          begin
-            tags.map do |raw_key, raw_value|
-              key = raw_key.to_s
-              value = raw_value.to_s
+          tags.map do |raw_key, raw_value|
+            key = raw_key.to_s
+            value = raw_value.to_s
 
-              raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
-              raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
+            raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
+            raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
 
-              "#{key}=#{value.strip}"
-            end.join(',')
-          rescue => e
-            raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
-          end
+            "#{key}=#{value.strip}"
+          end.join(',')
+        rescue => e
+          raise EncodingError, "Error encoding tags `#{tags}`: `#{e.class}: #{e.message}`"
         end
 
         # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.
@@ -52,7 +37,7 @@ module Datadog
         # @return [Hash<String,String>] decoded input as a hash of strings
         # @raise [DecodingError] if string does not conform to the `x-datadog-tags` format
         def self.decode(string)
-          result = Hash[string.split(',').map do |raw_tag|
+          result = (string.split(',').map do |raw_tag|
             raw_tag.split('=', 2).tap do |raw_key, raw_value|
               key = raw_key.to_s
               value = raw_value.to_s
@@ -62,7 +47,7 @@ module Datadog
 
               value.strip!
             end
-          end]
+          end).to_h
 
           raise DecodingError, "Invalid empty tags: #{string}" if result.empty? && !string.empty?
 

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

@@ -25,7 +25,7 @@ module Datadog
 
           value = value.to_s
 
-          num   = value.to_i
+          num = value.to_i
 
           # Ensure the parsed number is the same as the original string value
           # e.g. We want to make sure to throw away `'nan'.to_i == 0`

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

@@ -8,10 +8,12 @@ module Datadog
       # @see https://github.com/open-telemetry/opentelemetry-specification/blob/255a6c52b8914a2ed7e26bb5585abecab276aafc/specification/sdk-environment-variables.md?plain=1#L88
       class None
         # No-op
-        def inject!(_digest, _data); end
+        def inject!(_digest, _data)
+        end
 
         # No-op
-        def extract(_data); end
+        def extract(_data)
+        end
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require_relative '../configuration/ext'
 require_relative '../trace_digest'
 require_relative '../trace_operation'
+require_relative '../span_link'
 require_relative '../../core/telemetry/logger'
 require_relative 'baggage'
 
@@ -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] }
@@ -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
 
@@ -139,13 +152,32 @@ module Datadog
           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
@@ -155,7 +187,10 @@ module Datadog
             # Merge with baggage if present
             digest = @baggage_propagator.extract(data)
             if digest
-              extracted_trace_digest.merge(baggage: digest.baggage)
+              extracted_trace_digest.merge(
+                baggage: digest.baggage,
+                trace_distributed_tags: digest.trace_distributed_tags
+              )
             else
               extracted_trace_digest
             end

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

@@ -31,7 +31,7 @@ module Datadog
             return false
           end
 
-          return pin_config[:distributed_tracing] if pin_config && pin_config.key?(:distributed_tracing)
+          return pin_config[:distributed_tracing] if pin_config&.key?(:distributed_tracing)
           return global_config[:distributed_tracing] if global_config
 
           true