datadog 2.17.0 → 2.37.0

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -43,6 +43,15 @@ module Datadog
           digest = @datadog_propagator.extract(carrier)
           return context unless digest
 
+          # Always call continue_trace! so span links are created in restart mode
+          # (when digest.trace_id is nil) before we attempt to build the OTel SpanContext.
+          trace = Tracing.continue_trace!(digest)
+
+          # In restart mode DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT=restart, the extracted
+          # digest carries no trace_id (fresh start). continue_trace! has already recorded
+          # the span link; return the current context so the caller's span starts a new root.
+          return context unless digest.trace_id
+
           # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
           # 128-bit unsigned, big-endian integer
           trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack('Q>Q>')
@@ -54,10 +63,10 @@ module Datadog
             tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
           else
             trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
-                            ::OpenTelemetry::Trace::TraceFlags::SAMPLED
-                          else
-                            ::OpenTelemetry::Trace::TraceFlags::DEFAULT
-                          end
+              ::OpenTelemetry::Trace::TraceFlags::SAMPLED
+            else
+              ::OpenTelemetry::Trace::TraceFlags::DEFAULT
+            end
             tracestate = ::OpenTelemetry::Trace::Tracestate::DEFAULT
           end
 
@@ -70,9 +79,6 @@ module Datadog
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)
-
-          trace = Tracing.continue_trace!(digest)
-
           span.datadog_trace = trace
 
           ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'trace/span'
+require_relative '../../core/utils'
 require_relative '../../tracing/span_link'
 require_relative '../../tracing/span_event'
 require_relative '../../tracing/trace_digest'
@@ -101,12 +102,14 @@ module Datadog
 
           unless span.links.nil?
             datadog_span.links = span.links.map do |link|
+              tracestate = link.span_context.tracestate&.to_s
+
               Datadog::Tracing::SpanLink.new(
                 Datadog::Tracing::TraceDigest.new(
                   trace_id: link.span_context.hex_trace_id.to_i(16),
                   span_id: link.span_context.hex_span_id.to_i(16),
                   trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
-                  trace_state: link.span_context.tracestate&.to_s,
+                  trace_state: tracestate && ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil),
                   span_remote: link.span_context.remote?,
                 ),
                 attributes: link.attributes
@@ -120,7 +123,7 @@ module Datadog
         # Some special attributes can override Datadog Span fields
         def span_arguments(span, attributes)
           if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
-            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = (analytics_event.casecmp('true') == 0) ? 1 : 0
           end
 
           if attributes.key?('http.response.status_code')
@@ -129,15 +132,15 @@ module Datadog
 
           attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
 
-          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+          kwargs = {start_time: ns_to_time(span.start_timestamp)}
 
           name = if attributes.key?('operation.name')
-                   attributes['operation.name']
-                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
-                   rich_name.downcase
-                 else
-                   span.kind
-                 end
+            attributes['operation.name']
+          elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+            rich_name.downcase
+          else
+            span.kind
+          end
 
           kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
           kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -38,8 +38,8 @@ module Datadog
           res
         end
 
-        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
-        alias []= set_attribute
+        # `alias` performed to match {::OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute # rubocop:disable Style/Alias
 
         # Attributes are equivalent to span tags and metrics.
         def add_attributes(attributes)
@@ -72,24 +72,24 @@ module Datadog
             return 'http.client.request' if kind == :client
           end
 
-          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+          return "#{attrs["db.system"]}.query" if attrs.key?('db.system') && kind == :client
 
           if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
               [:consumer, :producer, :server, :client].include?(kind)
 
-            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+            return "#{attrs["messaging.system"]}.#{attrs["messaging.operation"]}"
           end
 
           if attrs.key?('rpc.system')
             if attrs['rpc.system'] == 'aws-api' && kind == :client
               service = attrs['rpc.service']
-              return "aws.#{service || 'client'}.request"
+              return "aws.#{service || "client"}.request"
             end
 
             if kind == :client
-              return "#{attrs['rpc.system']}.client.request"
+              return "#{attrs["rpc.system"]}.client.request"
             elsif kind == :server
-              return "#{attrs['rpc.system']}.server.request"
+              return "#{attrs["rpc.system"]}.server.request"
             end
           end
 
@@ -99,7 +99,7 @@ module Datadog
             return "#{provider}.#{name}.invoke"
           end
 
-          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?('faas.trigger') && kind == :server
 
           return 'graphql.server.request' if attrs.key?('graphql.operation.type')
 
