datadog 2.41.0 → 2.43.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "../../sampling/rate_sampler"
+require_relative "ext"
+
+module Datadog
+  module Tracing
+    module Distributed
+      class TraceState
+        # Encodes consistent probability sampling in the OpenTelemetry `ot=` tracestate member.
+        # @see https://opentelemetry.io/docs/specs/otel/trace/tracestate-probability-sampling/
+        class OpenTelemetry
+          class << self
+            def from_digest(digest, propagate_sampling: true)
+              new(
+                random_value: (digest.trace_otel_random_value if propagate_sampling),
+                threshold: (digest.trace_otel_threshold if propagate_sampling),
+                unknown_fields: digest.trace_otel_unknown_fields,
+              )
+            end
+
+            # Parses known fields and retains unknown fields for propagation.
+            def from_tracestate_member(value)
+              return new unless value
+
+              # @type var random_value: ::String?
+              # @type var threshold: ::String?
+              random_value = nil
+              threshold = nil
+              unknown = []
+
+              value.split(";").each do |pair|
+                key, field = pair.split(":", 2)
+                case key
+                when "rv"
+                  random_value = field
+                when "th"
+                  threshold = field
+                else
+                  unknown << pair
+                end
+              end
+
+              threshold = nil if threshold && !Ext::OpenTelemetry::VALID_THRESHOLD.match?(threshold)
+              random_value = nil if random_value && !Ext::OpenTelemetry::VALID_RANDOM_VALUE.match?(random_value)
+
+              new(
+                random_value: random_value,
+                threshold: threshold,
+                unknown_fields: unknown.empty? ? nil : "#{unknown.join(";")};",
+              )
+            end
+          end
+
+          attr_reader :random_value, :threshold, :unknown_fields
+
+          def initialize(random_value: nil, threshold: nil, unknown_fields: nil)
+            @random_value = random_value
+            @threshold = threshold
+            @unknown_fields = unknown_fields
+          end
+
+          # Resolves fields that represent the trace's current sampling decision.
+          def outbound(
+            trace_id:,
+            sampling_priority:,
+            decision_maker:,
+            applied_rate:,
+            rate_limiter_rate:,
+            distributed_sampling_priority:
+          )
+            if Ext::OpenTelemetry::NON_PROBABILITY_DECISIONS.include?(decision_maker)
+              return self.class.new(random_value: random_value, unknown_fields: unknown_fields)
+            end
+
+            trace_kept = sampling_priority && sampling_priority >= Sampling::Ext::Priority::AUTO_KEEP
+            if rate_limiter_rate && !trace_kept
+              return self.class.new(random_value: random_value, unknown_fields: unknown_fields)
+            end
+
+            return self if random_value || threshold
+            return self.class.new(unknown_fields: unknown_fields) if distributed_sampling_priority || !applied_rate
+
+            outbound_threshold = threshold_for(applied_rate)
+            outbound_random_value = reconcile_random_value(
+              random_value_for(trace_id),
+              outbound_threshold,
+              !!trace_kept
+            )
+            self.class.new(
+              random_value: format_random_value(outbound_random_value),
+              threshold: format_threshold(outbound_threshold),
+              unknown_fields: unknown_fields,
+            )
+          end
+
+          def to_s
+            fields = []
+            fields << "rv:#{random_value}" if random_value
+            fields << "th:#{threshold}" if threshold
+            fields.concat(unknown_fields.chomp(";").split(";")) if unknown_fields
+
+            value = +""
+            fields.each do |field|
+              separator = value.empty? ? "" : ";"
+              break if value.bytesize + separator.bytesize + field.bytesize > Ext::TRACESTATE_VALUE_SIZE_LIMIT
+
+              value << separator << field
+            end
+            value.empty? ? "" : "ot=#{value}"
+          end
+
+          private
+
+          # Converts Datadog's Knuth hash into OTel's 56-bit random value.
+          def random_value_for(trace_id)
+            hash = (trace_id * Sampling::RateSampler::KNUTH_FACTOR) % Ext::OpenTelemetry::UINT64_MODULO
+            (~hash & Ext::OpenTelemetry::UINT64_MASK) >> 8
+          end
+
+          # Converts a sample rate into a 56-bit rejection threshold.
+          def threshold_for(rate)
+            threshold = ((1.0 - rate) * Ext::OpenTelemetry::MAX_THRESHOLD).round
+            return 0 if threshold < 0
+            return Ext::OpenTelemetry::MAX_ENCODABLE_THRESHOLD if threshold > Ext::OpenTelemetry::MAX_ENCODABLE_THRESHOLD
+
+            threshold
+          end
+
+          # Preserve Datadog's 64-bit decision after expressing it with 56-bit OTel values.
+          def reconcile_random_value(random_value, threshold, kept)
+            if kept && random_value < threshold
+              threshold
+            elsif !kept && random_value >= threshold
+              [threshold - 1, 0].max
+            else
+              random_value
+            end
+          end
+
+          def format_random_value(random_value)
+            format("%014x", random_value)
+          end
+
+          # OTel thresholds omit trailing zero nibbles but retain leading zeroes.
+          def format_threshold(threshold)
+            return "0" if threshold.zero?
+
+            trailing_nibbles = ((threshold & -threshold).bit_length - 1) / 4
+            (threshold >> (trailing_nibbles * 4)).to_s(16).rjust(14 - trailing_nibbles, "0")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../../core/utils"
+require_relative "trace_state/ext"
+require_relative "trace_state/datadog"
+require_relative "trace_state/open_telemetry"
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Parsed vendor state from a W3C `tracestate` header.
+      # @api private
+      class TraceState
+        class << self
+          def from_digest(digest, propagate_sampling: true)
+            new(
+              unknown_vendors: digest.trace_state,
+              datadog: Datadog.from_digest(digest),
+              open_telemetry: OpenTelemetry.from_digest(digest, propagate_sampling: propagate_sampling),
+            )
+          end
+
+          def serialize_digest(digest)
+            serialize(
+              unknown_vendors: digest.trace_state,
+              datadog: Datadog.from_digest(digest),
+              open_telemetry: OpenTelemetry.from_digest(digest),
+            )
+          end
+
+          # Parses owned members while retaining other vendors unchanged.
+          def extract(tracestate)
+            vendors = split(tracestate) || []
+            datadog_index = vendors.index { |vendor| vendor.start_with?("dd=") }
+            datadog_value = vendors.delete_at(datadog_index).delete_prefix("dd=") if datadog_index
+            otel_index = vendors.index { |vendor| vendor.start_with?("ot=") }
+            otel_value = vendors.delete_at(otel_index).delete_prefix("ot=") if otel_index
+
+            new(
+              unknown_vendors: vendors.empty? ? nil : vendors.join(","),
+              datadog: Datadog.from_tracestate_member(datadog_value),
+              open_telemetry: OpenTelemetry.from_tracestate_member(otel_value),
+            )
+          end
+
+          # Partial members must not be propagated, but complete members within the limits are retained.
+          def split(tracestate)
+            return if tracestate.nil? || tracestate.empty?
+
+            remove_last_vendor = false
+            if tracestate.bytesize > Ext::TRACESTATE_MAX_SIZE_LIMIT
+              remove_last_vendor = tracestate.byteslice(Ext::TRACESTATE_MAX_SIZE_LIMIT, 1) != ","
+              tracestate = tracestate.byteslice(0, Ext::TRACESTATE_MAX_SIZE_LIMIT + 1) #: String
+              tracestate = tracestate.chop
+            end
+
+            tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
+            return unless tracestate
+
+            vendors = tracestate.split(",", Ext::TRACESTATE_MAX_LIST_VENDORS + 1)
+            vendors.pop if vendors.length > Ext::TRACESTATE_MAX_LIST_VENDORS || remove_last_vendor
+            vendors.each(&:strip!)
+            vendors.pop while vendors.last == ""
+            vendors
+          end
+
+          private
+
+          def serialize(unknown_vendors:, datadog:, open_telemetry:)
+            leading_vendors = select_leading_vendors(datadog, open_telemetry)
+            vendors = split(unknown_vendors)
+
+            if leading_vendors.empty?
+              return unless vendors && !vendors.empty?
+
+              return vendors.join(",")
+            end
+
+            vendors&.reject! { |vendor| vendor.start_with?("dd=", "ot=") }
+
+            tracestate = leading_vendors.join(",")
+            if vendors && !vendors.empty?
+              vendors.first(Ext::TRACESTATE_MAX_LIST_VENDORS - leading_vendors.size).each do |vendor|
+                break if tracestate.bytesize + vendor.bytesize + 1 > Ext::TRACESTATE_MAX_SIZE_LIMIT
+
+                tracestate << "," << vendor
+              end
+            end
+
+            tracestate
+          end
+
+          def select_leading_vendors(datadog, open_telemetry)
+            leading_vendors = []
+            add_leading_vendor(leading_vendors, datadog)
+            add_leading_vendor(leading_vendors, open_telemetry)
+
+            leading_vendors
+          end
+
+          def add_leading_vendor(leading_vendors, state)
+            vendor = state.to_s
+            return if vendor.empty?
+
+            combined_size = leading_vendors.sum { |current| current.bytesize } +
+              leading_vendors.size + vendor.bytesize
+            leading_vendors << vendor if combined_size <= Ext::TRACESTATE_MAX_SIZE_LIMIT
+          end
+        end
+
+        attr_reader :unknown_vendors, :datadog, :open_telemetry
+
+        def initialize(unknown_vendors: nil, datadog: nil, open_telemetry: nil)
+          @unknown_vendors = unknown_vendors
+          @datadog = datadog || Datadog.new
+          @open_telemetry = open_telemetry || OpenTelemetry.new
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/otel_thread_context.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    # Publishes a per-thread OpenTelemetry context record into a thread-local slot,
+    # so an out-of-process reader (e.g. the eBPF profiler) can discover it.
+    #
+    # See the "OTel Thread Context" OTEP:
+    # https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/profiles/4947-thread-ctx.md
+    #
+    # Native functions are implemented in ext/libdatadog_api/otel_thread_context.c
+    module OTelThreadContext
+      class << self
+        def supported?
+          Datadog::Core::LIBDATADOG_API_FAILURE.nil? && _native_supported?
+        end
+
+        def enable!
+          return false unless supported?
+
+          _native_enable
+        end
+
+        def set(trace_id:, span_id:, local_root_span_id:)
+          _native_set(trace_id, span_id, local_root_span_id)
+        end
+
+        def clear
+          _native_clear
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/remote.rb

