datadog 2.4.0 → 2.44.0

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

@@ -9,12 +9,33 @@ 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 waiting_for_gvl_threshold_ns: ::Integer
+        # @rbs skip_idle_samples_for_testing: false
+        # @rbs return: void
         def initialize(
           gc_profiling_enabled:,
           no_signals_workaround_enabled:,
@@ -23,6 +44,9 @@ module Datadog
           allocation_profiling_enabled:,
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
+          sighandler_sampling_enabled:,
+          cpu_sampling_interval_ms:,
+          waiting_for_gvl_threshold_ns:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -33,6 +57,13 @@ module Datadog
             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 +77,10 @@ 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,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -56,13 +90,15 @@ 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?
 
             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
@@ -70,13 +106,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 +130,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
@@ -101,14 +147,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,22 +165,30 @@ 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)
 
             @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
 
+            # Not using `_native_is_running?(self) || raise(...)` here: `_native_is_running?` is declared
+            # to return `bool`, so steep infers the `||` expression as `bool` too and rejects it against
+            # this method's declared `true` return type. The explicit `if`/`else` type-checks correctly.
+            # rubocop:disable Style/RedundantCondition
             if self.class._native_is_running?(self)
               true
             else
               raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
             end
+            # rubocop:enable Style/RedundantCondition
           end
         end
 
         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,18 +8,23 @@ 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
 
-        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?
 
@@ -32,15 +37,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, cpu_and_wall_time_worker)
 
               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 +55,7 @@ module Datadog
           true
         end
 
+        #: () -> void
         def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")

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
@@ -14,8 +13,17 @@ module Datadog
       # could be seen as overkill for this case but it allows us to centralize information
       # gathering and easily support more flexible/dynamic info collection in the future.
       class Info
+        # @rbs @info: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
+        # @rbs @platform_info: ::Hash[::Symbol, untyped]
+        # @rbs @runtime_info: ::Hash[::Symbol, untyped]
+        # @rbs @application_info: ::Hash[::Symbol, untyped]
+        # @rbs @profiler_info: ::Hash[::Symbol, untyped]?
+        # @rbs @gc_tuning_info: ::Hash[::Symbol, ::String]
+
+        #: (untyped) -> void
         def initialize(settings)
           @profiler_info = nil
+
           @info = {
             platform: collect_platform_info,
             runtime: collect_runtime_info,
@@ -24,33 +32,68 @@ module Datadog
           }.freeze
         end
 
-        attr_reader :info
+        attr_reader :info #: ::Hash[::Symbol, ::Hash[::Symbol, untyped]]
 
         private
 
+        # Ruby GC tuning environment variables
+        RUBY_GC_TUNING_ENV_VARS = [
+          "RUBY_GC_HEAP_FREE_SLOTS",
+          "RUBY_GC_HEAP_GROWTH_FACTOR",
+          "RUBY_GC_HEAP_GROWTH_MAX_SLOTS",
+          "RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_MAX_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO",
+          "RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR",
+          "RUBY_GC_HEAP_REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO",
+          "RUBY_GC_MALLOC_LIMIT",
+          "RUBY_GC_MALLOC_LIMIT_MAX",
+          "RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR",
+          "RUBY_GC_OLDMALLOC_LIMIT",
+          "RUBY_GC_OLDMALLOC_LIMIT_MAX",
+          "RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR",
+          # INIT_SLOTS changed for Ruby 3.3+:
+          # * https://bugs.ruby-lang.org/issues/19785
+          # * https://www.ruby-lang.org/en/news/2023/12/25/ruby-3-3-0-released/#:~:text=Removed%20environment%20variables
+          "RUBY_GC_HEAP_0_INIT_SLOTS",
+          "RUBY_GC_HEAP_1_INIT_SLOTS",
+          "RUBY_GC_HEAP_2_INIT_SLOTS",
+          "RUBY_GC_HEAP_3_INIT_SLOTS",
+          "RUBY_GC_HEAP_4_INIT_SLOTS",
+          # There was only one setting for older Rubies:
+          "RUBY_GC_HEAP_INIT_SLOTS",
+          # Ruby 2.x only, alias for others:
+          "RUBY_FREE_MIN",
+          "RUBY_HEAP_MIN_SLOTS",
+        ].freeze
+
         # 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.
