datadog 2.44.0 → 2.45.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -25,6 +25,9 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
   #include <iseq.h>
+  #ifdef HAVE_ZJIT_FRAME
+    #include <zjit.h>
+  #endif
 #pragma GCC diagnostic pop
 
 #ifndef NO_INTERNAL_CLASS_HEADER_INCLUDE
@@ -53,23 +56,45 @@
 #define PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
 #include "private_vm_api_access.h"
 
+#ifdef HAVE_RUBY_RACTOR_H
+  typedef rb_ractor_t gvl_owner_context_t;
+#else
+  typedef rb_vm_t gvl_owner_context_t;
+#endif
+
 static inline const rb_callable_method_entry_t* get_cfunc_method_entry(const rb_control_frame_t *cfp);
 static const rb_callable_method_entry_t* safe_vm_frame_method_entry(const rb_control_frame_t *cfp);
+static gvl_owner_context_t *get_gvl_owner_context(void);
+
+typedef struct {
+  gvl_owner_context_t *main_ractor_gvl_owner_context;
+  const rb_data_type_t *thread_data_type;
+} private_vm_api_global_t;
+
+// Initialized once on the main ractor with the GVL held, before sampling starts; never rewritten.
+// The native context stays at the same address across GC compaction and forks from the main ractor.
+static private_vm_api_global_t private_vm_api_global;
+
+void private_vm_api_access_init(void) {
+  private_vm_api_global.thread_data_type = RTYPEDDATA_TYPE(rb_thread_current());
+  private_vm_api_global.main_ractor_gvl_owner_context = get_gvl_owner_context();
+}
+
+void private_vm_api_access_self_test(void) {
+  if (private_vm_api_global.main_ractor_gvl_owner_context != get_gvl_owner_context()) {
+    rb_raise(rb_eRuntimeError, "BUG: main_ractor_gvl_owner_context changed unexpectedly");
+  }
+}
 
 // MRI has a similar rb_thread_ptr() function which we can't call it directly
 // because Ruby does not expose the thread_data_type publicly.