@@ -15,22 +15,198 @@ 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
+          1 << 45, # APM_TRACING_MULTICONFIG: merge multiple org/env-level APM_TRACING configs
           # 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
 
+        # Diagnostic scope label per specificity priority.
+        SCOPE_LABELS = {
+          5 => "service+env",
+          4 => "service",
+          3 => "env",
+          2 => "cluster",
+          1 => "org",
+        }.freeze
+
+        # @return [Array[String]] the remote config products this module handles
         def products
           [PRODUCT]
         end
 
+        # @return [Array[Integer]] the remote config capability bits advertised
         def capabilities
           CAPABILITIES
         end
 
-        def process_config(config, content, repository = nil)
-          lib_config = config["lib_config"]
+        # Merges every active APM_TRACING config in the repository and applies the
+        # result once. Org/env-level (multi-config) remote enablement delivers
+        # several APM_TRACING configs in parallel (a (service, env)-specific one,
+        # an env-wide one, and/or an org-wide "*" one); for each lib_config field
+        # the value from the most-specific matching config wins. The RC repository
+        # prunes deleted configs, so this recomputes the merge from the repository's
+        # current contents on each dispatch.
+        #
+        # @param repository [Core::Remote::Configuration::Repository] the current RC repository
+        # @return [nil]
+        def merge_and_apply_configs(repository)
+          # Resolve the service identity the same way the RC client registers
+          # it with the backend (Core::Remote::Client#service_name =
+          # remote.service || service). When a customer sets remote.service,
+          # the backend delivers service_target.service values targeting that
+          # override; matching against the local service instead would drop
+          # every service-scoped config and let a less-specific org config win.
+          service = Datadog.configuration.remote.service || Datadog.configuration.service
+          env = Datadog.configuration.env
+
+          # @type var parsed: Array[[::Datadog::Core::Remote::Configuration::Content, ::Hash[::String, untyped]]]
+          parsed = []
+          repository.contents.each do |content|
+            next unless content.path.product == PRODUCT
+
+            begin
+              config = parse_content(content)
+              unless config.is_a?(Hash)
+                # A syntactically valid but non-object payload (null, [], 42)
+                # would later make config_matches? raise outside this per-content
+                # rescue and abort the whole merge, erroring valid configs too.
+                raise TypeError, "APM_TRACING remote config must be a JSON object, got #{config.class}"
+              end
+              # A present but non-object lib_config (e.g. {"lib_config": []}) is a
+              # schema violation the customer can fix. Acknowledging it as applied
+              # would tell the backend the config was successfully applied when it
+              # was not, and an empty merge would revert active tracing overrides
+              # to their non-RC values. Reject it per content so the malformed
+              # payload is reported errored instead. A null or absent lib_config
+              # carries no overrides and is left as a no-op.
+              lib_config = config["lib_config"]
+              if !lib_config.nil? && !lib_config.is_a?(Hash)
+                raise TypeError, "APM_TRACING lib_config must be a JSON object, got #{lib_config.class}"
+              end
+              parsed << [content, config]
+            rescue => e
+              Datadog.logger.debug { "APM_TRACING RC: skipping unparseable config: #{e.class}: #{e.message}" }
+              Datadog.send(:components, allow_initialization: false)&.telemetry&.report(
+                e,
+                description: "Failed to parse APM_TRACING remote config",
+              )
+              content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
+            end
+          end
+
+          Datadog.logger.debug { "APM_TRACING RC: received #{parsed.length} config(s)" }
+
+          applicable = parsed.select do |content, config|
+            if config_matches?(config, service, env)
+              Datadog.logger.debug do
+                "APM_TRACING RC: config #{content.path.config_id} " \
+                  "scope=#{SCOPE_LABELS[config_priority(config)]} priority=#{config_priority(config)}"
+              end
+              true
+            else
+              Datadog.logger.debug do
+                "APM_TRACING RC: dropped config #{content.path.config_id} " \
+                  "(service_target=#{config["service_target"].inspect}, self=#{service}/#{env})"
+              end
+              false
+            end
+          end
+
+          # Most-specific first; ties broken by config id (ascending) for a
+          # deterministic merge.
+          ordered = applicable.sort_by { |content, config| [-config_priority(config), content.path.config_id] }
+          merged = merge_lib_configs(ordered.map { |_content, config| config })
+
+          # Applied even when the set is empty: an emptied repository (last config
+          # removed) reverts the tracing overrides to their non-RC values.
+          apply_lib_config(merged, repository)
+
+          parsed.each { |content, _config| content.applied }
+          nil
+        rescue => e
+          Datadog.logger.debug { "APM_TRACING RC: failed to apply configs: #{e.class}: #{e.message}" }
+          Datadog.send(:components, allow_initialization: false)&.telemetry&.report(
+            e,
+            description: "Failed to apply APM_TRACING remote configs",
+          )
+          parsed&.each do |content, _config|
+            content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
+          end
+          nil
+        end
 
