datadog 2.4.0 → 2.44.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -2,12 +2,14 @@
 
 #include <stdbool.h>
 
-// The private_vm_api_access.c includes the RUBY_MJIT_HEADER which replaces and conflicts with any other Ruby headers;
-// so we use PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES to be able to include private_vm_api_access.h on that file
-// without also dragging the incompatible includes
+// The private_vm_api_access.c includes private VM headers (via datadog-ruby_core_source) which replace and conflict
+// with any other Ruby headers; so we use PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES to be able to include
+// private_vm_api_access.h on that file without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
   #include <ruby/thread_native.h>
   #include <ruby/vm.h>
+  typedef struct RubyCME rb_callable_method_entry_t;
+  typedef struct RubyISEQ rb_iseq_t;
 #endif
 
 #include "extconf.h"
@@ -18,17 +20,19 @@ typedef struct {
   rb_nativethread_id_t owner;
 } current_gvl_owner;
 
-typedef struct frame_info {
-  union {
+// If a sample is kept around for later use, some of its fields need marking. Remember to
+// update the marking code in `sampling_buffer_mark` if new fields are added.
+// This is very similar to rb_backtrace_location_t (cme, iseq, pc) on purpose:
+// we want to show frames like Ruby backtraces,
+// not like rb_profile_frame_qualified_method_name() which differs in some cases.
+typedef struct {
+  const rb_callable_method_entry_t* cme; // Needs marking, kept alive by sampling_buffer
+  struct {
     struct {
-      VALUE iseq;
-      void *caching_pc; // For caching only
+      const rb_iseq_t* iseq; // Needs marking, kept alive by sampling_buffer
+      void *caching_pc; // For caching validation/invalidation only (does not need marking)
       int line;
     } ruby_frame;
-    struct {
-      VALUE caching_cme; // For caching only
-      ID method_id;
-    } native_frame;
   } as;
   bool is_ruby_frame : 1;
   bool same_frame : 1;
@@ -38,12 +42,18 @@ rb_nativethread_id_t pthread_id_for(VALUE thread);
 bool is_current_thread_holding_the_gvl(void);
 current_gvl_owner gvl_owner(void);
 uint64_t native_thread_id_for(VALUE thread);
-ptrdiff_t stack_depth_for(VALUE thread);
 void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);
+void self_test_thread_name_for(void);
 
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
+
+size_t sizeof_rb_iseq_t(void);
+size_t sizeof_rb_callable_method_entry_t(void);
+VALUE ddtrace_iseq_base_label(const rb_iseq_t *iseq);
+VALUE ddtrace_iseq_path(const rb_iseq_t *iseq);
+
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 
@@ -68,3 +78,29 @@ const char *imemo_kind(VALUE imemo);
 
 #define ENFORCE_THREAD(value) \
   { if (RB_UNLIKELY(!rb_typeddata_is_kind_of(value, RTYPEDDATA_TYPE(rb_thread_current())))) raise_unexpected_type(value, ADD_QUOTES(value), "Thread", __FILE__, __LINE__, __func__); }
+
+bool is_raised_flag_set(VALUE thread);
+
+// Can be nil if `rb_fiber_current()` or similar has not been called (gets allocated lazily)
+// Only implemented for Ruby 3.1+
+VALUE current_fiber_for(VALUE thread);
+
+void self_test_current_fiber_for(void);
+
+// Returns the module name without allocating, or nil if the module is anonymous (i.e., Module#name is nil).
+// Never returns an empty String (returns nil instead if it the name would be empty).
+// Also consider ddtrace_permanent_mod_name().
+//
+// Use this instead of rb_class2name() or rb_mod_name() which can trigger allocations
+VALUE ddtrace_alloc_free_rb_mod_name(VALUE mod);
+// Same as `ddtrace_alloc_free_rb_mod_name` but additionally returns nil (filters out)
+// if the module does not have a permanent name (e.g. `#<Module:0x0123>::Foo`).
+VALUE ddtrace_permanent_mod_name(VALUE mod);
+
+ssize_t ddtrace_location_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq, char *buf, size_t buf_size);
+VALUE ddtrace_location_base_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq);
+void* ddtrace_cme_cfunc_func(const rb_callable_method_entry_t *cme);
+const char *ddtrace_cme_original_method_name(const rb_callable_method_entry_t *cme);
+
+// Returns true for internal objects (like T_IMEMO/T_ICLASS/etc) and "hidden" objects (rb_class_of(obj) == 0)
+bool ddtrace_is_internal_object_p(VALUE obj);

