ddtrace 1.6.1 → 1.8.0

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -3,11 +3,18 @@
 #include <ruby/thread_native.h>
 #include <ruby/debug.h>
 #include <stdbool.h>
+#include <stdatomic.h>
 #include <signal.h>
+#include <errno.h>
+
 #include "helpers.h"
 #include "ruby_helpers.h"
 #include "collectors_cpu_and_wall_time.h"
+#include "collectors_dynamic_sampling_rate.h"
+#include "collectors_idle_sampling_helper.h"
 #include "private_vm_api_access.h"
+#include "setup_signal_handler.h"
+#include "time_helpers.h"
 
 // Used to trigger the periodic execution of Collectors::CpuAndWallTime, which implements all of the sampling logic
 // itself; this class only implements the "doing it periodically" part.
@@ -29,7 +36,7 @@
 // internals, we may be able to figure out a way of overcoming it. But it's definitely going to be hard so for now
 // we're considering it as a given.
 //
-// ### Flow for triggering samples
+// ### Flow for triggering CPU/Wall-time samples
 //
 // The flow for triggering samples is as follows:
 //
@@ -56,23 +63,56 @@
 // 4. The Ruby VM calls our `sample_from_postponed_job` from a thread holding the global VM lock. A sample is recorded by
 // calling `cpu_and_wall_time_collector_sample`.
 //
+// ### TracePoints and Forking
+//
+// When the Ruby VM forks, the CPU/Wall-time profiling stops naturally because it's triggered by a background thread
+// that doesn't get automatically restarted by the VM on the child process. (The profiler does trigger its restart at
+// some point -- see `Profiling::Tasks::Setup` for details).
+//
+// But this doesn't apply to any `TracePoint`s this class may use, which will continue to be active. Thus, we need to
+// always remember consider this case of -- the worker thread may not be alive but the `TracePoint`s can continue to
+// trigger samples.
+//
 // ---
 
 // Contains state for a single CpuAndWallTimeWorker instance
 struct cpu_and_wall_time_worker_state {
-  // Important: This is not atomic nor is it guaranteed to replace memory barriers and the like. Aka this works for
-  // telling the sampling trigger loop to stop, but if we ever need to communicate more, we should move to actual
-  // atomic operations. stdatomic.h seems a nice thing to reach out for.
-  volatile bool should_run;
+  atomic_bool should_run;
+
   bool gc_profiling_enabled;
+  VALUE self_instance;
   VALUE cpu_and_wall_time_collector_instance;
+  VALUE idle_sampling_helper_instance;
+  VALUE owner_thread;
+  dynamic_sampling_rate_state dynamic_sampling_rate;
 
   // When something goes wrong during sampling, we record the Ruby exception here, so that it can be "re-raised" on
   // the CpuAndWallTimeWorker thread
   VALUE failure_exception;
+  // Used by `_native_stop` to flag the worker thread to start (see comment on `_native_sampling_loop`)
+  VALUE stop_thread;
 
   // Used to get gc start/finish information
   VALUE gc_tracepoint;
+
+  struct stats {
+    // How many times we tried to trigger a sample
+    unsigned int trigger_sample_attempts;
+    // How many times we tried to simulate signal delivery
+    unsigned int trigger_simulated_signal_delivery_attempts;
+    // How many times we actually simulated signal delivery
+    unsigned int simulated_signal_delivery;
+    // How many times we actually called rb_postponed_job_register_one from a signal handler
+    unsigned int signal_handler_enqueued_sample;
+    // How many times the signal handler was called from the wrong thread
+    unsigned int signal_handler_wrong_thread;
+    // How many times we actually sampled (except GC samples)
+    unsigned int sampled;
+    // Min/max/total wall-time spent sampling (except GC samples)
+    uint64_t sampling_time_ns_min;
+    uint64_t sampling_time_ns_max;
+    uint64_t sampling_time_ns_total;
+  } stats;
 };
 
 static VALUE _native_new(VALUE klass);
@@ -80,19 +120,18 @@ static VALUE _native_initialize(
   DDTRACE_UNUSED VALUE _self,
   VALUE self_instance,
   VALUE cpu_and_wall_time_collector_instance,
-  VALUE gc_profiling_enabled
+  VALUE gc_profiling_enabled,
+  VALUE idle_sampling_helper_instance
 );
 static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr);
 static VALUE _native_sampling_loop(VALUE self, VALUE instance);
-static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance);
+static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE worker_thread);
 static VALUE stop(VALUE self_instance, VALUE optional_exception);
-static void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *));
-static void remove_sigprof_signal_handler(void);
-static void block_sigprof_signal_handler_from_running_in_current_thread(void);
 static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 static void *run_sampling_trigger_loop(void *state_ptr);
 static void interrupt_sampling_trigger_loop(void *state_ptr);
 static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused);