+        # Whether a config targets this tracer. A concrete (non-"*") service or
+        # env that differs from ours excludes the config; "*" and an absent
+        # service_target match anything.
+        #
+        # @param config [Hash[String, untyped]] a parsed config
+        # @param service [String, nil] this tracer's service
+        # @param env [String, nil] this tracer's env
+        # @return [bool] true when the config applies to this tracer
+        def config_matches?(config, service, env)
+          target = config["service_target"]
+          return true unless target.is_a?(Hash)
+
+          target_service = target["service"]
+          target_env = target["env"]
+          return false if target_service && target_service != "*" && target_service != service
+          return false if target_env && target_env != "*" && target_env != env
+
+          true
+        end
+
+        # Specificity of a config, higher meaning more specific: service+env (5),
+        # service (4), env (3), cluster (2), org (1). A target counts as concrete
+        # only when present and not "*".
+        #
+        # @param config [Hash[String, untyped]] a parsed config
+        # @return [Integer] the specificity rank, 1 through 5
+        def config_priority(config)
+          target = config["service_target"]
+          service = target.is_a?(Hash) ? target["service"] : nil
+          env = target.is_a?(Hash) ? target["env"] : nil
+          single_service = !service.nil? && service != "*"
+          single_env = !env.nil? && env != "*"
+
+          return 5 if single_service && single_env
+          return 4 if single_service
+          return 3 if single_env
+          return 2 unless config["k8s_target_v2"].nil?
+
+          1
+        end
+
+        # Merges lib_configs from configs ordered most-specific first: for each
+        # field, the first (most-specific) non-nil value wins. Fields are
+        # independent, so a lower-priority config can supply a field the
+        # higher-priority one omits.
+        #
+        # @param configs_most_specific_first [Array[Hash[String, untyped]]] configs, most-specific first
+        # @return [Hash[String, untyped]] the merged lib_config
+        def merge_lib_configs(configs_most_specific_first)
+          merged = {}
+          configs_most_specific_first.each do |config|
+            lib_config = config["lib_config"]
+            next unless lib_config.is_a?(Hash)
+
+            lib_config.each do |key, value|
+              next if value.nil?
+
+              merged[key] = value unless merged.key?(key)
+            end
+          end
+          merged
+        end
+
+        # Applies one lib_config: maps the dynamic OPTIONS to telemetry, drives DI
+        # enablement from "dynamic_instrumentation_enabled", and reports the
+        # configuration change to telemetry.
+        #
+        # @param lib_config [Hash[String, untyped]] the lib_config to apply
+        # @param repository [Core::Remote::Configuration::Repository, nil] forwarded to DI enablement
+        # @return [nil]
+        def apply_lib_config(lib_config, repository)
           env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
             value = lib_config[name]
 