data/ext/datadog_profiling_native_extension/profiling.c

@@ -8,9 +8,11 @@
 #include "clock_id.h"
 #include "helpers.h"
 #include "private_vm_api_access.h"
+#include "datadog_ruby_common.h"
 #include "ruby_helpers.h"
 #include "setup_signal_handler.h"
 #include "time_helpers.h"
+#include "unsafe_api_calls_check.h"
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module);
@@ -19,12 +21,19 @@ void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
 void collectors_thread_context_init(VALUE profiling_module);
+void collectors_heap_recorder_init(void);
+void encoded_profile_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
+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);
@@ -37,9 +46,20 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl);
 static void *trigger_enforce_success(void *trigger_args);
 static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self);
+static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj);
 
 void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
+  // The profiler still has a lot of limitations around being used in Ractors BUT for now we're choosing to take care of those
+  // on our side, rather than asking Ruby to block calling our APIs from Ractors.
+  #ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+  #endif
+
   VALUE datadog_module = rb_define_module("Datadog");
+
+  // MUST be called before all other initialization
+  datadog_ruby_common_init();
+
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
   VALUE native_extension_module = rb_define_module_under(profiling_module, "NativeExtension");
 
@@ -47,18 +67,25 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_funcall(native_extension_module, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("native_working?")));
 
   ruby_helpers_init();
+  setup_signal_handler_init(profiling_module);
   collectors_cpu_and_wall_time_worker_init(profiling_module);
   collectors_discrete_dynamic_sampler_init(profiling_module);
   collectors_dynamic_sampling_rate_init(profiling_module);
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
   collectors_thread_context_init(profiling_module);
+  collectors_heap_recorder_init();
+  encoded_profile_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
+  crashtracking_runtime_stacks_init();
+  unsafe_api_calls_check_init();
 
   // 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);
@@ -72,82 +99,117 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_define_singleton_method(testing_module, "_native_trigger_holding_the_gvl_signal_handler_on", _native_trigger_holding_the_gvl_signal_handler_on, 1);
   rb_define_singleton_method(testing_module, "_native_enforce_success", _native_enforce_success, 2);
   rb_define_singleton_method(testing_module, "_native_malloc_stats", _native_malloc_stats, 0);
+  rb_define_singleton_method(testing_module, "_native_safe_object_info", _native_safe_object_info, 1);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
+  self_test_thread_name_for();
   self_test_clock_id();
+  self_test_current_fiber_for();
   self_test_mn_enabled();
 
   return Qtrue;
 }
 
-struct trigger_grab_gvl_and_raise_arguments {
+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;
-  int test_message_arg;
-};
+  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);
 
-  struct trigger_grab_gvl_and_raise_arguments args;
+  trigger_grab_gvl_and_raise_arguments args;
 
   args.exception_class = exception_class;
   args.test_message = StringValueCStr(test_message);
-  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+  args.test_message_arg = test_message_arg != Qnil ? StringValueCStr(test_message_arg) : NULL;
 
   if (RTEST(release_gvl)) {
     rb_thread_call_without_gvl(trigger_grab_gvl_and_raise, &args, NULL, NULL);
   } else {
-    grab_gvl_and_raise(args.exception_class, "%s", args.test_message);
+    private_grab_gvl_and_raise(args.exception_class, 0, args.test_message, args.test_message_arg);
   }
 
-  rb_raise(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) {
-  struct trigger_grab_gvl_and_raise_arguments *args = (struct trigger_grab_gvl_and_raise_arguments *) trigger_args;
+  trigger_grab_gvl_and_raise_arguments *args = (trigger_grab_gvl_and_raise_arguments *) trigger_args;
+
+  if (args->test_message_arg != NULL) {
+    private_grab_gvl_and_raise(args->exception_class, 0, args->test_message, args->test_message_arg);
+  } else {
+    private_grab_gvl_and_raise(args->exception_class, 0, args->test_message, NULL);
+  }
+
+  return NULL;
+}
 
