datadog 2.35.0 → 2.37.0

data/lib/datadog/symbol_database/file_hash.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'digest/sha1'
+require_relative '../di/fatal_exceptions'
 
 module Datadog
   module SymbolDatabase
@@ -37,7 +38,8 @@ module Datadog
         # This is not a security vulnerability - we're computing file content hashes
         # to match against Git objects, not using SHA-1 for authentication/integrity.
         Digest::SHA1.hexdigest(git_blob)  # nosemgrep: ruby.lang.security.weak-hashes-sha1.weak-hashes-sha1
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         logger.debug { "symdb: file hash failed for #{file_path}: #{e.class}: #{e.message}" }
         nil
       end

data/lib/datadog/symbol_database/remote.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../di/fatal_exceptions'
+
 module Datadog
   module SymbolDatabase
     # Provides remote configuration integration for symbol database.
@@ -44,7 +46,8 @@ module Datadog
             telemetry = lookup_telemetry
             component = begin
               Datadog.send(:components, allow_initialization: false)&.symbol_database
-            rescue => e
+            rescue Exception => e # standard:disable Lint/RescueException
+              Datadog::DI.reraise_if_fatal(e)
               Datadog.logger.debug { "symdb: failed to look up component in RC receiver: #{e.class}: #{e.message}" }
               telemetry&.report(e, description: 'symdb: failed to look up component in RC receiver')
               nil
@@ -76,7 +79,8 @@ module Datadog
         # @api private
         def lookup_telemetry
           Datadog.send(:components, allow_initialization: false)&.telemetry
-        rescue
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           nil
         end
 
@@ -107,7 +111,8 @@ module Datadog
             # the Repository::Change union type where `Deleted` lacks `content`.
             change.content.errored("Unrecognized change type: #{change.type}") if change.respond_to?(:content) # steep:ignore NoMethod
           end
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           component.logger.debug { "symdb: error processing remote config change: #{e.class}: #{e.message}" }
           telemetry&.report(e, description: 'symdb: error processing remote config change')
           # Rescue runs regardless of which branch raised — Steep cannot narrow the

data/lib/datadog/symbol_database/scope_batcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'set'
+require_relative '../di/fatal_exceptions'
 
 module Datadog
   module SymbolDatabase
@@ -122,7 +123,8 @@ module Datadog
 
         # Upload outside mutex (if batch was full)
         perform_upload(scopes_to_upload) if scopes_to_upload
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: failed to add scope: #{e.class}: #{e.message}" }
         # Don't propagate, continue operation
       end
@@ -267,7 +269,8 @@ module Datadog
             flush
           end
         end
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: timer thread error: #{e.class}: #{e.message}" }
       end
 
@@ -279,7 +282,8 @@ module Datadog
 
         @uploader.upload_scopes(scopes)
         @on_upload&.call(scopes)  # Notify tests after upload
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: upload failed: #{e.class}: #{e.message}" }
         # Don't propagate, uploader handles retries
       end

data/lib/datadog/symbol_database/uploader.rb

@@ -6,8 +6,10 @@ require 'zlib'
 require 'stringio'
 require_relative '../core/environment/identity'
 require_relative '../core/vendor/multipart-post/multipart/post/composite_read_io'
+require_relative '../tracing/ext'
 require_relative 'service_version'
 require_relative 'transport/http'
+require_relative '../di/fatal_exceptions'
 
 module Datadog
   module SymbolDatabase
@@ -68,7 +70,11 @@ module Datadog
         compressed_data = Zlib.gzip(json_data)
 
         # Emitted unconditionally so the rare oversized case is observable.
-        @telemetry&.distribution('tracers', 'symbol_database.payload_size', compressed_data.bytesize)
+        @telemetry&.distribution(
+          Tracing::Ext::TELEMETRY_METRICS_NAMESPACE,
+          'symbol_database.payload_size',
+          compressed_data.bytesize
+        )
 
         # Symbols for very large applications (>50MB after gzip) are dropped:
         # the upload is skipped and the customer sees no autocomplete /