@@ -55,11 +231,11 @@ module Datadog
             if di_enabled
               components&.symbol_database&.resume_pending_upload
               # Advertise the DI products only if the component actually started.
-              # handle_rc_enablement above no-ops when DI cannot run — the
-              # component is nil on an unsupported runtime, or the enable signal
-              # is blocked by DD_DYNAMIC_INSTRUMENTATION_ENABLED=false. Advertising
-              # then would report DI as in use when it is not and invite probe
-              # configs the tracer must refuse; withdraw the products otherwise.
+              # handle_rc_enablement above no-ops when DI cannot run: the component
+              # is nil on an unsupported runtime, or the enable signal is blocked
+              # by DD_DYNAMIC_INSTRUMENTATION_ENABLED=false. Advertising then would
+              # report DI as in use when it is not and invite probe configs the
+              # tracer must refuse; withdraw the products otherwise.
               if components&.dynamic_instrumentation&.started?
                 components&.remote&.add_products(*di_products)
               else
@@ -69,33 +245,25 @@ module Datadog
               components&.symbol_database&.stop_for_di_disable
               components&.remote&.remove_products(*di_products)
             end
-          end
 
-          content.applied
+            Datadog.logger.debug { "APM_TRACING RC: merged dynamic_instrumentation_enabled=#{di_enabled}" }
+          end
 