@@ -119,6 +119,7 @@ module Datadog
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def datadog_set_attribute(key)
           # Return if attributes are currently disabled by OpenTelemetry.
           return unless defined?(@attributes) && @attributes
@@ -149,9 +150,11 @@ module Datadog
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
         # Some special attributes can override Datadog Span fields beyond tags and metrics.
         # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def override_datadog_values(span, key, value)
           span.name = value if key == 'operation.name'
           span.resource = value if key == 'resource.name'
@@ -161,15 +164,16 @@ module Datadog
           if key == 'analytics.event' && value.respond_to?(:casecmp)
             Datadog::Tracing::Analytics.set_sample_rate(
               span,
-              value.casecmp('true') == 0 ? 1 : 0
+              (value.casecmp('true') == 0) ? 1 : 0
             )
           end
 
           span.set_tag('http.status_code', value) if key == 'http.response.status_code'
         end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
         DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
-                                            'span.type', 'http.response.status_code'].freeze
+          'span.type', 'http.response.status_code'].freeze
 
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end

data/lib/datadog/opentelemetry/sdk.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/ext'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+
+      def self.telemetry_inc(metric_name, value)
+        telemetry&.inc(Datadog::Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: TELEMETRY_TAGS)
+      end
+
+      def self.telemetry
+        Datadog.send(:components).telemetry
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+require_relative '../core/environment/socket'
+
+module Datadog
+  module OpenTelemetry
+    # Shared resource building and signal-specific config fallback logic for Logs and Metrics.
+    module SignalConfiguration
+      private
+
+      def create_resource
+        resource_attributes = {}
+
+        @settings.tags&.each do |key, value| # steep:ignore
+          otel_key = case key
+          when 'service' then 'service.name'
+          when 'env' then 'deployment.environment'
+          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
+
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        if hostname
+          if hostname == @settings.hostname # steep:ignore
+            resource_attributes['host.name'] = hostname
+          elsif !resource_attributes.key?('host.name')
+            resource_attributes['host.name'] = hostname
+          end
+        end
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      # 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
+        if signal_settings.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+        else
+          signal_settings.public_send(option_name)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/trace.rb

@@ -15,10 +15,10 @@ module Datadog
         # @return [TraceOperation]
         def start_trace_copy(trace, parent_span: nil)
           digest = if parent_span
-                     digest_with_parent_span(trace, parent_span)
-                   else
-                     trace.to_digest
-                   end
+            digest_with_parent_span(trace, parent_span)
+          else
+            trace.to_digest
+          end
 
           # Create a new TraceOperation, attached to the current Datadog Tracer.
           Datadog::Tracing.continue_trace!(digest)

data/lib/datadog/opentelemetry.rb

@@ -22,6 +22,9 @@ require_relative 'opentelemetry/api/baggage'
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
+require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+require_relative 'opentelemetry/logs' if defined?(OpenTelemetry::SDK::Logs)
+
 module Datadog
   # Datadog OpenTelemetry integration.
   module OpenTelemetry
@@ -47,6 +50,7 @@ end
 # Currently, this closely translates to Datadog's partial flushing.
 #
 # @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+
 Datadog.configure do |c|
   c.tracing.partial_flush.enabled = true
 end

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

