datadog 2.39.0 → 2.47.0

data/lib/datadog/symbol_database/extractor.rb

@@ -43,7 +43,7 @@ module Datadog
     #    These are expected failures — no logging needed.
     #
     # 2. **Method-level rescues** (`rescue => e` with logging):
-    #    Catch failures in extract_method_scope, find_source_file, etc. Log at debug
+    #    Catch failures in build_class_method_scopes, find_source_file, etc. Log at debug
     #    for post-hoc diagnosis, return nil or empty array. One bad method/module
     #    doesn't kill the entire class extraction.
     #
@@ -133,16 +133,16 @@ module Datadog
         return nil unless Module === mod
         mod_name = safe_mod_name(mod)
         return nil unless mod_name
-
-        return nil unless user_code_module?(mod)
+        return nil unless user_code_module_name?(mod)
 
         source_file = find_source_file(mod)
         return nil unless source_file
+        return nil unless user_code_path?(source_file)
 
         inner_scope = if Class === mod
-          extract_class_scope(mod)
+          extract_class_scope(mod, source_file)
         else
-          extract_module_scope(mod)
+          extract_module_scope(mod, source_file)
         end
 
         wrap_in_file_scope(source_file, [inner_scope])
@@ -275,10 +275,12 @@ module Datadog
         false
       end
 
-      # Check if module is from user code (not gems or stdlib)
-      # @param mod [Module] The module to check
-      # @return [Boolean] true if user code
-      def user_code_module?(mod)
+      # Return whether +mod+ passes the name-based user-code exclusions
+      # (named, outside Datadog, not a Ruby root class). Does not resolve
+      # a source file.
+      # @param mod [Module]
+      # @return [Boolean]
+      def user_code_module_name?(mod)
         mod_name = safe_mod_name(mod)
         return false unless mod_name
 
@@ -297,6 +299,15 @@ module Datadog
         return false if mod.equal?(Object) || mod.equal?(BasicObject) ||
           mod.equal?(Kernel) || mod.equal?(Module) || mod.equal?(Class)
 
+        true
+      end
+
+      # Check if module is from user code (not gems or stdlib)
+      # @param mod [Module] The module to check
+      # @return [Boolean] true if user code
+      def user_code_module?(mod)
+        return false unless user_code_module_name?(mod)
+
         source_file = find_source_file(mod)
         return false unless source_file
 
@@ -331,6 +342,25 @@ module Datadog
         true
       end
 
+      # Resolve the UnboundMethod +mod+ itself declares for +method_name+,
+      # skipping prepended wrapper modules (e.g. a DI method-logpoint wrapper)
+      # that shadow it.
+      #
+      # @param mod [Module] Module or class expected to declare the method
+      # @param method_name [Symbol] Name of the method to resolve
+      # @return [UnboundMethod] Method whose owner is +mod+, or the
+      #   prepend-resolved method when +mod+ owns no method in the super chain
+      def declared_instance_method(mod, method_name)
+        original_method = mod.instance_method(method_name)
+        method = original_method
+        until method.owner.equal?(mod)
+          super_method = method.super_method
+          return original_method unless super_method
+          method = super_method
+        end
+        method
+      end
+
       # Find source file for a module.
       # Prefers user code paths over gem/stdlib paths. ActiveRecord models have
       # generated methods (autosave callbacks) whose source is in the gem, but
@@ -349,7 +379,7 @@ module Datadog
 
         # Try instance methods first
         mod.instance_methods(false).each do |method_name|
-          method = mod.instance_method(method_name)
+          method = declared_instance_method(mod, method_name)
           location = method.source_location
           next unless location
 
@@ -357,10 +387,15 @@ module Datadog
           return path if user_code_path?(path)
 
           fallback ||= path # steep:ignore
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
+          @logger.debug { "symdb: error resolving #{safe_mod_name(mod)}##{method_name}: #{e.class}: #{e.message}" }
         end
 
         # Try singleton methods
         mod.singleton_methods(false).each do |method_name|
+          # Method-logpoint probes prepend instance methods only, so singleton
+          # methods are never shadowed by a DI wrapper.
           method = mod.method(method_name)
           location = method.source_location
           next unless location
