datadog 2.30.0 → 2.43.0

data/lib/datadog/tracing/trace_digest.rb

@@ -22,6 +22,9 @@ module Datadog
       # @!attribute [r] span_type
       #   The type of the currently active span.
       #   @return [String]
+      # @!attribute [r] span_links
+      #   Span links associated with this trace context.
+      #   @return [Array<Datadog::Tracing::SpanLink>, nil]
       # @!attribute [r] trace_distributed_tags
       #   Datadog-specific tags that support richer distributed tracing association.
       #   @return [Hash<String,String>]
@@ -69,10 +72,7 @@ module Datadog
       #   @return [Integer]
       #   @see https://www.w3.org/TR/trace-context/#trace-flags
       # @!attribute [r] trace_state
-      #   The W3C "tracestate" extracted from a distributed context.
-      #   This field is a string representing vendor-specific distribution data.
-      #   The `dd=` entry is removed from `trace_state` as its value is dynamically calculated
-      #   on every propagation injection.
+      #   W3C "tracestate" members other than `dd=` and `ot=`, which are stored in parsed fields.
       #   @return [String]
       #   @see https://www.w3.org/TR/trace-context/#tracestate-header
       # @!attribute [r] trace_state_unknown_fields
@@ -80,6 +80,15 @@ module Datadog
       #   This allows later propagation to include those unknown fields, as they can represent future versions of the spec
       #   sending data through this service. This value ends in a trailing `;` to facilitate serialization.
       #   @return [String]
+      # @!attribute [r] trace_otel_random_value
+      #   OpenTelemetry consistent probability sampling random value.
+      #   @return [String]
+      # @!attribute [r] trace_otel_threshold
+      #   OpenTelemetry consistent probability sampling threshold.
+      #   @return [String]
+      # @!attribute [r] trace_otel_unknown_fields
+      #   Unrecognized `ot=` fields, retained with a trailing `;` for propagation.
+      #   @return [String]
       # @!attribute [r] baggage
       #   The W3C "baggage" extracted from a distributed context. This field is a hash of key/value pairs.
       #   @return [Hash<String,String>]
@@ -91,6 +100,7 @@ module Datadog
         :span_resource,
         :span_service,
         :span_type,
+        :span_links,
         :trace_distributed_tags,
         :trace_hostname,
         :trace_id,
@@ -105,6 +115,9 @@ module Datadog
         :trace_flags,
         :trace_state,
         :trace_state_unknown_fields,
+        :trace_otel_random_value,
+        :trace_otel_threshold,
+        :trace_otel_unknown_fields,
         :span_remote,
         :baggage
 
@@ -114,6 +127,7 @@ module Datadog
         span_resource: nil,
         span_service: nil,
         span_type: nil,
+        span_links: nil,
         trace_distributed_tags: nil,
         trace_hostname: nil,
         trace_id: nil,
@@ -128,6 +142,9 @@ module Datadog
         trace_flags: nil,
         trace_state: nil,
         trace_state_unknown_fields: nil,
+        trace_otel_random_value: nil,
+        trace_otel_threshold: nil,
+        trace_otel_unknown_fields: nil,
         span_remote: true,
         baggage: nil
       )
@@ -136,6 +153,7 @@ module Datadog
         @span_resource = span_resource && span_resource.dup.freeze
         @span_service = span_service && span_service.dup.freeze
         @span_type = span_type && span_type.dup.freeze
+        @span_links = span_links && span_links.dup.freeze
         @trace_distributed_tags = trace_distributed_tags && trace_distributed_tags.dup.freeze
         @trace_hostname = trace_hostname && trace_hostname.dup.freeze
         @trace_id = trace_id
@@ -150,6 +168,9 @@ module Datadog
         @trace_flags = trace_flags
         @trace_state = trace_state && trace_state.dup.freeze
         @trace_state_unknown_fields = trace_state_unknown_fields && trace_state_unknown_fields.dup.freeze
+        @trace_otel_random_value = trace_otel_random_value && trace_otel_random_value.dup.freeze
+        @trace_otel_threshold = trace_otel_threshold && trace_otel_threshold.dup.freeze
+        @trace_otel_unknown_fields = trace_otel_unknown_fields && trace_otel_unknown_fields.dup.freeze
         @span_remote = span_remote
         @baggage = baggage && baggage.dup.freeze
         freeze