-// Instead, we have our own version of that function, and we lazily initialize the thread_data_type pointer
+// Instead, we have our own version of that function, and we initialize the thread_data_type pointer
 // from a known-correct object: the current thread.
 //
 // Note that beyond returning the rb_thread_struct*, rb_check_typeddata() raises an exception
 // if the argument passed in is not actually a `Thread` instance.
 static inline rb_thread_t *thread_struct_from_object(VALUE thread) {
-  static const rb_data_type_t *thread_data_type = NULL;
-  if (UNLIKELY(thread_data_type == NULL)) {
-    thread_data_type = RTYPEDDATA_TYPE(rb_thread_current());
-  }
-
-  return (rb_thread_t *) rb_check_typeddata(thread, thread_data_type);
+  return (rb_thread_t *) rb_check_typeddata(thread, private_vm_api_global.thread_data_type);
 }
 
 rb_nativethread_id_t pthread_id_for(VALUE thread) {
@@ -86,19 +111,16 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
-// Queries if the current thread is the owner of the global VM lock.
+// Combines checking for main ractor and GVL in one check that can be done safely from a signal handler, even
+// if the thread is not a Ruby thread or if we're in the middle of GC.
 //
-// @ivoanjo: Ruby has a similarly-named `ruby_thread_has_gvl_p` but that API is insufficient for our needs because it can
-// still return `true` even when a thread DOES NOT HAVE the global VM lock.
-// In particular, looking at the implementation, that API assumes that if a thread is not in a "blocking region" then it
-// will have the GVL which is probably true for the situations that API was designed to be called from BUT this assumption
-// does not hold true when calling `ruby_thread_has_gvl_p` from a signal handler. (Because the thread may have lost the
-// GVL due to a scheduler decision, not because it decided to block.)
-// I have also submitted https://bugs.ruby-lang.org/issues/19172 to discuss this with upstream Ruby developers.
+// Note that Ruby has `ruby_thread_has_gvl_p`, but unfortunately it can return true in a signal
+// handler even when the thread doesn't hold the GVL. It assumes that a thread outside a "blocking region" holds
+// the GVL, but the scheduler can also take it away (https://bugs.ruby-lang.org/issues/19172).
 //
-// Thus we need our own gvl-checking method which actually looks at the gvl structure to determine if it is the owner.
-bool is_current_thread_holding_the_gvl(void) {
-  current_gvl_owner owner = gvl_owner();
+// This must not touch Ruby objects, since GC compaction may have protected their heap pages.
+bool is_current_thread_in_main_ractor_and_holding_the_gvl(void) {
+  current_gvl_owner owner = main_ractor_gvl_owner();
   return owner.valid && pthread_equal(pthread_self(), owner.owner);
 }
 
@@ -112,23 +134,37 @@ static inline rb_ractor_t *ddtrace_get_ractor(void) {
 }
 #endif
 
+static gvl_owner_context_t *get_gvl_owner_context(void) {
+  if (!ddtrace_rb_ractor_main_p()) {
+    rb_raise(rb_eRuntimeError, "BUG: get_gvl_owner_context must be called from the main ractor");
+  }
+
+  #ifdef HAVE_RUBY_RACTOR_H
+    return ddtrace_get_ractor();
+  #else
+    return GET_VM();
+  #endif
+}
+
 #ifndef NO_GVL_OWNER // Ruby < 2.6 doesn't have the owner/running field
 // NOTE: Reading the owner in this is a racy read, because we're not grabbing the lock that Ruby uses to protect it.
 //
 // While we could potentially grab this lock, I (@ivoanjo) think we actually don't need it because:
-// * In the case where a thread owns the GVL and calls `gvl_owner`, it will always see the correct value. That's
+// * In the case where a thread owns the GVL and calls `main_ractor_gvl_owner`, it will always see the correct value. That's
 //   because every thread sets itself as the owner when it grabs the GVL and unsets itself at the end.
-//   That means that `is_current_thread_holding_the_gvl` is always accurate.
+//   That means that `is_current_thread_in_main_ractor_and_holding_the_gvl` is always accurate.
 // * In a case where we observe a different thread, then this may change by the time we do something with this value
 //   anyway. So unless we want to prevent the Ruby scheduler from switching threads, we need to deal with races here.
-current_gvl_owner gvl_owner(void) {
+current_gvl_owner main_ractor_gvl_owner(void) {
+  if (private_vm_api_global.main_ractor_gvl_owner_context == NULL) return (current_gvl_owner) {.valid = false};
+
   const rb_thread_t *current_owner =
     #ifndef NO_RB_THREAD_SCHED // Introduced in Ruby 3.2 as a replacement for struct rb_global_vm_lock_struct
-      ddtrace_get_ractor()->threads.sched.running;
+      private_vm_api_global.main_ractor_gvl_owner_context->threads.sched.running;
     #elif HAVE_RUBY_RACTOR_H
-      ddtrace_get_ractor()->threads.gvl.owner;
+      private_vm_api_global.main_ractor_gvl_owner_context->threads.gvl.owner;
     #else
-      GET_VM()->gvl.owner;
+      private_vm_api_global.main_ractor_gvl_owner_context->gvl.owner;
     #endif
 
   if (current_owner == NULL) {
@@ -149,8 +185,9 @@ current_gvl_owner gvl_owner(void) {
   #endif
 }
 #else
-current_gvl_owner gvl_owner(void) {
-  rb_vm_t *vm = GET_VM();
+current_gvl_owner main_ractor_gvl_owner(void) {
+  rb_vm_t *vm = private_vm_api_global.main_ractor_gvl_owner_context;
+  if (vm == NULL) return (current_gvl_owner) {.valid = false};
 
   // BIG Issue: Ruby < 2.6 did not have the owner field. The really nice thing about the owner field is that it's
   // "atomic" -- when a thread sets it, it "declares" two things in a single step
@@ -169,15 +206,15 @@ current_gvl_owner gvl_owner(void) {
   // * Thread A sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread A`)
   // * Thread A releases the GVL (`gvl.acquired == 0` + `running_thread == Thread A`)
   // * Thread B grabs the GVL (`gvl.acquired == 1` + `running_thread == Thread A`)
-  // * Thread A calls gvl_owner. Due to the current state (`gvl.acquired == 1` + `running_thread == Thread A`), this
+  // * Thread A calls main_ractor_gvl_owner. Due to the current state (`gvl.acquired == 1` + `running_thread == Thread A`), this
   //   function returns an incorrect result.
   // * Thread B finally sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread B`)
   //
-  // This is especially problematic because we use `gvl_owner` to implement `is_current_thread_holding_the_gvl` which
+  // This is especially problematic because we use `main_ractor_gvl_owner` to implement `is_current_thread_in_main_ractor_and_holding_the_gvl` which
   // is called in a signal handler to decide "is it safe for me to call `rb_postponed_job_register_one` or not".
   // (See constraints in `collectors_cpu_and_wall_time_worker.c` comments for why).
   //
-  // Thus an incorrect `is_current_thread_holding_the_gvl` result may lead to issues inside `rb_postponed_job_register_one`.
+  // Thus an incorrect `is_current_thread_in_main_ractor_and_holding_the_gvl` result may lead to issues inside `rb_postponed_job_register_one`.
   //
   // For this reason we default to use the "no signals workaround" on Ruby 2.5 by default, and we print a
   // warning when customers force-enable it.
@@ -373,7 +410,6 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id) {
     ptrdiff_t n = pc - ISEQ_BODY(iseq)->iseq_encoded;
     VM_ASSERT(n <= ISEQ_BODY(iseq)->iseq_size);
     VM_ASSERT(n >= 0);
-    ASSUME(n >= 0);
     size_t pos = n; /* no overflow */
     if (LIKELY(pos)) {
       /* use pos-1 because PC points next instruction at the beginning of instruction */
@@ -556,15 +592,38 @@ 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)) {
+    const VALUE *pc = cfp->pc;
+    #ifdef HAVE_ZJIT_FRAME
+      const rb_iseq_t *iseq = cfp->_iseq;
+    #else
+      const rb_iseq_t *iseq = cfp->iseq;
+    #endif
+
+    #if defined(HAVE_ZJIT_FRAME) && USE_ZJIT
+      // Based on CFP_ZJIT_FRAME, which we currently can't use directly.
+      if (CFP_ZJIT_FRAME_P(cfp)) {
+        if ((VALUE)cfp->jit_return == ZJIT_JIT_RETURN_C_FRAME) {
+          // ZJIT uses this sentinel for C method frames, which have no Ruby ISEQ or bytecode PC.
+          // Set both to NULL explicitly because ZJIT leaves those fields untouched, so they may contain stale data.
+          iseq = NULL;
+          pc = NULL;
+        } else {
+          const zjit_jit_frame_t *jit_frame = (const zjit_jit_frame_t *)((VALUE *)cfp->jit_return)[-1];
+          iseq = jit_frame->iseq;
+          pc = jit_frame->pc;
+        }
+      }
+    #endif
+
     #ifndef NO_T_MOVED
-      if (cfp->iseq && RB_TYPE_P((VALUE) cfp->iseq, T_MOVED)) {
+      if (iseq && RB_TYPE_P((VALUE) 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) {
+    if (iseq && !pc) {
       // Fix: Do nothing -- this frame should not be used
       //
       // rb_profile_frames does not do this check, but `backtrace_each` (`vm_backtrace.c`) does. This frame is not
@@ -593,8 +652,8 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
 
       stack_buffer[i].same_frame =
         stack_buffer[i].is_ruby_frame &&
-        stack_buffer[i].as.ruby_frame.iseq == cfp->iseq &&
-        stack_buffer[i].as.ruby_frame.caching_pc == cfp->pc &&
+        stack_buffer[i].as.ruby_frame.iseq == iseq &&
+        stack_buffer[i].as.ruby_frame.caching_pc == pc &&
         stack_buffer[i].cme == cme;
 
       if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
@@ -602,8 +661,8 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
         continue;
       }
 
-      stack_buffer[i].as.ruby_frame.iseq = cfp->iseq;
-      stack_buffer[i].as.ruby_frame.caching_pc = (void *) cfp->pc;
+      stack_buffer[i].as.ruby_frame.iseq = iseq;
+      stack_buffer[i].as.ruby_frame.caching_pc = (void *) pc;
       stack_buffer[i].cme = cme;
 
       // The topmost frame may not have an updated PC because the JIT
@@ -614,10 +673,10 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
         if (cfp == top && cfp->jit_return) {
           stack_buffer[i].as.ruby_frame.line = 0;
         } else {
-          stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
+          stack_buffer[i].as.ruby_frame.line = calc_lineno(iseq, pc);
         }
       #else // Ruby < 3.1
-        stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
+        stack_buffer[i].as.ruby_frame.line = calc_lineno(iseq, pc);
       #endif
 
       stack_buffer[i].is_ruby_frame = true;
@@ -822,26 +881,11 @@ void self_test_mn_enabled(void) {
   #endif
 }
 
-// Taken from upstream imemo.h at commit 6ebcf25de2859b5b6402b7e8b181066c32d0e0bf (November 2023, master branch)
-// (See the Ruby project copyright and license above)
-// to enable calling rb_imemo_name
-//
-// Modifications:
-// * Added IMEMO_MASK define
-// * Changed return type to int to avoid having to define `enum imemo_type`
-static inline int ddtrace_imemo_type(VALUE imemo) {
-  // This mask is the same between Ruby 2.5 and 3.3-preview3. Furthermore, the intention of this method is to be used
-  // to call `rb_imemo_name` which correctly handles invalid numbers so even if the mask changes in the future, at most
-  // we'll get incorrect results (and never a VM crash)
-  #define IMEMO_MASK   0x0f
-  return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
-}
-
 // Safety: This function assumes the object passed in is of the imemo type. But in the worst case, you'll just get
 // a string that doesn't make any sense.
 #ifndef NO_IMEMO_NAME
 const char *imemo_kind(VALUE imemo) {
-  return rb_imemo_name(ddtrace_imemo_type(imemo));
+  return rb_imemo_name(imemo_type(imemo));
 }
 #else
 const char *imemo_kind(__attribute__((unused)) VALUE imemo) {

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -39,8 +39,11 @@ typedef struct {
 } frame_info;
 
 rb_nativethread_id_t pthread_id_for(VALUE thread);
-bool is_current_thread_holding_the_gvl(void);
-current_gvl_owner gvl_owner(void);
+// Must be called from the main ractor while holding the GVL
+void private_vm_api_access_init(void);
+void private_vm_api_access_self_test(void);
+current_gvl_owner main_ractor_gvl_owner(void);
+bool is_current_thread_in_main_ractor_and_holding_the_gvl(void);
 uint64_t native_thread_id_for(VALUE thread);
 void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);

data/ext/datadog_profiling_native_extension/profiling.c

@@ -37,9 +37,9 @@ static void *trigger_grab_gvl_and_raise_value_arg(void *trigger_args);
 static VALUE _native_grab_gvl_and_raise_syserr(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
 static void *trigger_grab_gvl_and_raise_syserr(void *trigger_args);
 static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self);
-static VALUE _native_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
-static VALUE _native_release_gvl_and_call_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
-static void *testing_is_current_thread_holding_the_gvl(DDTRACE_UNUSED void *_unused);
+static VALUE _native_is_current_thread_in_main_ractor_and_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
+static VALUE _native_release_gvl_and_call_is_current_thread_in_main_ractor_and_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
+static void *testing_is_current_thread_in_main_ractor_and_holding_the_gvl(void *unused);
 static VALUE _native_install_holding_the_gvl_signal_handler(DDTRACE_UNUSED VALUE _self);
 static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VALUE _self, VALUE background_thread);
@@ -66,6 +66,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_define_singleton_method(native_extension_module, "native_working?", native_working_p, 0);
   rb_funcall(native_extension_module, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("native_working?")));
 
+  private_vm_api_access_init();
   ruby_helpers_init();
   setup_signal_handler_init(profiling_module);
   collectors_cpu_and_wall_time_worker_init(profiling_module);
@@ -88,11 +89,11 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise_value_arg", _native_grab_gvl_and_raise_value_arg, 3);
   rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise_syserr", _native_grab_gvl_and_raise_syserr, 4);
   rb_define_singleton_method(testing_module, "_native_ddtrace_rb_ractor_main_p", _native_ddtrace_rb_ractor_main_p, 0);
-  rb_define_singleton_method(testing_module, "_native_is_current_thread_holding_the_gvl", _native_is_current_thread_holding_the_gvl, 0);
+  rb_define_singleton_method(testing_module, "_native_is_current_thread_in_main_ractor_and_holding_the_gvl", _native_is_current_thread_in_main_ractor_and_holding_the_gvl, 0);
   rb_define_singleton_method(
     testing_module,
-    "_native_release_gvl_and_call_is_current_thread_holding_the_gvl",
-    _native_release_gvl_and_call_is_current_thread_holding_the_gvl,
+    "_native_release_gvl_and_call_is_current_thread_in_main_ractor_and_holding_the_gvl",
+    _native_release_gvl_and_call_is_current_thread_in_main_ractor_and_holding_the_gvl,
     0
   );
   rb_define_singleton_method(testing_module, "_native_install_holding_the_gvl_signal_handler", _native_install_holding_the_gvl_signal_handler, 0);
@@ -103,6 +104,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
+  private_vm_api_access_self_test();
   self_test_thread_name_for();
   self_test_clock_id();
   self_test_current_fiber_for();
@@ -219,41 +221,37 @@ static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self) {
   return ddtrace_rb_ractor_main_p() ? Qtrue : Qfalse;
 }
 
-static VALUE _native_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
-  return ((bool) testing_is_current_thread_holding_the_gvl(NULL)) ? Qtrue : Qfalse;
+static VALUE _native_is_current_thread_in_main_ractor_and_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
+  return is_current_thread_in_main_ractor_and_holding_the_gvl() ? Qtrue : Qfalse;
 }
 
-static VALUE _native_release_gvl_and_call_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
-  return ((bool) rb_thread_call_without_gvl(testing_is_current_thread_holding_the_gvl, NULL, NULL, NULL)) ? Qtrue : Qfalse;
+static VALUE _native_release_gvl_and_call_is_current_thread_in_main_ractor_and_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
+  return ((bool) rb_thread_call_without_gvl(testing_is_current_thread_in_main_ractor_and_holding_the_gvl, NULL, NULL, NULL)) ? Qtrue : Qfalse;
 }
 
-static void *testing_is_current_thread_holding_the_gvl(DDTRACE_UNUSED void *_unused) {
-  return (void *) is_current_thread_holding_the_gvl();
-}
-
-static VALUE _native_install_holding_the_gvl_signal_handler(DDTRACE_UNUSED VALUE _self) {
-  install_sigprof_signal_handler(holding_the_gvl_signal_handler, "holding_the_gvl_signal_handler");
-  return Qtrue;
+static void *testing_is_current_thread_in_main_ractor_and_holding_the_gvl(DDTRACE_UNUSED void *unused) {
+  return (void *) is_current_thread_in_main_ractor_and_holding_the_gvl();
 }
 
 static pthread_mutex_t holding_the_gvl_signal_handler_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t holding_the_gvl_signal_handler_executed = PTHREAD_COND_INITIALIZER;
 static VALUE holding_the_gvl_signal_handler_result[3];
 
-// Ruby VM API that is exported but not present in the header files. Only used by holding_the_gvl_signal_handler below and SHOULD NOT
-// be used in any other situation. See the comments on is_current_thread_holding_the_gvl for details.
-int ruby_thread_has_gvl_p(void);
+static VALUE _native_install_holding_the_gvl_signal_handler(DDTRACE_UNUSED VALUE _self) {
+  install_sigprof_signal_handler(holding_the_gvl_signal_handler, "holding_the_gvl_signal_handler");
+  return Qtrue;
+}
 
 static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
   pthread_mutex_lock(&holding_the_gvl_signal_handler_mutex);
 
   VALUE test_executed = Qtrue;
   VALUE ruby_thread_has_gvl_p_result = ruby_thread_has_gvl_p() ? Qtrue : Qfalse;
-  VALUE is_current_thread_holding_the_gvl_result = is_current_thread_holding_the_gvl() ? Qtrue : Qfalse;
+  VALUE is_current_thread_in_main_ractor_and_holding_the_gvl_result = is_current_thread_in_main_ractor_and_holding_the_gvl() ? Qtrue : Qfalse;
 
   holding_the_gvl_signal_handler_result[0] = test_executed;
   holding_the_gvl_signal_handler_result[1] = ruby_thread_has_gvl_p_result;
-  holding_the_gvl_signal_handler_result[2] = is_current_thread_holding_the_gvl_result;
+  holding_the_gvl_signal_handler_result[2] = is_current_thread_in_main_ractor_and_holding_the_gvl_result;
 
   pthread_cond_broadcast(&holding_the_gvl_signal_handler_executed);
   pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex);
@@ -299,7 +297,7 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 
   VALUE result = rb_hash_new();
   rb_hash_aset(result, ID2SYM(rb_intern("ruby_thread_has_gvl_p")), holding_the_gvl_signal_handler_result[1]);
-  rb_hash_aset(result, ID2SYM(rb_intern("is_current_thread_holding_the_gvl")), holding_the_gvl_signal_handler_result[2]);
+  rb_hash_aset(result, ID2SYM(rb_intern("is_current_thread_in_main_ractor_and_holding_the_gvl")), holding_the_gvl_signal_handler_result[2]);
   return result;
 }
 

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -66,7 +66,9 @@ void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const c
   args.format_string = format_string;
   va_start(args.va_args, format_string);
 
-  if (is_current_thread_holding_the_gvl()) {
+  // Callers run with the GVL or inside an explicit no-GVL region, so Ruby's blocking-region check is sufficient.
+  // We don't run in signal handlers or scheduler hooks, so we don't need is_current_thread_in_main_ractor_and_holding_the_gvl().
+  if (ruby_thread_has_gvl_p()) {
     VALUE detailed_message = rb_vsprintf(format_string, args.va_args);
     va_end(args.va_args);
 

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -4,6 +4,10 @@
 #include <stdarg.h>
 #include "datadog_ruby_common.h"
 
+// Public since Ruby 4.0 (https://bugs.ruby-lang.org/issues/20877); older Rubies export it without a header declaration.
+// Be careful about using this in the profiler; see notes on is_current_thread_in_main_ractor_and_holding_the_gvl().
+int ruby_thread_has_gvl_p(void);
+
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
 // usage of ruby helpers.
 void ruby_helpers_init(void);

data/ext/datadog_profiling_native_extension/setup_signal_handler.c

@@ -36,8 +36,6 @@ static void install_sigprof_signal_handler_internal(
 ) {
   struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
   struct sigaction signal_handler_config = {
-    // NOTE: Deliberately not SA_ONSTACK. `handle_sampling_signal` uses "am I running on the alternate signal stack?"
-    // to detect that if it interrupted another signal handler from the Ruby VM, see `is_running_on_alternate_signal_stack` for details.
     .sa_flags = SA_RESTART | SA_SIGINFO,
     .sa_sigaction = signal_handler_function
   };

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -9,7 +9,6 @@
 #include "time_helpers.h"
 #include "heap_recorder.h"
 #include "encoded_profile.h"
-#include "collectors_thread_context.h"
 
 // Used to wrap a ddog_prof_Profile in a Ruby object and expose Ruby-level serialization APIs
 // This file implements the native bits of the Datadog::Profiling::StackRecorder class
@@ -178,10 +177,6 @@ typedef struct {
   heap_recorder *heap_recorder;
   bool heap_clean_after_gc_enabled;
 
-  // When set, _native_serialize will call thread_context_collector_on_serialize on this instance
-  // before serializing, so that threads suspended across the whole profile period still get sampled.
-  VALUE thread_context_collector_instance;
-
   pthread_mutex_t mutex_slot_one;
   profile_slot profile_slot_one;
   pthread_mutex_t mutex_slot_two;
@@ -343,7 +338,6 @@ static VALUE _native_new(VALUE klass) {
   // being leaked.
 
   state->heap_clean_after_gc_enabled = false;
-  state->thread_context_collector_instance = Qnil;
 
   ddog_prof_Slice_SampleType sample_types = {.ptr = all_sample_types, .len = ALL_VALUE_TYPES_COUNT};
 
@@ -415,7 +409,6 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Sam
 static void stack_recorder_typed_data_mark(void *state_ptr) {
   stack_recorder_state *state = (stack_recorder_state *) state_ptr;
 
-  rb_gc_mark(state->thread_context_collector_instance);
   heap_recorder_mark(state->heap_recorder);
 }
 
@@ -539,17 +532,13 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
   stack_recorder_state *state;
   TypedData_Get_Struct(recorder_instance, stack_recorder_state, &stack_recorder_typed_data, state);
 
-  if (state->thread_context_collector_instance != Qnil) {
-    thread_context_collector_on_serialize(state->thread_context_collector_instance);
-  }
-
-  long heap_iteration_prep_start_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
+  long heap_iteration_prep_start_time_ns = monotonic_wall_time_now_ns();
   // Prepare the iteration on heap recorder we'll be doing outside the GVL. The preparation needs to
   // happen while holding the GVL.
   // NOTE: While rare, it's possible for the GVL to be released inside this function (see comments on `heap_recorder_update`)
   // and thus don't assume this is an "atomic" step -- other threads may get some running time in the meanwhile.
   heap_recorder_prepare_iteration(state->heap_recorder);
-  long heap_iteration_prep_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - heap_iteration_prep_start_time_ns;
+  long heap_iteration_prep_time_ns = monotonic_wall_time_now_ns() - heap_iteration_prep_start_time_ns;
 
   ddog_Timespec finish_timestamp = system_epoch_now_timespec();
   // Need to do this while still holding the Global VM Lock; see comments on method for why
@@ -811,7 +800,7 @@ static void build_heap_profile_without_gvl(stack_recorder_state *state, profile_
 static void *call_serialize_without_gvl(void *call_args) {
   call_serialize_without_gvl_arguments *args = (call_serialize_without_gvl_arguments *) call_args;
 
-  long serialize_no_gvl_start_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
+  long serialize_no_gvl_start_time_ns = monotonic_wall_time_now_ns();
 
   profile_slot *slot_now_inactive = serializer_flip_active_and_inactive_slots(args->state);
   args->slot = slot_now_inactive;
@@ -819,13 +808,13 @@ static void *call_serialize_without_gvl(void *call_args) {
   // Now that we have the inactive profile with all but heap samples, lets fill it with heap data
   // without needing to race with the active sampler
   build_heap_profile_without_gvl(args->state, args->slot);
-  args->heap_profile_build_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - serialize_no_gvl_start_time_ns;
+  args->heap_profile_build_time_ns = monotonic_wall_time_now_ns() - serialize_no_gvl_start_time_ns;
 
   // Note: The profile gets reset by the serialize call
   args->result = ddog_prof_Profile_serialize(&args->slot->profile, &args->slot->start_timestamp, &args->finish_timestamp);
   args->advance_gen_result = ddog_prof_ManagedStringStorage_advance_gen(args->state->string_storage);
   args->serialize_ran = true;
-  args->serialize_no_gvl_time_ns = long_max_of(0, monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - serialize_no_gvl_start_time_ns);
+  args->serialize_no_gvl_time_ns = long_max_of(0, monotonic_wall_time_now_ns() - serialize_no_gvl_start_time_ns);
 
   return NULL; // Unused
 }
@@ -925,7 +914,7 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
 }
 
 static ddog_Timespec system_epoch_now_timespec(void) {
-  long now_ns = system_epoch_time_now_ns(RAISE_ON_FAILURE);
+  long now_ns = system_epoch_time_now_ns();
   return (ddog_Timespec) {.seconds = now_ns / SECONDS_AS_NS(1), .nanoseconds = now_ns % SECONDS_AS_NS(1)};
 }
 
@@ -1206,10 +1195,3 @@ static VALUE _native_commit_heap_recordings(DDTRACE_UNUSED VALUE _self, VALUE re
 
   return Qtrue;
 }
-
-void recorder_install_on_serialize(VALUE recorder_instance, VALUE thread_context_collector_instance) {
-  stack_recorder_state *state;
-  TypedData_Get_Struct(recorder_instance, stack_recorder_state, &stack_recorder_typed_data, state);
-
-  state->thread_context_collector_instance = enforce_thread_context_collector_instance(thread_context_collector_instance);
-}

data/ext/datadog_profiling_native_extension/stack_recorder.h

@@ -37,5 +37,4 @@ void record_sample(VALUE recorder_instance, ddog_prof_Slice_Location locations,
 void record_endpoint(VALUE recorder_instance, uint64_t local_root_span_id, ddog_CharSlice endpoint);
 void recorder_commit_heap_recordings_may_lose_gvl(VALUE recorder_instance);
 void recorder_heap_update_may_lose_gvl(VALUE recorder_instance);
-void recorder_install_on_serialize(VALUE recorder_instance, VALUE thread_context_collector_instance);
 VALUE enforce_recorder_instance(VALUE object);

data/ext/datadog_profiling_native_extension/time_helpers.c

@@ -28,10 +28,8 @@ long monotonic_to_system_epoch_ns(monotonic_to_system_epoch_state *state, long m
     (state->delta_to_epoch_ns + monotonic_wall_time_ns > state->system_epoch_ns_reference + SECONDS_AS_NS(60));
 
   if (reference_needs_update) {
-    state->system_epoch_ns_reference = system_epoch_time_now_ns(RAISE_ON_FAILURE);
-    long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
-
-    state->delta_to_epoch_ns = state->system_epoch_ns_reference - current_monotonic_wall_time_ns;
+    state->system_epoch_ns_reference = system_epoch_time_now_ns();
+    state->delta_to_epoch_ns = state->system_epoch_ns_reference - monotonic_wall_time_now_ns();
   }
 
   return state->delta_to_epoch_ns + monotonic_wall_time_ns;

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -1,18 +1,16 @@
 #pragma once
 
-#include <stdbool.h>
+#include <ruby.h>
 #include <errno.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include "extconf.h"
-#include "ruby_helpers.h"
 
 #define SECONDS_AS_NS(value) ((value) * 1000L * 1000L * 1000L)
 #define MILLIS_AS_NS(value)  ((value) * 1000L * 1000L)
 #define MICROS_AS_NS(value)  ((value) * 1000L)
 
-typedef enum { RAISE_ON_FAILURE, DO_NOT_RAISE_ON_FAILURE } raise_on_failure_setting;
-
 #define INVALID_TIME -1
 
 typedef struct {
@@ -23,12 +21,13 @@ typedef struct {
 
 #define MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER {.system_epoch_ns_reference = INVALID_TIME}
 
-static inline long retrieve_clock_as_ns(clockid_t clock_id, raise_on_failure_setting raise_on_failure) {
+// clock_id MUST be one of CLOCK_REALTIME/CLOCK_MONOTONIC_FOR_PROFILING/CLOCK_MONOTONIC_COARSE_FOR_PROFILING
+// as for those we're guaranteed to never see failures here unless something is really off
+static inline long retrieve_clock_as_ns(clockid_t clock_id) {
   struct timespec clock_value;
 
-  if (clock_gettime(clock_id, &clock_value) != 0) {
-    if (raise_on_failure == RAISE_ON_FAILURE) ENFORCE_SUCCESS_GVL(errno);
-    return 0;
+  if (RB_UNLIKELY(clock_gettime(clock_id, &clock_value) != 0)) {
+    rb_bug("[ddtrace] clock_gettime(%d) unexpectedly failed (errno=%d) but it should always succeed, libc/kernel bug?", (int) clock_id, errno);
   }
 
   return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
@@ -43,8 +42,8 @@ static inline long retrieve_clock_as_ns(clockid_t clock_id, raise_on_failure_set
   #define CLOCK_MONOTONIC_COARSE_FOR_PROFILING CLOCK_MONOTONIC_COARSE
 #endif
 
-static inline long monotonic_wall_time_now_ns(raise_on_failure_setting raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC_FOR_PROFILING, raise_on_failure); }
-static inline long system_epoch_time_now_ns(raise_on_failure_setting raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
+static inline long monotonic_wall_time_now_ns(void) { return retrieve_clock_as_ns(CLOCK_MONOTONIC_FOR_PROFILING); }
+static inline long system_epoch_time_now_ns(void)   { return retrieve_clock_as_ns(CLOCK_REALTIME); }
 
 // Coarse instants use CLOCK_MONOTONIC_COARSE on Linux which is expected to provide resolution in the millisecond range:
 // https://docs.redhat.com/en/documentation/red_hat_enterprise_linux_for_real_time/7/html/reference_guide/sect-posix_clocks#Using_clock_getres_to_compare_clock_resolution
@@ -57,7 +56,7 @@ typedef struct {
 static inline coarse_instant to_coarse_instant(long timestamp_ns) { return (coarse_instant) {.timestamp_ns = timestamp_ns}; }
 
 static inline coarse_instant monotonic_coarse_wall_time_now_ns(void) {
-  return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE_FOR_PROFILING, DO_NOT_RAISE_ON_FAILURE));
+  return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE_FOR_PROFILING));
 }
 
 long monotonic_to_system_epoch_ns(monotonic_to_system_epoch_state *state, long monotonic_wall_time_ns);