datadog 2.31.0 → 2.32.0

data/lib/datadog/kit/enable_core_dumps.rb

@@ -30,7 +30,7 @@ module Datadog
           Process.setrlimit(:CORE, maximum_size)
         rescue => e
           Kernel.warn(
-            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e} " \
+            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e.message} " \
             "Location: #{Array(e.backtrace).first}"
           )
           return

data/lib/datadog/open_feature/component.rb

@@ -6,12 +6,13 @@ require_relative 'exposures/buffer'
 require_relative 'exposures/worker'
 require_relative 'exposures/deduplicator'
 require_relative 'exposures/reporter'
+require_relative 'metrics/flag_eval_metrics'
 
 module Datadog
   module OpenFeature
     # This class is the entry point for the OpenFeature component
     class Component
-      attr_reader :engine
+      attr_reader :engine, :flag_eval_hook
 
       def self.build(settings, agent_settings, logger:, telemetry:)
         return unless settings.respond_to?(:open_feature) && settings.open_feature.enabled
@@ -50,11 +51,27 @@ module Datadog
 
         reporter = Exposures::Reporter.new(@worker, telemetry: telemetry, logger: logger)
         @engine = EvaluationEngine.new(reporter, telemetry: telemetry, logger: logger)
+
+        @telemetry = telemetry
+        @logger = logger
+        @flag_eval_hook = create_flag_eval_hook
       end
 
       def shutdown!
         @worker.graceful_shutdown
       end
+
+      private
+
+      def create_flag_eval_hook
+        require_relative 'hooks/flag_eval_hook'
+        return unless Hooks::FlagEvalHook.available?
+
+        metrics = Metrics::FlagEvalMetrics.new(telemetry: @telemetry, logger: @logger)
+        Hooks::FlagEvalHook.new(metrics)
+      rescue LoadError
+        nil
+      end
     end
   end
 end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -42,7 +42,7 @@ module Datadog
         @telemetry.report(e, description: 'OpenFeature: Failed to fetch flag value')
 
         ResolutionDetails.build_error(
-          value: default_value, error_code: Ext::GENERAL, error_message: e.message
+          value: default_value, error_code: Ext::GENERAL, error_message: "#{e.class}: #{e.message}"
         )
       end
 
@@ -60,10 +60,10 @@ module Datadog
       rescue => e
         message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
 
-        @logger.error("#{message}, #{e.class}: #{e}")
+        @logger.error("#{message}, #{e.class}: #{e.message}")
         @telemetry.report(e, description: "#{message} (#{e.class})")
 
-        raise ReconfigurationError, e.message
+        raise ReconfigurationError, "#{e.class}: #{e.message}"
       end
     end
   end

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -29,7 +29,7 @@ module Datadog
           event = Event.build(result, flag_key: flag_key, context: context)
           @worker.enqueue(event)
         rescue => e
-          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e}" }
+          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to report resolution details')
 
           false

data/lib/datadog/open_feature/exposures/worker.rb

@@ -105,7 +105,7 @@ module Datadog
 
           response
         rescue => e
-          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e}" }
+          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to flush resolution details events')
 
           nil

