datadog 2.35.0 → 2.36.0

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -8,18 +8,19 @@
 
 void thread_context_collector_sample(
   VALUE self_instance,
-  long current_monotonic_wall_time_ns,
-  VALUE profiler_overhead_stack_thread
+  long current_monotonic_wall_time_ns
 );
-__attribute__((warn_unused_result)) bool thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance);
-__attribute__((warn_unused_result)) bool thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object);
+__attribute__((warn_unused_result)) bool thread_context_collector_prepare_sample_inside_signal_handler(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_after_allocation(VALUE self_instance);
 void thread_context_collector_sample_skipped_allocation_samples(VALUE self_instance, unsigned int skipped_samples);
 VALUE thread_context_collector_sample_after_gc(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);
 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);
 
 #ifndef NO_GVL_INSTRUMENTATION
   typedef enum {
@@ -33,7 +34,8 @@ VALUE enforce_thread_context_collector_instance(VALUE object);
     long waiting_for_gvl_duration_ns;
   } on_gvl_running_result;
 
-  void thread_context_collector_on_gvl_waiting(gvl_profiling_thread thread);
-  __attribute__((warn_unused_result)) on_gvl_running_result thread_context_collector_on_gvl_running(gvl_profiling_thread thread);
+  void thread_context_collector_on_gvl_waiting(per_thread_context *thread_context);
+  __attribute__((warn_unused_result)) on_gvl_running_result thread_context_collector_on_gvl_running(VALUE self_instance, VALUE thread, per_thread_context *thread_context);
   VALUE thread_context_collector_sample_after_gvl_running(VALUE self_instance, VALUE current_thread, long current_monotonic_wall_time_ns);
+  void thread_context_collector_on_gvl_released(per_thread_context *thread_context);
 #endif

data/ext/datadog_profiling_native_extension/datadog_ruby_common.c

@@ -29,16 +29,15 @@ void private_raise_exception(VALUE exception, const char *static_message) {
   rb_exc_raise(exception);
 }
 
-// Helper for raising pre-formatted exceptions
-void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message) {
-  VALUE exception = rb_exc_new_cstr(exception_class, detailed_message);
-  private_raise_exception(exception, static_message);
-}
-
 // Use `raise_error` the macro instead, as it provides additional argument checks.
 void private_raise_error(VALUE exception_class, const char *fmt, ...) {
-  FORMAT_VA_ERROR_MESSAGE(detailed_message, fmt);
-  private_raise_error_formatted(exception_class, detailed_message, fmt);
+  va_list args;
+  va_start(args, fmt);
+  VALUE detailed_message = rb_vsprintf(fmt, args);
+  va_end(args);
+
+  VALUE exception = rb_exc_new_str(exception_class, detailed_message);
+  private_raise_exception(exception, fmt);
 }
 
 VALUE datadog_gem_version(void) {

data/ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -47,11 +47,6 @@ NORETURN(
   __attribute__ ((format (printf, 2, 3)));
 );
 
-// Internal helper for raising pre-formatted exceptions
-NORETURN(
-  void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message)
-);
-
 // Raises an exception with separate telemetry-safe and detailed messages.
 // NOTE: Raising an exception always invokes Ruby code so it requires the GVL and is not compatible with "debug_enter_unsafe_context".
 // @see debug_enter_unsafe_context
