cw-datadog 2.23.0.2

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#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
+#ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
+  #include <ruby/thread_native.h>
+  #include <ruby/vm.h>
+#endif
+
+#include "extconf.h"
+
+// Contains the current gvl owner, and a flag to indicate if it is valid
+typedef struct {
+  bool valid;
+  rb_nativethread_id_t owner;
+} current_gvl_owner;
+
+// 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.
+typedef struct {
+  union {
+    struct {
+      VALUE iseq; // Needs marking if kept around
+      void *caching_pc; // For caching validation/invalidation only (does not need marking)
+      int line;
+    } ruby_frame;
+    struct {
+      VALUE caching_cme; // For caching validation/invalidation only (does not need marking)
+      ID method_id;
+      void *function;
+    } native_frame;
+  } as;
+  bool is_ruby_frame : 1;
+  bool same_frame : 1;
+} 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);
+uint64_t native_thread_id_for(VALUE thread);
+void ddtrace_thread_list(VALUE result_array);
+bool is_thread_alive(VALUE thread);
+VALUE thread_name_for(VALUE thread);
+
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
+
+// 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);
+
+// See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
+#define PLACEHOLDER_STACK_IN_NATIVE_CODE -1
+
+// This method provides the file and line of the "invoke location" of a thread (first file:line of the block used to
+// start the thread), if any.
+// This is what Ruby shows in `Thread#to_s`.
+// The file is returned directly, and the line is recorded onto *line_location.
+VALUE invoke_location_for(VALUE thread, int *line_location);
+
+// Check if RUBY_MN_THREADS is enabled (aka main Ractor is not doing 1:1 threads)
+void self_test_mn_enabled(void);
+
+// Provides more specific information on what kind an imemo is
+const char *imemo_kind(VALUE imemo);
+
+#ifdef NO_POSTPONED_TRIGGER
+  void *objspace_ptr_for_gc_finalize_deferred_workaround(void);
+#endif
+
+#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);

data/ext/datadog_profiling_native_extension/profiling.c

