datadog 2.43.0 → 2.44.0

data/lib/datadog/open_feature/configuration.rb

@@ -5,6 +5,25 @@ module Datadog
     module Configuration
       # A settings class for the OpenFeature component.
       module Settings
+        DEFAULT_POLL_INTERVAL_SECONDS = 30
+        DEFAULT_REQUEST_TIMEOUT_SECONDS = 5
+        DEFAULT_INITIALIZATION_TIMEOUT_MS = 30_000
+
+        MAX_REQUEST_TIMEOUT_SECONDS = 300
+        MAX_INITIALIZATION_TIMEOUT_MS = 2_147_483_647
+
+        def self.configure_integer_option(option, environment_variable:, default:, setting_name:)
+          option.type :int
+          option.env environment_variable
+          option.env_parser do |value|
+            Integer(value, 10)
+          rescue ArgumentError
+            Datadog.logger.warn("#{setting_name} must be an integer; using the default")
+            default
+          end
+          option.default default
+        end
+
         def self.extended(base)
           base = base.singleton_class unless base.is_a?(Class)
           add_settings!(base)
@@ -15,10 +34,19 @@ module Datadog
             # Steep does not update `self` for this `class_eval` block.
             # @type self: Datadog::Core::Configuration::Base::_DslContext
             settings :open_feature do
+              # Deprecated switch retained for existing Remote Configuration adopters.
               option :enabled do |o|
                 o.type :bool
                 o.env "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED"
                 o.default false
+                o.after_set do |_, _, precedence|
+                  next if precedence == Core::Configuration::Option::Precedence::DEFAULT
+
+                  Datadog.logger.warn(
+                    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED is deprecated; use " \
+                    "DD_FEATURE_FLAGS_ENABLED and DD_FEATURE_FLAGS_CONFIGURATION_SOURCE instead"
+                  )
+                end
               end
 
               # Opt-in gate for APM feature-flag span enrichment. When enabled,
@@ -42,6 +70,96 @@ module Datadog
                 o.default true
               end
             end
+
+            settings :feature_flags do
+              option :enabled do |o|
+                o.type :bool
+                o.env "DD_FEATURE_FLAGS_ENABLED"
+                o.default true
+              end
+
+              option :configuration_source do |o|
+                o.type :string
+                o.env "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE"
+                o.default "agentless"
+                o.setter do |value|
+                  value.to_s.strip.downcase
+                end
+              end
+
+              settings :agentless do
+                option :base_url do |o|
+                  o.type :string, nilable: true
+                  o.env "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL"
+                  o.skip_telemetry true
+                  o.setter do |value|
+                    next unless value
+
+                    stripped_value = value.to_s.strip
+                    stripped_value.empty? ? nil : stripped_value
+                  end
+                end
+
+                option :poll_interval_seconds do |o|
+                  Settings.configure_integer_option(
+                    o,
+                    environment_variable: "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS",
+                    default: Settings::DEFAULT_POLL_INTERVAL_SECONDS,
+                    setting_name: "Feature Flags agentless poll interval",
+                  )
+                  o.setter do |value|
+                    if value.is_a?(Integer) && value > 0
+                      value
+                    else
+                      Datadog.logger.warn(
+                        "Feature Flags agentless poll interval must be positive; using the default"
+                      )
+                      Settings::DEFAULT_POLL_INTERVAL_SECONDS
+                    end
+                  end
+                end
+
+                option :request_timeout_seconds do |o|
+                  Settings.configure_integer_option(
+                    o,
+                    environment_variable: "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS",
+                    default: Settings::DEFAULT_REQUEST_TIMEOUT_SECONDS,
+                    setting_name: "Feature Flags agentless request timeout",
+                  )
+                  o.setter do |value|
+                    if value.is_a?(Integer) && value > 0 && value <= Settings::MAX_REQUEST_TIMEOUT_SECONDS
+                      value
+                    else
+                      Datadog.logger.warn(
+                        "Feature Flags agentless request timeout must be within (0, " \
+                        "#{Settings::MAX_REQUEST_TIMEOUT_SECONDS}]; using the default"
+                      )
+                      Settings::DEFAULT_REQUEST_TIMEOUT_SECONDS
+                    end
+                  end
+                end
+              end
+
+              option :initialization_timeout_ms do |o|
+                Settings.configure_integer_option(
+                  o,
+                  environment_variable: "DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS",
+                  default: Settings::DEFAULT_INITIALIZATION_TIMEOUT_MS,
+                  setting_name: "Feature Flags provider initialization timeout",
+                )
+                o.setter do |value|
+                  if value.is_a?(Integer) && value > 0 && value <= Settings::MAX_INITIALIZATION_TIMEOUT_MS
+                    value
+                  else
+                    Datadog.logger.warn(
+                      "Feature Flags provider initialization timeout must be within (0, " \
+                      "#{Settings::MAX_INITIALIZATION_TIMEOUT_MS}]; using the default"
+                    )
+                    Settings::DEFAULT_INITIALIZATION_TIMEOUT_MS
+                  end
+                end
+              end
+            end
           end
         end
       end

data/lib/datadog/open_feature/native_evaluator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require_relative "../core/feature_flags"
 require_relative "ext"
 require_relative "resolution_details"
