datadog 2.36.0 → 2.38.0

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/debug.h>
 
 #include "datadog_ruby_common.h"
 #include "collectors_thread_context.h"
@@ -42,11 +43,8 @@
 // When `thread_context_collector_on_gc_start` gets called, the current cpu and wall-time get recorded to the thread
 // context: `cpu_time_at_gc_start_ns` and `wall_time_at_gc_start_ns`.
 //
-// While `cpu_time_at_gc_start_ns` is set, regular samples (if any) do not account for cpu-time any time that passes
-// after this timestamp. The idea is that this cpu-time will be blamed separately on GC, and not on the user thread.
-// Wall-time accounting is not affected by this (e.g. we still record 60 seconds every 60 seconds).
-//
-// (Regular samples can still account for the cpu-time between the previous sample and the start of GC.)
+// While `cpu_time_at_gc_start_ns` is set, we don't expect the thread to be sampled: the VM is doing GC
+// on the thread holding the GVL so no other samples can/will be triggered until GC finishes.
 //
 // When `thread_context_collector_on_gc_finish` gets called, the cpu-time and wall-time spent during GC gets recorded
 // into the global gc_tracking structure, and further samples are not affected. (The `cpu_time_at_previous_sample_ns`
@@ -75,8 +73,6 @@
 
 #define THREAD_ID_LIMIT_CHARS 44 // Why 44? "#{2**64} (#{2**64})".size + 1 for \0
 #define THREAD_INVOKE_LOCATION_LIMIT_CHARS 512
-#define IS_WALL_TIME true
-#define IS_CPU_TIME false
 #define MISSING_TRACER_CONTEXT_KEY 0
 #define TIME_BETWEEN_GC_EVENTS_NS MILLIS_AS_NS(10)
 #define GVL_SUSPENDED ((uint64_t)1)
@@ -108,6 +104,20 @@ static ID server_id;      // id of :server in Ruby
 static ID otel_context_storage_id; // id of :__opentelemetry_context_storage__ in Ruby
 static ID otel_fiber_context_storage_id; // id of :@opentelemetry_context in Ruby
 
+// This is mutable and gets set last-writer-wins style by
+// `thread_context_collector_reset_all_per_thread_contexts`, which is called whenever
+// profiling is starting or restating.
+//
+// Note: We must be careful to not change this value while the profiler is still running,
+// otherwise new threads can get the new value and cause profiling to stop with an
+// exception due to the mismatched size.
+//
+// The initial value should be kept in sync with the default for DD_PROFILING_MAX_FRAMES
+// in settings.rb. See `initialize_context` for details on why this is needed/used.
+static uint16_t latest_max_frames = 400;
+
+// Global tracepoint for RUBY_EVENT_THREAD_BEGIN. Created and enabled once when the first ThreadContext collector is initialized.
+static VALUE thread_begin_tracepoint = Qnil;
 
 typedef enum { OTEL_CONTEXT_ENABLED_FALSE, OTEL_CONTEXT_ENABLED_ONLY, OTEL_CONTEXT_ENABLED_BOTH } otel_context_enabled;
 typedef enum { OTEL_CONTEXT_SOURCE_UNKNOWN, OTEL_CONTEXT_SOURCE_FIBER_IVAR, OTEL_CONTEXT_SOURCE_FIBER_LOCAL } otel_context_source;
@@ -160,6 +170,7 @@ typedef struct {
     // How many per-thread samples were skipped because the thread has been continuously suspended
     // (no GVL) since its previous sample, so its Ruby stack cannot have changed.
     unsigned int inactive_thread_samples_skipped;
+    unsigned int profiler_thread_samples_skipped;
   } stats;
 
   struct {
@@ -171,7 +182,21 @@ typedef struct {
   } gc_tracking;
 } thread_context_collector_state;
 
-// Tracks per-thread state
+// Tracks per-thread state.
+// This state is global and lives forever on the Ruby Thread (until the Thread is GC'd).
+// The state is created early on for all threads on the main Ractor
+// (enabling a TracePoint only enables it for the current Ractor).
+// The state is either created when the Thread starts running (via the RUBY_EVENT_THREAD_BEGIN TracePoint),
+// or via `thread_context_collector_reset_all_per_thread_contexts` when the profiler starts.
+//
+// Unfortunately that RUBY_EVENT_THREAD_BEGIN TracePoint still fires after some other events:
+// * RUBY_INTERNAL_THREAD_EVENT_RESUMED for the Thread acquiring the GVL for the first time
+// * an early SIGPROF calling handle_sampling_signal()
+// * Ruby might check for interrupts and run postponed jobs (e.g. thread_context_collector_sample)
+// * another RUBY_EVENT_THREAD_BEGIN TracePoint which might run before ours
+// * etc
+// For those cases we have to ignore those events and we cannot assume the state is always set,
+// however this only matters for a very short period when a thread starts.
 struct per_thread_context {
   sampling_buffer sampling_buffer;
   char thread_id[THREAD_ID_LIMIT_CHARS];
@@ -179,8 +204,8 @@ struct per_thread_context {
   char thread_invoke_location[THREAD_INVOKE_LOCATION_LIMIT_CHARS];
   ddog_CharSlice thread_invoke_location_char_slice;
   thread_cpu_time_id thread_cpu_time_id;
-  long cpu_time_at_previous_sample_ns;  // Can be INVALID_TIME until initialized or if getting it fails for another reason
-  long wall_time_at_previous_sample_ns; // Can be INVALID_TIME until initialized
+  long cpu_time_at_previous_sample_ns;
+  long wall_time_at_previous_sample_ns;
 
   // There are 3 possible states for the GVL (per thread), and 3 transitions for which we receive GVL events:
   // Thread holds the GVL
@@ -233,6 +258,14 @@ struct per_thread_context {
   // but this is deemed worth it for this optimization. In any case we don't know exactly
   // at what time a thread was doing CPU work (unless it's on CPU 100% of the time).
   bool was_skipped_at_last_sample;
+  // Set as true for CpuAndWallTimeWorker and IdleSamplingHelper threads.
+  // When true, per-tick samples are skipped entirely; the thread is sampled only once per
+  // reporting period during the on_serialize flush.
+  //
+  // These threads are always in native code so their stacks aren't interesting;
+  // the Profiling::Scheduler thread on the other hand does a lot of different
+  // things using a mix of Ruby and native code, so that one isn't considered internal.
+  bool is_profiler_internal_thread;
 
   struct {
     // Both of these fields are set by on_gc_start and kept until on_gc_finish is called.
@@ -270,7 +303,6 @@ static void update_metrics_and_sample(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  sampling_buffer* sampling_buffer,
   long current_cpu_time_ns,
   long current_monotonic_wall_time_ns,
   bool force_sample
@@ -279,7 +311,6 @@ static void trigger_sample_for_thread(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  sampling_buffer* sampling_buffer,
   sample_values values,
   long current_monotonic_wall_time_ns,
   ddog_CharSlice *ruby_vm_type,
@@ -288,14 +319,16 @@ static void trigger_sample_for_thread(
   bool is_safe_to_allocate_objects
 );
 static VALUE _native_thread_list(VALUE self);
-static per_thread_context *get_or_create_context_for(VALUE thread, thread_context_collector_state *state);
-static void initialize_context(VALUE thread, per_thread_context *thread_context, thread_context_collector_state *state);
+static void check_frozen_thread(VALUE thread);
+static per_thread_context *get_or_create_context_for(VALUE thread);
+static void initialize_context(VALUE thread, per_thread_context *thread_context);
 static VALUE _native_inspect(VALUE self, VALUE collector_instance);
 static VALUE per_thread_context_to_ruby_hash(per_thread_context *thread_context);
 static VALUE stats_to_ruby_hash(thread_context_collector_state *state, VALUE hash);
 static VALUE gc_tracking_as_ruby_hash(thread_context_collector_state *state);
 static VALUE _native_per_thread_context(VALUE self, VALUE collector_instance);
-static long update_time_since_previous_sample(long *time_at_previous_sample_ns, long current_time_ns, long gc_start_time_ns, bool is_wall_time);
+static long update_cpu_time_since_previous_sample(per_thread_context *thread_context, long current_cpu_time_ns);
+static long update_wall_time_since_previous_sample(per_thread_context *thread_context, long current_wall_time_ns);
 static long cpu_time_now_ns(per_thread_context *thread_context);
 static long thread_id_for(VALUE thread);
 static VALUE _native_stats(VALUE self, VALUE collector_instance);
@@ -326,17 +359,16 @@ static bool handle_gvl_waiting(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  sampling_buffer* sampling_buffer,
   long current_cpu_time_ns
 );
+static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
+static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread);
 #ifndef NO_GVL_INSTRUMENTATION
-  static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
   static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread);
   static VALUE _native_on_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread);
-  static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread);
   static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception);
-  static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE thread, VALUE delta_ns);
 #endif