@@ -61,13 +56,6 @@ NORETURN(
 
 #define MAX_RAISE_MESSAGE_SIZE 256
 
-#define FORMAT_VA_ERROR_MESSAGE(buf, fmt) \
-  char buf[MAX_RAISE_MESSAGE_SIZE]; \
-  va_list buf##_args; \
-  va_start(buf##_args, fmt); \
-  vsnprintf(buf, MAX_RAISE_MESSAGE_SIZE, fmt, buf##_args); \
-  va_end(buf##_args);
-
 // Helper to retrieve Datadog::VERSION::STRING
 VALUE datadog_gem_version(void);
 

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -174,8 +174,8 @@ $defs << "-DUSE_RACTOR_INTERNAL_APIS_DIRECTLY" if RUBY_VERSION < "3.3"
 # On older Rubies, there was no GVL instrumentation API and APIs created to support it
 $defs << "-DNO_GVL_INSTRUMENTATION" if RUBY_VERSION < "3.2"
 
-# Supporting GVL instrumentation on 3.2 needs some workarounds
-$defs << "-DUSE_GVL_PROFILING_3_2_WORKAROUNDS" if RUBY_VERSION.start_with?("3.2")
+# rb_internal_thread_specific_*()
+$defs << "-DHAVE_RUBY_THREAD_STORAGE_API" if RUBY_VERSION >= "3.3"
 
 # On older Rubies, there was no struct rb_native_thread. See private_vm_api_acccess.c for details.
 $defs << "-DNO_RB_NATIVE_THREAD" if RUBY_VERSION < "3.2"

data/ext/datadog_profiling_native_extension/gvl_profiling_helper.c

@@ -4,49 +4,10 @@
 #include "datadog_ruby_common.h"
 #include "gvl_profiling_helper.h"
 
-#if !defined(NO_GVL_INSTRUMENTATION) && !defined(USE_GVL_PROFILING_3_2_WORKAROUNDS) // Ruby 3.3+
-  rb_internal_thread_specific_key_t gvl_waiting_tls_key;
+#ifdef HAVE_RUBY_THREAD_STORAGE_API
+  rb_internal_thread_specific_key_t per_thread_context_key;
 
-  void gvl_profiling_init(void) {
-    gvl_waiting_tls_key = rb_internal_thread_specific_key_create();
-  }
-
-#endif
-
-#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
-  __thread gvl_profiling_thread gvl_waiting_tls;
-  static bool gvl_profiling_state_thread_tracking_workaround_installed = false;
-
-  static void on_thread_start(
-    DDTRACE_UNUSED rb_event_flag_t _unused1,
-    DDTRACE_UNUSED const rb_internal_thread_event_data_t *_unused2,
-    DDTRACE_UNUSED void *_unused3
-  ) {
-    gvl_waiting_tls = (gvl_profiling_thread) {.thread = NULL};
-  }
-
-  // Hack: We're using the gvl_waiting_tls native thread-local to store per-thread information. Unfortunately, Ruby puts a big hole
-  // in our plan because it reuses native threads -- specifically, in Ruby 3.2, native threads are still 1:1 to Ruby
-  // threads (M:N wasn't a thing yet) BUT once a Ruby thread dies, the VM will keep the native thread around for a
-  // bit, and if another Ruby thread starts right after, Ruby will reuse the native thread, rather than create a new one.
-  //
-  // This will mean that the new Ruby thread will still have the same native thread-local data that we set on the
-  // old thread. For the purposes of our tracking, where we're keeping a pointer to the current thread object in
-  // thread-local storage **this is disastrous** since it means we'll be pointing at the wrong thread (and its
-  // memory may have been freed or reused since!)
-  //
-  // To work around this issue, once GVL profiling is enabled, we install an event hook on thread start
-  // events that clears the thread-local data. This guarantees that there will be no stale data -- any existing
-  // data will be cleared at thread start.
-  //
-  // Note that once installed, this event hook becomes permanent -- stopping the profiler does not stop this event
-  // hook, unlike all others. This is because we can't afford to miss any thread start events while the
-  // profiler is stopped (e.g. during reconfiguration) as that would mean stale data once the profiler starts again.
-  void gvl_profiling_state_thread_tracking_workaround(void) {
-    if (gvl_profiling_state_thread_tracking_workaround_installed) return;
-
-    rb_internal_thread_add_event_hook(on_thread_start, RUBY_INTERNAL_THREAD_EVENT_STARTED, NULL);
-
-    gvl_profiling_state_thread_tracking_workaround_installed = true;
+  void per_thread_context_tls_init(void) {
+    per_thread_context_key = rb_internal_thread_specific_key_create();
   }
 #endif

data/ext/datadog_profiling_native_extension/gvl_profiling_helper.h

@@ -6,62 +6,30 @@
 
 #include "extconf.h"
 
-#if !defined(NO_GVL_INSTRUMENTATION) && !defined(USE_GVL_PROFILING_3_2_WORKAROUNDS) // Ruby 3.3+
-  #include <ruby.h>
-  #include <ruby/thread.h>
-  #include "datadog_ruby_common.h"
+#include <ruby.h>
 
-  typedef struct { VALUE thread; } gvl_profiling_thread;
-  extern rb_internal_thread_specific_key_t gvl_waiting_tls_key;
+// Opaque to this header; the full definition lives in collectors_thread_context.c.
+typedef struct per_thread_context per_thread_context;
 
-  void gvl_profiling_init(void);
+#ifdef HAVE_RUBY_THREAD_STORAGE_API
+  #include <ruby/thread.h>
 
-  static inline gvl_profiling_thread thread_from_thread_object(VALUE thread) {
-    return (gvl_profiling_thread) {.thread = thread};
-  }
+  extern rb_internal_thread_specific_key_t per_thread_context_key;
 
-  static inline gvl_profiling_thread thread_from_event(const rb_internal_thread_event_data_t *event_data) {
-    return thread_from_thread_object(event_data->thread);
-  }
+  void per_thread_context_tls_init(void);
 
-  static inline intptr_t gvl_profiling_state_get(gvl_profiling_thread thread) {
-    return (intptr_t) rb_internal_thread_specific_get(thread.thread, gvl_waiting_tls_key);
+  static inline per_thread_context* get_per_thread_context(VALUE thread) {
+    return rb_internal_thread_specific_get(thread, per_thread_context_key);
   }
 
-  static inline void gvl_profiling_state_set(gvl_profiling_thread thread, intptr_t value) {
-    rb_internal_thread_specific_set(thread.thread, gvl_waiting_tls_key, (void *) value);
+  static inline void set_per_thread_context(VALUE thread, per_thread_context* value) {
+    rb_internal_thread_specific_set(thread, per_thread_context_key, value);
   }
-#endif
-
-#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
-  typedef struct { void *thread; } gvl_profiling_thread;
-  extern __thread gvl_profiling_thread gvl_waiting_tls;
-
-  static inline void gvl_profiling_init(void) { }
-
-  // NOTE: This is a hack that relies on the knowledge that on Ruby 3.2 the
-  // RUBY_INTERNAL_THREAD_EVENT_READY and RUBY_INTERNAL_THREAD_EVENT_RESUMED events always get called on the thread they
-  // are about. Thus, we can use our thread local storage hack to get this data, even though the event doesn't include it.
-  static inline gvl_profiling_thread thread_from_event(DDTRACE_UNUSED const void *event_data) {
-    return gvl_waiting_tls;
-  }
-
-  void gvl_profiling_state_thread_tracking_workaround(void);
-  gvl_profiling_thread gvl_profiling_state_maybe_initialize(void);
+#else
+  static inline void per_thread_context_tls_init(void) { }
 
   // Implementing these on Ruby 3.2 requires access to private VM things, so the following methods are
   // implemented in `private_vm_api_access.c`
-  gvl_profiling_thread thread_from_thread_object(VALUE thread);
-  intptr_t gvl_profiling_state_get(gvl_profiling_thread thread);
-  void gvl_profiling_state_set(gvl_profiling_thread thread, intptr_t value);
-#endif
-
-#ifndef NO_GVL_INSTRUMENTATION // For all Rubies supporting GVL profiling (3.2+)
-  static inline intptr_t gvl_profiling_state_thread_object_get(VALUE thread) {
-    return gvl_profiling_state_get(thread_from_thread_object(thread));
-  }
-
-  static inline void gvl_profiling_state_thread_object_set(VALUE thread, intptr_t value) {
-    gvl_profiling_state_set(thread_from_thread_object(thread), value);
-  }
+  per_thread_context* get_per_thread_context(VALUE thread);
+  void set_per_thread_context(VALUE thread, per_thread_context* value);
 #endif

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -5,7 +5,7 @@
 #include "libdatadog_helpers.h"
 #include "time_helpers.h"
 
-// Note on calloc vs ruby_xcalloc use:
+// note on calloc vs ruby_xcalloc use:
 // * Whenever we're allocating memory after being called by the Ruby VM in a "regular" situation (e.g. initializer)
 //   we should use `ruby_xcalloc` to give the VM visibility into what we're doing + give it a chance to manage GC
 // * BUT, when we're being called during a sample, being in the middle of an object allocation is a very special
@@ -58,7 +58,7 @@ typedef struct {
   heap_frame frames[];
 } heap_record;
 static heap_record* heap_record_new(heap_recorder*, ddog_prof_Slice_Location);
-static void heap_record_free(heap_recorder*, heap_record*);
+static void heap_record_free(heap_recorder*, heap_record*, bool should_unintern);
 
 #if MAX_FRAMES_LIMIT > UINT16_MAX
   #error Frames len type not compatible with MAX_FRAMES_LIMIT
@@ -75,7 +75,7 @@ typedef struct {
   live_object_data object_data;
 } object_record;
 static object_record* object_record_new(long, heap_record*, live_object_data);
-static void object_record_free(heap_recorder*, object_record*);
+static void object_record_free(heap_recorder*, object_record*, bool should_unintern);
 static VALUE object_record_inspect(heap_recorder*, object_record*);
 static object_record SKIPPED_RECORD = {0};
 
@@ -196,8 +196,8 @@ typedef struct {
 static heap_record* get_or_create_heap_record(heap_recorder*, ddog_prof_Slice_Location);
 static void cleanup_heap_record_if_unused(heap_recorder*, heap_record*);
 static void on_committed_object_record_cleanup(heap_recorder *heap_recorder, object_record *record);
-static int st_heap_record_entry_free(st_data_t, st_data_t, st_data_t);
-static int st_object_record_entry_free(st_data_t, st_data_t, st_data_t);
+static int st_heap_record_entry_free_no_unintern(st_data_t, st_data_t, st_data_t);
+static int st_object_record_entry_free_no_unintern(st_data_t, st_data_t, st_data_t);
 static int st_object_record_update(st_data_t, st_data_t, st_data_t);
 static int st_object_records_iterate(st_data_t, st_data_t, st_data_t);
 static int st_object_records_debug(st_data_t key, st_data_t value, st_data_t extra);
@@ -250,17 +250,24 @@ void heap_recorder_free(heap_recorder *heap_recorder) {
     heap_recorder_finish_iteration(heap_recorder);
   }
 
+  // NOTE: We don't unintern the strings referenced by the records we're about to free, thus we use
+  // `..._no_unintern` and `should_unintern: false`. This is intentional: `heap_recorder_free` is only ever called as part of
+  // tearing down the entire stack recorder, and the caller drops the whole managed string storage right after
+  // (see `stack_recorder_typed_data_free`), so there's no need to spend effort updating the managed string table.
+  // Crucially, this also keeps us from crashing: this code runs from the stack recorder's GC free callback, and
+  // because uninterning can fail, we can't raise exceptions in the middle of a dfree.
+
   // Clean-up all object records
-  st_foreach(heap_recorder->object_records, st_object_record_entry_free, (st_data_t) heap_recorder);
+  st_foreach(heap_recorder->object_records, st_object_record_entry_free_no_unintern, (st_data_t) heap_recorder);
   st_free_table(heap_recorder->object_records);
 
   // Clean-up all heap records (this includes those only referred to by queued_samples)
-  st_foreach(heap_recorder->heap_records, st_heap_record_entry_free, (st_data_t) heap_recorder);
+  st_foreach(heap_recorder->heap_records, st_heap_record_entry_free_no_unintern, (st_data_t) heap_recorder);
   st_free_table(heap_recorder->heap_records);
 
   if (heap_recorder->active_recording != NULL && heap_recorder->active_recording != &SKIPPED_RECORD) {
     // If there's a partial object record, clean it up as well
-    object_record_free(heap_recorder, heap_recorder->active_recording);
+    object_record_free(heap_recorder, heap_recorder->active_recording, false);
   }
 
   ruby_xfree(heap_recorder->reusable_locations);
@@ -306,7 +313,7 @@ void heap_recorder_after_fork(heap_recorder *heap_recorder) {
   // simply be noticed on next heap_recorder_prepare_iteration.
   //
   // There is one small caveat though: fork only preserves one thread and in a Ruby app, that
-  // will be the thread holding on to the GVL. Since we support iteration on the heap recorder
+  // will be the thread holding the GVL. Since we support iteration on the heap recorder
   // outside of the GVL, any state specific to that interaction may be inconsistent after fork
   // (e.g. an acquired lock for thread safety). Iteration operates on object_records_snapshot
   // though and that one will be updated on next heap_recorder_prepare_iteration so we really
@@ -714,15 +721,17 @@ VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
 // ==========================
 // Heap Recorder Internal API
 // ==========================
-static int st_heap_record_entry_free(st_data_t key, DDTRACE_UNUSED st_data_t value, st_data_t extra_arg) {
+// NOTE: Only expected to be used from heap_recorder_free, which will separately destroy the string table
+static int st_heap_record_entry_free_no_unintern(st_data_t key, DDTRACE_UNUSED st_data_t value, st_data_t extra_arg) {
   heap_recorder *recorder = (heap_recorder *) extra_arg;
-  heap_record_free(recorder, (heap_record *) key);
+  heap_record_free(recorder, (heap_record *) key, false);
   return ST_DELETE;
 }
 
-static int st_object_record_entry_free(DDTRACE_UNUSED st_data_t key, st_data_t value, st_data_t extra_arg) {
+// NOTE: Only expected to be used from heap_recorder_free, which will separately destroy the string table
+static int st_object_record_entry_free_no_unintern(DDTRACE_UNUSED st_data_t key, st_data_t value, st_data_t extra_arg) {
   heap_recorder *recorder = (heap_recorder *) extra_arg;
-  object_record_free(recorder, (object_record *) value);
+  object_record_free(recorder, (object_record *) value, false);
   return ST_DELETE;
 }
 
@@ -888,7 +897,7 @@ static heap_record* get_or_create_heap_record(heap_recorder *heap_recorder, ddog
   heap_record *new_or_existing_record = NULL; // Will be set inside update_heap_record_entry_with_new_allocation
   bool existing = st_update(heap_recorder->heap_records, (st_data_t) stack, update_heap_record_entry_with_new_allocation, (st_data_t) &new_or_existing_record);
   if (existing) {
-    heap_record_free(heap_recorder, stack);
+    heap_record_free(heap_recorder, stack, true);
   }
 
   return new_or_existing_record;
@@ -903,7 +912,7 @@ static void cleanup_heap_record_if_unused(heap_recorder *heap_recorder, heap_rec
   if (!st_delete(heap_recorder->heap_records, (st_data_t*) &heap_record, NULL)) {
     raise_error(rb_eRuntimeError, "Attempted to cleanup an untracked heap_record");
   };
-  heap_record_free(heap_recorder, heap_record);
+  heap_record_free(heap_recorder, heap_record, true);
 }
 
 static void on_committed_object_record_cleanup(heap_recorder *heap_recorder, object_record *record) {
@@ -925,7 +934,7 @@ static void on_committed_object_record_cleanup(heap_recorder *heap_recorder, obj
   // One less object using this heap record, it may have become unused...
   cleanup_heap_record_if_unused(heap_recorder, heap_record);
 
-  object_record_free(heap_recorder, record);
+  object_record_free(heap_recorder, record, true);
 }
 
 // =================
@@ -939,8 +948,12 @@ object_record* object_record_new(long obj_id, heap_record *heap_record, live_obj
   return record;
 }
 
-void object_record_free(heap_recorder *recorder, object_record *record) {
-  unintern_or_raise(recorder, record->object_data.class);
+void object_record_free(heap_recorder *recorder, object_record *record, bool should_unintern) {
+  // When tearing down the whole recorder state, we skip uninterning as it's not needed (the managed
+  // string table is going to be destroyed anyway) and if there's any failures we can't raise
+  // in the middle of a dfree callback.
+  if (should_unintern) unintern_or_raise(recorder, record->object_data.class);
+
   free(record); // See "note on calloc vs ruby_xcalloc use" above
 }
 
@@ -1012,15 +1025,20 @@ heap_record* heap_record_new(heap_recorder *recorder, ddog_prof_Slice_Location l
   return stack;
 }
 
-void heap_record_free(heap_recorder *recorder, heap_record *stack) {
-  ddog_prof_ManagedStringId *ids = recorder->reusable_ids;
-
-  // Put all the ids in the same array; doesn't really matter the order
-  for (u_int16_t i = 0; i < stack->frames_len; i++) {
-    ids[i] = stack->frames[i].filename;
-    ids[i + stack->frames_len] = stack->frames[i].name;
+void heap_record_free(heap_recorder *recorder, heap_record *stack, bool should_unintern) {
+  // When tearing down the whole recorder state, we skip uninterning as it's not needed (the managed
+  // string table is going to be destroyed anyway) and if there's any failures we can't raise
+  // in the middle of a dfree callback.
+  if (should_unintern) {
+    ddog_prof_ManagedStringId *ids = recorder->reusable_ids;
+
+    // Put all the ids in the same array; doesn't really matter the order
+    for (u_int16_t i = 0; i < stack->frames_len; i++) {
+      ids[i] = stack->frames[i].filename;
+      ids[i + stack->frames_len] = stack->frames[i].name;
+    }
+    unintern_all_or_raise(recorder, (ddog_prof_Slice_ManagedStringId) { .ptr = ids, .len = stack->frames_len * 2 });
   }
-  unintern_all_or_raise(recorder, (ddog_prof_Slice_ManagedStringId) { .ptr = ids, .len = stack->frames_len * 2 });
 
   free(stack); // See "note on calloc vs ruby_xcalloc use" above
 }

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -790,15 +790,11 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
   }
 #endif
 
-#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
+#ifndef HAVE_RUBY_THREAD_STORAGE_API
   #include "gvl_profiling_helper.h"
 
-  gvl_profiling_thread thread_from_thread_object(VALUE thread) {
-    return (gvl_profiling_thread) {.thread = thread_struct_from_object(thread)};
-  }
-
   // Hack: In Ruby 3.3+ we attach gvl profiling state to Ruby threads using the
-  // rb_internal_thread_specific_* APIs. These APIs did not exist on Ruby 3.2. On Ruby 3.2 we instead store the
+  // rb_internal_thread_specific_* APIs. These APIs did not exist on Ruby <= 3.2. On Ruby <= 3.2 we instead store the
   // needed data inside the `rb_thread_t` structure, specifically in `stat_insn_usage` as a Ruby FIXNUM.
   //
   // Why `stat_insn_usage`? We needed some per-thread storage, and while looking at the Ruby VM sources I noticed
@@ -806,38 +802,21 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
   // code. There's a comment attached to it "/* statistics data for profiler */" but other than marking this
   // field for GC, I could not find any place in the VM commit history or on GitHub where this has ever been used.
   //
-  // Thus, since this hack is only for 3.2, which presumably will never see this field either removed or used
-  // during its remaining maintenance release period we... kinda take it for our own usage. It's ugly, I know...
-  intptr_t gvl_profiling_state_get(gvl_profiling_thread thread) {
-    if (thread.thread == NULL) return 0;
-
-    VALUE current_value = ((rb_thread_t *)thread.thread)->stat_insn_usage;
-    intptr_t result = current_value == Qnil ? 0 : FIX2LONG(current_value);
-    return result;
-  }
-
-  void gvl_profiling_state_set(gvl_profiling_thread thread, intptr_t value) {
-    if (thread.thread == NULL) return;
-    ((rb_thread_t *)thread.thread)->stat_insn_usage = LONG2FIX(value);
+  // Thus, since this hack is only for Ruby <= 3.2, which presumably will never see this field either removed or used
+  // we... kinda take it for our own usage. It's ugly, I know...
+  //
+  // 64-bit pointers actually use 48-bit virtual addresses (https://muxup.com/2023q4/storing-data-in-pointers),
+  // so we are sure the addresses fit in Fixnums.
+  per_thread_context *get_per_thread_context(VALUE thread) {
+    VALUE current_value = thread_struct_from_object(thread)->stat_insn_usage;
+    return RB_FIXNUM_P(current_value) ? (per_thread_context *) FIX2LONG(current_value) : NULL;
   }
 
-  // Because Ruby 3.2 does not give us the current thread when calling the RUBY_INTERNAL_THREAD_EVENT_READY and
-  // RUBY_INTERNAL_THREAD_EVENT_RESUMED APIs, we need to figure out this info ourselves.
-  //
-  // Specifically, this method was created to be called from a RUBY_INTERNAL_THREAD_EVENT_RESUMED callback --
-  // when it's triggered, we know the thread the code gets executed on is holding the GVL, so we use this
-  // opportunity to initialize our thread-local value.
-  gvl_profiling_thread gvl_profiling_state_maybe_initialize(void) {
-    gvl_profiling_thread current_thread = gvl_waiting_tls;
-
-    if (current_thread.thread == NULL) {
-      // threads.sched.running is the thread currently holding the GVL, which when this gets executed is the
-      // current thread!
-      current_thread = (gvl_profiling_thread) {.thread = (void *) rb_current_ractor()->threads.sched.running};
-      gvl_waiting_tls = current_thread;
+  void set_per_thread_context(VALUE thread, per_thread_context *value) {
+    if (!RB_FIXABLE((intptr_t) value)) {
+      rb_bug("per_thread_context pointer does not fit in a Fixnum: %p", value);
     }
-
-    return current_thread;
+    thread_struct_from_object(thread)->stat_insn_usage = value ? LONG2FIX((intptr_t) value) : Qfalse;
   }
 #endif
 

data/ext/datadog_profiling_native_extension/profiling.c

@@ -28,8 +28,11 @@ void crashtracking_runtime_stacks_init(void);
 void setup_signal_handler_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
-static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
+static VALUE _native_raise_error_value_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message_value_arg);
+static VALUE _native_grab_gvl_and_raise_cstr_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
 static void *trigger_grab_gvl_and_raise(void *trigger_args);
+static VALUE _native_grab_gvl_and_raise_value_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message_value_arg, VALUE release_gvl);
+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);
@@ -78,7 +81,9 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
 
   // Hosts methods used for testing the native code using RSpec
   VALUE testing_module = rb_define_module_under(native_extension_module, "Testing");
-  rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise", _native_grab_gvl_and_raise, 4);
+  rb_define_singleton_method(testing_module, "_native_raise_error_value_arg", _native_raise_error_value_arg, 2);
+  rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise_cstr_arg", _native_grab_gvl_and_raise_cstr_arg, 4);
+  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);
@@ -103,13 +108,17 @@ static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   return Qtrue;
 }
 
+static VALUE _native_raise_error_value_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message_value_arg) {
+  raise_error(exception_class, ">%"PRIsVALUE"<", test_message_value_arg);
+}
+
 typedef struct {
   VALUE exception_class;
   char *test_message;
   char *test_message_arg;
 } trigger_grab_gvl_and_raise_arguments;
 
-static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
+static VALUE _native_grab_gvl_and_raise_cstr_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
   ENFORCE_TYPE(test_message, T_STRING);
 
   trigger_grab_gvl_and_raise_arguments args;
@@ -124,7 +133,7 @@ static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE except
     private_grab_gvl_and_raise(args.exception_class, 0, args.test_message, args.test_message_arg);
   }
 
-  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise; this should never happen");
+  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_cstr_arg; this should never happen");
 }
 
 static void *trigger_grab_gvl_and_raise(void *trigger_args) {
@@ -139,6 +148,34 @@ static void *trigger_grab_gvl_and_raise(void *trigger_args) {
   return NULL;
 }
 
+typedef struct {
+  VALUE exception_class;
+  VALUE test_message_value_arg;
+} trigger_grab_gvl_and_raise_value_arguments;
+
+static VALUE _native_grab_gvl_and_raise_value_arg(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message_value_arg, VALUE release_gvl) {
+  trigger_grab_gvl_and_raise_value_arguments args;
+
+  args.exception_class = exception_class;
+  args.test_message_value_arg = test_message_value_arg;
+
+  if (RTEST(release_gvl)) {
+    rb_thread_call_without_gvl(trigger_grab_gvl_and_raise_value_arg, &args, NULL, NULL);
+  } else {
+    private_grab_gvl_and_raise(args.exception_class, 0, ">%"PRIsVALUE"<", args.test_message_value_arg);
+  }
+
+  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_value_arg; this should never happen");
+}
+
+static void *trigger_grab_gvl_and_raise_value_arg(void *trigger_args) {
+  trigger_grab_gvl_and_raise_value_arguments *args = (trigger_grab_gvl_and_raise_value_arguments *) trigger_args;
+
+  private_grab_gvl_and_raise(args->exception_class, 0, ">%"PRIsVALUE"<", args->test_message_value_arg);
+
+  return NULL;
+}
+
 typedef struct {
   int syserr_errno;
   char *test_message;