@@ -16,7 +15,7 @@ module Datadog
       #       in the format expected by `libdatadog` without any modifications
       def initialize(configuration)
         @configuration = Core::FeatureFlags::Configuration.new(configuration)
-        @observe_full_evaluation_data = parse_observe_full_evaluation_data(configuration)
+        @observe_full_evaluation_data = @configuration.observe_full_evaluation_data
       end
 
       attr_reader :observe_full_evaluation_data
@@ -42,18 +41,6 @@ module Datadog
 
       private
 
-      # Parse observe_full_evaluation_data from the top level of the UFC JSON (a sibling
-      # of `environment`). Absent, null, or wrong-typed values return false.
-      def parse_observe_full_evaluation_data(configuration)
-        return false unless configuration.is_a?(String) && !configuration.empty?
-
-        parsed = JSON.parse(configuration)
-        parsed.is_a?(Hash) && parsed["observeFullEvaluationData"] == true
-      rescue
-        # This secondary policy parse must not reject configuration accepted by the native evaluator.
-        false
-      end
-
       def build_resolution_details(result, default_value)
         ResolutionDetails.new(
           value: result.variant.nil? ? default_value : result.value,

data/lib/datadog/open_feature/remote.rb

@@ -19,11 +19,11 @@ module Datadog
           FFE_PRODUCTS
         end
 
-        def receivers(telemetry)
+        def receivers(telemetry, component_provider:)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
           receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
-            engine = OpenFeature.engine
-            next unless engine
+            component = component_provider.call
+            next unless component
 
             changes.each do |change|
               content = repository[change.path]
@@ -38,7 +38,7 @@ module Datadog
               when :insert, :update
                 begin
                   # @type var content: Core::Remote::Configuration::Content
-                  engine.reconfigure!(read_content(content))
+                  component.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
                   content.errored("Error applying OpenFeature configuration: #{e.class}: #{e.message}")
@@ -46,7 +46,7 @@ module Datadog
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration
                 #       In a multi-config scenario, we might track configs per path
-                engine.reconfigure!(nil)
+                component.reconfigure!(nil)
               end
             end
           end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -12,23 +12,24 @@ module Datadog
       def create_resource
         resource_attributes = {}
 
-        @settings.tags&.each do |key, value| # steep:ignore
+        @settings.tags&.each do |key, value|
           otel_key = case key
           when "service" then "service.name"
-          when "env" then "deployment.environment"
+          when "env", "deployment.environment.name", "deployment.environment" then next
           when "version" then "service.version"
           else key
           end
           resource_attributes[otel_key] = value
         end
 
-        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
-        resource_attributes["deployment.environment"] = @settings.env if @settings.env # steep:ignore
-        resource_attributes["service.version"] = @settings.version if @settings.version # steep:ignore
+        resource_attributes["service.name"] = @settings.service_without_fallback || resource_attributes["service.name"] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        environment = @settings.env || @settings.tags["env"] || @settings.tags["deployment.environment.name"] || @settings.tags["deployment.environment"]
+        resource_attributes["deployment.environment.name"] = environment if environment
+        resource_attributes["service.version"] = @settings.version if @settings.version
 
-        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
         if hostname
-          if hostname == @settings.hostname # steep:ignore
+          if hostname == @settings.hostname
             resource_attributes["host.name"] = hostname
           elsif !resource_attributes.key?("host.name")
             resource_attributes["host.name"] = hostname
@@ -41,9 +42,12 @@ module Datadog
       # Returns the signal-specific option value when explicitly set,
       # otherwise falls back to the general OTLP exporter config or computed_default.
       def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
-        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        signal_settings = case signal
+        when :logs then @settings.opentelemetry.logs
+        when :metrics then @settings.opentelemetry.metrics
+        end
         if signal_settings.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
         else
           signal_settings.public_send(option_name)
         end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -51,7 +51,7 @@ module Datadog
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
+          idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -98,7 +98,7 @@ module Datadog
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
-            @idle_sampling_helper.start
+            @idle_sampling_helper.start(self)
 
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -10,7 +10,6 @@ module Datadog
       class IdleSamplingHelper
         # @rbs @worker_thread: untyped
         # @rbs @start_stop_mutex: ::Thread::Mutex
-        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
 
         private
 
@@ -18,15 +17,14 @@ module Datadog
 
         public
 
-        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
-        def initialize(thread_context_collector:)
+        #: () -> void
+        def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
-          @thread_context_collector = thread_context_collector
         end
 
-        #: () -> (nil | true)
-        def start
+        #: (CpuAndWallTimeWorker cpu_and_wall_time_worker) -> true?
+        def start(cpu_and_wall_time_worker)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
 
@@ -39,7 +37,7 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self, @thread_context_collector)
+              self.class._native_idle_sampling_loop(self, cpu_and_wall_time_worker)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException

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
@@ -808,7 +796,7 @@ module Datadog
         # 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
@@ -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]) : []

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"
@@ -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),

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

@@ -13,6 +13,7 @@ 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"

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

@@ -255,6 +255,12 @@ module Datadog
                 o.type :bool
               end
 
+              option :otel_thread_context_enabled do |o|
+                o.env Tracing::Configuration::Ext::ENV_OTEL_CONTEXT_ENABLED
+                o.default true
+                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.