@@ -369,6 +404,9 @@ module Datadog
           return path if user_code_path?(path)
 
           fallback ||= path # steep:ignore
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
+          @logger.debug { "symdb: error resolving #{safe_mod_name(mod)}.#{method_name}: #{e.class}: #{e.message}" }
         end
 
         # Use const_source_location to find where this class/module is declared.
@@ -460,10 +498,9 @@ module Datadog
       # Extract MODULE scope (without file_hash — that belongs on the FILE root scope).
       # Does not include nested classes — nesting is handled by extract_all via FQN splitting.
       # @param mod [Module] The module
+      # @param source_file [String] Source file resolved by the caller
       # @return [Scope] The module scope
-      def extract_module_scope(mod)
-        source_file = find_source_file(mod)
-
+      def extract_module_scope(mod, source_file)
         Scope.new(
           scope_type: "MODULE",
           name: safe_mod_name(mod),
@@ -476,11 +513,11 @@ module Datadog
 
       # Extract CLASS scope
       # @param klass [Class] The class
+      # @param source_file [String] Source file resolved by the caller
       # @return [Scope] The class scope
-      def extract_class_scope(klass)
-        methods = klass.instance_methods(false)
-        start_line, end_line = calculate_class_line_range(klass, methods)
-        source_file = find_source_file(klass)
+      def extract_class_scope(klass, source_file)
+        method_scopes = build_class_method_scopes(klass)
+        start_line, end_line = line_range_from_scopes(method_scopes)
 
         Scope.new(
           scope_type: "CLASS",
@@ -489,36 +526,20 @@ module Datadog
           start_line: start_line,
           end_line: end_line,
           language_specifics: build_class_language_specifics(klass),
-          scopes: extract_method_scopes(klass),
+          scopes: method_scopes,
           symbols: extract_scope_symbols(klass)
         )
       end
 
-      # Calculate class line range from method locations.
-      # Start from the earliest method start, end at the latest method end (derived
-      # from iseq trace_points so methods spanning multiple lines aren't truncated).
-      # @param klass [Class] The class
-      # @param methods [Array<Symbol>] Method names
+      # Derive a [start_line, end_line] range from method scopes, ignoring
+      # UNKNOWN sentinel values. The end is the max of method end_lines so a
+      # multi-line method's last line is not truncated to its start_line.
+      # @param method_scopes [Array<Scope>]
       # @return [Array<Integer, Integer>] [start_line, end_line]
-      def calculate_class_line_range(klass, methods)
-        starts = []
-        ends = []
-        methods.each do |method_name|
-          method = klass.instance_method(method_name)
-          location = method.source_location
-          next unless location && location[0]
-          starts << location[1]
-          _ranges, method_end = extract_targetable_lines(method, location[1])
-          ends << method_end
-        end
-
-        return [UNKNOWN_MIN_LINE, UNKNOWN_MAX_LINE] if starts.empty?
-
-        [starts.min, ends.max]
-      rescue Exception => e # standard:disable Lint/RescueException
-        Datadog::DI.reraise_if_fatal(e)
-        @logger.debug { "symdb: error calculating line range for #{safe_mod_name(klass)}: #{e.class}: #{e.message}" }
-        [UNKNOWN_MIN_LINE, UNKNOWN_MAX_LINE]
+      def line_range_from_scopes(method_scopes)
+        starts = method_scopes.map(&:start_line).reject { |line| line == UNKNOWN_MIN_LINE }
+        ends = method_scopes.map(&:end_line).reject { |line| line == UNKNOWN_MAX_LINE }
+        [starts.min || UNKNOWN_MIN_LINE, ends.max || UNKNOWN_MAX_LINE]
       end
 
       # Build language specifics for CLASS
@@ -566,66 +587,33 @@ module Datadog
         {}
       end
 
-      # Extract method scopes from a class
-      # @param klass [Class] The class
-      # @return [Array<Scope>] Method scopes
-      def extract_method_scopes(klass)
-        scopes = []
-
-        # Get all instance methods (public, protected, private)
-        all_instance_methods = klass.instance_methods(false) +
+      # Build a METHOD scope for each user-code instance method +klass+
+      # declares.
+      # @param klass [Class]
+      # @return [Array<Scope>]
+      def build_class_method_scopes(klass)
+        method_names = (klass.instance_methods(false) +
           klass.protected_instance_methods(false) +
-          klass.private_instance_methods(false)
-        all_instance_methods.uniq!
+          klass.private_instance_methods(false)).uniq
 
-        all_instance_methods.each do |method_name|
-          method_scope = extract_method_scope(klass, method_name, :instance)
-          scopes << method_scope if method_scope
-        end
+        Core::Utils::EnumerableCompat.filter_map(method_names) do |method_name|
+          method = declared_instance_method(klass, method_name)
+          location = method.source_location
+          next unless location
+          next unless user_code_path?(location[0])
 
-        scopes
+          build_instance_method_scope(klass, method_name, method)
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
+          @logger.debug { "symdb: error resolving #{safe_mod_name(klass)}##{method_name}: #{e.class}: #{e.message}" }
+          nil
+        end
       rescue Exception => e # standard:disable Lint/RescueException
         Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: failed to extract methods from #{safe_mod_name(klass)}: #{e.class}: #{e.message}" }
         []
       end
 
-      # Extract a single method scope
-      # @param klass [Class] The class
-      # @param method_name [Symbol] Method name
-      # @param method_type [Symbol] :instance or :class
-      # @return [Scope, nil] Method scope or nil
-      def extract_method_scope(klass, method_name, method_type)
-        method = klass.instance_method(method_name)
-        location = method.source_location
-
-        return nil unless location  # Skip methods without source location
-
-        source_file, line = location
-        return nil unless user_code_path?(source_file)  # Skip gem/stdlib methods
-
-        targetable_lines, end_line = extract_targetable_lines(method, line)
-
-        Scope.new(
-          scope_type: "METHOD",
-          name: method_name.to_s,
-          source_file: source_file,
-          start_line: line,
-          end_line: end_line,
-          targetable_lines: targetable_lines,
-          language_specifics: {
-            visibility: method_visibility(klass, method_name),
-            method_type: method_type.to_s,
-            arity: method.arity
-          },
-          symbols: extract_method_parameters(method)
-        )
-      rescue Exception => e # standard:disable Lint/RescueException
-        Datadog::DI.reraise_if_fatal(e)
-        @logger.debug { "symdb: failed to extract method #{safe_mod_name(klass)}##{method_name}: #{e.class}: #{e.message}" }
-        nil
-      end
-
       # Get method visibility
       # @param klass [Class] The class
       # @param method_name [Symbol] Method name
@@ -647,7 +635,7 @@ module Datadog
       # @param start_line [Integer] Fallback end_line if iseq unavailable
       # @return [Array(Array<Hash>, Integer), Array(nil, Integer)]
       def extract_targetable_lines(method, start_line)
-        iseq = RubyVM::InstructionSequence.of(method) # steep:ignore
+        iseq = RubyVM::InstructionSequence.of(method)
         unless iseq
           @logger.debug { "symdb: no iseq for #{method.name} (C extension or native), skipping targetable lines" }
           return [nil, start_line]
@@ -801,14 +789,14 @@ module Datadog
       # objects allocated to read `source_location` are not retained between
       # passes, so they can be GC'd as soon as the inner loop ends.
       def collect_method_names_by_file(mod)
-        result = Hash.new { |h, k| h[k] = [] } # steep:ignore
+        result = Hash.new { |h, k| h[k] = [] }
 
         # Module#instance_methods(false) already returns both public and protected
         # methods, so iterating it plus private_instance_methods covers all three
         # visibilities without an intermediate merged array.
         [mod.instance_methods(false), mod.private_instance_methods(false)].each do |method_names|
           method_names.each do |method_name|
-            method = mod.instance_method(method_name)
+            method = declared_instance_method(mod, method_name)
             loc = method.source_location
             next unless loc
             next unless user_code_path?(loc[0])
@@ -852,7 +840,7 @@ module Datadog
           # live only as long as the tree node holds them; they are released when
           # convert_tree_to_scope finishes building the file's Scope.
           method_infos = Core::Utils::EnumerableCompat.filter_map(method_names) do |name|
-            method = mod.instance_method(name)
+            method = declared_instance_method(mod, name)
             # Pass 1 (build_per_file_index) recorded this method under file_path.
             # If the method has been redefined in another file between the two
             # passes (e.g. a class reopened during a Rails reload while extract_all
@@ -905,7 +893,7 @@ module Datadog
           current[:children][part] ||= {
             name: fqn, type: resolve_scope_type(fqn),
             children: {}, methods: [], mod: nil,
-            source_file: file_path, fqn: fqn
+            source_file: file_path, fqn: fqn,
           }
           current = current[:children][part]
         end
@@ -924,7 +912,7 @@ module Datadog
             type: (Class === mod) ? "CLASS" : "MODULE",
             children: {}, methods: [],
             mod: mod, source_file: file_path,
-            fqn: mod_name
+            fqn: mod_name,
           }
           current[:children][leaf_name] = leaf
         end