@@ -0,0 +1,284 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <errno.h>
+#ifdef HAVE_MALLOC_STATS
+  #include <malloc.h>
+#endif
+
+#include "clock_id.h"
+#include "helpers.h"
+#include "private_vm_api_access.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);
+void collectors_discrete_dynamic_sampler_init(VALUE profiling_module);
+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 encoded_profile_init(VALUE profiling_module);
+void http_transport_init(VALUE profiling_module);
+void stack_recorder_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 void *trigger_grab_gvl_and_raise(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_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);
+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");
+  VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
+  VALUE native_extension_module = rb_define_module_under(profiling_module, "NativeExtension");
+
+  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?")));
+
+  ruby_helpers_init();
+  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);
+  encoded_profile_init(profiling_module);
+  http_transport_init(profiling_module);
+  stack_recorder_init(profiling_module);
+  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_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_release_gvl_and_call_is_current_thread_holding_the_gvl",
+    _native_release_gvl_and_call_is_current_thread_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);
+  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_clock_id();
+  self_test_current_fiber_for();
+  self_test_mn_enabled();
+
+  return Qtrue;
+}
+
+typedef struct {
+  VALUE exception_class;
+  char *test_message;
+  int 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) {
+  ENFORCE_TYPE(test_message, T_STRING);
+
+  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;
+
+  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);
+  }
+
+  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise; this should never happen");
+}
+
+static void *trigger_grab_gvl_and_raise(void *trigger_args) {
+  trigger_grab_gvl_and_raise_arguments *args = (trigger_grab_gvl_and_raise_arguments *) trigger_args;
+
+  if (args->test_message_arg >= 0) {
+    grab_gvl_and_raise(args->exception_class, "%s%d", args->test_message, args->test_message_arg);
+  } else {
+    grab_gvl_and_raise(args->exception_class, "%s", args->test_message);
+  }
+
+  return NULL;
+}
+
+typedef struct {
+  int syserr_errno;
+  char *test_message;
+  int 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);
+
+  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;
+
+  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);
+  }
+
+  rb_raise(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) {
+  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);
+  } else {
+    grab_gvl_and_raise_syserr(args->syserr_errno, "%s", args->test_message);
+  }
+
+  return NULL;
+}
+
+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_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 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 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 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;
+
+  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;
+
+  pthread_cond_broadcast(&holding_the_gvl_signal_handler_executed);
+  pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex);
+}
+
+static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VALUE _self, VALUE background_thread) {
+  holding_the_gvl_signal_handler_result[0] = Qfalse;
+  holding_the_gvl_signal_handler_result[1] = Qfalse;
+  holding_the_gvl_signal_handler_result[2] = Qfalse;
+
+  rb_nativethread_id_t thread = pthread_id_for(background_thread);
+
+  ENFORCE_SUCCESS_GVL(pthread_mutex_lock(&holding_the_gvl_signal_handler_mutex));
+
+  // We keep trying for ~5 seconds (500 x 10ms) to try to avoid any flakiness if the test machine is a bit slow
+  for (int tries = 0; holding_the_gvl_signal_handler_result[0] == Qfalse && tries < 500; tries++) {
+    pthread_kill(thread, SIGPROF);
+
+    // pthread_cond_timedwait is simply awful -- the deadline is based on wall-clock using a struct timespec, so we need
+    // all of the below complexity just to tell it "timeout is 10ms". The % limit dance below is needed because the
+    // `tv_nsec` part of a timespec can't go over the limit.
+    struct timespec deadline;
+    clock_gettime(CLOCK_REALTIME, &deadline);
+
+    unsigned int timeout_ns = MILLIS_AS_NS(10);
+    unsigned int tv_nsec_limit = SECONDS_AS_NS(1);
+    if ((deadline.tv_nsec + timeout_ns) < tv_nsec_limit) {
+      deadline.tv_nsec += timeout_ns;
+    } else {
+      deadline.tv_nsec = (deadline.tv_nsec + timeout_ns) % tv_nsec_limit;
+      deadline.tv_sec++;
+    }
+
+    int error = pthread_cond_timedwait(&holding_the_gvl_signal_handler_executed, &holding_the_gvl_signal_handler_mutex, &deadline);
+    if (error && error != ETIMEDOUT) ENFORCE_SUCCESS_GVL(error);
+  }
+
+  ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex));
+
+  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
+
+  if (holding_the_gvl_signal_handler_result[0] == Qfalse) rb_raise(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]);
+  rb_hash_aset(result, ID2SYM(rb_intern("is_current_thread_holding_the_gvl")), holding_the_gvl_signal_handler_result[2]);
+  return result;
+}
+
+static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl) {
+  if (RTEST(with_gvl)) {
+    ENFORCE_SUCCESS_GVL(NUM2INT(syserr_errno));
+  } else {
+    rb_thread_call_without_gvl(trigger_enforce_success, (void *) (intptr_t) NUM2INT(syserr_errno), NULL, NULL);
+  }
+
+  return Qtrue;
+}
+
+static void *trigger_enforce_success(void *trigger_args) {
+  intptr_t syserr_errno = (intptr_t) trigger_args;
+  ENFORCE_SUCCESS_NO_GVL((int) syserr_errno);
+  return NULL;
+}
+
+static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self) {
+  #ifdef HAVE_MALLOC_STATS
+    malloc_stats();
+    return Qtrue;
+  #else
+    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

@@ -0,0 +1,235 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+
+#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
+
+typedef struct {
+  VALUE exception_class;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+} raise_args;
+
+static void *trigger_raise(void *raise_arguments) {
+  raise_args *args = (raise_args *) raise_arguments;
+  rb_raise(args->exception_class, "%s", args->exception_message);
+}
+
+void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
+  raise_args args;
+
+  args.exception_class = exception_class;
+
+  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);
+
+  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
+    );
+  }
+
+  rb_thread_call_with_gvl(trigger_raise, &args);
+
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
+}
+
+typedef struct {
+  int syserr_errno;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+} syserr_raise_args;
+
+static void *trigger_syserr_raise(void *syserr_raise_arguments) {
+  syserr_raise_args *args = (syserr_raise_args *) 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, ...) {
+  syserr_raise_args args;
+
+  args.syserr_errno = syserr_errno;
+
+  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);
+
+  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
+    );
+  }
+
+  rb_thread_call_with_gvl(trigger_syserr_raise, &args);
+
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+}
+
+void raise_syserr(
+  int syserr_errno,
+  bool have_gvl,
+  const char *expression,
+  const char *file,
+  int line,
+  const char *function_name
+) {
+  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)));
+  } else {
+    grab_gvl_and_raise_syserr(syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
+  }
+}
+
+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;
+}
+
+// See notes on header for important details
+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;
+  }
+
+  return true;
+}
+
+// Not part of public headers but is externed from Ruby
+size_t rb_obj_memsize_of(VALUE obj);
+
+// Wrapper around rb_obj_memsize_of to avoid hitting crashing paths.
+//
+// The crashing paths are due to calls to rb_bug so should hopefully
+// be situations that can't happen. But given that rb_obj_memsize_of
+// isn't fully public (it's externed but not part of public headers)
+// there is a possibility that it is just assumed that whoever calls
+// it, will do proper checking for those cases. We want to be cautious
+// so we'll assume that's the case and will skip over known crashing
+// paths in this wrapper.
+size_t ruby_obj_memsize_of(VALUE obj) {
+  switch (rb_type(obj)) {
+    case T_OBJECT:
+    case T_MODULE:
+    case T_CLASS:
+    case T_ICLASS:
+    case T_STRING:
+    case T_ARRAY:
+    case T_HASH:
+    case T_REGEXP:
+    case T_DATA:
+    case T_MATCH:
+    case T_FILE:
+    case T_RATIONAL:
+    case T_COMPLEX:
+    case T_IMEMO:
+    case T_FLOAT:
+    case T_SYMBOL:
+    case T_BIGNUM:
+    // case T_NODE: -> Crashes the vm in rb_obj_memsize_of
+    case T_STRUCT:
+    case T_ZOMBIE:
+    #ifndef NO_T_MOVED
+    case T_MOVED:
+    #endif
+      return rb_obj_memsize_of(obj);
+    default:
+      // Unsupported, return 0 instead of erroring like rb_obj_memsize_of likes doing
+      return 0;
+  }
+}
+
+// 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;
+  }
+
+  return false;
+}
+
+// This function is not present in the VM headers, but is a public symbol that can be invoked.
+int rb_objspace_internal_object_p(VALUE obj);
+
+#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);
+
+  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_objspace_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)");
+}

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <stdbool.h>
+#include "datadog_ruby_common.h"
+
+// 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);
+
+// Processes any pending interruptions, including exceptions to be raised.
+// If there's an exception to be raised, it raises it. In that case, this function does not return.
+static inline VALUE process_pending_interruptions(DDTRACE_UNUSED VALUE _) {
+  rb_thread_check_ints();
+  return Qnil;
+}
+
+// Calls process_pending_interruptions BUT "rescues" any exceptions to be raised, returning them instead as
+// a non-zero `pending_exception`.
+//
+// Thus, if there's a non-zero `pending_exception`, the caller MUST call `rb_jump_tag(pending_exception)` after any
+// needed clean-ups.
+//
+// Usage example:
+//
+// ```c
+// foo = ruby_xcalloc(...);
+// pending_exception = check_if_pending_exception();
+// if (pending_exception) {
+//   ruby_xfree(foo);
+//   rb_jump_tag(pending_exception); // Re-raises exception
+// }
+// ```
+__attribute__((warn_unused_result))
+static inline int check_if_pending_exception(void) {
+  int pending_exception;
+  rb_protect(process_pending_interruptions, Qnil, &pending_exception);
+  return pending_exception;
+}
+
+#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+
+NORETURN(
+  void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+NORETURN(
+  void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+
+#define ENFORCE_SUCCESS_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, true)
+#define ENFORCE_SUCCESS_NO_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, false)
+
+#define ENFORCE_SUCCESS_HELPER(expression, have_gvl) \
+  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) raise_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
+
+#define RUBY_NUM_OR_NIL(val, condition, conv) ((val condition) ? conv(val) : Qnil)
+#define RUBY_AVG_OR_NIL(total, count) ((count == 0) ? Qnil : DBL2NUM(((double) total) / count))
+
+// Called by ENFORCE_SUCCESS_HELPER; should not be used directly
+NORETURN(void raise_syserr(
+  int syserr_errno,
+  bool have_gvl,
+  const char *expression,
+  const char *file,
+  int line,
+  const char *function_name
+));
+
+// 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).
+//
+// Note: GVL can be released and other threads may get to run before this method returns
+bool ruby_ref_from_id(VALUE obj_id, VALUE *value);
+
+// Native wrapper to get the approximate/estimated current size of the passed
+// object.
+size_t ruby_obj_memsize_of(VALUE obj);
+
+// Safely inspect any ruby object. If the object responds to 'inspect',
+// return a string with the result of that call. Elsif the object responds to
+// 'to_s', return a string with the result of that call. Otherwise, return Qnil.
+VALUE ruby_safe_inspect(VALUE obj);
+
+// You probably want ruby_safe_inspect instead; this is a lower-level dependency
+// of it, that's being exposed here just to facilitate testing.
+const char* safe_object_info(VALUE obj);