-          # 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.
+          # allow_initialization: false because this runs on the remote-config
+          # worker thread. If components haven't been built yet (e.g. during a
+          # teardown/reset window), the default value 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")}")
+          nil
         end
 
+        # @param _telemetry [Core::Telemetry::Component] unused; kept for the receiver contract
+        # @return [Array[Core::Remote::Dispatcher::Receiver]] the APM_TRACING receiver
         def receivers(_telemetry)
           receiver do |repository, _changes|
-            # DEV: Filter our by product. Given it will be very common
-            # DEV: we can filter this out before we receive the data in this method.
-            # DEV: Apply this refactor to AppSec as well if implemented.
-            repository.contents.map do |content|
-              case content.path.product
-              when PRODUCT
-                config = parse_content(content)
-                process_config(config, content, repository)
-              end
-            end
+            merge_and_apply_configs(repository)
           end
         end
 

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -192,6 +192,8 @@ module Datadog
 
         def reconsider_matching_rule!(trace, rule)
           trace.agent_sample_rate = nil
+          # Avoid mistaking a reconsidered probabilistic drop for a limiter drop.
+          trace.rate_limiter_rate = nil
           trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
           apply_rule!(trace, rule)
         end

data/lib/datadog/tracing/trace_digest.rb

@@ -72,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
@@ -83,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>]
@@ -109,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
 
@@ -133,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
       )
@@ -156,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
@@ -188,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
         )