@@ -989,13 +977,7 @@ module Datadog
         # Recurse into child scopes (nested modules/classes)
         child_scopes = node[:children].values.map { |child| convert_node_to_scope(child) }
 
-        # Compute line range: start from the earliest method start, end at the latest
-        # method end. Using max(start_line) would underreport the class's end_line for
-        # classes whose last method spans multiple lines.
-        starts = method_scopes.map(&:start_line).reject { |l| l == UNKNOWN_MIN_LINE } # steep:ignore
-        ends = method_scopes.map(&:end_line).reject { |l| l == UNKNOWN_MAX_LINE } # steep:ignore
-        start_line = starts.empty? ? UNKNOWN_MIN_LINE : starts.min
-        end_line = ends.empty? ? UNKNOWN_MAX_LINE : ends.max
+        start_line, end_line = line_range_from_scopes(method_scopes)
 
         # Extract symbols (constants, class variables) if we have the actual module object
         symbols = node[:mod] ? extract_scope_symbols(node[:mod]) : []
@@ -1043,7 +1025,7 @@ module Datadog
           language_specifics: {
             visibility: klass ? method_visibility(klass, method_name) : "public", # steep:ignore
             method_type: "instance",
-            arity: method.arity
+            arity: method.arity,
           },
           symbols: extract_method_parameters(method)
         )

