datadog 2.8.0 → 2.39.0

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'json'
-require 'rbconfig'
-require_relative '../../core/diagnostics/environment_logger'
+require "date"
+require "json"
+require "rbconfig"
+require_relative "../../core/diagnostics/environment_logger"
 
 module Datadog
   module Tracing
@@ -14,17 +14,19 @@ module Datadog
 
         def self.collect_and_log!(responses: nil)
           if log?
-            log_configuration!('TRACING', EnvironmentCollector.collect_config!.to_json)
-            log_debug!('TRACING INTEGRATIONS', EnvironmentCollector.collect_integrations_settings!.to_json)
+            log_configuration!("TRACING", EnvironmentCollector.collect_config!.to_json)
+            log_debug!("TRACING INTEGRATIONS", EnvironmentCollector.collect_integrations_settings!.to_json)
 
             if responses
               err_data = EnvironmentCollector.collect_errors!(responses)
               err_data.reject! { |_, v| v.nil? } # Remove empty values from hash output
-              log_error!('TRACING', 'Agent Error', err_data.to_json) unless err_data.empty?
+              log_error!("TRACING", "Agent Error", err_data.to_json) unless err_data.empty?
             end
           end
         rescue => e
-          logger.warn("Failed to collect tracing environment information: #{e} Location: #{Array(e.backtrace).first}")
+          logger.warn(
+            "Failed to collect tracing environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
         end
       end
 
@@ -62,7 +64,7 @@ module Datadog
             # return `nil` with IO transport
             return unless transport.respond_to?(:client)
 
-            adapter = transport.client.api.adapter
+            adapter = transport.client.instance.adapter
             adapter.url
           end
 
@@ -73,7 +75,7 @@ module Datadog
 
             return nil if error_responses.empty?
 
-            error_responses.map(&:inspect).join(',')
+            error_responses.map(&:inspect).join(",")
           end
 
           # @return [Boolean, nil] analytics enabled in configuration
@@ -84,9 +86,13 @@ module Datadog
           # @return [Numeric, nil] tracer sample rate configured
           def sample_rate
             sampler = Datadog.configuration.tracing.sampler
-            return nil unless sampler
+            return Datadog.configuration.tracing.sampling.default_rate unless sampler
 
-            sampler.sample_rate(nil) rescue nil
+            begin
+              sampler.sample_rate(nil)
+            rescue
+              nil
+            end
           end
 
           # DEV: We currently only support SimpleRule instances.
@@ -97,6 +103,8 @@ module Datadog
           # @return [Hash, nil] sample rules configured
           def sampling_rules
             sampler = Datadog.configuration.tracing.sampler
+            return Datadog.configuration.tracing.sampling.rules unless sampler
+
             return nil unless sampler.is_a?(Tracing::Sampling::PrioritySampler) &&
               sampler.priority_sampler.is_a?(Tracing::Sampling::RuleSampler)
 
@@ -119,7 +127,7 @@ module Datadog
             integrations = instrumented_integrations
             return if integrations.empty?
 
-            integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(',')
+            integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(",")
           end
 
           # @return [Boolean, nil] partial flushing enabled in configuration

data/lib/datadog/tracing/diagnostics/ext.rb

@@ -9,25 +9,25 @@ module Datadog
         module Health
           # Metrics
           module Metrics
-            METRIC_API_ERRORS = 'datadog.tracer.api.errors'
-            METRIC_API_REQUESTS = 'datadog.tracer.api.requests'
-            METRIC_API_RESPONSES = 'datadog.tracer.api.responses'
-            METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'
-            METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'
-            METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'
-            METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'
-            METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'
-            METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'
-            METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'
-            METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'
-            METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'
-            METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'
-            METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'
-            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'
-            METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'
-            METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'
-            METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'
-            METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'
+            METRIC_API_ERRORS = "datadog.tracer.api.errors"
+            METRIC_API_REQUESTS = "datadog.tracer.api.requests"
+            METRIC_API_RESPONSES = "datadog.tracer.api.responses"
+            METRIC_ERROR_CONTEXT_OVERFLOW = "datadog.tracer.error.context_overflow"
+            METRIC_ERROR_INSTRUMENTATION_PATCH = "datadog.tracer.error.instrumentation_patch"
+            METRIC_ERROR_SPAN_FINISH = "datadog.tracer.error.span_finish"
+            METRIC_ERROR_UNFINISHED_SPANS = "datadog.tracer.error.unfinished_spans"
+            METRIC_INSTRUMENTATION_PATCHED = "datadog.tracer.instrumentation_patched"
+            METRIC_QUEUE_ACCEPTED = "datadog.tracer.queue.accepted"
+            METRIC_QUEUE_ACCEPTED_LENGTHS = "datadog.tracer.queue.accepted_lengths"
+            METRIC_QUEUE_DROPPED = "datadog.tracer.queue.dropped"
+            METRIC_QUEUE_LENGTH = "datadog.tracer.queue.length"
+            METRIC_QUEUE_MAX_LENGTH = "datadog.tracer.queue.max_length"
+            METRIC_QUEUE_SPANS = "datadog.tracer.queue.spans"
+            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = "datadog.tracer.sampling.service_cache_length"
+            METRIC_TRACES_FILTERED = "datadog.tracer.traces.filtered"
+            METRIC_TRANSPORT_CHUNKED = "datadog.tracer.transport.chunked"
+            METRIC_TRANSPORT_TRACE_TOO_LARGE = "datadog.tracer.transport.trace_too_large"
+            METRIC_WRITER_CPU_TIME = "datadog.tracer.writer.cpu_time"
           end
         end
       end

data/lib/datadog/tracing/diagnostics/health.rb

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

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(
@@ -55,7 +55,7 @@ module Datadog
           span_id = Helpers.parse_hex_id(fetcher[@span_id_key])
 
           # Return early if this propagation is not valid
-          return if span_id.nil? || span_id <= 0 || span_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if span_id.nil? || span_id <= 0 || span_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
           sampling_priority = Helpers.parse_decimal_id(fetcher[@sampled_key])

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
@@ -28,7 +28,7 @@ module Datadog
           span_id = digest.span_id || 0 # Fall back to zero (invalid) if not present
 
           # DEV: We need these to be hex encoded
-          value = "#{format('%032x', digest.trace_id)}-#{format('%016x', span_id)}"
+          value = "#{format("%032x", digest.trace_id)}-#{format("%016x", span_id)}"
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(
@@ -47,14 +47,14 @@ 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
 
           span_id = Helpers.parse_hex_id(parts[1]) if parts.length > 1
           # Return early if this propagation is not valid
-          return if span_id.nil? || span_id <= 0 || span_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if span_id.nil? || span_id <= 0 || span_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           sampling_priority = Helpers.parse_decimal_id(parts[2]) if parts.length > 2
 

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require_relative "../ext"
+require_relative "../metadata/ext"
+require_relative "../trace_digest"
+require_relative "datadog_tags_codec"
+require_relative "../utils"
+require_relative "helpers"
+require "uri"
+
+module Datadog
+  module Tracing
+    module Distributed
+      # W3C Baggage propagator implementation.
+      # The baggage header is propagated through `baggage`.
+      # @see https://www.w3.org/TR/baggage/
+      class Baggage
+        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_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)
+          return if digest.nil? || digest.baggage.nil?
+
+          baggage_items = digest.baggage.reject { |k, v| k.nil? || v.nil? }
+          return if baggage_items.empty?
+
+          begin
+            if baggage_items.size > DD_TRACE_BAGGAGE_MAX_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
+
+            encoded_items = []
+            total_size = 0
+
+            baggage_items.each do |key, value|
+              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 (#{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
+              total_size += item_size
+            end
+
+            # edge case where a single item is too large
+            return if encoded_items.empty?
+
+            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.class}: #{e.message}")
+          end
+        end
+
+        def extract(data)
+          fetcher = @fetcher.new(data)
+          data = fetcher[@baggage_key]
+          return unless data
+
+          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
+
+        private
+
+        def encode_item(item, safe_characters)
+          # 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")
+          # 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/
+              hex_str = encoded[1..2]
+              next encoded unless hex_str && !hex_str.empty?
+
+              # Convert hex representation back to character
+              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
+              encoded
+            end
+          end
+        end
+
+        # Parses a W3C Baggage header string into a hash of key-value pairs
+        # The header format follows the W3C Baggage specification:
+        # - Multiple baggage items are separated by commas
+        # - Each baggage item is a key-value pair separated by '='
+        # - 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 = {}
+          # 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"})
+              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
+
+            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
+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 "datadog_tags_codec"
+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:,
@@ -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)
 
@@ -89,7 +88,7 @@ module Datadog
           trace_id = Helpers.parse_decimal_id(fetcher_object[@trace_id_key])
 
           return unless trace_id
-          return if trace_id <= 0 || trace_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if trace_id <= 0 || trace_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           trace_id
         end
@@ -98,7 +97,7 @@ module Datadog
           parent_id = Helpers.parse_decimal_id(fetcher_object[@parent_id_key])
 
           return unless parent_id
-          return if parent_id <= 0 || parent_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if parent_id <= 0 || parent_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           parent_id
         end
@@ -109,13 +108,15 @@ 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
         def extract_trace_id!(trace_id, tags)
           return trace_id unless tags
           return trace_id unless (high_order = tags.delete(Tracing::Metadata::Ext::Distributed::TAG_TID))
+          return trace_id unless high_order.size == 16
+          return trace_id unless /\A[0-9a-f]+\z/i.match?(high_order)
 
           Tracing::Utils::TraceId.concatenate(high_order.to_i(16), trace_id)
         end
@@ -126,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)
 
-          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.
@@ -153,8 +152,8 @@ 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)
           # Only extract keys with the expected Datadog prefix
@@ -163,15 +162,16 @@ module Datadog
           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) if active_trace
+          active_trace&.set_tag("_dd.propagation_error", reason)
           nil
         end
 
@@ -179,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