@@ -14,11 +14,18 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
-        def initialize(standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"))
+        # @rbs standard_library_path: ::String
+        # @rbs ruby_native_filename: ::String?
+        # @rbs return: void
+        def initialize(
+          standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
+          ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
+        )
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
           @seen_libraries = Set.new
+          @executable_paths = [Gem.bindir, bundler_bin_path].uniq.compact.freeze
 
           record_library(
             Library.new(
@@ -26,10 +33,14 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
+              extra_paths: [ruby_native_filename],
             )
           )
         end
 
+        # @rbs loaded_files: ::Array[::String]
+        # @rbs loaded_specs: ::Array[::Gem::BasicSpecification]
+        # @rbs return: self
         def refresh(loaded_files: $LOADED_FEATURES, loaded_specs: Gem.loaded_specs.values)
           record_loaded_specs(loaded_specs)
           record_loaded_files(loaded_files)
@@ -37,22 +48,20 @@ module Datadog
           self
         end
 
-        def generate
-          seen_libraries
-        end
-
+        #: () -> ::String
         def generate_json
           JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
 
-        attr_reader \
-          :libraries_by_name,
-          :libraries_by_path,
-          :seen_files,
-          :seen_libraries
+        attr_reader :libraries_by_name #: ::Hash[::String, Library]
+        attr_reader :libraries_by_path #: ::Hash[::String, Library]
+        attr_reader :seen_files #: ::Set[::String]
+        attr_reader :seen_libraries #: ::Set[Library]
+        attr_reader :executable_paths #: ::Array[::String]
 
+        #: (Library) -> void
         def record_library(library)
           libraries_by_name[library.name] = library
           libraries_by_path[library.path] = library
@@ -69,23 +78,41 @@ module Datadog
         #
         # Alternatively/in the future we could instead use a trie to match paths, but I doubt for the data sizes we're
         # looking at that a trie is that much faster than using Ruby's built-in native collections.
+        #: () -> void
         def sort_libraries_by_longest_path_first
           @libraries_by_path = @libraries_by_path.sort.reverse!.to_h
         end
 
+        #: (::Array[::Gem::BasicSpecification]) -> void
         def record_loaded_specs(loaded_specs)
           recorded_library = false
 
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
-            record_library(Library.new(kind: "library", name: spec.name, version: spec.version, path: spec.gem_dir))
+            extra_paths = [(spec.extension_dir if spec.extensions.any?)]
+            spec.executables&.each do |executable|
+              executable_paths.each do |path|
+                extra_paths << File.join(path, executable)
+              end
+            end
+
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_paths: extra_paths,
+              )
+            )
             recorded_library = true
           end
 
           sort_libraries_by_longest_path_first if recorded_library
         end
 
+        #: (::Array[::String]) -> void
         def record_loaded_files(loaded_files)
           loaded_files.each do |file_path|
             next if seen_files.include?(file_path)
@@ -99,6 +126,31 @@ module Datadog
           end
         end
 
+        # This is intended to mirror bundler's `Bundler.bin_path` with one key difference: the bundler version of the
+        # method **tries to create the path** if it doesn't exist, whereas our version doesn't.
+        #
+        # This "try to create the path" is annoying because creating the path can fail if e.g. the app doesn't have
+        # permissions to do that, see https://github.com/DataDog/dd-trace-rb/issues/5137.
+        # Thus we have our own version that a) Avoids creating the path, and b) Rescues exceptions to avoid any
+        # bundler complaints here impacting the application. (Bundler tends to go "something is wrong, raise!" which
+        # I think makes a lot of sense given how bundler is intended to be used, but for this our kind of "ask a few
+        # questions usage" it's not what we want.)
+        #: () -> ::String?
+        def bundler_bin_path
+          return unless defined?(Bundler)
+
+          path = Bundler.settings[:bin] || "bin"
+          root = Bundler.root
+          result = Pathname.new(path).expand_path(root).expand_path
+          result.to_s
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.debug(
+            "CodeProvenance#bundler_bin_path failed. " \
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          nil
+        end
+
         # Represents metadata we have for a ruby gem
         #
         # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
@@ -108,20 +160,36 @@ module Datadog
         # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
         # fields. (Also, we have a spec for this)
         class Library
-          attr_reader :kind, :name, :version
-
-          def initialize(kind:, name:, version:, path:)
+          # @rbs @kind: ::String
+          # @rbs @name: ::String
+          # @rbs @version: ::String
+          # @rbs @paths: ::Array[::String]
+
+          attr_reader :kind #: ::String
+          attr_reader :name #: ::String
+          attr_reader :version #: ::String
+
+          # @rbs kind: ::String
+          # @rbs name: ::String
+          # @rbs version: ::String | ::Gem::Version
+          # @rbs path: ::String
+          # @rbs extra_paths: ::Array[::String?]
+          # @rbs return: void
+          def initialize(kind:, name:, version:, path:, extra_paths:)
+            extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze].freeze
+            @paths = [path.dup.freeze, *extra_paths].freeze
             freeze
           end
 