@@ -167,6 +188,7 @@ module Datadog
           span_resource: span_resource,
           span_service: span_service,
           span_type: span_type,
+          span_links: span_links,
           trace_distributed_tags: trace_distributed_tags,
           trace_hostname: trace_hostname,
           trace_id: trace_id,
@@ -181,6 +203,9 @@ module Datadog
           trace_flags: trace_flags,
           trace_state: trace_state,
           trace_state_unknown_fields: trace_state_unknown_fields,
+          trace_otel_random_value: trace_otel_random_value,
+          trace_otel_threshold: trace_otel_threshold,
+          trace_otel_unknown_fields: trace_otel_unknown_fields,
           span_remote: span_remote,
           baggage: baggage, **field_value_pairs
         )

data/lib/datadog/tracing/trace_operation.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require_relative '../core/environment/identity'
-require_relative '../core/utils'
-require_relative 'event'
-require_relative 'metadata/tagging'
-require_relative 'sampling/ext'
-require_relative 'span_operation'
-require_relative 'trace_digest'
-require_relative 'correlation'
-require_relative 'trace_segment'
-require_relative 'utils'
+require_relative "../core/environment/identity"
+require_relative "../core/utils"
+require_relative "event"
+require_relative "metadata/tagging"
+require_relative "sampling/ext"
+require_relative "distributed/trace_state"
+require_relative "span_operation"
+require_relative "trace_digest"
+require_relative "correlation"
+require_relative "trace_segment"
+require_relative "utils"
 
 module Datadog
   module Tracing
@@ -27,6 +28,8 @@ module Datadog
       include Metadata::Tagging
 
       DEFAULT_MAX_LENGTH = 100_000
+      AUTO_SAMPLING_PRIORITIES = [Sampling::Ext::Priority::AUTO_KEEP, Sampling::Ext::Priority::AUTO_REJECT].freeze
+      RECONSIDERABLE_DECISIONS = [Sampling::Ext::Decision::DEFAULT, Sampling::Ext::Decision::AGENT_RATE].freeze
 
       attr_accessor \
         :agent_sample_rate,
@@ -46,17 +49,16 @@ module Datadog
         :id,
         :max_length,
         :parent_span_id,
-        :trace_state,
-        :trace_state_unknown_fields
+        :trace_state
 
       attr_writer \
         :name,
-        :resource,
         :sampled,
         :service
 
       # Creates a new TraceOperation.
       #
+      # @param span_links [Array<Datadog::Tracing::SpanLink>, nil] links to attach to the local root span.
       # @param auto_finish [Boolean] when true, automatically finishes the trace when the local root span finishes.
       #   When false, the trace remains unfinished until {#finish!} is called.
       #   This is useful when this {TraceOperation} represents the continuation of a remote {TraceDigest},
@@ -71,6 +73,7 @@ module Datadog
         name: nil,
         origin: nil,
         parent_span_id: nil,
+        span_links: nil,
         rate_limiter_rate: nil,
         resource: nil,
         rule_sample_rate: nil,
@@ -83,8 +86,8 @@ module Datadog
         tags: nil,
         metrics: nil,
         trace_state: nil,
-        trace_state_unknown_fields: nil,
         remote_parent: false,
+        distributed_sampling_priority: false,
         tracer: nil, # DEV-3.0: deprecated, remove in 3.0
         baggage: nil,
         auto_finish: true
@@ -97,7 +100,8 @@ module Datadog
         @parent_span_id = parent_span_id
         @sampled = sampled.nil? || sampled
         @remote_parent = remote_parent
-
+        @distributed_sampling_priority = distributed_sampling_priority
+        @span_links = span_links
         # Tags
         @agent_sample_rate = agent_sample_rate
         @hostname = hostname
@@ -111,8 +115,7 @@ module Datadog
         @service = service
         @profiling_enabled = profiling_enabled
         @apm_tracing_enabled = apm_tracing_enabled