data/lib/datadog/open_feature/hooks/flag_eval_hook.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Hooks
+      # Records flag evaluation metrics via OpenTelemetry hook
+      #
+      # Compatible with OpenFeature SDK >= 0.5.0 which provides the Hooks::Hook module,
+      # but also works with older versions since the SDK uses respond_to?(:finally)
+      # to detect hook capabilities.
+      class FlagEvalHook
+        # Include the Hook module if available (SDK >= 0.5.0) for interface documentation
+        # and default implementations of other hook methods (before, after, error)
+        include ::OpenFeature::SDK::Hooks::Hook if defined?(::OpenFeature::SDK::Hooks::Hook)
+
+        # Returns true if the OpenFeature SDK supports hooks (>= 0.5.0)
+        def self.available?
+          !!defined?(::OpenFeature::SDK::Hooks::Hook)
+        end
+
+        def initialize(metrics)
+          @metrics = metrics
+        end
+
+        def finally(hook_context:, evaluation_details:, **_opts)
+          metrics = @metrics
+          return unless metrics
+
+          metrics.record(
+            hook_context.flag_key,
+            variant: evaluation_details.variant,
+            reason: evaluation_details.reason,
+            error_code: evaluation_details.error_code,
+            allocation_key: extract_allocation_key(evaluation_details),
+          )
+        end
+
+        private
+
+        def extract_allocation_key(evaluation_details)
+          metadata = evaluation_details.flag_metadata
+          return unless metadata.is_a?(Hash)
+
+          metadata['__dd_allocation_key']
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/metrics/flag_eval_metrics.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Metrics
+      # Records flag evaluation metrics via OpenTelemetry
+      class FlagEvalMetrics
+        METER_NAME = 'ddtrace.openfeature'
+        METRIC_NAME = 'feature_flag.evaluations'
+        METRIC_UNIT = '{evaluation}'
+        METRIC_DESCRIPTION = 'Number of feature flag evaluations'
+
+        ATTR_FLAG_KEY = 'feature_flag.key'
+        ATTR_VARIANT = 'feature_flag.result.variant'
+        ATTR_REASON = 'feature_flag.result.reason'
+        ATTR_ALLOCATION_KEY = 'feature_flag.result.allocation_key'
+        ATTR_ERROR_TYPE = 'error.type'
+
+        DEFAULT_ERROR_TYPE = 'general'
+
+        ERROR_TYPE_MAP = {
+          'FLAG_NOT_FOUND' => 'flag_not_found',
+          'TYPE_MISMATCH' => 'type_mismatch',
+          'PARSE_ERROR' => 'parse_error',
+          'PROVIDER_NOT_READY' => 'provider_not_ready',
+          'TARGETING_KEY_MISSING' => 'targeting_key_missing',
+          'INVALID_CONTEXT' => 'invalid_context',
+          'PROVIDER_FATAL' => 'provider_fatal',
+          'GENERAL' => DEFAULT_ERROR_TYPE,
+        }.freeze
+
+        # Reasons that should not include allocation_key in metrics
+        EXCLUDE_ALLOCATION_KEY_REASONS = %w[error default disabled].freeze
+
+        def initialize(telemetry:, logger:)
+          @telemetry = telemetry
+          @logger = logger
+          @enabled = Datadog.configuration.opentelemetry.metrics.enabled
+          @counter = nil
+          @mutex = Mutex.new
+
+          unless @enabled
+            @logger.debug { 'OpenFeature: OTel metrics not enabled (DD_METRICS_OTEL_ENABLED=false), flag evaluation metrics disabled' }
+          end
+        end
+
+        def record(flag_key, variant:, reason:, error_code: nil, allocation_key: nil)
+          return unless @enabled
+
+          counter = get_or_create_counter
+          return unless counter
+
+          attributes = build_attributes(
+            flag_key,
+            variant: variant,
+            reason: reason,
+            error_code: error_code,
+            allocation_key: allocation_key,
+          )
+          counter.add(1, attributes: attributes)
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to record evaluation metric: #{e.class}: #{e.message}" }
+          @telemetry.report(e, description: 'OpenFeature: Failed to record evaluation metric')
+        end
+
+        private
+
+        # Counter is created lazily because OTel SDK may not be initialized
+        # when the OpenFeature component is created.
+        def get_or_create_counter
+          @mutex.synchronize do
+            return @counter if @counter
+
+            meter_provider = get_or_initialize_meter_provider
+            return unless meter_provider
+
+            meter = meter_provider.meter(METER_NAME)
+            @counter = meter.create_counter(
+              METRIC_NAME,
+              unit: METRIC_UNIT,
+              description: METRIC_DESCRIPTION
+            )
+          end
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to create metrics counter: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        # Fetch an available OTel meter provider, initializing if needed.
+        # Returns the meter provider if available, nil otherwise.
+        def get_or_initialize_meter_provider
+          meter_provider = defined?(::OpenTelemetry) ? ::OpenTelemetry.meter_provider : nil
+          return meter_provider if sdk_meter_provider?(meter_provider)
+
+          @logger.debug { 'OpenFeature: Initializing OTel meter provider directly' }
+          require 'opentelemetry-metrics-sdk'
+          require 'datadog/opentelemetry/metrics'
+          Datadog::OpenTelemetry::Metrics.initialize!(Datadog.send(:components))
+
+          meter_provider = ::OpenTelemetry.meter_provider
+          sdk_meter_provider?(meter_provider) ? meter_provider : nil
+        rescue LoadError => e
+          @logger.debug { "OpenFeature: Failed to initialize OTel metrics: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        def sdk_meter_provider?(meter_provider)
+          return false if meter_provider.nil?
+          return false unless defined?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+          meter_provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+        end
+
+        def build_attributes(flag_key, variant:, reason:, error_code:, allocation_key:)
+          reason_downcase = normalize_reason(reason)
+
+          attrs = {
+            ATTR_FLAG_KEY => flag_key,
+            ATTR_VARIANT => variant.to_s,
+            ATTR_REASON => reason_downcase,
+          }
+
+          if allocation_key && !allocation_key.empty? && !exclude_allocation_key?(reason_downcase)
+            attrs[ATTR_ALLOCATION_KEY] = allocation_key
+          end
+
+          if error_code
+            attrs[ATTR_ERROR_TYPE] = normalize_error_type(error_code)
+          end
+
+          attrs
+        end
+
+        def normalize_reason(reason)
+          reason = reason.to_s
+          reason.empty? ? 'unknown' : reason.downcase
+        end
+
+        def normalize_error_type(error_code)
+          ERROR_TYPE_MAP.fetch(error_code.to_s, DEFAULT_ERROR_TYPE)
+        end
+
+        def exclude_allocation_key?(reason_downcase)
+          EXCLUDE_ALLOCATION_KEY_REASONS.include?(reason_downcase)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/provider.rb

@@ -7,6 +7,8 @@ module Datadog
   module OpenFeature
     # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
     #
+    # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics support.
+    #
     # Implementation follows the OpenFeature contract of Provider SDK.
     # For details see:
     #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/README.md#develop-a-provider
@@ -67,6 +69,11 @@ module Datadog
         # no-op
       end
 
+      def hooks
+        hook = Datadog.send(:components).open_feature&.flag_eval_hook
+        [hook].compact
+      end
+
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value: default_value, expected_type: :boolean, evaluation_context: evaluation_context)
       end