-        START_TIME = Time.now.utc.freeze
+        START_TIME = Datadog::Core::Utils::Time.now.utc.freeze
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_platform_info
           @platform_info ||= {
             container_id: Datadog::Core::Environment::Container.container_id,
             hostname: Datadog::Core::Environment::Platform.hostname,
             kernel_name: Datadog::Core::Environment::Platform.kernel_name,
             kernel_release: Datadog::Core::Environment::Platform.kernel_release,
-            kernel_version: Datadog::Core::Environment::Platform.kernel_version
+            kernel_version: Datadog::Core::Environment::Platform.kernel_version,
           }.freeze
         end
 
+        #: () -> ::Hash[::Symbol, untyped]
         def collect_runtime_info
           @runtime_info ||= {
             engine: Datadog::Core::Environment::Identity.lang_engine,
             version: Datadog::Core::Environment::Identity.lang_version,
             platform: Datadog::Core::Environment::Identity.lang_platform,
+            gc_tuning: collect_gc_tuning_info,
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_application_info(settings)
           @application_info ||= {
             start_time: START_TIME.iso8601,
@@ -60,8 +103,9 @@ module Datadog
           }.freeze
         end
 
+        #: (untyped) -> ::Hash[::Symbol, untyped]
         def collect_profiler_info(settings)
-          unless @profiler_info
+          @profiler_info ||= begin
             lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
 
             libdatadog_version =
@@ -73,13 +117,12 @@ module Datadog
                 "#{Libdatadog::VERSION}-(unknown)"
               end
 
-            @profiler_info = {
+            {
               version: Datadog::Core::Environment::Identity.gem_datadog_version,
               libdatadog: libdatadog_version,
               settings: collect_settings_recursively(settings.profiling),
             }.freeze
           end
-          @profiler_info
         end
 
         # The settings/option model isn't directly serializable because
@@ -87,6 +130,7 @@ module Datadog
         # instances without proper serialization.
         # This method navigates a settings object recursively, converting
         # it into more basic types that are trivially convertible to JSON.
+        #: (untyped) -> untyped
         def collect_settings_recursively(v)
           v = v.options_hash if v.respond_to?(:options_hash)
 
@@ -106,6 +150,16 @@ module Datadog
             v.inspect
           end
         end
+
+        #: () -> ::Hash[::Symbol, ::String]
+        def collect_gc_tuning_info
+          return @gc_tuning_info if defined?(@gc_tuning_info)
+
+          @gc_tuning_info = RUBY_GC_TUNING_ENV_VARS.each_with_object({}) do |var, hash|
+            current_value = DATADOG_ENV[var]
+            hash[var.to_sym] = current_value if current_value
+          end.freeze
+        end
       end
     end
   end

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

@@ -19,22 +19,21 @@ module Datadog
           max_frames:,
           tracer:,
           endpoint_collection_enabled:,
-          timeline_enabled:,
-          waiting_for_gvl_threshold_ns:,
           otel_context_enabled:,
-          allocation_type_enabled: true
+          native_filenames_enabled:,
+          show_classes:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
-            self,
-            recorder,
-            max_frames,
-            tracer_context_key,
-            endpoint_collection_enabled,
-            timeline_enabled,
-            waiting_for_gvl_threshold_ns,
-            otel_context_enabled,
-            allocation_type_enabled,
+            self_instance: self,
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer_context_key: tracer_context_key,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
+            overhead_filename: __FILE__,
           )
         end
 
@@ -43,26 +42,34 @@ module Datadog
           max_frames: 400,
           tracer: nil,
           endpoint_collection_enabled: false,
-          timeline_enabled: false,
-          waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
+          native_filenames_enabled: true,
+          show_classes: false,
+          trigger_global_reset: true,
           **options
         )
-          new(
+          collector = new(
             recorder: recorder,
             max_frames: max_frames,
             tracer: tracer,
             endpoint_collection_enabled: endpoint_collection_enabled,
-            timeline_enabled: timeline_enabled,
-            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             **options,
           )
+
+          # By default, mirror what the CpuAndWallTimeWorker does when profiling starts: reset the global per-thread
+          # context state, which (among other things) resizes the per-thread sampling buffers to this collector's
+          # max_frames. Tests that need to control this explicitly can pass `trigger_global_reset: false`.
+          Testing._native_global_reset_per_thread_context(collector) if trigger_global_reset
+
+          collector
         end
 
         def inspect
           # Compose Ruby's default inspect with our custom inspect for the native parts
-          result = super()
+          result = super
           result[-1] = "#{self.class._native_inspect(self)}>"
           result
         end