-  if (args->test_message_arg >= 0) {
-    grab_gvl_and_raise(args->exception_class, "%s%d", args->test_message, args->test_message_arg);
+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 {
-    grab_gvl_and_raise(args->exception_class, "%s", args->test_message);
+    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;
 }
 
-struct trigger_grab_gvl_and_raise_syserr_arguments {
+typedef struct {
   int syserr_errno;
   char *test_message;
-  int test_message_arg;
-};
+  char *test_message_arg;
+} trigger_grab_gvl_and_raise_syserr_arguments;
 
 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) {
   ENFORCE_TYPE(test_message, T_STRING);
 
-  struct trigger_grab_gvl_and_raise_syserr_arguments args;
+  trigger_grab_gvl_and_raise_syserr_arguments args;
 
   args.syserr_errno = NUM2INT(syserr_errno);
   args.test_message = StringValueCStr(test_message);
-  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+  args.test_message_arg = test_message_arg != Qnil ? StringValueCStr(test_message_arg) : NULL;
 
   if (RTEST(release_gvl)) {
     rb_thread_call_without_gvl(trigger_grab_gvl_and_raise_syserr, &args, NULL, NULL);
   } else {
-    grab_gvl_and_raise_syserr(args.syserr_errno, "%s", args.test_message);
+    private_grab_gvl_and_raise(Qnil, args.syserr_errno, args.test_message, args.test_message_arg);
   }
 
-  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_syserr; this should never happen");
+  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_syserr; this should never happen");
 }
 
 static void *trigger_grab_gvl_and_raise_syserr(void *trigger_args) {
-  struct trigger_grab_gvl_and_raise_syserr_arguments *args = (struct trigger_grab_gvl_and_raise_syserr_arguments *) trigger_args;
+  trigger_grab_gvl_and_raise_syserr_arguments *args = (trigger_grab_gvl_and_raise_syserr_arguments *) trigger_args;
 
-  if (args->test_message_arg >= 0) {
-    grab_gvl_and_raise_syserr(args->syserr_errno, "%s%d", args->test_message, args->test_message_arg);
+  if (args->test_message_arg != NULL) {
+    private_grab_gvl_and_raise(Qnil, args->syserr_errno, args->test_message, args->test_message_arg);
   } else {
-    grab_gvl_and_raise_syserr(args->syserr_errno, "%s", args->test_message);
+    private_grab_gvl_and_raise(Qnil, args->syserr_errno, args->test_message, NULL);
   }
 
   return NULL;
@@ -231,9 +293,9 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 
   ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex));
 
-  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
+  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler, true);
 
-  if (holding_the_gvl_signal_handler_result[0] == Qfalse) rb_raise(rb_eRuntimeError, "Could not signal background_thread");
+  if (holding_the_gvl_signal_handler_result[0] == Qfalse) raise_error(rb_eRuntimeError, "Could not signal background_thread");
 
   VALUE result = rb_hash_new();
   rb_hash_aset(result, ID2SYM(rb_intern("ruby_thread_has_gvl_p")), holding_the_gvl_signal_handler_result[1]);
@@ -265,3 +327,7 @@ static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self) {
     return Qfalse;
   #endif
 }
+
+static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj) {
+  return rb_str_new_cstr(safe_object_info(obj));
+}

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -3,91 +3,95 @@
 
 #include "ruby_helpers.h"
 #include "private_vm_api_access.h"
+#include "extconf.h"
 
 // The following global variables are initialized at startup to save expensive lookups later.
 // They are not expected to be mutated outside of init.
-static VALUE module_object_space = Qnil;
-static ID _id2ref_id = Qnil;
 static ID inspect_id = Qnil;
 static ID to_s_id = Qnil;
 
 void ruby_helpers_init(void) {
-  rb_global_variable(&module_object_space);
-
-  module_object_space = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
-  _id2ref_id = rb_intern("_id2ref");
   inspect_id = rb_intern("inspect");
   to_s_id = rb_intern("to_s");
 }
 