+static VALUE rescued_sample_from_postponed_job(VALUE self_instance);
 static VALUE handle_sampling_failure(VALUE self_instance, VALUE exception);
 static VALUE _native_current_sigprof_signal_handler(DDTRACE_UNUSED VALUE self);
 static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance);
@@ -104,22 +143,30 @@ static VALUE _native_trigger_sample(DDTRACE_UNUSED VALUE self);
 static VALUE _native_gc_tracepoint(DDTRACE_UNUSED VALUE self, VALUE instance);
 static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused);
 static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused);
-static void safely_call(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg, VALUE instance);
+static VALUE safely_call(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg, VALUE instance);
 static VALUE _native_simulate_handle_sampling_signal(DDTRACE_UNUSED VALUE self);
 static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE self);
-
-// Global state -- be very careful when accessing or modifying it
-
-// Note: Global state must only be mutated while holding the global VM lock (we piggy back on it to ensure correctness).
-// The active_sampler_instance needs to be global because we access it from the signal handler.
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance);
+static VALUE _native_is_sigprof_blocked_in_current_thread(DDTRACE_UNUSED VALUE self);
+static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance);
+void *simulate_sampling_signal_delivery(DDTRACE_UNUSED void *_unused);
+static void grab_gvl_and_sample(void);
+static void reset_stats(struct cpu_and_wall_time_worker_state *state);
+static void sleep_for(uint64_t time_ns);
+
+// Note on sampler global state safety:
+//
+// Both `active_sampler_instance` and `active_sampler_instance_state` are **GLOBAL** state. Be careful when accessing
+// or modifying them.
+// In particular, it's important to only mutate them while holding the global VM lock, to ensure correctness.
+//
+// This global state is needed because a bunch of functions on this file need to access it from situations
+// (e.g. signal handler) where it's impossible or just awkward to pass it as an argument.
 static VALUE active_sampler_instance = Qnil;
-// ...We also store active_sampler_owner_thread to be able to tell who the active_sampler_instance belongs to (and also
-// to detect when it is outdated)
-static VALUE active_sampler_owner_thread = Qnil;
+struct cpu_and_wall_time_worker_state *active_sampler_instance_state = NULL;
 
 void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   rb_global_variable(&active_sampler_instance);
-  rb_global_variable(&active_sampler_owner_thread);
 
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
   VALUE collectors_cpu_and_wall_time_worker_class = rb_define_class_under(collectors_module, "CpuAndWallTimeWorker", rb_cObject);
@@ -136,9 +183,11 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   // https://bugs.ruby-lang.org/issues/18007 for a discussion around this.
   rb_define_alloc_func(collectors_cpu_and_wall_time_worker_class, _native_new);
 
-  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 3);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 4);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_sampling_loop", _native_sampling_loop, 1);
-  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stop", _native_stop, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stop", _native_stop, 2);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stats", _native_stats, 1);
   rb_define_singleton_method(testing_module, "_native_current_sigprof_signal_handler", _native_current_sigprof_signal_handler, 0);
   rb_define_singleton_method(testing_module, "_native_is_running?", _native_is_running, 1);
   rb_define_singleton_method(testing_module, "_native_install_testing_signal_handler", _native_install_testing_signal_handler, 0);
@@ -147,6 +196,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   rb_define_singleton_method(testing_module, "_native_gc_tracepoint", _native_gc_tracepoint, 1);
   rb_define_singleton_method(testing_module, "_native_simulate_handle_sampling_signal", _native_simulate_handle_sampling_signal, 0);
   rb_define_singleton_method(testing_module, "_native_simulate_sample_from_postponed_job", _native_simulate_sample_from_postponed_job, 0);
+  rb_define_singleton_method(testing_module, "_native_is_sigprof_blocked_in_current_thread", _native_is_sigprof_blocked_in_current_thread, 0);
 }
 
 // This structure is used to define a Ruby object that stores a pointer to a struct cpu_and_wall_time_worker_state