-        @trace_state = trace_state
-        @trace_state_unknown_fields = trace_state_unknown_fields
+        @trace_state = trace_state || Distributed::TraceState.new
         @baggage = baggage
 
         # Generic tags
@@ -127,6 +130,8 @@ module Datadog
         @finished = false
         @spans = []
         @auto_finish = !!auto_finish
+        @flushed = false
+        @propagated = false
       end
 
       def full?
@@ -170,6 +175,17 @@ module Datadog
         set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Tracing::Sampling::Ext::Decision::MANUAL)
       end
 
+      def resource=(value)
+        previous_resource = @resource
+        @resource = value
+
+        return if !!previous_resource || value.nil?
+
+        events.trace_resource_change.publish(self)
+      rescue => e
+        logger.debug { "Error updating trace resource: #{e.class}: #{e.message} Backtrace: #{e.backtrace.first(3)}" }
+      end
+
       def name
         @name || root_span&.name
       end
@@ -190,7 +206,7 @@ module Datadog
       def set_distributed_source(product_bit)
         source = get_tag(Metadata::Ext::Distributed::TAG_TRACE_SOURCE)&.to_i(16) || 0
         source |= product_bit
-        set_tag(Metadata::Ext::Distributed::TAG_TRACE_SOURCE, format('%02X', source))
+        set_tag(Metadata::Ext::Distributed::TAG_TRACE_SOURCE, format("%02X", source))
       end
 
       def tags
@@ -208,6 +224,12 @@ module Datadog
         !@resource.nil?
       end
 
+      def reconsider_resource_sample?
+        return false if @resource.nil?
+
+        reconsider_rule_sample?
+      end
+
       def service
         @service || root_span&.service
       end
@@ -274,15 +296,20 @@ module Datadog
         parent_id = parent ? parent.id : @parent_span_id || 0
 
         # Build events
-        events ||= SpanOperation::Events.new(logger: logger)
+        span_events = events || SpanOperation::Events.new(logger: logger)
 
         # Before start: activate the span, publish events.
-        events.before_start.subscribe do |span_op|
+        span_events.before_start.subscribe do |span_op|
           start_span(span_op)
         end
 
+        # Before finish: allow enrichment before the span is finalized, publish events.
+        span_events.before_finish.subscribe do |span_op|
+          before_finish_span(span_op)
+        end
+
         # After finish: deactivate the span, record, publish events.
-        events.after_finish.subscribe do |span, span_op|
+        span_events.after_finish.subscribe do |span, span_op|
           finish_span(span, span_op, parent)
         end
 
@@ -290,9 +317,10 @@ module Datadog
         SpanOperation.new(
           op_name,
           logger: logger,
-          events: events,
+          events: span_events,
           on_error: on_error,
           parent_id: parent_id,
+          links: (@root_span.nil? ? @span_links : nil),
           resource: resource || op_name,
           service: service,
           start_time: start_time,
@@ -302,7 +330,7 @@ module Datadog
           id: id
         )
       rescue => e
-        logger.debug { "Failed to build new span: #{e}" }
+        logger.debug { "Failed to build new span: #{e.class}: #{e.message}" }
 
         # Return dummy span
         SpanOperation.new(op_name, logger: logger)
@@ -319,6 +347,7 @@ module Datadog
         # Copy out completed spans
         spans = @spans.dup
         @spans = []
+        @flushed = true
 
         spans = yield(spans) if block_given?
 
@@ -359,8 +388,18 @@ module Datadog
         span_id = @active_span&.id
         span_id ||= @parent_span_id unless finished?
         # sample the trace_operation with the tracer
+        @propagated = true
         events.trace_propagated.publish(self)
 