+static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE thread, VALUE delta_ns);
 static void otel_without_ddtrace_trace_identifiers_for(
   thread_context_collector_state *state,
   VALUE thread,
@@ -348,12 +380,16 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id);
 static VALUE safely_lookup_hash_without_going_into_ruby_code(VALUE hash, VALUE key);
 static VALUE _native_system_epoch_time_now_ns(DDTRACE_UNUSED VALUE self, VALUE collector_instance);
 static VALUE _native_prepare_sample_inside_signal_handler(DDTRACE_UNUSED VALUE self);
-static VALUE _native_clear_per_thread_context_for(DDTRACE_UNUSED VALUE self, VALUE thread);
-static bool skip_sample(thread_context_collector_state *state, per_thread_context *thread_context, bool is_gvl_waiting_state, bool force_sample_suspended);
+static VALUE _native_mark_thread_as_profiler_internal(DDTRACE_UNUSED VALUE self, VALUE thread);
+static VALUE _native_remove_per_thread_context_for(DDTRACE_UNUSED VALUE self, VALUE thread);
+static VALUE _native_global_reset_per_thread_context(DDTRACE_UNUSED VALUE self, VALUE collector_instance);
+static bool skip_sample(thread_context_collector_state *state, per_thread_context *thread_context, bool is_gvl_waiting_state, bool force_sample);
+static void on_thread_begin_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused);
 
 void collectors_thread_context_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
   VALUE collectors_thread_context_class = rb_define_class_under(collectors_module, "ThreadContext", rb_cObject);
+
   // Hosts methods used for testing the native code using RSpec
   VALUE testing_module = rb_define_module_under(collectors_thread_context_class, "Testing");
 