data/lib/datadog/tracing/component.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "otel_thread_context"
 require_relative "tracer"
 require_relative "flush"
 require_relative "sync_writer"
@@ -20,14 +21,14 @@ module Datadog
         tracer = settings.tracing.instance
         return tracer unless tracer.nil?
 
+        sampler = build_sampler(settings)
+
         # Apply test mode settings if test mode is activated
         if settings.tracing.test_mode.enabled
           trace_flush = build_test_mode_trace_flush(settings)
-          sampler = build_test_mode_sampler
           writer = build_test_mode_writer(settings, agent_settings)
         else
           trace_flush = build_trace_flush(settings)
-          sampler = build_sampler(settings)
           writer = build_writer(settings, agent_settings)
         end
 
@@ -42,6 +43,7 @@ module Datadog
           default_service: settings.service,
           enabled: settings.tracing.enabled,
           logger: logger,
+          otel_thread_context: OTelThreadContext.build(settings.tracing),
           trace_flush: trace_flush,
           sampler: sampler_delegator,
           span_sampler: build_span_sampler(settings),
@@ -60,7 +62,26 @@ module Datadog
         end
       end
 
+      def bind_transport_telemetry(tracer, telemetry)
+        return unless tracer.is_a?(Tracing::Tracer)
+
+        writer = tracer.writer
+        return unless writer.respond_to?(:transport)
+
+        transport = writer.transport
+        if transport.is_a?(Transport::Traces::Transport) ||
+            (defined?(Transport::Native::Transport) && transport.is_a?(Transport::Native::Transport))
+          transport.telemetry = telemetry
+        end
+        nil
+      end
+
+      # Builds the sampler for the given settings: the sampler that keeps
+      # every trace when test mode is enabled, otherwise the sampler built
+      # from the custom sampler, sampling rules and rates.
       def build_sampler(settings)
+        return build_test_mode_sampler if settings.tracing.test_mode.enabled
+
         # A custom sampler is provided
         if (sampler = settings.tracing.sampler)
           return sampler
@@ -104,9 +125,30 @@ module Datadog
           return writer
         end
 
+        if !options.key?(:transport) && settings.tracing.native_transport && (transport = build_native_transport(agent_settings))
+          options = options.merge(transport: transport)
+        end
+
         Tracing::Writer.new(agent_settings: agent_settings, **options)
       end
 