-#define MAX_RAISE_MESSAGE_SIZE 256
-
-struct raise_arguments {
-  VALUE exception_class;
-  char exception_message[MAX_RAISE_MESSAGE_SIZE];
-};
+// Use `raise_syserr` the macro instead, as it provides additional argument checks.
+void private_raise_syserr(int syserr_errno, const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  VALUE detailed_message = rb_vsprintf(fmt, args);
+  va_end(args);
 
-static void *trigger_raise(void *raise_arguments) {
-  struct raise_arguments *args = (struct raise_arguments *) raise_arguments;
-  rb_raise(args->exception_class, "%s", args->exception_message);
+  VALUE exception = rb_syserr_new_str(syserr_errno, detailed_message);
+  private_raise_exception(exception, fmt);
 }
 
-void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
-  struct raise_arguments args;
+typedef struct {
+  VALUE exception_class;
+  int syserr_errno;
+  const char *format_string;
+  va_list va_args;
+} raise_args;
 
-  args.exception_class = exception_class;
+// Called via rb_thread_call_with_gvl from private_grab_gvl_and_raise.
+// Formats the message with rb_vsprintf (which requires the GVL) and raises.
+static void *trigger_raise(void *raise_arguments) {
+  raise_args *args = (raise_args *) raise_arguments;
 
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+  VALUE detailed_message = rb_vsprintf(args->format_string, args->va_args);
 
-  if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise called by thread holding the global VM lock. exception_message: '%s'",
-      args.exception_message
-    );
+  VALUE exception;
+  if (args->syserr_errno) {
+    exception = rb_syserr_new_str(args->syserr_errno, detailed_message);
+  } else {
+    exception = rb_exc_new_str(args->exception_class, detailed_message);
   }
 
-  rb_thread_call_with_gvl(trigger_raise, &args);
+  private_raise_exception(exception, args->format_string);
 
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
+  return NULL;
 }
 
-struct syserr_raise_arguments {
-  int syserr_errno;
-  char exception_message[MAX_RAISE_MESSAGE_SIZE];
-};
+void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const char *format_string, ...) {
+  raise_args args;
 
-static void *trigger_syserr_raise(void *syserr_raise_arguments) {
-  struct syserr_raise_arguments *args = (struct syserr_raise_arguments *) syserr_raise_arguments;
-  rb_syserr_fail(args->syserr_errno, args->exception_message);
-}
-
-void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...) {
-  struct syserr_raise_arguments args;
-
-  args.syserr_errno = syserr_errno;
+  if (syserr_errno != 0) {
+    args.exception_class = Qnil;
+    args.syserr_errno = syserr_errno;
+  } else {
+    args.exception_class = exception_class;
+    args.syserr_errno = 0;
+  }
 
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+  args.format_string = format_string;
+  va_start(args.va_args, format_string);
 
   if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise_syserr called by thread holding the global VM lock. syserr_errno: %d, exception_message: '%s'",
-      syserr_errno,
-      args.exception_message
+    VALUE detailed_message = rb_vsprintf(format_string, args.va_args);
+    va_end(args.va_args);
+
+    VALUE wrapped_message = rb_sprintf(
+      "grab_gvl_and_raise called by thread holding the global VM lock: %"PRIsVALUE,
+      detailed_message
     );
+    char telemetry_message[MAX_RAISE_MESSAGE_SIZE];
+    snprintf(
+      telemetry_message,
+      MAX_RAISE_MESSAGE_SIZE,
+      "grab_gvl_and_raise called by thread holding the global VM lock: %s",
+      format_string
+    );
+    VALUE exception = rb_exc_new_str(rb_eRuntimeError, wrapped_message);
+    private_raise_exception(exception, telemetry_message);
   }
 
-  rb_thread_call_with_gvl(trigger_syserr_raise, &args);
+  rb_thread_call_with_gvl(trigger_raise, &args);
 
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+  va_end(args.va_args);
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", format_string);
 }
 