@@ -383,15 +419,17 @@ void collectors_thread_context_init(VALUE profiling_module) {
   rb_define_singleton_method(testing_module, "_native_sample_skipped_allocation_samples", _native_sample_skipped_allocation_samples, 2);
   rb_define_singleton_method(testing_module, "_native_system_epoch_time_now_ns", _native_system_epoch_time_now_ns, 1);
   rb_define_singleton_method(testing_module, "_native_prepare_sample_inside_signal_handler", _native_prepare_sample_inside_signal_handler, 0);
-  rb_define_singleton_method(testing_module, "_native_clear_per_thread_context_for", _native_clear_per_thread_context_for, 1);
+  rb_define_singleton_method(testing_module, "_native_remove_per_thread_context_for", _native_remove_per_thread_context_for, 1);
+  rb_define_singleton_method(testing_module, "_native_global_reset_per_thread_context", _native_global_reset_per_thread_context, 1);
+  rb_define_singleton_method(testing_module, "_native_mark_thread_as_profiler_internal", _native_mark_thread_as_profiler_internal, 1);
+  rb_define_singleton_method(testing_module, "_native_on_gvl_waiting", _native_on_gvl_waiting, 1);
+  rb_define_singleton_method(testing_module, "_native_on_gvl_released", _native_on_gvl_released, 1);
   #ifndef NO_GVL_INSTRUMENTATION
-    rb_define_singleton_method(testing_module, "_native_on_gvl_waiting", _native_on_gvl_waiting, 1);
     rb_define_singleton_method(testing_module, "_native_gvl_waiting_at_for", _native_gvl_waiting_at_for, 1);
     rb_define_singleton_method(testing_module, "_native_on_gvl_running", _native_on_gvl_running, 2);
-    rb_define_singleton_method(testing_module, "_native_on_gvl_released", _native_on_gvl_released, 1);
     rb_define_singleton_method(testing_module, "_native_sample_after_gvl_running", _native_sample_after_gvl_running, 3);
-    rb_define_singleton_method(testing_module, "_native_apply_delta_to_cpu_time_at_previous_sample_ns", _native_apply_delta_to_cpu_time_at_previous_sample_ns, 2);
   #endif
+  rb_define_singleton_method(testing_module, "_native_apply_delta_to_cpu_time_at_previous_sample_ns", _native_apply_delta_to_cpu_time_at_previous_sample_ns, 2);
 
   at_active_span_id = rb_intern_const("@active_span");
   at_active_trace_id = rb_intern_const("@active_trace");
@@ -417,6 +455,8 @@ void collectors_thread_context_init(VALUE profiling_module) {
   // This will raise if Ruby already ran out of thread-local keys
   per_thread_context_tls_init();
 
+  rb_global_variable(&thread_begin_tracepoint);
+
   gc_profiling_init();
 }
 
@@ -485,17 +525,24 @@ static void per_thread_context_typed_data_free(void *ctx_ptr) {
   free(ctx);
 }
 
-static VALUE _native_clear_per_thread_context_for(DDTRACE_UNUSED VALUE self, VALUE thread) {
+// Only for testing: removes the per-thread context without recreating it, so the thread has no context.
+// This simulates situations where we observe a thread running before our RUBY_EVENT_THREAD_BEGIN tracepoint fires,
+// so that we can test our `get_per_thread_context(...) => null` code paths.
+static VALUE _native_remove_per_thread_context_for(DDTRACE_UNUSED VALUE self, VALUE thread) {
+  check_frozen_thread(thread);
   per_thread_context *ctx = get_per_thread_context(thread);
   if (ctx != NULL) {
     set_per_thread_context(thread, NULL);
-    if (!RB_OBJ_FROZEN(thread)) {
-      rb_ivar_set(thread, dd_per_thread_context_id, Qnil);
-    }
+    rb_ivar_set(thread, dd_per_thread_context_id, Qnil);
   }
   return Qnil;
 }
 
+static VALUE _native_global_reset_per_thread_context(DDTRACE_UNUSED VALUE self, VALUE collector_instance) {
+  thread_context_collector_reset_all_per_thread_contexts(collector_instance);
+  return Qnil;
+}
+
 static VALUE _native_new(VALUE klass) {
   thread_context_collector_state *state = ruby_xcalloc(1, sizeof(thread_context_collector_state));
 
@@ -554,12 +601,14 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ENFORCE_BOOLEAN(native_filenames_enabled);
   ENFORCE_TYPE(overhead_filename, T_STRING);
 
+  uint16_t max_frame_int = sampling_buffer_check_max_frames(NUM2INT(max_frames));
+
   thread_context_collector_state *state;
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   // Update this when modifying state struct
-  state->locations.len = sampling_buffer_check_max_frames(NUM2INT(max_frames));
-  state->locations.ptr = ruby_xcalloc(state->locations.len, sizeof(ddog_prof_Location));
+  state->locations.len = max_frame_int;
+  state->locations.ptr = ruby_xcalloc(max_frame_int, sizeof(ddog_prof_Location));
   state->recorder_instance = enforce_recorder_instance(recorder_instance);
   recorder_install_on_serialize(recorder_instance, self_instance);
   state->endpoint_collection_enabled = (endpoint_collection_enabled == Qtrue);
@@ -585,6 +634,11 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
     state->tracer_context_key = rb_to_id(tracer_context_key);
   }
 
+  if (thread_begin_tracepoint == Qnil) {
+    thread_begin_tracepoint = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_BEGIN, on_thread_begin_event, NULL);
+    rb_tracepoint_enable(thread_begin_tracepoint);
+  }
+
   return Qtrue;
 }
 