+      def build_native_transport(agent_settings)
+        require_relative "transport/native"
+
+        unless Transport::Native.supported?
+          Datadog.logger.warn(
+            "Native transport requested but not available: #{Transport::Native::UNSUPPORTED_REASON}. " \
+            "Falling back to default HTTP transport."
+          )
+          return nil
+        end
+
+        Transport::Native::Transport.new(
+          agent_settings: agent_settings,
+          logger: Datadog.logger
+        )
+      end
+
       def subscribe_to_writer_events!(writer, sampler_delegator, test_mode)
         return unless writer.respond_to?(:events) # Check if it's a custom, external writer
 

data/lib/datadog/tracing/configuration/dynamic/option.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../../core/telemetry/configuration_value"
+
 module Datadog
   module Tracing
     module Configuration
@@ -56,6 +58,8 @@ module Datadog
                 precedence: Core::Configuration::Option::Precedence::REMOTE_CONFIGURATION
               )
             end
+
+            Core::Telemetry::ConfigurationValue.convert(value)
           end
 
           protected

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

@@ -24,11 +24,11 @@ module Datadog
           def call(tracing_header_tags)
             # Modify the remote configuration value that it matches the
             # environment variable it configures.
-            tracing_header_tags&.map! do |hash|
+            parsed_header_tags = tracing_header_tags&.map do |hash|
               "#{hash["header"]}:#{hash["tag_name"]}"
             end
 
-            super
+            super(parsed_header_tags)
           end
         end
 
@@ -42,6 +42,7 @@ module Datadog
           def call(tracing_sampling_rate)
             super
             Datadog.send(:components).reconfigure_sampler
+            tracing_sampling_rate
           end
 
           protected
@@ -78,8 +79,9 @@ module Datadog
               tracing_sampling_rules = tracing_sampling_rules.to_json
             end
 
-            super
+            telemetry_value = super
             Datadog.send(:components).reconfigure_sampler
+            telemetry_value
           end
 
           protected

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

@@ -13,9 +13,11 @@ module Datadog
         ENV_BAGGAGE_TAG_KEYS = "DD_TRACE_BAGGAGE_TAG_KEYS"
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = "DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED"
         ENV_NATIVE_SPAN_EVENTS = "DD_TRACE_NATIVE_SPAN_EVENTS"
+        ENV_OTEL_CONTEXT_ENABLED = "DD_TRACE_OTEL_CTX_ENABLED"
         ENV_RESOURCE_RENAMING_ENABLED = "DD_TRACE_RESOURCE_RENAMING_ENABLED"
         ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = "DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT"
         ENV_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED"
+        ENV_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED = "DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED"
 
         # @public_api
         module SpanAttributeSchema
@@ -126,6 +128,8 @@ module Datadog
           ENV_SERVER_ERROR_STATUSES = "DD_TRACE_HTTP_SERVER_ERROR_STATUSES"
           ENV_CLIENT_ERROR_STATUSES = "DD_TRACE_HTTP_CLIENT_ERROR_STATUSES"
         end
+
+        ENV_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE = "DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE"
       end
     end
   end

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

@@ -2,6 +2,7 @@
 
 require_relative "../../tracing/configuration/ext"
 require_relative "../../core/environment/variable_helpers"
+require_relative "../../ruby_version"
 require_relative "../contrib/status_range_matcher"
 require_relative "../contrib/status_range_env_parser"
 require_relative "http"
@@ -255,6 +256,14 @@ module Datadog
                 o.type :bool
               end
 
+              option :otel_thread_context_enabled do |o|
+                o.env Tracing::Configuration::Ext::ENV_OTEL_CONTEXT_ENABLED
+                o.default do
+                  RUBY_ENGINE == "ruby" && RUBY_PLATFORM.include?("linux")
+                end
+                o.type :bool
+              end
+
               # Configures an alternative trace transport behavior, where
               # traces can be sent to the agent and backend before all spans
               # have finished.
@@ -482,6 +491,22 @@ module Datadog
                 end
               end
 