+        open_telemetry = @trace_state.open_telemetry.outbound(
+          trace_id: @id,
+          sampling_priority: @sampling_priority,
+          decision_maker: get_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER),
+          applied_rate: @rule_sample_rate || @agent_sample_rate,
+          rate_limiter_rate: @rate_limiter_rate,
+          distributed_sampling_priority: @distributed_sampling_priority,
+        )
+
         TraceDigest.new(
           span_id: span_id,
           span_name: @active_span && @active_span.name,
@@ -377,8 +416,11 @@ module Datadog
           trace_runtime_id: Core::Environment::Identity.id,
           trace_sampling_priority: @sampling_priority,
           trace_service: service,
-          trace_state: @trace_state,
-          trace_state_unknown_fields: @trace_state_unknown_fields,
+          trace_state: @trace_state.unknown_vendors,
+          trace_state_unknown_fields: @trace_state.datadog.unknown_fields,
+          trace_otel_random_value: open_telemetry.random_value,
+          trace_otel_threshold: open_telemetry.threshold,
+          trace_otel_unknown_fields: open_telemetry.unknown_fields,
           span_remote: @remote_parent && @active_span.nil?,
           baggage: (@baggage.nil? || @baggage.empty?) ? nil : @baggage
         ).freeze
@@ -414,11 +456,11 @@ module Datadog
           sampled: @sampled,
           sampling_priority: @sampling_priority,
           service: service&.dup,
-          trace_state: @trace_state&.dup,
-          trace_state_unknown_fields: @trace_state_unknown_fields&.dup,
+          trace_state: @trace_state,
           tags: meta.dup,
           metrics: metrics.dup,
-          remote_parent: @remote_parent
+          remote_parent: @remote_parent,
+          distributed_sampling_priority: @distributed_sampling_priority
         )
       end
 
@@ -427,16 +469,28 @@ module Datadog
         include Tracing::Events
 
         attr_reader \
+          :span_before_finish,
           :span_before_start,
           :span_finished,
           :trace_finished,
-          :trace_propagated
+          :trace_propagated,
+          :trace_resource_change
 
         def initialize
+          @span_before_finish = SpanBeforeFinish.new
           @span_before_start = SpanBeforeStart.new
           @span_finished = SpanFinished.new
           @trace_finished = TraceFinished.new
           @trace_propagated = TracePropagated.new
+          @trace_resource_change = TraceResourceChange.new
+        end
+
+        # Triggered just before a span is finalized, mirroring SpanOperation::Events::BeforeFinish.
+        # Subscribers can still mutate tags on the SpanOperation at this point.
+        class SpanBeforeFinish < Tracing::Event
+          def initialize
+            super(:span_before_finish)
+          end
         end
 
         # Triggered before a span starts.
@@ -476,6 +530,14 @@ module Datadog
             subscribe(&block)
           end
         end
+
+        # Triggered when the resource name is set
+        # This is used to reconsider trace sampling on resource name change
+        class TraceResourceChange < Tracing::Event
+          def initialize
+            super(:trace_resource_change)
+          end
+        end
       end
 
       private
@@ -511,7 +573,14 @@ module Datadog
         # Publish :span_before_start event
         events.span_before_start.publish(span_op, self)
       rescue => e
-        logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
+        logger.debug { "Error starting span on trace: #{e.class}: #{e.message} Backtrace: #{e.backtrace.first(3)}" }
+      end
+
+      def before_finish_span(span_op)
+        # Publish :span_before_finish event
+        events.span_before_finish.publish(span_op, self)
+      rescue => e
+        logger.debug { "Error in before_finish_span on trace: #{e.class}: #{e.message} Backtrace: #{e.backtrace.first(3)}" }
       end
 
       # For traces with automatic context management (auto_finish),
@@ -540,7 +609,7 @@ module Datadog
         # Publish :trace_finished event
         events.trace_finished.publish(self) if finished?
       rescue => e
-        logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
+        logger.debug { "Error finishing span on trace: #{e.class}: #{e.message} Backtrace: #{e.backtrace.first(3)}" }
       end
 
       # Track the root {SpanOperation} object from the current execution context.
@@ -582,12 +651,24 @@ module Datadog
         meta.select { |name, _| name.start_with?(Metadata::Ext::Distributed::TAGS_PREFIX) }
       end
 