@@ -81,7 +87,8 @@ module Datadog
         end
 
         perform_http_upload(compressed_data, scopes.size, upload_id: upload_id, batch_num: batch_num)
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: upload failed: #{e.class}: #{e.message}" }
         @telemetry&.report(e, description: 'symdb: upload failed')
       end

data/lib/datadog/symbol_database.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'ruby_version'
+
 module Datadog
   # Namespace for Datadog symbol database upload.
   #
@@ -45,5 +47,25 @@ module Datadog
     # Reference: Symbol Database Backend RFC, section "Scope" and "Edge Cases"
     # @see https://www.postgresql.org/docs/current/datatype-numeric.html
     UNKNOWN_MAX_LINE = 2147483647
+
+    # Collapses the symbol_database.enabled tri-state setting to a boolean.
+    # An explicit true/false wins; nil (unconfigured) yields the caller-supplied
+    # fallback.
+    # @param setting_value [Boolean, nil] the symbol_database.enabled setting
+    # @param di_fallback [Boolean] value used when the setting is unconfigured
+    # @return [Boolean]
+    def self.resolve_enabled(setting_value, di_fallback)
+      setting_value.nil? ? di_fallback : setting_value
+    end
+
+    # Whether the current Ruby runtime can run symbol database extraction:
+    # MRI (CRuby) on Ruby 2.7 or later. Used by the remote-config layer to avoid
+    # advertising the product on runtimes where Component.build would return nil
+    # (e.g. Ruby 2.6, which Dynamic Instrumentation supports but Symbol Database
+    # does not).
+    # @return [Boolean]
+    def self.supported_runtime?
+      RUBY_ENGINE == 'ruby' && RubyVersion.is?('>= 2.7')
+    end
   end
 end

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

@@ -62,6 +62,19 @@ module Datadog
 
           ENV_PROPAGATION_STYLE_EXTRACT = 'DD_TRACE_PROPAGATION_STYLE_EXTRACT'
 
+          PROPAGATION_BEHAVIOR_EXTRACT_CONTINUE = 'continue'
+          PROPAGATION_BEHAVIOR_EXTRACT_RESTART = 'restart'
+          PROPAGATION_BEHAVIOR_EXTRACT_IGNORE = 'ignore'
+
+          PROPAGATION_BEHAVIOR_EXTRACT_SUPPORTED = [
+            PROPAGATION_BEHAVIOR_EXTRACT_CONTINUE,
+            PROPAGATION_BEHAVIOR_EXTRACT_RESTART,
+            PROPAGATION_BEHAVIOR_EXTRACT_IGNORE,
+          ].freeze
+
+          # Behavior applied to a distributed-trace context extracted from incoming requests.
+          ENV_PROPAGATION_BEHAVIOR_EXTRACT = 'DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT'
+
           # A no-op propagator. Compatible with OpenTelemetry's `none` propagator.
           # @see https://opentelemetry.io/docs/concepts/sdk-configuration/general-sdk-configuration/#get_otel__propagators
           PROPAGATION_STYLE_NONE = 'none'

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

@@ -117,6 +117,23 @@ module Datadog
                 end
               end
 
+              # Behavior applied to a distributed-trace context extracted from incoming requests.
+              option :propagation_behavior_extract do |o|
+                o.env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_BEHAVIOR_EXTRACT
+                o.default Tracing::Configuration::Ext::Distributed::PROPAGATION_BEHAVIOR_EXTRACT_CONTINUE
+                o.type :string
+                o.env_parser do |value|
+                  value = value&.downcase
+                  if Tracing::Configuration::Ext::Distributed::PROPAGATION_BEHAVIOR_EXTRACT_SUPPORTED.include?(value)
+                    value
+                  else
+                    Datadog.logger.warn("Unsupported propagation behavior extract: #{value.inspect}. " \
+                      "Set to default value (#{Tracing::Configuration::Ext::Distributed::PROPAGATION_BEHAVIOR_EXTRACT_CONTINUE}).")
+                    nil
+                  end
+                end
+              end
+
               # Strictly stop at the first successfully serialized style.
               # This prevents the tracer from enriching the extracted context with information from
               # other valid propagations styles present in the request.