+              # Use the native trace transport (Rust via C FFI) instead of
+              # the default pure-Ruby HTTP transport.
+              #
+              # The native transport delegates serialization, stats
+              # computation, and HTTP sending to the Rust data pipeline.
+              #
+              # This option is recommended for internal use only.
+              #
+              # @default `true` on CRuby 4.0.0 and later, otherwise `false`
+              # @return [Boolean]
+              option :native_transport do |o|
+                o.env Configuration::Ext::ENV_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED
+                o.default { RUBY_ENGINE == "ruby" && RubyVersion.is?(">= 4.0.0") }
+                o.type :bool
+              end
+
               # A custom writer instance.
               # The object must respect the {Datadog::Tracing::Writer} interface.
               #
@@ -543,6 +568,17 @@ module Datadog
                 o.default 512
               end
 
+              # Whether outbound HTTP client resource names include a quantized request path.
+              # URL tags and outgoing requests are unchanged.
+              #
+              # @default `DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE` environment variable, otherwise `false`.
+              # @return [Boolean]
+              option :http_client_resource_name_quantize do |o|
+                o.env Tracing::Configuration::Ext::ENV_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE
+                o.default false
+                o.type :bool
+              end
+
               # HTTP error statuses configuration
               # @public_api
               settings :http_error_statuses do

data/lib/datadog/tracing/context.rb

@@ -20,9 +20,15 @@ module Datadog
       attr_reader \
         :active_trace
 
+      attr_writer \
+        :otel_thread_context
+
       def initialize(
-        trace: nil
+        trace: nil,
+        otel_thread_context: nil
       )
+        @otel_thread_context = otel_thread_context
+        @active_trace = nil
         activate!(trace)
       end
 
@@ -54,14 +60,30 @@ module Datadog
       # Creates a copy of the context, when forked.
       def fork_clone
         forked_trace = @active_trace&.fork_clone
-        self.class.new(trace: forked_trace)
+
+        self.class.new(
+          trace: forked_trace,
+          otel_thread_context: @otel_thread_context
+        )
       end
 
       private
 
       def set_active_trace!(trace)
+        previous_trace = @active_trace
+
         # Don't retain finished traces
         @active_trace = (trace && !trace.finished?) ? trace : nil
+
+        return @active_trace if previous_trace == @active_trace
+
+        if @active_trace
+          @otel_thread_context&.update_from_trace_op(@active_trace)
+        elsif previous_trace
+          @otel_thread_context&.clear
+        end
+
+        @active_trace
       end
     end
   end

data/lib/datadog/tracing/context_provider.rb

@@ -12,12 +12,23 @@ module Datadog
     # @see https://ruby-doc.org/core-3.1.2/Thread.html#method-i-5B-5D Thread attributes are fiber-local
     class DefaultContextProvider
       # Initializes the default context provider with a fiber-bound context.
-      def initialize
-        @context = FiberLocalContext.new
+      def initialize(otel_thread_context: nil)
+        @otel_thread_context = otel_thread_context
+        @context = FiberLocalContext.new(otel_thread_context: otel_thread_context)
       end
 
       # Sets the current context.
       def context=(ctx)
+        ctx.otel_thread_context = @otel_thread_context if ctx.respond_to?(:otel_thread_context=)
+
+        if (otel_thread_context = @otel_thread_context)
+          if (trace = ctx&.active_trace)
+            otel_thread_context.update_from_trace_op(trace)
+          else
+            otel_thread_context.clear
+          end
+        end
+
         @context.local = ctx
       end
 
@@ -48,10 +59,11 @@ module Datadog
     class FiberLocalContext
       # To support multiple tracers simultaneously, each {Datadog::Tracing::FiberLocalContext}
       # instance has its own fiber-local variable.
-      def initialize
+      def initialize(otel_thread_context: nil)
+        @otel_thread_context = otel_thread_context
         @key = :"datadog_context_#{FiberLocalContext.next_instance_id}"
 
-        self.local = Context.new
+        self.local = Context.new(otel_thread_context: otel_thread_context)
       end
 
       # Override the fiber-local context with a new context.
@@ -61,7 +73,7 @@ module Datadog
 
       # Return the fiber-local context.
       def local(storage = Thread.current)
-        storage[@key] ||= Context.new
+        storage[@key] ||= Context.new(otel_thread_context: @otel_thread_context)
       end
 
       # Ensure two instances of {FiberLocalContext} do not conflict.