@@ -643,17 +697,8 @@ static void record_sampling_overhead(thread_context_collector_state *state, per_
   long wall_time_after_sampling = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
   long cpu_time_after_sampling = cpu_time_now_ns(current_thread_context);
 
-  long overhead_cpu_time_ns = update_time_since_previous_sample(
-    &current_thread_context->cpu_time_at_previous_sample_ns,
-    cpu_time_after_sampling,
-    current_thread_context->gc_tracking.cpu_time_at_start_ns,
-    IS_CPU_TIME);
-
-  long overhead_wall_time_ns = update_time_since_previous_sample(
-    &current_thread_context->wall_time_at_previous_sample_ns,
-    wall_time_after_sampling,
-    INVALID_TIME,
-    IS_WALL_TIME);
+  long overhead_cpu_time_ns = update_cpu_time_since_previous_sample(current_thread_context, cpu_time_after_sampling);
+  long overhead_wall_time_ns = update_wall_time_since_previous_sample(current_thread_context, wall_time_after_sampling);
 
   ddog_prof_Label overhead_labels[] = {
     {.key = DDOG_CHARSLICE_C("thread id"), .str = DDOG_CHARSLICE_C("0"), .num = 0},
@@ -698,7 +743,7 @@ void thread_context_collector_sample(VALUE self_instance, long current_monotonic
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   VALUE current_thread = rb_thread_current();
-  per_thread_context *current_thread_context = get_or_create_context_for(current_thread, state);
+  per_thread_context *current_thread_context = get_or_create_context_for(current_thread);
   long cpu_time_at_sample_start_for_current_thread = cpu_time_now_ns(current_thread_context);
 
   VALUE threads = thread_list(state);
@@ -706,7 +751,7 @@ void thread_context_collector_sample(VALUE self_instance, long current_monotonic
   const long thread_count = RARRAY_LEN(threads);
   for (long i = 0; i < thread_count; i++) {
     VALUE thread = RARRAY_AREF(threads, i);
-    per_thread_context *thread_context = get_or_create_context_for(thread, state);
+    per_thread_context *thread_context = get_or_create_context_for(thread);
 
     // We account for cpu-time for the current thread in a different way: we use the cpu-time at sampling start,
     // to avoid blaming the time the profiler took on whatever is currently running on the thread,
@@ -717,44 +762,41 @@ void thread_context_collector_sample(VALUE self_instance, long current_monotonic
       state,
       thread,
       thread_context,
-      &thread_context->sampling_buffer,
       current_cpu_time_ns,
       current_monotonic_wall_time_ns,
       false);
   }
 
   state->stats.sample_count++;
-  record_sampling_overhead(state, current_thread_context);
+
+  // If the current thread is a profiler-internal thread, we don't use record_sampling_overhead()
+  // and accept the sampling overhead is attributed to the profiler-internal thread
+  // (both are under the same datadog group in the flamegraph).
+  // The reason we need to do this is profiler-internal threads are skipped during per-tick sampling
+  // so their timestamps are not updated. record_sampling_overhead() would see the stale previous-sample timestamps and
+  // attribute the entire sleep interval incorrectly as overhead instead of just the sampling work.
+  if (!current_thread_context->is_profiler_internal_thread) {
+    record_sampling_overhead(state, current_thread_context);
+  }
 }
 
 static void update_metrics_and_sample(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  sampling_buffer* sampling_buffer,
   long current_cpu_time_ns,
   long current_monotonic_wall_time_ns,
-  bool force_sample_suspended
+  bool force_sample
 ) {
   bool is_gvl_waiting_state =
-    handle_gvl_waiting(state, thread_being_sampled, thread_context, sampling_buffer, current_cpu_time_ns);
+    handle_gvl_waiting(state, thread_being_sampled, thread_context, current_cpu_time_ns);
 
-  if (skip_sample(state, thread_context, is_gvl_waiting_state, force_sample_suspended)) return;
+  if (skip_sample(state, thread_context, is_gvl_waiting_state, force_sample)) return;
 
   // Don't assign/update cpu during "Waiting for GVL"
-  long cpu_time_elapsed_ns = is_gvl_waiting_state ? 0 : update_time_since_previous_sample(
-    &thread_context->cpu_time_at_previous_sample_ns,
-    current_cpu_time_ns,
-    thread_context->gc_tracking.cpu_time_at_start_ns,
-    IS_CPU_TIME
-  );
+  long cpu_time_elapsed_ns = is_gvl_waiting_state ? 0 : update_cpu_time_since_previous_sample(thread_context, current_cpu_time_ns);
 
-  long wall_time_elapsed_ns = update_time_since_previous_sample(
-    &thread_context->wall_time_at_previous_sample_ns,
-    current_monotonic_wall_time_ns,
-    INVALID_TIME,
-    IS_WALL_TIME
-  );
+  long wall_time_elapsed_ns = update_wall_time_since_previous_sample(thread_context, current_monotonic_wall_time_ns);
 
   // A thread enters "Waiting for GVL", well, as the name implies, without the GVL.
   //
@@ -775,7 +817,6 @@ static void update_metrics_and_sample(
     state,
     thread_being_sampled,
     thread_context,
-    sampling_buffer,
     (sample_values) {.cpu_time_ns = cpu_time_elapsed_ns, .cpu_or_wall_samples = 1, .wall_time_ns = wall_time_elapsed_ns},
     current_monotonic_wall_time_ns,
     NULL,
@@ -785,7 +826,12 @@ static void update_metrics_and_sample(
   );
 }
 
-static bool skip_sample(thread_context_collector_state *state, per_thread_context *thread_context, bool is_gvl_waiting_state, bool force_sample_suspended) {
+static bool skip_sample(thread_context_collector_state *state, per_thread_context *thread_context, bool is_gvl_waiting_state, bool force_sample) {
+  if (!force_sample && thread_context->is_profiler_internal_thread) {
+    state->stats.profiler_thread_samples_skipped++;
+    return true;
+  }
+
   // Racy read but harmless, can only cause an extra sample
   uint64_t gvl_state_change_count = thread_context->gvl_state_change_count;
 
@@ -797,7 +843,7 @@ static bool skip_sample(thread_context_collector_state *state, per_thread_contex
   // in handle_gvl_waiting (situation 1 extra sample, situation 2 regular sample) keeps running.
   // TODO: we could probably also skip while "Waiting for GVL"
   if (!is_gvl_waiting_state &&
-      !force_sample_suspended &&
+      !force_sample &&
       (gvl_state_change_count & GVL_SUSPENDED) &&
       gvl_state_change_count == thread_context->gvl_state_change_count_at_previous_sample) {
     state->stats.inactive_thread_samples_skipped++;
@@ -829,10 +875,8 @@ void thread_context_collector_on_gc_start(VALUE self_instance) {
 
   per_thread_context *thread_context = get_per_thread_context(rb_thread_current());
 
-  // If there was no previously-existing context for this thread, we won't allocate one (see safety). For now we just drop
-  // the GC sample, under the assumption that "a thread that is so new that we never sampled it even once before it triggers
-  // GC" is a rare enough case that we can just ignore it.
-  // We can always improve this later if we find that this happens often (and we have the counter to help us figure that out)!
+  // Context is created eagerly via on_thread_begin_event, so this should not normally be NULL.
+  // We can't get_or_create_context_for() here since we can't allocate (GC context).
   if (thread_context == NULL) {
     state->stats.gc_samples_missed_due_to_missing_context++;
     return;
@@ -862,8 +906,7 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
 
   per_thread_context *thread_context = get_per_thread_context(rb_thread_current());
 
-  // If there was no previously-existing context for this thread, we won't allocate one (see safety). We keep a metric for
-  // how often this happens -- see on_gc_start.
+  // Context is created eagerly, so this should not normally be NULL (see on_gc_start).
   if (thread_context == NULL) return false;
 
   long cpu_time_at_start_ns = thread_context->gc_tracking.cpu_time_at_start_ns;
@@ -904,9 +947,9 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
   state->gc_tracking.accumulated_wall_time_ns += gc_wall_time_elapsed_ns;
   state->gc_tracking.wall_time_at_previous_gc_ns = wall_time_at_finish_ns;
 
-  // Update cpu-time accounting so it doesn't include the cpu-time spent in GC during the next sample
-  // We don't update the wall-time because we don't subtract the wall-time spent in GC (see call to
-  // `update_time_since_previous_sample` for wall-time in `update_metrics_and_sample`).
+  // Update cpu-time accounting so it doesn't include the cpu-time spent in GC during the next sample.
+  // We don't do the same for wall-time, because GC is just like any other reason a thread didn't make
+  // progress -- time always goes forward regardless of the thread making progress on what it wanted. 
   if (thread_context->cpu_time_at_previous_sample_ns != INVALID_TIME) {
     thread_context->cpu_time_at_previous_sample_ns += gc_cpu_time_elapsed_ns;
   }
@@ -982,7 +1025,6 @@ static void trigger_sample_for_thread(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  sampling_buffer* sampling_buffer,
   sample_values values,
   long current_monotonic_wall_time_ns,
   // These two labels are only used for allocation profiling; @ivoanjo: may want to refactor this at some point?
@@ -1104,7 +1146,7 @@ static void trigger_sample_for_thread(
 
   sample_thread(
     thread_being_sampled,
-    sampling_buffer,
+    &thread_context->sampling_buffer,
     state->locations,
     state->recorder_instance,
     values,
@@ -1133,17 +1175,22 @@ static VALUE _native_thread_list(DDTRACE_UNUSED VALUE _self) {
   return result;
 }
 
+static void check_frozen_thread(VALUE thread) {
+  if (RB_OBJ_FROZEN(thread)) {
+    raise_error(rb_eFrozenError, "Cannot setup profiler state for Thread %"PRIsVALUE" because it is frozen. Please avoid freezing Thread instances and/or report the issue to dd-trace-rb", thread);
+  }
+}
+
+// See the docs on struct per_thread_context.
 // This allocates a Ruby object and therefore needs the GVL and is not safe to call from RUBY_INTERNAL_EVENT_* hooks.
-static per_thread_context *get_or_create_context_for(VALUE thread, thread_context_collector_state *state) {
+static per_thread_context *get_or_create_context_for(VALUE thread) {
   per_thread_context *thread_context = get_per_thread_context(thread);
   if (thread_context != NULL) return thread_context;
 
-  if (RB_OBJ_FROZEN(thread)) {
-    raise_error(rb_eFrozenError, "Cannot setup profiler state for Thread %"PRIsVALUE" because it is frozen. Please avoid freezing Thread instances and/or report the issue to dd-trace-rb", thread);
-  }
+  check_frozen_thread(thread);
 
   thread_context = calloc(1, sizeof(per_thread_context)); // See "note on calloc vs ruby_xcalloc use" in heap_recorder.c
-  initialize_context(thread, thread_context, state);
+  initialize_context(thread, thread_context);
 
   VALUE wrapper = TypedData_Wrap_Struct(rb_cObject, &per_thread_context_typed_data, thread_context);
   rb_ivar_set(thread, dd_per_thread_context_id, wrapper);
@@ -1152,6 +1199,14 @@ static per_thread_context *get_or_create_context_for(VALUE thread, thread_contex
   return thread_context;
 }
 
+static void on_thread_begin_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
+  if (!ddtrace_rb_ractor_main_p()) return;
+
+  VALUE thread = rb_tracearg_self(rb_tracearg_from_tracepoint(tracepoint_data));
+  ENFORCE_THREAD(thread);
+  get_or_create_context_for(thread);
+}
+
 #define LOGGING_GEM_PATH "/lib/logging/diagnostic_context.rb"
 
 // The `logging` gem monkey patches thread creation, which makes the `invoke_location_for` useless, since every thread
@@ -1173,8 +1228,11 @@ static bool is_logging_gem_monkey_patch(VALUE invoke_file_location) {
   return strncmp(invoke_file + invoke_file_len - logging_gem_path_len, LOGGING_GEM_PATH, logging_gem_path_len) == 0;
 }
 
-static void initialize_context(VALUE thread, per_thread_context *thread_context, thread_context_collector_state *state) {
-  sampling_buffer_initialize(&thread_context->sampling_buffer, state->locations.len);
+static void initialize_context(VALUE thread, per_thread_context *thread_context) {
+  // We always create per_thread_context's with latest_max_frames; that value is kept in sync with the
+  // active profiler's max_frames by the global reset that runs when profiling starts
+  // so we expect to always see here the latest correct value to be used.
+  sampling_buffer_initialize(&thread_context->sampling_buffer, latest_max_frames);
 
   snprintf(thread_context->thread_id, THREAD_ID_LIMIT_CHARS, "%"PRIu64" (%lu)", native_thread_id_for(thread), (unsigned long) thread_id_for(thread));
   thread_context->thread_id_char_slice = (ddog_CharSlice) {.ptr = thread_context->thread_id, .len = strlen(thread_context->thread_id)};
@@ -1193,7 +1251,7 @@ static void initialize_context(VALUE thread, per_thread_context *thread_context,
     } else {
       snprintf(thread_context->thread_invoke_location, THREAD_INVOKE_LOCATION_LIMIT_CHARS, "%s", "(Unnamed thread)");
     }
-  } else if (thread != state->main_thread) {
+  } else if (thread != rb_thread_main()) {
     // If the first function of a thread is native code, there won't be an invoke location, so we use this fallback.
     // NOTE: In the future, I wonder if we could take the pointer to the native function, and try to see if there's a native
     // symbol attached to it.
@@ -1207,9 +1265,8 @@ static void initialize_context(VALUE thread, per_thread_context *thread_context,
 
   thread_context->thread_cpu_time_id = thread_cpu_time_id_for(thread);
 
-  // These will get initialized during actual sampling
-  thread_context->cpu_time_at_previous_sample_ns = INVALID_TIME;
-  thread_context->wall_time_at_previous_sample_ns = INVALID_TIME;
+  thread_context->wall_time_at_previous_sample_ns = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
+  thread_context->cpu_time_at_previous_sample_ns = cpu_time_now_ns(thread_context);
 
   // These will only be used during a GC operation
   thread_context->gc_tracking.cpu_time_at_start_ns = INVALID_TIME;
@@ -1219,6 +1276,45 @@ static void initialize_context(VALUE thread, per_thread_context *thread_context,
   thread_context->gvl_state_change_count = 0;
 }
 
+// This MUST be called before profiling starts, so that a new profiler session starts from a fresh state and never
+// observes or includes any leftover stale state from a previous session.
+// Such a call MUST happen while the CpuAndWallTimeWorker is stopped (e.g. no tracepoints active, no signals
+// triggering samples, no gvl hooks, etc).
+//
+// It updates the global `latest_max_frames` from the given (latest) ThreadContext and (re)creates every per-thread
+// context's sampling buffer sized accordingly, so the buffers always match the collector that's about to start
+// sampling -- even if a previous session used a different max_frames.
+void thread_context_collector_reset_all_per_thread_contexts(VALUE self_instance) {
+  thread_context_collector_state *state;
+  TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
+
+  // Update global max frames to be used when allocating sampling buffers
+  if (state->locations.len == 0) {
+    raise_error(rb_eRuntimeError, "BUG: Unexpected locations.len == 0. Is this ThreadContext not initialized?");
+  }
+
+  latest_max_frames = state->locations.len;
+
+  VALUE threads = thread_list(state);
+  const long thread_count = RARRAY_LEN(threads);
+  for (long i = 0; i < thread_count; i++) {
+    VALUE thread = rb_ary_entry(threads, i);
+    per_thread_context *thread_context = get_per_thread_context(thread);
+    if (thread_context != NULL) {
+      bool is_profiler_internal_thread = thread_context->is_profiler_internal_thread;
+
+      sampling_buffer_free(&thread_context->sampling_buffer);
+      memset(thread_context, 0, sizeof(per_thread_context));
+      initialize_context(thread, thread_context);
+
+      thread_context->is_profiler_internal_thread = is_profiler_internal_thread;
+    } else {
+      // If thread didn't have a context, let's trigger its creation
+      get_or_create_context_for(thread);
+    }
+  }
+}
+
 static VALUE _native_inspect(DDTRACE_UNUSED VALUE _self, VALUE collector_instance) {
   thread_context_collector_state *state;
   TypedData_Get_Struct(collector_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
@@ -1271,6 +1367,7 @@ static VALUE per_thread_context_to_ruby_hash(per_thread_context *thread_context)
     ID2SYM(rb_intern("gvl_state_change_count")), /* => */ ULL2NUM(thread_context->gvl_state_change_count),
     ID2SYM(rb_intern("gvl_state_change_count_at_previous_sample")), /* => */ ULL2NUM(thread_context->gvl_state_change_count_at_previous_sample),
     ID2SYM(rb_intern("was_skipped_at_last_sample")), /* => */ thread_context->was_skipped_at_last_sample ? Qtrue : Qfalse,
+    ID2SYM(rb_intern("is_profiler_internal_thread")), /* => */ thread_context->is_profiler_internal_thread ? Qtrue : Qfalse,
   };
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(context_as_hash, arguments[i], arguments[i+1]);
 
@@ -1284,6 +1381,7 @@ static VALUE stats_to_ruby_hash(thread_context_collector_state *state, VALUE has
     ID2SYM(rb_intern("gc_samples")),                               /* => */ UINT2NUM(state->stats.gc_samples),
     ID2SYM(rb_intern("gc_samples_missed_due_to_missing_context")), /* => */ UINT2NUM(state->stats.gc_samples_missed_due_to_missing_context),
     ID2SYM(rb_intern("inactive_thread_samples_skipped")),          /* => */ UINT2NUM(state->stats.inactive_thread_samples_skipped),
+    ID2SYM(rb_intern("profiler_thread_samples_skipped")),          /* => */ UINT2NUM(state->stats.profiler_thread_samples_skipped),
   };
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(hash, arguments[i], arguments[i+1]);
   return hash;
@@ -1323,48 +1421,59 @@ static VALUE _native_per_thread_context(DDTRACE_UNUSED VALUE _self, VALUE collec
   return result;
 }
 
-// gc_start_time_ns should only be passed if IS_CPU_TIME
-static long update_time_since_previous_sample(long *time_at_previous_sample_ns, long current_time_ns, long gc_start_time_ns, bool is_wall_time) {
+static long update_time_since_previous_sample(long *time_at_previous_sample_ns, long current_time_ns, per_thread_context *thread_context) {
   // If we didn't have a time for the previous sample, we use the current one
   if (*time_at_previous_sample_ns == INVALID_TIME) *time_at_previous_sample_ns = current_time_ns;
 
-  // We don't want wall-time accounting to change during GC.
-  // E.g. if 60 seconds pass in the real world, 60 seconds of wall-time are recorded, regardless of the thread doing GC or not.
-  bool is_thread_doing_gc = !is_wall_time && gc_start_time_ns != INVALID_TIME;
-  long elapsed_time_ns = -1;
+  // We don't expect to be sampling a thread (and thus updating these counters) while Ruby is doing GC (between
+  // `thread_context_collector_on_gc_start` and `thread_context_collector_on_gc_finish`)
+  if (thread_context->gc_tracking.cpu_time_at_start_ns != INVALID_TIME) {
+    raise_error(
+      rb_eRuntimeError,
+      "BUG: Unexpected sample during GC (thread_id=%s, gc_tracking.cpu_time_at_start_ns=%ld, "
+      "gc_tracking.wall_time_at_start_ns=%ld, monotonic_wall_time_now_ns=%ld)",
+      thread_context->thread_id,
+      thread_context->gc_tracking.cpu_time_at_start_ns,
+      thread_context->gc_tracking.wall_time_at_start_ns,
+      monotonic_wall_time_now_ns(RAISE_ON_FAILURE)
+    );
+  }
 
-  if (is_thread_doing_gc) {
-    bool previous_sample_was_during_gc = gc_start_time_ns <= *time_at_previous_sample_ns;
+  long elapsed_time_ns = current_time_ns - *time_at_previous_sample_ns; // Capture all time since previous sample
+  *time_at_previous_sample_ns = current_time_ns;
 
-    if (previous_sample_was_during_gc) {
-      elapsed_time_ns = 0; // No time to account for -- any time since the last sample is going to get assigned to GC separately
-    } else {
-      elapsed_time_ns = gc_start_time_ns - *time_at_previous_sample_ns; // Capture time between previous sample and start of GC only
-    }
+  return elapsed_time_ns;
+}
 
-    // Remaining time (from gc_start_time to current_time_ns) will be accounted for inside `sample_after_gc`
-    *time_at_previous_sample_ns = gc_start_time_ns;
-  } else {
-    elapsed_time_ns = current_time_ns - *time_at_previous_sample_ns; // Capture all time since previous sample
-    *time_at_previous_sample_ns = current_time_ns;
-  }
+static long update_cpu_time_since_previous_sample(per_thread_context *thread_context, long current_cpu_time_ns) {
+  long elapsed_time_ns = update_time_since_previous_sample(
+    &thread_context->cpu_time_at_previous_sample_ns,
+    current_cpu_time_ns,
+    thread_context
+  );
 
+  // We don't expect cpu-time to go backwards, so let's flag this as a bug
   if (elapsed_time_ns < 0) {
-    if (is_wall_time) {
-      // Wall-time can actually go backwards (e.g. when the system clock gets set) so we can't assume time going backwards
-      // was a bug.
-      // @ivoanjo: I've also observed time going backwards spuriously on macOS, see discussion on
-      // https://github.com/DataDog/dd-trace-rb/pull/2336.
-      elapsed_time_ns = 0;
-    } else {
-      // We don't expect non-wall time to go backwards, so let's flag this as a bug
-      raise_error(rb_eRuntimeError, "BUG: Unexpected negative elapsed_time_ns between samples");
-    }
+    raise_error(rb_eRuntimeError, "BUG: Unexpected CPU time going backwards between samples");
   }
 
   return elapsed_time_ns;
 }
 
+static long update_wall_time_since_previous_sample(per_thread_context *thread_context, long current_wall_time_ns) {
+  long elapsed_time_ns = update_time_since_previous_sample(
+    &thread_context->wall_time_at_previous_sample_ns,
+    current_wall_time_ns,
+    thread_context
+  );
+
+  // Wall-time can actually go backwards (e.g. when the system clock gets set) so we can't assume time going backwards
+  // was a bug.
+  // @ivoanjo: I've also observed time going backwards spuriously on macOS, see discussion on
+  // https://github.com/DataDog/dd-trace-rb/pull/2336.
+  return long_max_of(elapsed_time_ns, 0);
+}
+
 // Safety: This function is assumed never to raise exceptions by callers
 static long cpu_time_now_ns(per_thread_context *thread_context) {
   thread_cpu_time cpu_time = thread_cpu_time_for(thread_context->thread_cpu_time_id);
@@ -1521,8 +1630,8 @@ static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE collector
 
   state->stats = (struct stats) {}; // Resets all stats back to zero
 
-  // Clear any leftover state from parent process in the current thread; all other threads are assumed dead
-  _native_clear_per_thread_context_for(Qnil, rb_thread_current());
+  // No need to clean-up the per-thread context because the CpuAndWallTimeWorker always cleans
+  // it up unconditionally on every start/restart and that includes after a fork.
 
   rb_funcall(state->recorder_instance, rb_intern("reset_after_fork"), 0);
 
@@ -1634,11 +1743,10 @@ bool thread_context_collector_sample_allocation(VALUE self_instance, per_thread_
     state,
     current_thread,
     thread_context,
-    &thread_context->sampling_buffer,
     (sample_values) {.alloc_samples = sample_weight, .alloc_samples_unscaled = 1, .heap_sample = true},
     INVALID_TIME, // For now we're not collecting timestamps for allocation events, as per profiling team internal discussions
     &ruby_vm_type,
-     &class_name,
+    &class_name,
     /* is_gvl_waiting_state: */ false,
     /* is_safe_to_allocate_objects: */ false // Not safe to allocate further inside the NEWOBJ tracepoint
   );
@@ -1649,9 +1757,10 @@ bool thread_context_collector_sample_allocation(VALUE self_instance, per_thread_
 // This method exists only to enable testing Datadog::Profiling::Collectors::ThreadContext behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_sample_allocation(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE sample_weight, VALUE new_object) {
-  thread_context_collector_state *state;
-  TypedData_Get_Struct(collector_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
-  per_thread_context *thread_context = get_or_create_context_for(rb_thread_current(), state);
+  per_thread_context *thread_context = get_per_thread_context(rb_thread_current());
+  if (thread_context == NULL) {
+    rb_raise(rb_eRuntimeError, "Missing per_thread_context for current thread in _native_sample_allocation");
+  }
 
   debug_enter_unsafe_context();
 
@@ -1972,49 +2081,115 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
   state->stats = (struct stats) {};
 }
 
-#ifndef NO_GVL_INSTRUMENTATION
-  void thread_context_collector_on_gvl_released(per_thread_context *thread_context) {
-    thread_context->gvl_state_change_count |= GVL_SUSPENDED;
+static void mark_thread_as_profiler_internal(per_thread_context *ctx) {
+  ctx->is_profiler_internal_thread = true;
+}
+
+void thread_context_collector_profiler_internal_thread_started(void) {
+  per_thread_context *ctx = get_or_create_context_for(rb_thread_current());
+  mark_thread_as_profiler_internal(ctx);
+}
+
+static VALUE _native_mark_thread_as_profiler_internal(DDTRACE_UNUSED VALUE self, VALUE thread) {
+  per_thread_context *ctx = get_or_create_context_for(thread);
+  mark_thread_as_profiler_internal(ctx);
+  return Qnil;
+}
+
+// Called via rb_ensure when a profiler-internal thread (worker or idle helper) is about to exit.
+// Records a final sample so the thread's accumulated cpu/wall time since the last on_serialize
+// flush is not lost. on_serialize (below) also flushes profiler-internal threads during periodic
+// serialization, but it can't help at shutdown: by the time the final serialize runs, these
+// threads are already dead and absent from thread_list.
+void thread_context_collector_profiler_internal_thread_done(VALUE self_instance) {
+  thread_context_collector_state *state;
+  TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
+
+  VALUE current_thread = rb_thread_current();
+  per_thread_context *thread_context = get_or_create_context_for(current_thread);
+  if (!thread_context->is_profiler_internal_thread) {
+    rb_raise(rb_eRuntimeError, "current thread %"PRIsVALUE" is not profiler-internal thread", current_thread);
   }
 
-  // Called by the stack recorder at the start of _native_serialize, so that threads whose last
-  // per-tick sample was skipped by the SUSPENDED-skip optimization still get their accumulated
-  // time recorded in this reporting period. Without this, a thread that sleeps across the whole
-  // period would not be reported at all.
-  void thread_context_collector_on_serialize(VALUE self_instance) {
-    thread_context_collector_state *state;
-    TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
+  long current_cpu_time_ns = cpu_time_now_ns(thread_context);
+  long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
 
-    long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
-    VALUE threads = thread_list(state);
-    const long thread_count = RARRAY_LEN(threads);
-
-    for (long i = 0; i < thread_count; i++) {
-      VALUE thread = RARRAY_AREF(threads, i);
-      per_thread_context *thread_context = get_per_thread_context(thread);
-
-      if (thread_context != NULL && thread_context->was_skipped_at_last_sample) {
-        long current_cpu_time_ns = cpu_time_now_ns(thread_context);
-        // We need to force_sample_suspended=true otherwise this sample would be skipped too
-        update_metrics_and_sample(
-          state,
-          thread,
-          thread_context,
-          &thread_context->sampling_buffer,
-          current_cpu_time_ns,
-          current_monotonic_wall_time_ns,
-          true);
-      }
+  update_metrics_and_sample(
+    state,
+    current_thread,
+    thread_context,
+    current_cpu_time_ns,
+    current_monotonic_wall_time_ns,
+    true);
+}
+
+// Flushes threads whose last per-tick sample was skipped (either by the SUSPENDED-skip
+// optimization, or by is_profiler_internal_thread) so their accumulated time is recorded.
+// Called by the stack recorder at the start of _native_serialize (regular periodic flush).
+void thread_context_collector_on_serialize(VALUE self_instance) {
+  thread_context_collector_state *state;
+  TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
+
+  long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
+  VALUE threads = thread_list(state);
+  const long thread_count = RARRAY_LEN(threads);
+
+  for (long i = 0; i < thread_count; i++) {
+    VALUE thread = RARRAY_AREF(threads, i);
+    per_thread_context *thread_context = get_per_thread_context(thread);
+
+    if (thread_context != NULL && (thread_context->was_skipped_at_last_sample || thread_context->is_profiler_internal_thread)) {
+      long current_cpu_time_ns = cpu_time_now_ns(thread_context);
+      // We need to force_sample=true otherwise this sample would be skipped too
+      update_metrics_and_sample(
+        state,
+        thread,
+        thread_context,
+        current_cpu_time_ns,
+        current_monotonic_wall_time_ns,
+        true);
     }
   }
+}
 
-  void thread_context_collector_on_gvl_waiting(per_thread_context *thread_context) {
-    long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
-    if (current_monotonic_wall_time_ns <= 0) return;
+void thread_context_collector_on_gvl_released(per_thread_context *thread_context) {
+  thread_context->gvl_state_change_count |= GVL_SUSPENDED;
+}
 
-    thread_context->gvl_waiting_at = current_monotonic_wall_time_ns;
-  }
+void thread_context_collector_on_gvl_waiting(per_thread_context *thread_context) {
+  long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
+  if (current_monotonic_wall_time_ns <= 0) return;
+
+  thread_context->gvl_waiting_at = current_monotonic_wall_time_ns;
+}
+
+static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread) {
+  ENFORCE_THREAD(thread);
+
+  debug_enter_unsafe_context();
+
+  per_thread_context *thread_context = get_per_thread_context(thread);
+  if (thread_context) thread_context_collector_on_gvl_waiting(thread_context);
+
+  debug_leave_unsafe_context();
+
+  return Qnil;
+}
+
+static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread) {
+  ENFORCE_THREAD(thread);
+
+  debug_enter_unsafe_context();
+
+  per_thread_context *thread_context = get_per_thread_context(thread);
+  if (thread_context) thread_context_collector_on_gvl_released(thread_context);
 
+  debug_leave_unsafe_context();
+
+  return Qnil;
+}
+
+#ifndef NO_GVL_INSTRUMENTATION
   // This function runs on the passed thread and has the GVL because it gets called just after the Ruby thread acquired the GVL
   __attribute__((warn_unused_result))
   on_gvl_running_result thread_context_collector_on_gvl_running(VALUE self_instance, VALUE thread, per_thread_context *thread_context) {
@@ -2103,7 +2278,7 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     thread_context_collector_state *state;
     TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
-    per_thread_context *thread_context = get_or_create_context_for(current_thread, state);
+    per_thread_context *thread_context = get_or_create_context_for(current_thread);
 
     long gvl_waiting_at = thread_context->gvl_waiting_at;
 
@@ -2126,7 +2301,6 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
       state,
       current_thread,
       thread_context,
-      &thread_context->sampling_buffer,
       cpu_time_for_thread,
       current_monotonic_wall_time_ns,
       false);
@@ -2141,7 +2315,6 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     thread_context_collector_state *state,
     VALUE thread_being_sampled,
     per_thread_context *thread_context,
-    sampling_buffer* sampling_buffer,
     long current_cpu_time_ns
   ) {
     long gvl_waiting_at = thread_context->gvl_waiting_at;
@@ -2200,26 +2373,16 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     long gvl_waiting_started_wall_time_ns = labs(gvl_waiting_at);
 
     if (thread_context->wall_time_at_previous_sample_ns < gvl_waiting_started_wall_time_ns) { // situation 1 above
-      long cpu_time_elapsed_ns = update_time_since_previous_sample(
-        &thread_context->cpu_time_at_previous_sample_ns,
-        current_cpu_time_ns,
-        thread_context->gc_tracking.cpu_time_at_start_ns,
-        IS_CPU_TIME
-      );
+      long cpu_time_elapsed_ns = update_cpu_time_since_previous_sample(thread_context, current_cpu_time_ns);
 
-      long duration_until_start_of_gvl_waiting_ns = update_time_since_previous_sample(
-        &thread_context->wall_time_at_previous_sample_ns,
-        gvl_waiting_started_wall_time_ns,
-        INVALID_TIME,
-        IS_WALL_TIME
-      );
+      long duration_until_start_of_gvl_waiting_ns =
+        update_wall_time_since_previous_sample(thread_context, gvl_waiting_started_wall_time_ns);
 
       // Push extra sample
       trigger_sample_for_thread(
         state,
         thread_being_sampled,
         thread_context,
-        sampling_buffer,
         (sample_values) {.cpu_time_ns = cpu_time_elapsed_ns, .cpu_or_wall_samples = 1, .wall_time_ns = duration_until_start_of_gvl_waiting_ns},
         gvl_waiting_started_wall_time_ns,
         NULL,
@@ -2232,19 +2395,6 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     return true;
   }
 
-  static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread) {
-    ENFORCE_THREAD(thread);
-
-    debug_enter_unsafe_context();
-
-    per_thread_context *thread_context = get_per_thread_context(thread);
-    if (thread_context) thread_context_collector_on_gvl_waiting(thread_context);
-
-    debug_leave_unsafe_context();
-
-    return Qnil;
-  }
-
   static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread) {
     ENFORCE_THREAD(thread);
 
@@ -2276,19 +2426,6 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     return result;
   }
 
-  static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread) {
-    ENFORCE_THREAD(thread);
-
-    debug_enter_unsafe_context();
-
-    per_thread_context *thread_context = get_per_thread_context(thread);
-    if (thread_context) thread_context_collector_on_gvl_released(thread_context);
-
-    debug_leave_unsafe_context();
-
-    return Qnil;
-  }
-
   static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception) {
     ENFORCE_THREAD(thread);
     ENFORCE_BOOLEAN(allow_exception);
@@ -2306,29 +2443,27 @@ void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance) {
     return result;
   }
 
-  static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE thread, VALUE delta_ns) {
-    ENFORCE_THREAD(thread);
-
-    per_thread_context *thread_context = get_per_thread_context(thread);
-    if (thread_context == NULL) raise_error(rb_eArgError, "Unexpected: This method cannot be used unless the per-thread context for the thread already exists");
-
-    thread_context->cpu_time_at_previous_sample_ns += NUM2LONG(delta_ns);
-
-    return Qtrue;
-  }
-
 #else
   static bool handle_gvl_waiting(
     DDTRACE_UNUSED thread_context_collector_state *state,
     DDTRACE_UNUSED VALUE thread_being_sampled,
     DDTRACE_UNUSED per_thread_context *thread_context,
-    DDTRACE_UNUSED sampling_buffer* sampling_buffer,
     DDTRACE_UNUSED long current_cpu_time_ns
   ) { return false; }
 
-  void thread_context_collector_on_serialize(DDTRACE_UNUSED VALUE self_instance) { }
 #endif // NO_GVL_INSTRUMENTATION
 
+static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE thread, VALUE delta_ns) {
+  ENFORCE_THREAD(thread);
+
+  per_thread_context *thread_context = get_per_thread_context(thread);
+  if (thread_context == NULL) raise_error(rb_eArgError, "Unexpected: This method cannot be used unless the per-thread context for the thread already exists");
+
+  thread_context->cpu_time_at_previous_sample_ns += NUM2LONG(delta_ns);
+
+  return Qtrue;
+}
+
 #define MAX_SAFE_LOOKUP_SIZE 16
 
 typedef struct { VALUE lookup_key; VALUE result; } safe_lookup_hash_state;