data/lib/datadog/tracing/contrib/configuration/resolver.rb

@@ -101,6 +101,13 @@ module Datadog
             # shrink a Hash using an "st_table" back to an "ar_table")
             @cache = Hash[*1..20]
             @cache.clear
+            # Workaround for the segfault from https://github.com/DataDog/dd-trace-rb/issues/5718#issuecomment-4421844775.
+            # It crashes on a simple {Hash} lookup, {Hash#key?}, called from `@cache.fetch(value)`.
+            # Using an identity-based {Hash} avoids {Hash#key?} calls.
+            # We should attempt to remove this workaround when we only support Ruby 4+,
+            # as large change around the crash site was done in that version (https://github.com/ruby/ruby/pull/14039/changes#diff-884a5a8a369ef1b4c7597e00aa65974cec8c5f54f25f03ad5d24848f64892869R1743),
+            # where `RClass.cc_table` (the NULL dereferenced pointer) became a GC-managed object,
+            @cache.compare_by_identity
           end
 
           # (see Resolver#resolve)

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

@@ -20,6 +20,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -38,6 +39,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

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

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

@@ -19,6 +19,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -37,6 +38,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

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

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

@@ -19,6 +19,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -37,6 +38,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

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

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

@@ -268,7 +268,9 @@ module Datadog
             #   1. resource renaming is enabled
             #   2. AppSec is enabled and resource renaming is disabled (by default, not explicitly)
             if Datadog.configuration.tracing.resource_renaming.enabled ||
-                Datadog.configuration.appsec.enabled && Datadog.configuration.tracing.resource_renaming.options[:enabled].default_precedence?
+                Datadog.configuration.respond_to?(:appsec) &&
+                    Datadog.configuration.appsec&.enabled &&
+                    Datadog.configuration.tracing.resource_renaming.options[:enabled].default_precedence?
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT, value)
             end
           end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../../ruby_version'
+
 module Datadog
   module Tracing
     module Contrib
@@ -48,7 +50,7 @@ module Datadog
             nil
           end
 
-          if RUBY_VERSION >= '2.6.'
+          if RubyVersion.is?('>= 2.6')
             def split(path, pattern = nil, &block)
               path.split(pattern, &block)
             end

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

@@ -20,6 +20,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -38,6 +39,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

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

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

@@ -19,6 +19,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -37,6 +38,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

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

data/lib/datadog/tracing/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'
@@ -243,7 +244,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/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] }
@@ -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
 
@@ -145,7 +158,26 @@ module Datadog
           # 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

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../../core/utils'
+require_relative 'helpers'
+
 module Datadog
   module Tracing
     module Distributed
@@ -282,8 +285,11 @@ module Datadog
           trace_flags & TRACE_FLAGS_SAMPLED
         end
 
-        # @return [Array<String,Integer,String,String,Hash>] returns 4 values:
-        # tracestate, sampling_priority, ts_parent_id, origin, tags.
+        # @return [nil] when the tracestate is absent or has no vendor entries.
+        # @return [String] when no `dd=` entry is present, the joined vendor list.
+        # @return [Array(String, Integer, String, String, Hash, String)] when a `dd=`
+        #   entry is present: [tracestate without `dd=`, sampling_priority, origin,
+        #   ts_parent_id, tags, unknown_fields]. All elements past the first may be nil.
         def extract_tracestate(tracestate)
           vendors = split_tracestate(tracestate)
           return unless vendors && !vendors.empty?
@@ -395,6 +401,9 @@ module Datadog
             tracestate = tracestate.chop
           end
 
+          tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
+          return unless tracestate
+
           vendors = tracestate.split(',', TRACESTATE_MAX_LIST_MEMBERS + 1)
           if vendors.length > TRACESTATE_MAX_LIST_MEMBERS || remove_last_member
             vendors.pop

