ddtrace 1.12.1 → 1.23.2

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/private_vm_api_access.c

@@ -58,9 +58,12 @@ static inline rb_thread_t *thread_struct_from_object(VALUE thread) {
 }
 
 rb_nativethread_id_t pthread_id_for(VALUE thread) {
-  // struct rb_native_thread was introduced in Ruby 3.2 (preview2): https://github.com/ruby/ruby/pull/5836
+  // struct rb_native_thread was introduced in Ruby 3.2: https://github.com/ruby/ruby/pull/5836
   #ifndef NO_RB_NATIVE_THREAD
-    return thread_struct_from_object(thread)->nt->thread_id;
+    struct rb_native_thread* native_thread = thread_struct_from_object(thread)->nt;
+    // This can be NULL on Ruby 3.3 with MN threads (RUBY_MN_THREADS=1)
+    if (native_thread == NULL) return 0;
+    return native_thread->thread_id;
   #else
     return thread_struct_from_object(thread)->thread_id;
   #endif
@@ -82,6 +85,16 @@ bool is_current_thread_holding_the_gvl(void) {
   return owner.valid && pthread_equal(pthread_self(), owner.owner);
 }
 
+#ifdef HAVE_RUBY_RACTOR_H
+  static inline rb_ractor_t *ddtrace_get_ractor(void) {
+    #ifndef USE_RACTOR_INTERNAL_APIS_DIRECTLY // Ruby >= 3.3
+      return thread_struct_from_object(rb_thread_current())->ractor;
+    #else
+      return GET_RACTOR();
+    #endif
+  }
+#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.
   //
@@ -94,24 +107,25 @@ bool is_current_thread_holding_the_gvl(void) {
   current_gvl_owner gvl_owner(void) {
     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
-        GET_RACTOR()->threads.sched.running;
+        ddtrace_get_ractor()->threads.sched.running;
       #elif HAVE_RUBY_RACTOR_H
-        GET_RACTOR()->threads.gvl.owner;
+        ddtrace_get_ractor()->threads.gvl.owner;
       #else
         GET_VM()->gvl.owner;
       #endif
 
     if (current_owner == NULL) return (current_gvl_owner) {.valid = false};
 
-    return (current_gvl_owner) {
-      .valid = true,
-      .owner =
-        #ifndef NO_RB_NATIVE_THREAD
-          current_owner->nt->thread_id
-        #else
-          current_owner->thread_id
-        #endif
-    };
+    #ifndef NO_RB_NATIVE_THREAD
+      struct rb_native_thread* current_owner_native_thread = current_owner->nt;
+
+      // This can be NULL on Ruby 3.3 with MN threads (RUBY_MN_THREADS=1)
+      if (current_owner_native_thread == NULL) return (current_gvl_owner) {.valid = false};
+
+      return (current_gvl_owner) {.valid = true, .owner = current_owner_native_thread->thread_id};
+    #else
+      return (current_gvl_owner) {.valid = true, .owner = current_owner->thread_id};
+    #endif
   }
 #else
   current_gvl_owner gvl_owner(void) {
@@ -172,7 +186,9 @@ uint64_t native_thread_id_for(VALUE thread) {
   // The tid is only available on Ruby >= 3.1 + Linux (and FreeBSD). It's the same as `gettid()` aka the task id as seen in /proc
   #if !defined(NO_THREAD_TID) && defined(RB_THREAD_T_HAS_NATIVE_ID)
     #ifndef NO_RB_NATIVE_THREAD
-      return thread_struct_from_object(thread)->nt->tid;
+      struct rb_native_thread* native_thread = thread_struct_from_object(thread)->nt;
+      if (native_thread == NULL) rb_raise(rb_eRuntimeError, "BUG: rb_native_thread* is null. Is this Ruby running with RUBY_MN_THREADS=1?");
+      return native_thread->tid;
     #else
       return thread_struct_from_object(thread)->tid;
     #endif
@@ -234,7 +250,7 @@ void ddtrace_thread_list(VALUE result_array) {
   // I suspect the design in `rb_ractor_thread_list` may be done that way to perhaps in the future expose it to be
   // called from a different Ractor, but I'm not sure...
   #ifdef HAVE_RUBY_RACTOR_H
-    rb_ractor_t *current_ractor = GET_RACTOR();
+    rb_ractor_t *current_ractor = ddtrace_get_ractor();
     ccan_list_for_each(&current_ractor->threads.set, thread, lt_node) {
   #else
     rb_vm_t *vm =
@@ -302,7 +318,8 @@ VALUE thread_name_for(VALUE thread) {
 // Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
-// Modifications: None
+// Modifications:
+// * Support int first_lineno for Ruby 3.2.0+ (https://github.com/ruby/ruby/pull/6430)
 //
 // `node_id` gets used depending on Ruby VM compilation settings (USE_ISEQ_NODE_ID being defined).
 // To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
@@ -322,7 +339,11 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
             VM_ASSERT(! ISEQ_BODY(iseq)->local_table_size);
             return 0;
         }
-        if (lineno) *lineno = FIX2INT(ISEQ_BODY(iseq)->location.first_lineno);
+        # ifndef NO_INT_FIRST_LINENO // Ruby 3.2+
+          if (lineno) *lineno = ISEQ_BODY(iseq)->location.first_lineno;
+        # else
+          if (lineno) *lineno = FIX2INT(ISEQ_BODY(iseq)->location.first_lineno);
+        #endif
 #ifdef USE_ISEQ_NODE_ID
         if (node_id) *node_id = -1;
 #endif
@@ -392,6 +413,7 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //   the `VALUE` returned by rb_profile_frames returns `(eval)` instead of the path of the file where the `eval`
 //   was called from.
 // * Imported fix from https://github.com/ruby/ruby/pull/7116 to avoid sampling threads that are still being created
+// * Imported fix from https://github.com/ruby/ruby/pull/8415 to avoid potential crash when using YJIT.
 //
 // What is rb_profile_frames?
 // `rb_profile_frames` is a Ruby VM debug API added for use by profilers for sampling the stack trace of a Ruby thread.
@@ -427,12 +449,15 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     // Modified from upstream: Instead of using `GET_EC` to collect info from the current thread,
     // support sampling any thread (including the current) passed as an argument
     rb_thread_t *th = thread_struct_from_object(thread);
-#ifndef USE_THREAD_INSTEAD_OF_EXECUTION_CONTEXT // Modern Rubies
-    const rb_execution_context_t *ec = th->ec;
-#else // Ruby < 2.5
-    const rb_thread_t *ec = th;
-#endif
+    #ifndef USE_THREAD_INSTEAD_OF_EXECUTION_CONTEXT // Modern Rubies
+      const rb_execution_context_t *ec = th->ec;
+    #else // Ruby < 2.5
+      const rb_thread_t *ec = th;
+    #endif
     const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
+    #ifndef NO_JIT_RETURN
+      const rb_control_frame_t *top = cfp;
+    #endif
     const rb_callable_method_entry_t *cme;
 
     // Avoid sampling dead threads
@@ -446,6 +471,11 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     // it from https://github.com/ruby/ruby/pull/7116 in a "just in case" kind of mindset.
     if (cfp == NULL) return 0;
 
+    // As of this writing, we don't support profiling with MN enabled, and this only happens in that mode, but as we
+    // probably want to experiment with it in the future, I've decided to import https://github.com/ruby/ruby/pull/9310
+    // here.
+    if (ec == NULL) return 0;
+
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -507,7 +537,20 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
                 buff[i] = (VALUE)cfp->iseq;
             }
 
-            lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+            // The topmost frame may not have an updated PC because the JIT
+            // may not have set one.  The JIT compiler will update the PC
+            // before entering a new function (so that `caller` will work),
+            // so only the topmost frame could possibly have an out of date PC
+            #ifndef NO_JIT_RETURN
+              if (cfp == top && cfp->jit_return) {
+                lines[i] = 0;
+              } else {
+                lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+              }
+            #else // Ruby < 3.1
+              lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+            #endif
+
             is_ruby_frame[i] = true;
             i++;
         }
@@ -731,15 +774,10 @@ check_method_entry(VALUE obj, int can_be_svar)
     // versions, so we need to do a bit more work.
     struct rb_ractor_struct *ruby_single_main_ractor = NULL;
 
-    // Taken from upstream ractor.c at commit a1b01e7701f9fc370f8dff777aad6d39a2c5a3e3 (May 2023, Ruby 3.3.0-preview1)
-    // to allow us to ensure that we're always operating on the main ractor (if Ruby has ractors)
-    // Modifications:
-    // * None
-    bool rb_ractor_main_p_(void)
-    {
-        VM_ASSERT(rb_multi_ractor_p());
-        rb_execution_context_t *ec = GET_EC();
-        return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
+    // Alternative implementation of rb_ractor_main_p_ that avoids relying on non-public symbols
+    bool rb_ractor_main_p_(void) {
+      // We need to get the main ractor in a bit of a roundabout way, since Ruby >= 3.3 hid `GET_VM()`
+      return ddtrace_get_ractor() == thread_struct_from_object(rb_thread_current())->vm->ractor.main_ractor;
     }
   #else
     // Directly access Ruby internal fast path for detecting multiple Ractors.
@@ -767,3 +805,88 @@ check_method_entry(VALUE obj, int can_be_svar)
   // they're always on the main Ractor
   bool ddtrace_rb_ractor_main_p(void) { return true; }
 #endif // NO_RACTORS
+
+// This is a tweaked and inlined version of
+// threadptr_invoke_proc_location + rb_proc_location + iseq_location .
+//
+// It's useful to have here because not all of the methods above are accessible to extensions + to avoid the
+// array allocation that iseq_location did to contain its return value.
+static const rb_iseq_t *maybe_thread_invoke_proc_iseq(VALUE thread_value) {
+  rb_thread_t *thread = thread_struct_from_object(thread_value);
+
+  #ifndef NO_THREAD_INVOKE_ARG // Ruby 2.6+
+    if (thread->invoke_type != thread_invoke_type_proc) return NULL;
+
+    VALUE proc = thread->invoke_arg.proc.proc;
+  #else
+    if (thread->first_func || !thread->first_proc) return NULL;
+
+    VALUE proc = thread->first_proc;
+  #endif
+
+  const rb_iseq_t *iseq = rb_proc_get_iseq(proc, 0);
+  if (iseq == NULL) return NULL;
+
+  rb_iseq_check(iseq);
+  return iseq;
+}
+
+VALUE invoke_location_for(VALUE thread, int *line_location) {
+  const rb_iseq_t *iseq = maybe_thread_invoke_proc_iseq(thread);
+
+  if (iseq == NULL) return Qnil;
+
+  *line_location = NUM2INT(rb_iseq_first_lineno(iseq));
+  return rb_iseq_path(iseq);
+}
+
+void self_test_mn_enabled(void) {
+  #ifdef NO_MN_THREADS_AVAILABLE
+    return;
+  #else
+    if (ddtrace_get_ractor()->threads.sched.enable_mn_threads == true) {
+      rb_raise(rb_eRuntimeError, "Ruby VM is running with RUBY_MN_THREADS=1. This is not yet supported");
+    }
+  #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));
+  }
+#else
+  const char *imemo_kind(__attribute__((unused)) VALUE imemo) {
+    return NULL;
+  }
+#endif
+
+// This is used to workaround a VM bug. See "handle_sampling_signal" in "collectors_cpu_and_wall_time_worker" for details.
+#ifdef NO_POSTPONED_TRIGGER
+  void *objspace_ptr_for_gc_finalize_deferred_workaround(void) {
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM // TODO: Inline GET_VM below once we drop support in dd-trace-rb 2.x for < Ruby 2.5
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
+
+    return vm->objspace;
+  }
+#endif

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/private_vm_api_access.h

@@ -43,3 +43,19 @@ 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

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/profiling.c

@@ -1,6 +1,9 @@
 #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"
@@ -11,6 +14,7 @@
 
 // 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);
@@ -32,8 +36,9 @@ static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_U
 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);
 
-void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
+void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   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");
@@ -41,9 +46,9 @@ void DDTRACE_EXPORT Init_ddtrace_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?")));
 
-  rb_define_singleton_method(native_extension_module, "clock_id_for", clock_id_for, 1); // from clock_id.h
-
+  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);
@@ -66,10 +71,12 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   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);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   self_test_clock_id();
+  self_test_mn_enabled();
 
   return Qtrue;
 }
@@ -249,3 +256,12 @@ static void *trigger_enforce_success(void *trigger_args) {
   ENFORCE_SUCCESS_NO_GVL(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
+}

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -0,0 +1,267 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+
+#include "ruby_helpers.h"
+#include "private_vm_api_access.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");
+}
+
+void raise_unexpected_type(
+  VALUE value,
+  const char *value_name,
+  const char *type_name,
+  const char *file,
+  int line,
+  const char* function_name
+) {
+  rb_exc_raise(
+    rb_exc_new_str(
+      rb_eTypeError,
+      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+        rb_inspect(value),
+        value_name,
+        type_name,
+        file,
+        line,
+        function_name
+      )
+    )
+  );
+}
+
+#define MAX_RAISE_MESSAGE_SIZE 256
+
+struct raise_arguments {
+  VALUE exception_class;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+};
+
+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);
+}
+
+void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
+  struct raise_arguments 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);
+}
+
+struct syserr_raise_arguments {
+  int syserr_errno;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+};
+
+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;
+
+  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);
+  }
+}
+
+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;
+  }
+
+  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;
+}
+
+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)");
+  }
+}
+
+VALUE ddtrace_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("DDTrace"));
+  ENFORCE_TYPE(ddtrace_module, T_MODULE);
+  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
+  ENFORCE_TYPE(version_module, T_MODULE);
+  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
+  ENFORCE_TYPE(version_string, T_STRING);
+  return version_string;
+}

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/ruby_helpers.h

@@ -5,6 +5,10 @@
 
 #include "helpers.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 _) {
@@ -78,6 +82,9 @@ NORETURN(
 #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,
@@ -87,3 +94,29 @@ NORETURN(void raise_syserr(
   int line,
   const char *function_name
 ));
+
+// Alternative to ruby_strdup that takes a size argument.
+// Similar to C's strndup but slightly less smart as size is expected to
+// be smaller or equal to the real size of str (minus null termination if it
+// exists).
+// A new string will be returned with size+1 bytes and last byte set to '\0'.
+// The returned string must be freed explicitly.
+//
+// WARN: Cannot be used during GC or outside the GVL.
+char* ruby_strndup(const char *str, size_t size);
+
+// 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(size_t 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);
+
+VALUE ddtrace_version(void);