@@ -156,7 +206,7 @@ static const rb_data_type_t cpu_and_wall_time_worker_typed_data = {
   .function = {
     .dmark = cpu_and_wall_time_worker_typed_data_mark,
     .dfree = RUBY_DEFAULT_FREE,
-    .dsize = NULL, // We don't track profile memory usage (although it'd be cool if we did!)
+    .dsize = NULL, // We don't track memory usage (although it'd be cool if we did!)
     //.dcompact = NULL, // FIXME: Add support for compaction
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -165,20 +215,26 @@ static const rb_data_type_t cpu_and_wall_time_worker_typed_data = {
 static VALUE _native_new(VALUE klass) {
   struct cpu_and_wall_time_worker_state *state = ruby_xcalloc(1, sizeof(struct cpu_and_wall_time_worker_state));
 
-  state->should_run = false;
+  atomic_init(&state->should_run, false);
   state->gc_profiling_enabled = false;
   state->cpu_and_wall_time_collector_instance = Qnil;
+  state->idle_sampling_helper_instance = Qnil;
+  state->owner_thread = Qnil;
+  dynamic_sampling_rate_init(&state->dynamic_sampling_rate);
   state->failure_exception = Qnil;
+  state->stop_thread = Qnil;
   state->gc_tracepoint = Qnil;
+  reset_stats(state);
 
-  return TypedData_Wrap_Struct(klass, &cpu_and_wall_time_worker_typed_data, state);
+  return state->self_instance = TypedData_Wrap_Struct(klass, &cpu_and_wall_time_worker_typed_data, state);
 }
 
 static VALUE _native_initialize(
   DDTRACE_UNUSED VALUE _self,
   VALUE self_instance,
   VALUE cpu_and_wall_time_collector_instance,
-  VALUE gc_profiling_enabled
+  VALUE gc_profiling_enabled,
+  VALUE idle_sampling_helper_instance
 ) {
   ENFORCE_BOOLEAN(gc_profiling_enabled);
 
@@ -187,6 +243,7 @@ static VALUE _native_initialize(
 
   state->gc_profiling_enabled = (gc_profiling_enabled == Qtrue);
   state->cpu_and_wall_time_collector_instance = enforce_cpu_and_wall_time_collector_instance(cpu_and_wall_time_collector_instance);
+  state->idle_sampling_helper_instance = idle_sampling_helper_instance;
   state->gc_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_GC_ENTER | RUBY_INTERNAL_EVENT_GC_EXIT, on_gc_event, NULL /* unused */);
 
   return Qtrue;
@@ -197,7 +254,10 @@ static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr) {
   struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
 
   rb_gc_mark(state->cpu_and_wall_time_collector_instance);
+  rb_gc_mark(state->idle_sampling_helper_instance);
+  rb_gc_mark(state->owner_thread);
   rb_gc_mark(state->failure_exception);
+  rb_gc_mark(state->stop_thread);
   rb_gc_mark(state->gc_tracepoint);
 }
 
@@ -206,8 +266,9 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   struct cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  if (active_sampler_owner_thread != Qnil) {
-    if (is_thread_alive(active_sampler_owner_thread)) {
+  struct cpu_and_wall_time_worker_state *old_state = active_sampler_instance_state;
+  if (old_state != NULL) {
+    if (is_thread_alive(old_state->owner_thread)) {
       rb_raise(
         rb_eRuntimeError,
         "Could not start CpuAndWallTimeWorker: There's already another instance of CpuAndWallTimeWorker active in a different thread"
@@ -221,23 +282,26 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
       // b) If this is the same instance of the CpuAndWallTimeWorker if we call enable on a tracepoint that is already
       //    enabled, it will start firing more than once, see https://bugs.ruby-lang.org/issues/19114 for details.
 
-      struct cpu_and_wall_time_worker_state *old_state;
-      TypedData_Get_Struct(active_sampler_instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, old_state);
       rb_tracepoint_disable(old_state->gc_tracepoint);
     }
   }
 
+  // We use `stop_thread` to distinguish when `_native_stop` was called before we actually had a chance to start. In this
+  // situation we stop immediately and never even start the sampling trigger loop.
+  if (state->stop_thread == rb_thread_current()) return Qnil;
+
+  // Reset the dynamic sampling rate state, if any (reminder: the monotonic clock reference may change after a fork)
+  dynamic_sampling_rate_reset(&state->dynamic_sampling_rate);
+
   // This write to a global is thread-safe BECAUSE we're still holding on to the global VM lock at this point
+  active_sampler_instance_state = state;
   active_sampler_instance = instance;
-  active_sampler_owner_thread = rb_thread_current();
+  state->owner_thread = rb_thread_current();
 
-  state->should_run = true;
+  atomic_store(&state->should_run, true);
 
   block_sigprof_signal_handler_from_running_in_current_thread(); // We want to interrupt the thread with the global VM lock, never this one
 
-  install_sigprof_signal_handler(handle_sampling_signal);
-  if (state->gc_profiling_enabled) rb_tracepoint_enable(state->gc_tracepoint);
-
   // Release GVL, get to the actual work!
   int exception_state;
   rb_protect(release_gvl_and_run_sampling_trigger_loop, instance, &exception_state);
@@ -245,9 +309,32 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   // The sample trigger loop finished (either cleanly or with an error); let's clean up
 
   rb_tracepoint_disable(state->gc_tracepoint);
-  remove_sigprof_signal_handler();
+
+  active_sampler_instance_state = NULL;
   active_sampler_instance = Qnil;
-  active_sampler_owner_thread = Qnil;
+  state->owner_thread = Qnil;
+
+  // If this `Thread` is about to die, why is this important? It's because Ruby caches native threads for a period after
+  // the `Thread` dies, and reuses them if a new Ruby `Thread` gets created. This means that while conceptually the
+  // worker background `Thread` is about to die, the low-level native OS thread can be reused for something else in the Ruby app.
+  // Then, the reused thread would "inherit" the SIGPROF blocking, which is... really unexpected.
+  // This actually caused a flaky test -- the `native_extension_spec.rb` creates a `Thread` and tries to specifically
+  // send SIGPROF signals to it, and oops it could fail if it got the reused native thread from the worker which still
+  // had SIGPROF delivery blocked. :hide_the_pain_harold:
+  unblock_sigprof_signal_handler_from_running_in_current_thread();
+
+  // Why replace and not use remove the signal handler? We do this because when a process receives a SIGPROF without
+  // having an explicit signal handler set up, the process will instantly terminate with a confusing
+  // "Profiling timer expired" message left behind. (This message doesn't come from us -- it's the default message for
+  // an unhandled SIGPROF. Pretty confusing UNIX/POSIX behavior...)
+  //
+  // Unfortunately, because signal delivery is asynchronous, there's no way to guarantee that there are no pending
+  // profiler-sent signals by the time we get here and want to clean up.
+  // @ivoanjo: I suspect this will never happen, but the cost of getting it wrong is really high (VM terminates) so this
+  // is a just-in-case situation.
+  //
+  // Note 2: This can raise exceptions as well, so make sure that all cleanups are done by the time we get here.
+  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal);
 
   // Ensure that instance is not garbage collected while the native sampling loop is running; this is probably not needed, but just in case
   RB_GC_GUARD(instance);
@@ -257,7 +344,12 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   return Qnil;
 }
 
-static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance) {
+static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE worker_thread) {
+  struct cpu_and_wall_time_worker_state *state;
+  TypedData_Get_Struct(self_instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+
+  state->stop_thread = worker_thread;
+
   return stop(self_instance, /* optional_exception: */ Qnil);
 }
 
@@ -265,7 +357,7 @@ static VALUE stop(VALUE self_instance, VALUE optional_exception) {
   struct cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  state->should_run = false;
+  atomic_store(&state->should_run, false);
   state->failure_exception = optional_exception;
 
   // Disable the GC tracepoint as soon as possible, so the VM doesn't keep on calling it
@@ -274,92 +366,80 @@ static VALUE stop(VALUE self_instance, VALUE optional_exception) {
   return Qtrue;
 }
 
-static void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *)) {
-  struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
-  struct sigaction signal_handler_config = {
-    .sa_flags = SA_RESTART | SA_SIGINFO,
-    .sa_sigaction = signal_handler_function
-  };
-  sigemptyset(&signal_handler_config.sa_mask);
-
-  if (sigaction(SIGPROF, &signal_handler_config, &existing_signal_handler_config) != 0) {
-    rb_sys_fail("Could not start CpuAndWallTimeWorker: Could not install signal handler");
-  }
-
-  // In some corner cases (e.g. after a fork), our signal handler may still be around, and that's ok
-  if (existing_signal_handler_config.sa_sigaction == handle_sampling_signal) return;
-
-  if (existing_signal_handler_config.sa_handler != NULL || existing_signal_handler_config.sa_sigaction != NULL) {
-    // A previous signal handler already existed. Currently we don't support this situation, so let's just back out
-    // of the installation.
-
-    if (sigaction(SIGPROF, &existing_signal_handler_config, NULL) != 0) {
-      rb_sys_fail(
-        "Could not start CpuAndWallTimeWorker: Could not re-install pre-existing SIGPROF signal handler. " \
-        "This may break the component had installed it."
-      );
-    }
-
-    rb_raise(rb_eRuntimeError, "Could not start CpuAndWallTimeWorker: There's a pre-existing SIGPROF signal handler");
-  }
-}
-
-static void remove_sigprof_signal_handler(void) {
-  struct sigaction signal_handler_config = {
-    .sa_handler = SIG_DFL, // Reset back to default
-    .sa_flags = SA_RESTART // TODO: Unclear if this is actually needed/does anything at all
-  };
-  sigemptyset(&signal_handler_config.sa_mask);
-
-  if (sigaction(SIGPROF, &signal_handler_config, NULL) != 0) rb_sys_fail("Failure while removing the signal handler");
-}
-
-static void block_sigprof_signal_handler_from_running_in_current_thread(void) {
-  sigset_t signals_to_block;
-  sigemptyset(&signals_to_block);
-  sigaddset(&signals_to_block, SIGPROF);
-  pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL);
-}
-
 // NOTE: Remember that this will run in the thread and within the scope of user code, including user C code.
 // We need to be careful not to change any state that may be observed OR to restore it if we do. For instance, if anything
 // we do here can set `errno`, then we must be careful to restore the old `errno` after the fact.
 static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
-  if (!ruby_thread_has_gvl_p()) {
-    return; // Not safe to enqueue a sample from this thread
-  }
-  if (!ddtrace_rb_ractor_main_p()) {
-    return; // We're not on the main Ractor; we currently don't support profiling non-main Ractors
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
+
+  // This can potentially happen if the CpuAndWallTimeWorker was stopped while the signal delivery was happening; nothing to do
+  if (state == NULL) return;
+
+  if (
+    !ruby_native_thread_p() || // Not a Ruby thread
+    !is_current_thread_holding_the_gvl() || // Not safe to enqueue a sample from this thread
+    !ddtrace_rb_ractor_main_p() // We're not on the main Ractor; we currently don't support profiling non-main Ractors
+  ) {
+    state->stats.signal_handler_wrong_thread++;
+    return;
   }
 
   // We implicitly assume there can be no concurrent nor nested calls to handle_sampling_signal because
   // a) we get triggered using SIGPROF, and the docs state second SIGPROF will not interrupt an existing one
   // b) we validate we are in the thread that has the global VM lock; if a different thread gets a signal, it will return early
   //    because it will not have the global VM lock
-  // TODO: Validate that this does not impact Ractors
 
   // Note: rb_postponed_job_register_one ensures that if there's a previous sample_from_postponed_job queued for execution
   // then we will not queue a second one. It does this by doing a linear scan on the existing jobs; in the future we
   // may want to implement that check ourselves.
 
-  // TODO: Do something with result (potentially update tracking counters?)
+  state->stats.signal_handler_enqueued_sample++;
+
+  // Note: If we ever want to get rid of rb_postponed_job_register_one, remember not to clobber Ruby exceptions, as
+  // this function does this helpful job for us now -- https://github.com/ruby/ruby/commit/a98e343d39c4d7bf1e2190b076720f32d9f298b3.
   /*int result =*/ rb_postponed_job_register_one(0, sample_from_postponed_job, NULL);
+  // TODO: Do something with result (potentially update tracking counters?)
 }
 
 // The actual sampling trigger loop always runs **without** the global vm lock.
 static void *run_sampling_trigger_loop(void *state_ptr) {
   struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
 
-  struct timespec time_between_signals = {.tv_nsec = 10 * 1000 * 1000 /* 10ms */};
+  uint64_t minimum_time_between_signals = MILLIS_AS_NS(10);
+
+  while (atomic_load(&state->should_run)) {
+    state->stats.trigger_sample_attempts++;
 
-  while (state->should_run) {
     // TODO: This is still a placeholder for a more complex mechanism. In particular:
-    // * We want to signal a particular thread or threads, not the process in general
-    // * We want to track if a signal landed on the thread holding the global VM lock and do something about it
     // * We want to do more than having a fixed sampling rate
 
-    kill(getpid(), SIGPROF);
-    nanosleep(&time_between_signals, NULL);
+    current_gvl_owner owner = gvl_owner();
+    if (owner.valid) {
+      // Note that reading the GVL owner and sending them a signal is a race -- the Ruby VM keeps on executing while
+      // we're doing this, so we may still not signal the correct thread from time to time, but our signal handler
+      // includes a check to see if it got called in the right thread
+      pthread_kill(owner.owner, SIGPROF);
+    } else {
+      // If no thread owns the Global VM Lock, the application is probably idle at the moment. We still want to sample
+      // so we "ask a friend" (the IdleSamplingHelper component) to grab the GVL and simulate getting a SIGPROF.
+      //
+      // In a previous version of the code, we called `grab_gvl_and_sample` directly BUT this was problematic because
+      // Ruby may concurrently get busy and so the CpuAndWallTimeWorker would be blocked in line to acquire the GVL
+      // for an uncontrolled amount of time. (This can still happen to the IdleSamplingHelper, but the
+      // CpuAndWallTimeWorker will still be free to interrupt the Ruby VM and keep sampling for the entire blocking period).
+      state->stats.trigger_simulated_signal_delivery_attempts++;
+      idle_sampling_helper_request_action(state->idle_sampling_helper_instance, grab_gvl_and_sample);
+    }
+
+    sleep_for(minimum_time_between_signals);
+
+    // The dynamic sampling rate module keeps track of how long samples are taking, and in here we extend our sleep time
+    // to take that into account.
+    // Note that we deliberately should NOT combine this sleep_for with the one above because the result of
+    // `dynamic_sampling_rate_get_sleep` may have changed while the above sleep was ongoing.
+    uint64_t extra_sleep =
+      dynamic_sampling_rate_get_sleep(&state->dynamic_sampling_rate, monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE));
+    if (extra_sleep > 0) sleep_for(extra_sleep);
   }
 
   return NULL; // Unused
@@ -369,14 +449,14 @@ static void *run_sampling_trigger_loop(void *state_ptr) {
 static void interrupt_sampling_trigger_loop(void *state_ptr) {
   struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
 
-  state->should_run = false;
+  atomic_store(&state->should_run, false);
 }
 
 static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
-  VALUE instance = active_sampler_instance; // Read from global variable
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
 
   // This can potentially happen if the CpuAndWallTimeWorker was stopped while the postponed job was waiting to be executed; nothing to do
-  if (instance == Qnil) return;
+  if (state == NULL) return;
 
   // @ivoanjo: I'm not sure this can ever happen because `handle_sampling_signal` only enqueues this callback if
   // it's running on the main Ractor, but just in case...
@@ -384,14 +464,45 @@ static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
     return; // We're not on the main Ractor; we currently don't support profiling non-main Ractors
   }
 
+  // Rescue against any exceptions that happen during sampling
+  safely_call(rescued_sample_from_postponed_job, state->self_instance, state->self_instance);
+}
+
+static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
   struct cpu_and_wall_time_worker_state *state;
-  TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+  TypedData_Get_Struct(self_instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  // Trigger sampling using the Collectors::CpuAndWallTime; rescue against any exceptions that happen during sampling
-  safely_call(cpu_and_wall_time_collector_sample, state->cpu_and_wall_time_collector_instance, instance);
+  long wall_time_ns_before_sample = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
+
+  if (!dynamic_sampling_rate_should_sample(&state->dynamic_sampling_rate, wall_time_ns_before_sample)) {
+    // TODO: Add a counter for this
+    return Qnil;
+  }
+
+  state->stats.sampled++;
+
+  cpu_and_wall_time_collector_sample(state->cpu_and_wall_time_collector_instance, wall_time_ns_before_sample);
+
+  long wall_time_ns_after_sample = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
+  long delta_ns = wall_time_ns_after_sample - wall_time_ns_before_sample;
+
+  // Guard against wall-time going backwards, see https://github.com/DataDog/dd-trace-rb/pull/2336 for discussion.
+  uint64_t sampling_time_ns = delta_ns < 0 ? 0 : delta_ns;
+
+  state->stats.sampling_time_ns_min = uint64_min_of(sampling_time_ns, state->stats.sampling_time_ns_min);
+  state->stats.sampling_time_ns_max = uint64_max_of(sampling_time_ns, state->stats.sampling_time_ns_max);
+  state->stats.sampling_time_ns_total += sampling_time_ns;
+
+  dynamic_sampling_rate_after_sample(&state->dynamic_sampling_rate, wall_time_ns_after_sample, sampling_time_ns);
+
+  // Return a dummy VALUE because we're called from rb_rescue2 which requires it
+  return Qnil;
 }
 
-static VALUE handle_sampling_failure(VALUE self_instance, VALUE exception) { return stop(self_instance, exception); }
+static VALUE handle_sampling_failure(VALUE self_instance, VALUE exception) {
+  stop(self_instance, exception);
+  return Qnil;
+}
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
@@ -403,6 +514,8 @@ static VALUE _native_current_sigprof_signal_handler(DDTRACE_UNUSED VALUE self) {
 
   if (existing_signal_handler_config.sa_sigaction == handle_sampling_signal) {
     return ID2SYM(rb_intern("profiling"));
+  } else if (existing_signal_handler_config.sa_sigaction == empty_signal_handler) {
+    return ID2SYM(rb_intern("empty"));
   } else if (existing_signal_handler_config.sa_sigaction != NULL) {
     return ID2SYM(rb_intern("other"));
   } else {
@@ -414,6 +527,11 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
   struct cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
+  // Final preparations: Setup signal handler and enable tracepoint. We run these here and not in `_native_sampling_loop`
+  // because they may raise exceptions.
+  install_sigprof_signal_handler(handle_sampling_signal, "handle_sampling_signal");
+  if (state->gc_profiling_enabled) rb_tracepoint_enable(state->gc_tracepoint);
+
   rb_thread_call_without_gvl(run_sampling_trigger_loop, state, interrupt_sampling_trigger_loop, state);
 
   // If we stopped sampling due to an exception, re-raise it (now in the worker thread)
@@ -425,9 +543,9 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_is_running(DDTRACE_UNUSED VALUE self, VALUE instance) {
-  return \
-    (active_sampler_owner_thread != Qnil && is_thread_alive(active_sampler_owner_thread) && active_sampler_instance == instance) ?
-    Qtrue : Qfalse;
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
+
+  return (state != NULL && is_thread_alive(state->owner_thread) && state->self_instance == instance) ? Qtrue : Qfalse;
 }
 
 static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
@@ -437,7 +555,7 @@ static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_install_testing_signal_handler(DDTRACE_UNUSED VALUE self) {
-  install_sigprof_signal_handler(testing_signal_handler);
+  install_sigprof_signal_handler(testing_signal_handler, "testing_signal_handler");
   return Qtrue;
 }
 
@@ -485,16 +603,11 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
   int event = rb_tracearg_event_flag(rb_tracearg_from_tracepoint(tracepoint_data));
   if (event != RUBY_INTERNAL_EVENT_GC_ENTER && event != RUBY_INTERNAL_EVENT_GC_EXIT) return; // Unknown event
 
-  VALUE instance = active_sampler_instance; // Read from global variable
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
 
   // This should not happen in a normal situation because the tracepoint is always enabled after the instance is set
   // and disabled before it is cleared, but just in case...
-  if (instance == Qnil) return;
-
-  struct cpu_and_wall_time_worker_state *state;
-  if (!rb_typeddata_is_kind_of(instance, &cpu_and_wall_time_worker_typed_data)) return;
-  // This should never fail the the above check passes
-  TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+  if (state == NULL) return;
 
   if (event == RUBY_INTERNAL_EVENT_GC_ENTER) {
     cpu_and_wall_time_collector_on_gc_start(state->cpu_and_wall_time_collector_instance);
@@ -517,15 +630,18 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
     cpu_and_wall_time_collector_on_gc_finish(state->cpu_and_wall_time_collector_instance);
     // We use rb_postponed_job_register_one to ask Ruby to run cpu_and_wall_time_collector_sample_after_gc after if
     // fully finishes the garbage collection, so that one is allowed to do allocations and throw exceptions as usual.
+    //
+    // Note: If we ever want to get rid of rb_postponed_job_register_one, remember not to clobber Ruby exceptions, as
+    // this function does this helpful job for us now -- https://github.com/ruby/ruby/commit/a98e343d39c4d7bf1e2190b076720f32d9f298b3.
     rb_postponed_job_register_one(0, after_gc_from_postponed_job, NULL);
   }
 }
 
 static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused) {
-  VALUE instance = active_sampler_instance; // Read from global variable
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
 
   // This can potentially happen if the CpuAndWallTimeWorker was stopped while the postponed job was waiting to be executed; nothing to do
-  if (instance == Qnil) return;
+  if (state == NULL) return;
 
   // @ivoanjo: I'm not sure this can ever happen because `on_gc_event` only enqueues this callback if
   // it's running on the main Ractor, but just in case...
@@ -533,18 +649,15 @@ static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused) {
     return; // We're not on the main Ractor; we currently don't support profiling non-main Ractors
   }
 
-  struct cpu_and_wall_time_worker_state *state;
-  TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
-
   // Trigger sampling using the Collectors::CpuAndWallTime; rescue against any exceptions that happen during sampling
-  safely_call(cpu_and_wall_time_collector_sample_after_gc, state->cpu_and_wall_time_collector_instance, instance);
+  safely_call(cpu_and_wall_time_collector_sample_after_gc, state->cpu_and_wall_time_collector_instance, state->self_instance);
 }
 
 // Equivalent to Ruby begin/rescue call, where we call a C function and jump to the exception handler if an
 // exception gets raised within
-static void safely_call(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg, VALUE instance) {
+static VALUE safely_call(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg, VALUE instance) {
   VALUE exception_handler_function_arg = instance;
-  rb_rescue2(
+  return rb_rescue2(
     function_to_call_safely,
     function_to_call_safely_arg,
     handle_sampling_failure,
@@ -567,3 +680,97 @@ static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE sel
   sample_from_postponed_job(NULL);
   return Qtrue;
 }
+
+// After the Ruby VM forks, this method gets called in the child process to clean up any leftover state from the parent.
+//
+// Assumption: This method gets called BEFORE restarting profiling. Note that profiling-related tracepoints may still
+// be active, so we make sure to disable them before calling into anything else, so that there are no components
+// attempting to trigger samples at the same time as the reset is done.
+//
+// In the future, if we add more other components with tracepoints, we will need to coordinate stopping all such
+// tracepoints before doing the other cleaning steps.
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance) {
+  struct cpu_and_wall_time_worker_state *state;
+  TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+
+  // Disable all tracepoints, so that there are no more attempts to mutate the profile
+  rb_tracepoint_disable(state->gc_tracepoint);
+
+  reset_stats(state);
+
+  // Remove all state from the `Collectors::CpuAndWallTime` and connected downstream components
+  rb_funcall(state->cpu_and_wall_time_collector_instance, rb_intern("reset_after_fork"), 0);
+
+  return Qtrue;
+}
+
+static VALUE _native_is_sigprof_blocked_in_current_thread(DDTRACE_UNUSED VALUE self) {
+  return is_sigprof_blocked_in_current_thread();
+}
+
+static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
+  struct cpu_and_wall_time_worker_state *state;
+  TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+
+  VALUE pretty_sampling_time_ns_min = state->stats.sampling_time_ns_min == UINT64_MAX ? Qnil : ULL2NUM(state->stats.sampling_time_ns_min);
+  VALUE pretty_sampling_time_ns_max = state->stats.sampling_time_ns_max == 0 ? Qnil : ULL2NUM(state->stats.sampling_time_ns_max);
+  VALUE pretty_sampling_time_ns_total = state->stats.sampling_time_ns_total == 0 ? Qnil : ULL2NUM(state->stats.sampling_time_ns_total);
+  VALUE pretty_sampling_time_ns_avg =
+    state->stats.sampled == 0 ? Qnil : DBL2NUM(((double) state->stats.sampling_time_ns_total) / state->stats.sampled);
+
+  VALUE stats_as_hash = rb_hash_new();
+  VALUE arguments[] = {
+    ID2SYM(rb_intern("trigger_sample_attempts")),                    /* => */ UINT2NUM(state->stats.trigger_sample_attempts),
+    ID2SYM(rb_intern("trigger_simulated_signal_delivery_attempts")), /* => */ UINT2NUM(state->stats.trigger_simulated_signal_delivery_attempts),
+    ID2SYM(rb_intern("simulated_signal_delivery")),                  /* => */ UINT2NUM(state->stats.simulated_signal_delivery),
+    ID2SYM(rb_intern("signal_handler_enqueued_sample")),             /* => */ UINT2NUM(state->stats.signal_handler_enqueued_sample),
+    ID2SYM(rb_intern("signal_handler_wrong_thread")),                /* => */ UINT2NUM(state->stats.signal_handler_wrong_thread),
+    ID2SYM(rb_intern("sampled")),                                    /* => */ UINT2NUM(state->stats.sampled),
+    ID2SYM(rb_intern("sampling_time_ns_min")),                       /* => */ pretty_sampling_time_ns_min,
+    ID2SYM(rb_intern("sampling_time_ns_max")),                       /* => */ pretty_sampling_time_ns_max,
+    ID2SYM(rb_intern("sampling_time_ns_total")),                     /* => */ pretty_sampling_time_ns_total,
+    ID2SYM(rb_intern("sampling_time_ns_avg")),                       /* => */ pretty_sampling_time_ns_avg,
+  };
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(stats_as_hash, arguments[i], arguments[i+1]);
+  return stats_as_hash;
+}
+
+void *simulate_sampling_signal_delivery(DDTRACE_UNUSED void *_unused) {
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
+
+  // This can potentially happen if the CpuAndWallTimeWorker was stopped while the IdleSamplingHelper was trying to execute this action
+  if (state == NULL) return NULL;
+
+  state->stats.simulated_signal_delivery++;
+
+  // @ivoanjo: We could instead directly call sample_from_postponed_job, but I chose to go through the signal handler
+  // so that the simulated case is as close to the original one as well (including any metrics increases, etc).
+  handle_sampling_signal(0, NULL, NULL);
+
+  return NULL; // Unused
+}
+
+static void grab_gvl_and_sample(void) { rb_thread_call_with_gvl(simulate_sampling_signal_delivery, NULL); }
+
+static void reset_stats(struct cpu_and_wall_time_worker_state *state) {
+  state->stats = (struct stats) {}; // Resets all stats back to zero
+  state->stats.sampling_time_ns_min = UINT64_MAX; // Since we always take the min between existing and latest sample
+}
+
+static void sleep_for(uint64_t time_ns) {
+  // As a simplification, we currently only support setting .tv_nsec
+  if (time_ns >= SECONDS_AS_NS(1)) {
+    grab_gvl_and_raise(rb_eArgError, "sleep_for can only sleep for less than 1 second, time_ns: %"PRIu64, time_ns);
+  }
+
+  struct timespec time_to_sleep = {.tv_nsec = time_ns};
+
+  while (nanosleep(&time_to_sleep, &time_to_sleep) != 0) {
+    if (errno == EINTR) {
+      // We were interrupted. nanosleep updates "time_to_sleep" to contain only the remaining time, so we just let the
+      // loop keep going.
+    } else {
+      ENFORCE_SUCCESS_NO_GVL(errno);
+    }
+  }
+}