data/lib/datadog/tracing/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Ext
+      TELEMETRY_METRICS_NAMESPACE = 'tracers'
+    end
+  end
+end

data/lib/datadog/tracing/remote.rb

@@ -15,6 +15,9 @@ module Datadog
           1 << 13, # APM_TRACING_LOGS_INJECTION: Dynamic trace logs injection configuration
           1 << 14, # APM_TRACING_HTTP_HEADER_TAGS: Dynamic trace HTTP header tags configuration
           1 << 29, # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
+          # APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION (bit 38) is declared in
+          # DI::Remote.capabilities, not here, so it is registered only when DI
+          # is not explicitly disabled and the runtime supports DI.
         ].freeze
 
         def products
@@ -25,7 +28,7 @@ module Datadog
           CAPABILITIES
         end
 
-        def process_config(config, content)
+        def process_config(config, content, repository = nil)
           lib_config = config['lib_config']
 
           env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
@@ -39,9 +42,37 @@ module Datadog
             [env_var, value]
           end
 
+          if (di_enabled = lib_config['dynamic_instrumentation_enabled']) != nil # rubocop:disable Style/NonNilCheck
+            # repository is forwarded so that an enable signal can reconcile DI
+            # against probes delivered in an earlier poll while DI was stopped
+            # (see Datadog::DI::Remote.handle_rc_enablement).
+            Datadog::DI::Remote.handle_rc_enablement(di_enabled, repository)
+
+            if di_enabled
+              # DI was just (implicitly) enabled. A Symbol Database upload signal
+              # received in an earlier poll while DI was inactive was deferred by
+              # the component's DI-active gate; re-attempt it now. Mirrors the DI
+              # probe replay in handle_rc_enablement above. allow_initialization:
+              # false because this runs on the remote-config worker thread.
+              Datadog.send(:components, allow_initialization: false)&.symbol_database&.resume_pending_upload
+            else
+              # DI was disabled via remote configuration. In the nil-default
+              # (follows-DI) case, stop Symbol Database too so its TracePoint and
+              # scheduler don't keep uploading while DI is off. An explicit
+              # symbol_database.enabled = true is independent and keeps running.
+              Datadog.send(:components, allow_initialization: false)&.symbol_database&.stop_for_di_disable
+            end
+          end
+
           content.applied
 
-          Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
+          # allow_initialization: false because process_config runs on the
+          # remote-config worker thread. If components haven't been built yet
+          # (e.g. during a teardown/reset window), the default `true` would
+          # synchronously build the entire component tree from this thread.
+          # The &. chain matches the pattern used by DI::Remote.handle_rc_enablement
+          # in the same dispatch path.
+          Datadog.send(:components, allow_initialization: false)&.telemetry&.client_configuration_change!(env_vars)
         rescue => e
           content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
         end
@@ -55,7 +86,7 @@ module Datadog
               case content.path.product
               when PRODUCT
                 config = parse_content(content)
-                process_config(config, content)
+                process_config(config, content, repository)
               end
             end
           end

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>]
@@ -91,6 +94,7 @@ module Datadog
         :span_resource,
         :span_service,
         :span_type,
+        :span_links,
         :trace_distributed_tags,
         :trace_hostname,
         :trace_id,
@@ -114,6 +118,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,
@@ -136,6 +141,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
@@ -167,6 +173,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,

data/lib/datadog/tracing/trace_operation.rb

@@ -58,6 +58,7 @@ module Datadog
 
       # 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},
@@ -72,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,
@@ -98,7 +100,7 @@ module Datadog
         @parent_span_id = parent_span_id
         @sampled = sampled.nil? || sampled
         @remote_parent = remote_parent
-
+        @span_links = span_links
         # Tags
         @agent_sample_rate = agent_sample_rate
         @hostname = hostname
@@ -318,6 +320,7 @@ module Datadog
           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,