+          #: (?::JSON::State?) -> ::String
           def to_json(arg = nil)
             {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
+          #: () -> ::String
           def path
             @paths.first
           end

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

@@ -9,12 +9,32 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_cpu_and_wall_time_worker.c`
       class CpuAndWallTimeWorker
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @failure_exception: ::Exception?
+        # @rbs @idle_sampling_helper: IdleSamplingHelper
+        # @rbs @wait_until_running_mutex: ::Thread::Mutex
+        # @rbs @wait_until_running_condition: ::Thread::ConditionVariable
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
+        # @rbs gc_profiling_enabled: bool
+        # @rbs no_signals_workaround_enabled: bool
+        # @rbs thread_context_collector: Datadog::Profiling::Collectors::ThreadContext
+        # @rbs dynamic_sampling_rate_overhead_target_percentage: Float
+        # @rbs cpu_sampling_interval_ms: ::Integer
+        # @rbs idle_sampling_helper: Datadog::Profiling::Collectors::IdleSamplingHelper
+        # @rbs dynamic_sampling_rate_enabled: bool
+        # @rbs allocation_profiling_enabled: bool
+        # @rbs allocation_counting_enabled: bool
+        # @rbs gvl_profiling_enabled: bool
+        # @rbs sighandler_sampling_enabled: bool
+        # @rbs skip_idle_samples_for_testing: false
+        # @rbs return: void
         def initialize(
           gc_profiling_enabled:,
           no_signals_workaround_enabled:,
@@ -23,16 +43,25 @@ module Datadog
           allocation_profiling_enabled:,
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
+          sighandler_sampling_enabled:,
+          cpu_sampling_interval_ms:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
           skip_idle_samples_for_testing: false,
-          idle_sampling_helper: IdleSamplingHelper.new
+          idle_sampling_helper: IdleSamplingHelper.new(thread_context_collector: thread_context_collector)
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
               "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
+            )
+          end
+
+          if cpu_sampling_interval_ms < 1
+            raise ArgumentError, "cpu_sampling_interval_ms must be a positive integer, got #{cpu_sampling_interval_ms}"
           end
 
           self.class._native_initialize(
@@ -46,7 +75,9 @@ module Datadog
             allocation_profiling_enabled: allocation_profiling_enabled,
             allocation_counting_enabled: allocation_counting_enabled,
             gvl_profiling_enabled: gvl_profiling_enabled,
+            sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
+            cpu_sampling_interval_ms: cpu_sampling_interval_ms,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -56,6 +87,8 @@ module Datadog
           @wait_until_running_condition = ConditionVariable.new
         end
 
+        # @rbs on_failure_proc: (^(?log_failure: bool) -> void)?
+        # @rbs return: bool?
         def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -70,13 +103,22 @@ module Datadog
               self.class._native_sampling_loop(self)
 
               Datadog.logger.debug("CpuAndWallTimeWorker thread stopping cleanly")
+            rescue Profiling::ExistingSignalHandler => e
+              @failure_exception = e
+              Datadog.logger.warn(
+                "Profiling was not started as another profiler or gem is already using the SIGPROF signal. " \
+                "Please disable the other profiler to use Datadog profiling."
+              )
+              on_failure_proc&.call(log_failure: false)
             rescue Exception => e # rubocop:disable Lint/RescueException
               @failure_exception = e
+              operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Operation: #{operation_name} Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error: #{operation_name}")
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)
@@ -85,6 +127,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
@@ -101,14 +144,17 @@ module Datadog
           end
         end
 
+        #: () -> true
         def reset_after_fork
           self.class._native_reset_after_fork(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats
           self.class._native_stats(self)
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def stats_and_reset_not_thread_safe
           stats = self.stats
           self.class._native_stats_reset_not_thread_safe(self)
@@ -116,6 +162,8 @@ module Datadog
         end
 
         # Useful for testing, to e.g. make sure the profiler is running before we start running some code we want to observe
+        # @rbs timeout_seconds: ::Integer?
+        # @rbs return: true
         def wait_until_running(timeout_seconds: 5)
           @wait_until_running_mutex.synchronize do
             return true if self.class._native_is_running?(self)
@@ -132,6 +180,7 @@ module Datadog
 
         private
 
+        #: () -> void
         def signal_running
           @wait_until_running_mutex.synchronize { @wait_until_running_condition.broadcast }
         end

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

@@ -8,17 +8,24 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_idle_sampling_helper.c`
       class IdleSamplingHelper
+        # @rbs @worker_thread: untyped
+        # @rbs @start_stop_mutex: ::Thread::Mutex
+        # @rbs @thread_context_collector: Datadog::Profiling::Collectors::ThreadContext?
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
-        def initialize
+        #: (thread_context_collector: Datadog::Profiling::Collectors::ThreadContext) -> void
+        def initialize(thread_context_collector:)
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
+          @thread_context_collector = thread_context_collector
         end
 
+        #: () -> (nil | true)
         def start
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -32,15 +39,16 @@ module Datadog
             @worker_thread = Thread.new do
               Thread.current.name = self.class.name
 
-              self.class._native_idle_sampling_loop(self)
+              self.class._native_idle_sampling_loop(self, @thread_context_collector)
 
               Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
             rescue Exception => e # rubocop:disable Lint/RescueException
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)
@@ -49,6 +57,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")