datadog 2.43.0 → 2.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154c126111f9b92cc59626264fc83b954b36317f96798bc33a0bcb7784516968
-  data.tar.gz: 4098225f4c88a0c3e31b069ca1a17231af4298ca149ce530d0dc4ccc9a8d8db5
+  metadata.gz: c60f4ef57b9508827fac3387bd07b4233666ed9d22684c0d063187d05dcfc449
+  data.tar.gz: 6e795bd6f5fc8b5f59d040a4da62e636a15d12024ff4e6b5c2b10d0989c047ec
 SHA512:
-  metadata.gz: a566b1ab03efdf8c881ff7a6af93aff5fc946dc213ea1ccfabc554458ae733769ab98002ea14f039e3b2a19c150b2e208083e35fd0519f34b77ff239247412dd
-  data.tar.gz: 3a9f8574b7325c9f6e77da1a7f8ad65b8b6a74426b9dab829db84c8adbe8757c1f09d57d8232085c51d074c60e4a77e017cbdd9bfaa5d9f84efba0ad66869866
+  metadata.gz: 27f955e40d920907b2af84f36f8671f4e306235dce525be84da5221e2c66b852183974095afbbcc4acff4148e9202f585067e676d897b20da08c41e535846e9c
+  data.tar.gz: 29f4f51331feb1e0a6e70437490b8067b9e4a6f561b55c7f1b5fff58ae326964d92cf8e2dcf16c31466b5f654b851a25e8b683322795573e5ee3742fb395f519

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [2.44.0] - 2026-10-07
+
+### Added
+
+* AI Guard: Add sensitive-data redaction to evaluated messages, enabled by default; configure it with `ai_guard.redaction_enabled` or `DD_AI_GUARD_REDACTION_ENABLED`. ([#6394][])
+* Open Feature: Add agentless Feature Flags configuration delivery and settings for selecting agentless, Remote Configuration, or offline delivery. ([#6291][])
+
+### Changed
+
+* AI Guard: Require `ruby_llm` 2.0 or later for the `RubyLLM` integration. ([#6394][])
+* Dynamic Instrumentation: Condition evaluation error snapshots are now subject to the process-wide Dynamic Instrumentation snapshot rate limit in addition to the per-probe limit. ([#6250][])
+* OpenTelemetry: Emit `deployment.environment.name` instead of `deployment.environment` for Logs and Metrics resources, and accept it as the Datadog environment while retaining `deployment.environment` as a fallback. ([#6261][])
+
+### Fixed
+
+* Core: Fix native extension build failures when installing gems in a directory whose path contains spaces. ([#6371][])
+* Core: Fix Remote Configuration polling remaining stopped in forked web workers when application warmup started it before the fork. ([#6427][])
+* Tracing: Fix the `grape` integration creating no `grape.endpoint_run` span on Grape 4, which moved the API class, HTTP verb and route path off `Grape::Endpoint#options`. ([#6354][]) ([@dduugg][])
+* Tracing: Fix an empty `http.route` tag on spans for 405 responses when running `grape` versions 2.3 through 3.0. ([#6358][])
+* Profiling: Fix the profiler stopping with `BUG: Unexpected CPU time going backwards between samples`. ([#6364][])
+* Profiling: Fix a sampling race condition during profiler shutdown. ([#6375][])
+* Profiling: Fix a potential crash during garbage collection compaction when profiling is enabled. ([#6395][])
+* Profiling: Stop profiling if `thread_name_for`/`rb_thread_t` changes. ([#6398][])
+* Profiling: Fix native extension build breaking when trying to log %. ([#6407][])
+* Dynamic Instrumentation: Fix methods disappearing from code search and source lookup when method logpoints are already installed. ([#6339][])
+* Dynamic Instrumentation: Fix missing condition evaluation error snapshots for method probes with a `when` condition; errors raised while evaluating the condition are now reported to the backend. ([#6250][])
+
 ## [2.43.0] - 2026-09-22
 
 ### Added
@@ -3793,7 +3820,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.44.0...master
+[2.44.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...v2.44.0
 [2.43.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.42.0...v2.43.0
 [2.42.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.41.0...v2.42.0
 [2.41.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.40.0...v2.41.0
@@ -5628,10 +5656,24 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6232]: https://github.com/DataDog/dd-trace-rb/issues/6232
 [#6234]: https://github.com/DataDog/dd-trace-rb/issues/6234
 [#6242]: https://github.com/DataDog/dd-trace-rb/issues/6242
+[#6250]: https://github.com/DataDog/dd-trace-rb/issues/6250
+[#6261]: https://github.com/DataDog/dd-trace-rb/issues/6261
 [#6286]: https://github.com/DataDog/dd-trace-rb/issues/6286
+[#6291]: https://github.com/DataDog/dd-trace-rb/issues/6291
 [#6316]: https://github.com/DataDog/dd-trace-rb/issues/6316
 [#6320]: https://github.com/DataDog/dd-trace-rb/issues/6320
+[#6339]: https://github.com/DataDog/dd-trace-rb/issues/6339
 [#6350]: https://github.com/DataDog/dd-trace-rb/issues/6350
+[#6354]: https://github.com/DataDog/dd-trace-rb/issues/6354
+[#6358]: https://github.com/DataDog/dd-trace-rb/issues/6358
+[#6364]: https://github.com/DataDog/dd-trace-rb/issues/6364
+[#6371]: https://github.com/DataDog/dd-trace-rb/issues/6371
+[#6375]: https://github.com/DataDog/dd-trace-rb/issues/6375
+[#6394]: https://github.com/DataDog/dd-trace-rb/issues/6394
+[#6395]: https://github.com/DataDog/dd-trace-rb/issues/6395
+[#6398]: https://github.com/DataDog/dd-trace-rb/issues/6398
+[#6407]: https://github.com/DataDog/dd-trace-rb/issues/6407
+[#6427]: https://github.com/DataDog/dd-trace-rb/issues/6427
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5684,6 +5726,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@cwoodcox]: https://github.com/cwoodcox
 [@danhodge]: https://github.com/danhodge
 [@dasch]: https://github.com/dasch
+[@dduugg]: https://github.com/dduugg
 [@dim]: https://github.com/dim
 [@dirk]: https://github.com/dirk
 [@djmb]: https://github.com/djmb

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -228,6 +228,7 @@ static VALUE _native_new(VALUE klass);
 static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 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_profiler_internal_thread_done(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, const char *optional_exception_during_operation);
 static void stop_state(cpu_and_wall_time_worker_state *state, VALUE optional_exception, const char *optional_operation_name);
@@ -289,6 +290,7 @@ static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instan
 static VALUE handle_sampling_failure_rescued_commit_heap_recordings(VALUE self_instance, VALUE exception);
 static inline void during_sample_enter(cpu_and_wall_time_worker_state* state);
 static inline void during_sample_exit(cpu_and_wall_time_worker_state* state);
+static VALUE during_sample_exit_rescue(VALUE state_ptr);
 static void commit_heap_recordings_from_postponed_job_may_lose_gvl(DDTRACE_UNUSED void *_unused);
 
 // We're using `on_newobj_event` function with `rb_add_event_hook2`, which requires in its public signature a function
@@ -380,6 +382,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
 
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, -1);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_sampling_loop", _native_sampling_loop, 1);
+  rb_define_method(collectors_cpu_and_wall_time_worker_class, "_native_profiler_internal_thread_done", _native_profiler_internal_thread_done, 0);
   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);
@@ -650,6 +653,17 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   return Qnil;
 }
 
+static VALUE _native_profiler_internal_thread_done(VALUE self_instance) {
+  cpu_and_wall_time_worker_state *state;
+  TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
+
+  during_sample_enter(state);
+  return rb_ensure(
+    thread_context_collector_profiler_internal_thread_done, state->thread_context_collector_instance,
+    during_sample_exit_rescue, (VALUE) state
+  );
+}
+
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE worker_thread) {
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
@@ -751,11 +765,20 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
     !state->during_sample;
 
   if (sample_from_signal_handler) {
-    // Buffer current stack trace. Note that this will not actually record the sample, for that we still need to wait
-    // until the postponed job below gets run.
-    bool prepared = thread_context_collector_prepare_sample_inside_signal_handler();
+    if (rb_during_gc()) {
+      // During GC Ruby might be marking our buffer or compacting (moving) where iseqs live so we skip preparing the
+      // sample immediately, and instead ask on_gc_finish to do the job when GC is at its end.
+      //
+      // When GC profiling is disabled, we just fall back to sampling the stack after GC finishes, e.g. it's the
+      // equivalent of disabling `sample_from_signal_handler` for samples that happen during GC.
+      thread_context_collector_request_prepare_on_gc_finish();
+    } else {
+      // Buffer current stack trace. Note that this will not actually record the sample, for that we still need to wait
+      // until the postponed job below gets run.
+      bool prepared = thread_context_collector_prepare_sample_inside_signal_handler();
 
-    if (prepared) state->stats.signal_handler_prepared_sample++;
+      if (prepared) state->stats.signal_handler_prepared_sample++;
+    }
   }
 
   #ifndef NO_POSTPONED_TRIGGER // Ruby 3.3+
@@ -1096,7 +1119,10 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
   if (event == RUBY_INTERNAL_EVENT_GC_ENTER) {
     thread_context_collector_on_gc_start(state->thread_context_collector_instance);
   } else if (event == RUBY_INTERNAL_EVENT_GC_EXIT) {
-    bool should_flush = thread_context_collector_on_gc_finish(state->thread_context_collector_instance);
+    bool allow_prepare_sample = !state->during_sample;
+    if (allow_prepare_sample) during_sample_enter(state);
+    bool should_flush = thread_context_collector_on_gc_finish(state->thread_context_collector_instance, allow_prepare_sample);
+    if (allow_prepare_sample) during_sample_exit(state);
 
     // We use rb_postponed_job_register_one to ask Ruby to run thread_context_collector_sample_after_gc when the
     // thread collector flags it's time to flush.
@@ -1775,3 +1801,8 @@ static inline void during_sample_exit(cpu_and_wall_time_worker_state* state) {
   atomic_signal_fence(memory_order_seq_cst);
   state->during_sample = false;
 }
+
+static VALUE during_sample_exit_rescue(VALUE state_ptr) {
+  during_sample_exit((cpu_and_wall_time_worker_state *) state_ptr);
+  return Qnil;
+}

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -31,9 +31,9 @@ typedef struct {
 
 static VALUE _native_new(VALUE klass);
 static void reset_state(idle_sampling_loop_state *state);
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance);
 static VALUE idle_sampling_loop_body(VALUE self_instance);
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance);
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static void *run_idle_sampling_loop(void *state_ptr);
 static void interrupt_idle_sampling_loop(void *state_ptr);
@@ -112,8 +112,8 @@ static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance) {
-  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance) {
+  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, cpu_and_wall_time_worker_instance);
 }
 
 static VALUE idle_sampling_loop_body(VALUE self_instance) {
@@ -128,9 +128,8 @@ static VALUE idle_sampling_loop_body(VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance) {
-  thread_context_collector_profiler_internal_thread_done(thread_context_collector_instance);
-  return Qnil;
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance) {
+  return rb_funcall(cpu_and_wall_time_worker_instance, rb_intern("_native_profiler_internal_thread_done"), 0);
 }
 
 static void *run_idle_sampling_loop(void *state_ptr) {

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -642,8 +642,8 @@ void record_placeholder_stack(
 }
 
 bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
-  // Since this can get called from inside a signal handler, we don't want to touch the buffer if
-  // the thread was actually in the middle of marking it.
+  // While the signal handler checks if there's GC going on, it's actually possible for `sampling_buffer_mark` to
+  // still run outside of GC (see comments on that function) and thus we guard for it here.
   if (buffer->is_marking) return false;
 
   buffer->pending_sample = true;
@@ -705,12 +705,11 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
   }
 
   buffer->is_marking = true;
-  // Tell the compiler it's not allowed to reorder the `is_marking` flag with the iteration below.
-  //
-  // Specifically, in the middle of `sampling_buffer_mark` a signal handler may execute and call
-  // `prepare_sample_thread` to add a new sample to the buffer. This flag is here to prevent that BUT we need to
-  // make sure the signal handler actually sees the flag being set.
+  // The sampling buffer isn't supposed to be touched during GC. Yet, marking can happen outside of GC -- in particular
+  // ObjectSpace.dump/dump_all and reachable_objects_from invoke mark callbacks outside GC to enumerate references.
+  // Thus we keep this flag to tell the signal handler "hey you're still not allowed to touch the buffer at this time".
   //
+  // The fences ensure the compiler doesn't reorder the flags and a signal handler observes them
   // See https://github.com/ruby/ruby/pull/11036 for a similar change made to the Ruby VM with more context.
   atomic_signal_fence(memory_order_seq_cst);
 

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -13,7 +13,7 @@ typedef struct {
   uint16_t max_frames;
   frame_info *stack_buffer;
   bool pending_sample;
-  bool is_marking; // Used to avoid recording a sample when marking
+  bool is_marking; // Used to avoid recording a sample when marking (marking can happen outside of GC as well)
   int pending_sample_result;
 } sampling_buffer;
 

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -207,6 +207,7 @@ typedef struct {
 // however this only matters for a very short period when a thread starts.
 struct per_thread_context {
   sampling_buffer sampling_buffer;
+  bool prepare_sample_on_gc_finish;
   char thread_id[THREAD_ID_LIMIT_CHARS];
   ddog_CharSlice thread_id_char_slice;
   char thread_invoke_location[THREAD_INVOKE_LOCATION_LIMIT_CHARS];
@@ -311,7 +312,6 @@ static void update_metrics_and_sample(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  long current_cpu_time_ns,
   long current_monotonic_wall_time_ns,
   bool force_sample
 );
@@ -385,6 +385,7 @@ 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_request_prepare_on_gc_finish(DDTRACE_UNUSED VALUE self);
 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);
@@ -424,6 +425,7 @@ 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_request_prepare_on_gc_finish", _native_request_prepare_on_gc_finish, 0);
   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);
@@ -679,7 +681,7 @@ static VALUE _native_on_gc_start(DDTRACE_UNUSED VALUE self, VALUE collector_inst
 static VALUE _native_on_gc_finish(DDTRACE_UNUSED VALUE self, VALUE collector_instance) {
   debug_enter_unsafe_context();
 
-  (void) !thread_context_collector_on_gc_finish(collector_instance);
+  (void) !thread_context_collector_on_gc_finish(collector_instance, true);
 
   debug_leave_unsafe_context();
 
@@ -741,6 +743,7 @@ static void record_sampling_overhead(thread_context_collector_state *state, per_
 // Assumption 3: This function IS NOT called from a signal handler. This function is not async-signal-safe.
 // Assumption 4: This function IS NOT called in a reentrant way.
 // Assumption 5: This function is called from the main Ractor (if Ruby has support for Ractors).
+// Assumption 6: When called while the profiler is active, `during_sample` MUST be set.
 //
 bool thread_context_collector_sample(VALUE self_instance, long current_monotonic_wall_time_ns) {
   thread_context_collector_state *state;
@@ -748,25 +751,30 @@ bool thread_context_collector_sample(VALUE self_instance, long current_monotonic
 
   VALUE current_thread = rb_thread_current();
   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);
+
+  // Sample the current thread (which will use the current CPU-time) first.
+  // This ensures any CPU-time the profiler spends sampling (e.g. the rest of the function) is not wrongly blamed on this thread,
+  // and instead is separately accounted by `record_sampling_overhead()` below.
+  update_metrics_and_sample(
+    state,
+    current_thread,
+    current_thread_context,
+    current_monotonic_wall_time_ns,
+    false);
 
   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_or_create_context_for(thread);
+    VALUE thread = rb_ary_entry(threads, i);
+    ENFORCE_THREAD(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,
-    // and instead we report that time the profiler took as sampling overhead below.
-    long current_cpu_time_ns = (thread == current_thread) ? cpu_time_at_sample_start_for_current_thread : cpu_time_now_ns(thread_context);
+    if (thread == current_thread) continue; // Already sampled above
 
     update_metrics_and_sample(
       state,
       thread,
-      thread_context,
-      current_cpu_time_ns,
+      get_or_create_context_for(thread),
       current_monotonic_wall_time_ns,
       false);
   }
@@ -790,10 +798,10 @@ static void update_metrics_and_sample(
   thread_context_collector_state *state,
   VALUE thread_being_sampled,
   per_thread_context *thread_context,
-  long current_cpu_time_ns,
   long current_monotonic_wall_time_ns,
   bool force_sample
 ) {
+  long current_cpu_time_ns = cpu_time_now_ns(thread_context);
   bool is_gvl_waiting_state =
     handle_gvl_waiting(state, thread_being_sampled, thread_context, current_cpu_time_ns);
 
@@ -907,8 +915,9 @@ void thread_context_collector_on_gc_start(VALUE self_instance) {
 //
 // Assumption 1: This function is called in a thread that is holding the Global VM Lock. Caller is responsible for enforcing this.
 // Assumption 2: This function is called from the main Ractor (if Ruby has support for Ractors).
+// Assumption 3: If allow_prepare_sample is true while profiling is active, during_sample MUST be set by the caller.
 __attribute__((warn_unused_result))
-bool thread_context_collector_on_gc_finish(VALUE self_instance) {
+bool thread_context_collector_on_gc_finish(VALUE self_instance, bool allow_prepare_sample) {
   thread_context_collector_state *state;
   if (!rb_typeddata_is_kind_of(self_instance, &thread_context_collector_typed_data)) return false;
   // This should never fail when the above check passes
@@ -919,6 +928,11 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
   // Context is created eagerly, so this should not normally be NULL (see on_gc_start).
   if (thread_context == NULL) return false;
 
+  if (thread_context->prepare_sample_on_gc_finish) {
+    thread_context->prepare_sample_on_gc_finish = false;
+    if (allow_prepare_sample) prepare_sample_thread(rb_thread_current(), &thread_context->sampling_buffer);
+  }
+
   long cpu_time_at_start_ns = thread_context->gc_tracking.cpu_time_at_start_ns;
   long wall_time_at_start_ns = thread_context->gc_tracking.wall_time_at_start_ns;
 
@@ -986,6 +1000,7 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
 // Assumption 2: This function is allowed to raise exceptions. Caller is responsible for handling them, if needed.
 // Assumption 3: Unlike `on_gc_start` and `on_gc_finish`, this method is allowed to allocate memory as needed.
 // Assumption 4: This function is called from the main Ractor (if Ruby has support for Ractors).
+// Assumption 5: When called while the profiler is active, `during_sample` MUST be set.
 VALUE thread_context_collector_sample_after_gc(VALUE self_instance) {
   thread_context_collector_state *state;
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
@@ -1325,6 +1340,8 @@ void thread_context_collector_reset_all_per_thread_contexts(VALUE self_instance)
   const long thread_count = RARRAY_LEN(threads);
   for (long i = 0; i < thread_count; i++) {
     VALUE thread = rb_ary_entry(threads, i);
+    ENFORCE_THREAD(thread);
+
     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;
@@ -1393,6 +1410,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("prepare_sample_on_gc_finish")), /* => */ thread_context->prepare_sample_on_gc_finish ? 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]);
@@ -1439,7 +1457,9 @@ static VALUE _native_per_thread_context(DDTRACE_UNUSED VALUE _self, VALUE collec
   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);
+    VALUE thread = rb_ary_entry(threads, i);
+    ENFORCE_THREAD(thread);
+
     per_thread_context *thread_context = get_per_thread_context(thread);
     if (thread_context != NULL) {
       rb_hash_aset(result, thread, per_thread_context_to_ruby_hash(thread_context));
@@ -1679,7 +1699,7 @@ static VALUE thread_list(thread_context_collector_state *state) {
 // the current thread.
 //
 // Assumptions for this function are same as for `thread_context_collector_sample` except that this function is
-// expected to be called from a signal handler and to be async-signal-safe.
+// expected to be called from a signal handler and to be async-signal-safe, and `during_sample` MUST be unset.
 //
 // Also, no allocation (Ruby or malloc) can happen.
 bool thread_context_collector_prepare_sample_inside_signal_handler(void) {
@@ -1690,13 +1710,20 @@ bool thread_context_collector_prepare_sample_inside_signal_handler(void) {
   return prepare_sample_thread(current_thread, &thread_context->sampling_buffer);
 }
 
+// Called from the sampling signal handler; must not allocate or inspect the Ruby stack during GC.
+void thread_context_collector_request_prepare_on_gc_finish(void) {
+  per_thread_context *thread_context = get_per_thread_context(rb_thread_current());
+  if (thread_context != NULL) thread_context->prepare_sample_on_gc_finish = true;
+}
+
 // This method gets called from inside the RUBY_INTERNAL_EVENT_NEWOBJ tracepoint so it should neither allocate in the
 // Ruby heap nor release the GVL (https://github.com/DataDog/dd-trace-rb/pull/4240).
 //
 // Returns true if `thread_context_collector_commit_heap_recordings_may_lose_gvl` needs to be called (to do work
 // that can't be done from inside the tracepoint, such as allocate new objects), and false if it doesn't
 //
-// The callers must ensure thread_context is non-NULL.
+// Assumption 1: The callers must ensure thread_context is non-NULL.
+// Assumption 2: When called while the profiler is active, `during_sample` MUST be set.
 bool thread_context_collector_sample_allocation(VALUE self_instance, per_thread_context *thread_context, unsigned int sample_weight, VALUE new_object) {
   thread_context_collector_state *state;
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
@@ -1942,6 +1969,7 @@ static void ddtrace_otel_trace_identifiers_for(
   *numeric_span_id = resolved_numeric_span_id;
 }
 
+// Assumption 1: When called while the profiler is active, `during_sample` MUST be set.
 void thread_context_collector_sample_skipped_allocation_samples(VALUE self_instance, unsigned int skipped_samples) {
   thread_context_collector_state *state;
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
@@ -2156,7 +2184,9 @@ static VALUE _native_mark_thread_as_profiler_internal(DDTRACE_UNUSED VALUE self,
 // 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) {
+//
+// Assumption 1: When called while the profiler is active, `during_sample` MUST be set.
+VALUE 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);
 
@@ -2166,21 +2196,23 @@ void thread_context_collector_profiler_internal_thread_done(VALUE self_instance)
     rb_raise(rb_eRuntimeError, "current thread %"PRIsVALUE" is not profiler-internal thread", current_thread);
   }
 
-  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);
 
   update_metrics_and_sample(
     state,
     current_thread,
     thread_context,
-    current_cpu_time_ns,
     current_monotonic_wall_time_ns,
     true);
+
+  return Qnil;
 }
 
 // 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).
+//
+// Assumption 1: When called while the profiler is active, `during_sample` MUST be set.
 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);
@@ -2190,19 +2222,19 @@ void thread_context_collector_on_serialize(VALUE self_instance) {
   const long thread_count = RARRAY_LEN(threads);
 
   for (long i = 0; i < thread_count; i++) {
-    VALUE thread = RARRAY_AREF(threads, i);
+    VALUE thread = rb_ary_entry(threads, i);
+    ENFORCE_THREAD(thread);
+
     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);
+        true // We need to force_sample=true otherwise this sample would be skipped too
+      );
     }
   }
 }
@@ -2246,6 +2278,8 @@ static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread) {
 
 #ifndef NO_GVL_INSTRUMENTATION
   // We must only use async-signal-safe functions here, see notes in the caller
+  //
+  // Assumption 1: When called while the profiler is active, `during_sample` MUST be set.
   __attribute__((warn_unused_result))
   on_gvl_running_result thread_context_collector_on_gvl_running(VALUE thread, per_thread_context *thread_context, uint32_t waiting_for_gvl_threshold_ns) {
     // Bump the event counter and clears the state bit to "running"
@@ -2322,7 +2356,8 @@ static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread) {
   //
   // ---
   //
-  // Always called with the GVL, either from a postponed_job or from tests.
+  // Assumption 1: Always called with the GVL, either from a postponed_job or from tests.
+  // Assumption 2: When called while the profiler is active, `during_sample` MUST be set.
   //
   // NOTE: In normal use, current_thread is expected to be == rb_thread_current(); the `current_thread` parameter only
   // exists to enable testing.
@@ -2342,18 +2377,12 @@ static VALUE _native_on_gvl_released(DDTRACE_UNUSED VALUE self, VALUE thread) {
       return Qfalse;
     }
 
-    // We don't actually account for cpu-time during Waiting for GVL. BUT, we may choose to push an
-    // extra sample to represent the period prior to Waiting for GVL. To support that, we retrieve the current
-    // cpu-time of the thread and let `update_metrics_and_sample` decide what to do with it.
-    long cpu_time_for_thread = cpu_time_now_ns(thread_context);
-
     // TODO: Should we update the dynamic sampling rate overhead tracking with this sample as well?
 
     update_metrics_and_sample(
       state,
       current_thread,
       thread_context,
-      cpu_time_for_thread,
       current_monotonic_wall_time_ns,
       false);
 
@@ -2564,3 +2593,8 @@ static VALUE _native_system_epoch_time_now_ns(DDTRACE_UNUSED VALUE self, VALUE c
 static VALUE _native_prepare_sample_inside_signal_handler(DDTRACE_UNUSED VALUE self) {
   return thread_context_collector_prepare_sample_inside_signal_handler() ? Qtrue : Qfalse;
 }
+
+static VALUE _native_request_prepare_on_gc_finish(DDTRACE_UNUSED VALUE self) {
+  thread_context_collector_request_prepare_on_gc_finish();
+  return Qnil;
+}

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -13,6 +13,7 @@ __attribute__((warn_unused_result)) bool thread_context_collector_sample(
   long current_monotonic_wall_time_ns
 );
 __attribute__((warn_unused_result)) bool thread_context_collector_prepare_sample_inside_signal_handler(void);
+void thread_context_collector_request_prepare_on_gc_finish(void);
 __attribute__((warn_unused_result)) bool thread_context_collector_sample_allocation(VALUE self_instance, per_thread_context *thread_context, unsigned int sample_weight, VALUE new_object);
 void thread_context_collector_commit_heap_recordings_may_lose_gvl(VALUE self_instance);
 void thread_context_collector_sample_skipped_allocation_samples(VALUE self_instance, unsigned int skipped_samples);
@@ -20,14 +21,14 @@ VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
 VALUE thread_context_collector_heap_update_may_lose_gvl(VALUE self_instance);
 void thread_context_collector_resolve_otel_span_key_may_lose_gvl(VALUE self_instance);
 void thread_context_collector_on_gc_start(VALUE self_instance);
-__attribute__((warn_unused_result)) bool thread_context_collector_on_gc_finish(VALUE self_instance);
+__attribute__((warn_unused_result)) bool thread_context_collector_on_gc_finish(VALUE self_instance, bool allow_prepare_sample);
 VALUE enforce_thread_context_collector_instance(VALUE object);
 void thread_context_collector_stats(VALUE self_instance, VALUE stats_hash);
 void thread_context_collector_stats_reset_not_thread_safe(VALUE self_instance);
 void thread_context_collector_on_serialize(VALUE self_instance);
 void thread_context_collector_reset_all_per_thread_contexts(VALUE self_instance);
 void thread_context_collector_profiler_internal_thread_started(void);
-void thread_context_collector_profiler_internal_thread_done(VALUE self_instance);
+VALUE thread_context_collector_profiler_internal_thread_done(VALUE self_instance);
 
 #ifndef NO_GVL_INSTRUMENTATION
   typedef enum {

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -260,7 +260,9 @@ dir_config("ruby") # allow user to pass in non-standard core include directory
 #
 # To workaround this issue, we override `with_cppflags` for datadog-ruby_core_source to still include `$CPPFLAGS`.
 Datadog::RubyCoreSource.define_singleton_method(:with_cppflags) do |newflags, &block|
-  super("#{newflags} #{$CPPFLAGS}", &block)
+  # Note: The `Shellwords.escape` is an additional workaround for ruby_core_source supplying
+  # one unescaped -I argument containing the complete header path, not the CPPFLAGS thing above.
+  super("#{Shellwords.escape(newflags)} #{$CPPFLAGS}", &block)
 end
 
 Datadog::RubyCoreSource
@@ -270,7 +272,7 @@ Datadog::RubyCoreSource
         have_header("vm_core.h") &&
         have_header("iseq.h", "vm_core.h") &&
         # These are only used on Ruby 3+
-        (RUBY_VERSION < "3" || have_header("ractor_core.h") && have_header("internal/class.h"))
+        (RUBY_VERSION < "3" || have_header("ractor_core.h") && have_header("internal/class.h", "vm_core.h"))
 
       if headers_available
         # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -278,6 +278,23 @@ VALUE thread_name_for(VALUE thread) {
   return thread_struct_from_object(thread)->name;
 }
 
+// This test doubles as a validation for the layout of the rb_thread_t structure. Because the `name` is almost at
+// the end of the structure, if somehow we can't read the name, this probably means we're getting the structure wrong
+// and we should stop immediately (this includes covering the use of `stat_insn_usage` on Ruby <= 3.2).
+//
+// One example where this happens is in patches such as
+// https://github.com/gitlabhq/omnibus-gitlab/blob/master/config/patches/ruby/thread-memory-allocations-3.2.patch
+// that add items to the structure and thus shift its position from where we expect.
+void self_test_thread_name_for(void) {
+  VALUE thread = rb_eval_string("Thread.new { Thread.current.name = 'dd-prof-test' }.join");
+  VALUE expected_name = rb_funcall(thread, rb_intern("name"), 0);
+  if (thread_name_for(thread) != expected_name) {
+    rb_raise(rb_eRuntimeError,
+      "thread_name_for() self-test failed; this usually means the `rb_thread_t` on this Ruby doesn't match what the profiler expects"
+    );
+  }
+}
+
 // -----------------------------------------------------------------------------
 // The sources below are modified versions of code extracted from the Ruby project.
 // Each function is annotated with its origin, why we imported it, and the changes made.
@@ -539,6 +556,14 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
   cfp = RUBY_VM_NEXT_CONTROL_FRAME(end_cfp);
 
   for (i=0; i<limit && cfp != top_sentinel; cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp)) {
+    #ifndef NO_T_MOVED
+      if (cfp->iseq && RB_TYPE_P((VALUE) cfp->iseq, T_MOVED)) {
+        // The profiler is not supposed to sample during GC compaction, so T_MOVED is not expected here.
+        // Yet, crash tracking also uses this walker and may run at any time. For now, we choose to skip these frames.
+        continue;
+      }
+    #endif
+
     if (cfp->iseq && !cfp->pc) {
       // Fix: Do nothing -- this frame should not be used
       //