-void raise_syserr(
+void private_raise_enforce_syserr(
   int syserr_errno,
   bool have_gvl,
   const char *expression,
@@ -95,57 +99,12 @@ void raise_syserr(
   int line,
   const char *function_name
 ) {
+  const char *format = "Failure returned by '%s' at %s:%d:in `%s'";
   if (have_gvl) {
-    rb_exc_raise(rb_syserr_new_str(syserr_errno, rb_sprintf("Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name)));
+    private_raise_exception(rb_syserr_new_str(syserr_errno, rb_sprintf(format, expression, file, line, function_name)), format);
   } else {
-    grab_gvl_and_raise_syserr(syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
-  }
-}
-
-char* ruby_strndup(const char *str, size_t size) {
-  char *dup;
-
-  dup = xmalloc(size + 1);
-  memcpy(dup, str, size);
-  dup[size] = '\0';
-
-  return dup;
-}
-
-static VALUE _id2ref(VALUE obj_id) {
-  // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
-  return rb_funcall(module_object_space, _id2ref_id, 1, obj_id);
-}
-
-static VALUE _id2ref_failure(DDTRACE_UNUSED VALUE _unused1, DDTRACE_UNUSED VALUE _unused2) {
-  return Qfalse;
-}
-
-// Native wrapper to get an object ref from an id. Returns true on success and
-// writes the ref to the value pointer parameter if !NULL. False if id doesn't
-// reference a valid object (in which case value is not changed).
-bool ruby_ref_from_id(VALUE obj_id, VALUE *value) {
-  // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
-  // so we need to call it via rb_rescue2
-  // TODO: Benchmark rb_rescue2 vs rb_protect here
-  VALUE result = rb_rescue2(
-    _id2ref,
-    obj_id,
-    _id2ref_failure,
-    Qnil,
-    rb_eRangeError, // rb_eRangeError is the error used to flag invalid ids
-    0 // Required by API to be the last argument
-  );
-
-  if (result == Qfalse) {
-    return false;
-  }
-
-  if (value != NULL) {
-    (*value) = result;
+    private_grab_gvl_and_raise(Qnil, syserr_errno, format, expression, file, line, function_name);
   }
-
-  return true;
 }
 
 // Not part of public headers but is externed from Ruby
@@ -192,43 +151,24 @@ size_t ruby_obj_memsize_of(VALUE obj) {
   }
 }
 
-// Inspired by rb_class_of but without actually returning classes or potentially doing assertions
-static bool ruby_is_obj_with_class(VALUE obj) {
-  if (!RB_SPECIAL_CONST_P(obj)) {
-    return true;
-  }
-  if (obj == RUBY_Qfalse) {
-    return true;
-  }
-  else if (obj == RUBY_Qnil) {
-    return true;
-  }
-  else if (obj == RUBY_Qtrue) {
-    return true;
-  }
-  else if (RB_FIXNUM_P(obj)) {
-    return true;
-  }
-  else if (RB_STATIC_SYM_P(obj)) {
-    return true;
-  }
-  else if (RB_FLONUM_P(obj)) {
-    return true;
-  }
+#ifdef NO_RB_OBJ_INFO
+  const char* safe_object_info(DDTRACE_UNUSED VALUE obj) { return "(No rb_obj_info for current Ruby)"; }
+#else
+  // This function is a public symbol, but not on all Rubies; `safe_object_info` below abstracts this, and
+  // should be used instead.
+  const char *rb_obj_info(VALUE obj);
 
-  return false;
-}
+  const char* safe_object_info(VALUE obj) { return rb_obj_info(obj); }
+#endif
 
 VALUE ruby_safe_inspect(VALUE obj) {
-  if (!ruby_is_obj_with_class(obj)) {
-    return rb_str_new_cstr("(Not an object)");
-  }
-
-  if (rb_respond_to(obj, inspect_id)) {
-    return rb_sprintf("%+"PRIsVALUE, obj);
-  } else if (rb_respond_to(obj, to_s_id)) {
-    return rb_sprintf("%"PRIsVALUE, obj);
-  } else {
-    return rb_str_new_cstr("(Not inspectable)");
-  }
+  if (ddtrace_is_internal_object_p(obj))  return rb_sprintf("(VM Internal, %s)", safe_object_info(obj));
+  // @ivoanjo: I saw crashes on Ruby 3.1.4 when trying to #inspect matchdata objects. I'm not entirely sure why this
+  // is needed, but since we only use this method for debug purposes I put in this alternative and decided not to
+  // dig deeper.
+  if (rb_type(obj) == RUBY_T_MATCH)   return rb_sprintf("(MatchData, %s)", safe_object_info(obj));
+  if (rb_respond_to(obj, inspect_id)) return rb_sprintf("%+"PRIsVALUE, obj);
+  if (rb_respond_to(obj, to_s_id))    return rb_sprintf("%"PRIsVALUE, obj);
+
+  return rb_str_new_cstr("(Not inspectable)");
 }