datadog 2.42.0 → 2.44.0

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/profiling/collectors/info.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require "set"
-require "time"
 require "libdatadog"
+require_relative "../../core/utils/time"
 
 module Datadog
   module Profiling
@@ -71,10 +70,7 @@ module Datadog
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
-        #
-        # Note: this does not use Core::Utils::Time.now because this constant
-        # gets initialized before a user has a chance to configure the library.
-        START_TIME = Time.now.utc.freeze
+        START_TIME = Datadog::Core::Utils::Time.now.utc.freeze
 
         #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info

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.

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,15 @@ 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=)
+
         @context.local = ctx
       end
 
@@ -48,10 +51,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 +65,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.

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -15,6 +15,7 @@ module Datadog
         module Endpoint
           KEY_RUN = "datadog_grape_endpoint_run"
           KEY_RENDER = "datadog_grape_endpoint_render"
+          FORMAT_SEGMENT = /\(\.:?\w+\)\z/
 
           class << self
             def subscribe
@@ -43,8 +44,8 @@ module Datadog
               # collect endpoint details
               endpoint = payload.fetch(:endpoint)
               env = payload.fetch(:env)
-              api_view = api_view(endpoint.options[:for])
-              request_method = endpoint.options.fetch(:method).first
+              api_view = api_view(endpoint_api(endpoint))
+              request_method = endpoint_request_method(endpoint)
               path = endpoint_expand_path(endpoint)
               resource = "#{api_view} #{request_method} #{path}"
 
@@ -65,12 +66,16 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
 
               if (grape_route = env["grape.routing_args"]) && grape_route[:route_info]
+                route_info = grape_route[:route_info]
+                # Grape 2.3 through 3.0 return nil from GreedyRoute#path; the
+                # path lives at pattern.path in those versions.
+                route_path = route_info.path || route_info.pattern&.path
                 trace.set_tag(
                   Tracing::Metadata::Ext::HTTP::TAG_ROUTE,
                   # here we are removing the format from the path:
                   # e.g. /path/to/resource(.json) => /path/to/resource
                   # e.g. /path/to/resource(.:format) => /path/to/resource
-                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, "")
+                  route_path&.gsub(FORMAT_SEGMENT, "")
                 )
 
                 trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env["SCRIPT_NAME"])
@@ -96,8 +101,8 @@ module Datadog
               begin
                 # collect endpoint details
                 endpoint = payload.fetch(:endpoint)
-                api_view = api_view(endpoint.options[:for])
-                request_method = endpoint.options.fetch(:method).first
+                api_view = api_view(endpoint_api(endpoint))
+                request_method = endpoint_request_method(endpoint)
                 path = endpoint_expand_path(endpoint)
 
                 trace.resource = span.resource
@@ -266,8 +271,25 @@ module Datadog
               end
             end
 
+            # Grape 4 moved three values off the endpoint's public options Hash: the
+            # API class became the #api reader (ruby-grape/grape#2778), and the verb
+            # and path are read off the route (#2775, #2776). Each reader prefers the
+            # options Hash, so Grape 1.x through 3.x resolve as they did before.
+            def endpoint_api(endpoint)
+              endpoint.options.fetch(:for) { endpoint.api }
+            end
+
+            def endpoint_request_method(endpoint)
+              request_methods = endpoint.options[:method]
+              return request_methods.first if request_methods
+
+              endpoint.routes.first&.request_method
+            end
+
             def endpoint_expand_path(endpoint)
               route_path = endpoint.options[:path]
+              return endpoint_route_path(endpoint) if route_path.nil? || route_path.empty?
+
               namespace = endpoint.routes.first&.namespace || ""
 
               path = (namespace.split("/") + route_path)
@@ -277,6 +299,11 @@ module Datadog
               path
             end
 
+            # A compiled path already carries the namespace, so it is used whole.
+            def endpoint_route_path(endpoint)
+              endpoint.routes.first&.path&.sub(FORMAT_SEGMENT, "") || "/"
+            end
+
             def service_name
               datadog_configuration[:service_name]
             end