@@ -117,7 +124,7 @@ module Datadog
           value: result.value,
           variant: result.variant,
           reason: result.reason,
-          flag_metadata: result.flag_metadata
+          flag_metadata: build_flag_metadata(result),
         )
       rescue => e
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
@@ -128,6 +135,17 @@ module Datadog
         )
       end
 
+      def build_flag_metadata(result)
+        metadata = result.flag_metadata || {}
+        allocation_key = result.allocation_key
+        if allocation_key && !allocation_key.empty?
+          metadata = metadata.dup
+          metadata['__dd_allocation_key'] = allocation_key
+        end
+
+        metadata
+      end
+
       def component_not_configured_default(value)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,

data/lib/datadog/open_feature/remote.rb

@@ -41,7 +41,7 @@ module Datadog
                   engine.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
-                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e}")
+                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e.message}")
                 end
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration

data/lib/datadog/open_feature/transport.rb

@@ -55,7 +55,7 @@ module Datadog
             @api.call(env)
           end
         rescue => e
-          message = "Internal error during request. Cause: #{e.class}: #{e} " \
+          message = "Internal error during request. Cause: #{e.class}: #{e.message} " \
                     "Location: #{Array(e.backtrace).first}"
           @logger.debug(message)
 

data/lib/datadog/opentelemetry/metrics.rb

@@ -11,7 +11,7 @@ module Datadog
         new(components).configure_metrics_sdk
         true
       rescue => exc
-        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
         false
       end
 
@@ -67,7 +67,7 @@ module Datadog
 
         configure_otlp_exporter(provider)
       rescue => e
-        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
 
       def default_metrics_endpoint
@@ -101,7 +101,7 @@ module Datadog
         )
         provider.add_metric_reader(reader)
       rescue LoadError => e
-        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
 
       # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.

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

@@ -37,7 +37,7 @@ module Datadog
           begin
             require 'opentelemetry-metrics-sdk'
           rescue LoadError => exc
-            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc.message}")
             return super
           end
 

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

@@ -19,7 +19,7 @@ module Datadog
           telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
           result
         rescue => e
-          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
           telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
           raise
         end

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

@@ -14,6 +14,9 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
+        # @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
@@ -35,6 +38,9 @@ module Datadog
           )
         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)
@@ -42,19 +48,20 @@ module Datadog
           self
         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,
-          :executable_paths
+        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
@@ -71,10 +78,12 @@ 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
 
@@ -103,6 +112,7 @@ module Datadog
           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)
@@ -125,6 +135,7 @@ module Datadog
         # 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)
 
@@ -135,7 +146,7 @@ module Datadog
         rescue Exception => e # rubocop:disable Lint/RescueException
           Datadog.logger.debug(
             "CodeProvenance#bundler_bin_path failed. " \
-            "Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
+            "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           nil
         end
@@ -149,8 +160,21 @@ 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
-
+          # @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
@@ -160,10 +184,12 @@ module Datadog
             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:,
@@ -67,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?
@@ -93,7 +115,7 @@ module Datadog
               operation_name = self.class._native_failure_exception_during_operation(self).inspect
               Datadog.logger.warn(
                 "CpuAndWallTimeWorker thread error. " \
-                "Operation: #{operation_name} Cause: #{e.class}: #{e} 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}")
@@ -105,6 +127,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
@@ -121,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)
@@ -136,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)
@@ -152,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,22 @@ 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
+
         private
 
-        attr_accessor :failure_exception
+        attr_accessor :failure_exception #: ::Exception?
 
         public
 
+        #: () -> void
         def initialize
           @worker_thread = nil
           @start_stop_mutex = Mutex.new
         end
 
+        #: () -> (nil | true)
         def start
           @start_stop_mutex.synchronize do
             return if @worker_thread&.alive?
@@ -39,7 +44,7 @@ module Datadog
               @failure_exception = e
               Datadog.logger.warn(
                 "IdleSamplingHelper thread error. " \
-                "Cause: #{e.class}: #{e} 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
@@ -50,6 +55,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")