+      def reconsider_rule_sample?
+        decision = get_tag(Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+
+        return false if remote_parent || @propagated || @flushed
+        return false unless AUTO_SAMPLING_PRIORITIES.include?(@sampling_priority)
+        return false if decision && !RECONSIDERABLE_DECISIONS.include?(decision)
+
+        true
+      end
+
       def reset
         @root_span = nil
         @active_span = nil
         @active_span_count = 0
         @finished = false
         @spans = []
+        @flushed = false
+        @propagated = false
       end
     end
   end

data/lib/datadog/tracing/trace_segment.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative '../core/runtime/ext'
-require_relative '../core/utils/safe_dup'
+require_relative "../core/runtime/ext"
+require_relative "../core/utils/safe_dup"
 
-require_relative 'sampling/ext'
-require_relative 'metadata/ext'
-require_relative 'metadata/tagging'
-require_relative 'utils'
+require_relative "sampling/ext"
+require_relative "metadata/ext"
+require_relative "metadata/tagging"
+require_relative "utils"
 
 module Datadog
   module Tracing
     # Serializable construct representing a trace
     # @public_api
     class TraceSegment
-      TAG_NAME = 'name'
-      TAG_RESOURCE = 'resource'
-      TAG_SERVICE = 'service'
+      TAG_NAME = "name"
+      TAG_RESOURCE = "resource"
+      TAG_SERVICE = "service"
 
       attr_reader \
         :id,
@@ -140,7 +140,7 @@ module Datadog
       def high_order_tid
         high_order = Tracing::Utils::TraceId.to_high_order(@id)
 
-        format('%016x', high_order) if high_order != 0
+        format("%016x", high_order) if high_order != 0
       end
 
       protected

data/lib/datadog/tracing/tracer.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require_relative '../core/environment/ext'
-require_relative '../core/environment/socket'
-
-require_relative 'correlation'
-require_relative 'event'
-require_relative 'flush'
-require_relative 'context_provider'
-require_relative 'sampling/all_sampler'
-require_relative 'sampling/rule_sampler'
-require_relative 'sampling/priority_sampler'
-require_relative 'sampling/span/sampler'
-require_relative 'span_operation'
-require_relative 'trace_digest'
-require_relative 'trace_operation'
-require_relative 'writer'
+require_relative "../core/environment/ext"
+require_relative "../core/environment/socket"
+
+require_relative "correlation"
+require_relative "event"
+require_relative "flush"
+require_relative "context_provider"
+require_relative "sampling/all_sampler"
+require_relative "sampling/rule_sampler"
+require_relative "sampling/priority_sampler"
+require_relative "sampling/span/sampler"
+require_relative "span_operation"
+require_relative "trace_digest"
+require_relative "trace_operation"
+require_relative "writer"
 
 module Datadog
   module Tracing
@@ -153,7 +153,7 @@ module Datadog
             active_trace
           end
         rescue => e
-          logger.debug { "Failed to trace: #{e}" }
+          logger.debug { "Failed to trace: #{e.class}: #{e.message}" }
 
           # Tracing failed: fallback and run code without tracing.
           return skip_trace(name, &block)
@@ -303,7 +303,20 @@ module Datadog
         @sampler.sample!(trace_op) if trace_op.sampling_priority.nil?
       rescue => e
         SAMPLE_TRACE_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to sample trace: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
+        end
+      end
+
+      def reconsider_trace_sampling_on_resource(trace_op)
+        return unless trace_op.reconsider_resource_sample?
+        return unless @sampler.respond_to?(:reconsider_sample_resource!)
+
+        @sampler.reconsider_sample_resource!(trace_op)
+      rescue => e
+        RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE.run do
+          logger.warn do
+            "Failed to reconsider trace sampling: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+          end
         end
       end
 
@@ -359,14 +372,12 @@ module Datadog
       end
 
       def build_trace(digest, auto_finish)
-        # Resolve hostname if configured
-        hostname = Core::Environment::Socket.hostname if Datadog.configuration.tracing.report_hostname
-        hostname = (hostname && !hostname.empty?) ? hostname : nil
+        hostname = Core::Environment::Socket.resolved_hostname(Datadog.configuration)
 
         if digest
-          sampling_priority = if propagate_sampling_priority?(upstream_tags: digest.trace_distributed_tags)
-            digest.trace_sampling_priority
-          end
+          propagate_sampling = propagate_sampling_priority?(upstream_tags: digest.trace_distributed_tags)
+          sampling_priority = digest.trace_sampling_priority if propagate_sampling
+          trace_state = Distributed::TraceState.from_digest(digest, propagate_sampling: propagate_sampling)
           TraceOperation.new(
             logger: logger,
             hostname: hostname,
@@ -376,11 +387,12 @@ module Datadog
             origin: digest.trace_origin,
             parent_span_id: digest.span_id,
             sampling_priority: sampling_priority,
+            span_links: digest.span_links,
             # Distributed tags are just regular trace tags with special meaning to Datadog
             tags: digest.trace_distributed_tags,
-            trace_state: digest.trace_state,
-            trace_state_unknown_fields: digest.trace_state_unknown_fields,
+            trace_state: trace_state,
             remote_parent: digest.span_remote,
+            distributed_sampling_priority: !!sampling_priority,
             tracer: self,
             baggage: digest.baggage,
             auto_finish: auto_finish
@@ -406,6 +418,15 @@ module Datadog
           event_span_op.service ||= @default_service
         end
 
+        events.span_before_finish.subscribe do |event_span_op, _event_trace_op|
+          if event_span_op.service && event_span_op.service != @default_service
+            event_span_op.set_tag(Tracing::Metadata::Ext::TAG_BASE_SERVICE, @default_service)
+            event_span_op.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Tracing::Metadata::Ext::SVC_SRC_MANUAL) unless event_span_op.get_tag(Tracing::Metadata::Ext::TAG_SVC_SRC)
+          else
+            event_span_op.send(:meta).delete(Tracing::Metadata::Ext::TAG_SVC_SRC)
+          end
+        end
+
         events.trace_propagated.subscribe do |event_trace_op|
           sample_trace(event_trace_op)
         end
@@ -415,6 +436,15 @@ module Datadog
           sample_span(event_trace_op, event_span)
           flush_trace(event_trace_op)
         end
+
+        # Conditionally subscribe to the less common sampling rules below, to avoid
+        # measurable unnecessary performance overhead when they are not present.
+
+        if @sampler.respond_to?(:resource_sampling?) && @sampler.resource_sampling?
+          events.trace_resource_change.subscribe do |event_trace_op|
+            reconsider_trace_sampling_on_resource(event_trace_op)
+          end
+        end
       end
 
       # Creates a new TraceOperation, with events bounds to this Tracer instance.
@@ -534,11 +564,14 @@ module Datadog
       SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
       private_constant :SAMPLE_TRACE_LOG_ONLY_ONCE
 
+      RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
+      private_constant :RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE
+
       def sample_span(trace_op, span)
         @span_sampler.sample!(trace_op, span)
       rescue => e
         SAMPLE_SPAN_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to sample span: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -551,7 +584,7 @@ module Datadog
         write(trace) if trace && !trace.empty?
       rescue => e
         FLUSH_TRACE_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to flush trace: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -595,6 +628,10 @@ module Datadog
           appsec_bit = upstream_tags[Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE].to_i(16) &
             Datadog::AppSec::Ext::PRODUCT_BIT
           return appsec_enabled if appsec_bit != 0
+
+          ai_guard_bit = upstream_tags[Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE].to_i(16) &
+            Datadog::AIGuard::Ext::PRODUCT_BIT
+          return ai_guard_enabled if ai_guard_bit != 0
         end
 
         false
@@ -609,6 +646,10 @@ module Datadog
         @appsec_enabled ||= Datadog.configuration.appsec.enabled
       end
 
+      def ai_guard_enabled
+        @ai_guard_enabled ||= Datadog.configuration.respond_to?(:ai_guard) && Datadog.configuration.ai_guard.enabled
+      end
+
       # Due to APM Tracing (the product) and Tracing (the transport) being intertwined, we cannot completely disabled APM
       # without also disabling the tracer. When setting `@apm_tracing_enabled` to `false`, it does not disable the tracer,
       # but rather only sends heartbeat traces (1 per minutes), so that the service is considered alive in the backend.

data/lib/datadog/tracing/transport/http/client.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'statistics'
-require_relative '../../../core/transport/http/client'
-require_relative '../../../core/transport/http/env'
-require_relative '../../../core/transport/http/response'
+require_relative "statistics"
+require_relative "../../../core/transport/http/client"
+require_relative "../../../core/transport/http/env"
+require_relative "../../../core/transport/http/response"
 
 module Datadog
   module Tracing