datadog 2.38.0 → 2.40.0

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -153,6 +153,8 @@ typedef struct {
   VALUE otel_current_span_key;
   // Used to enable native filenames in stack traces
   bool native_filenames_enabled;
+  // Used to include class/module names in method names (e.g. "Foo#bar" instead of "bar")
+  bool show_classes;
   // Used to cache native filename lookup results (Map[void *function_pointer, char *filename])
   st_table *native_filenames_cache;
   // Used to attribute overhead during sampling to this component
@@ -493,7 +495,7 @@ static void thread_context_collector_typed_data_free(void *state_ptr) {
 
   // Important: Remember that we're only guaranteed to see here what's been set in _native_new, aka
   // pointers that have been set NULL there may still be NULL here.
-  if (state->locations.ptr != NULL) ruby_xfree(state->locations.ptr);
+  sample_locations_free(&state->locations);
 
   st_free_table(state->native_filenames_cache);
 
@@ -550,14 +552,13 @@ static VALUE _native_new(VALUE klass) {
   // being leaked.
 
   // Update this when modifying state struct
-  state->locations.ptr = NULL;
-  state->locations.len = 0;
   state->recorder_instance = Qnil;
   state->tracer_context_key = MISSING_TRACER_CONTEXT_KEY;
   VALUE thread_list_buffer = rb_ary_new();
   state->thread_list_buffer = thread_list_buffer;
   state->endpoint_collection_enabled = true;
   state->native_filenames_enabled = false;
+  state->show_classes = false;
   state->native_filenames_cache = st_init_numtable();
   state->otel_context_enabled = OTEL_CONTEXT_ENABLED_FALSE;
   state->otel_context_source = OTEL_CONTEXT_SOURCE_UNKNOWN;
@@ -593,12 +594,14 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE waiting_for_gvl_threshold_ns = rb_hash_fetch(options, ID2SYM(rb_intern("waiting_for_gvl_threshold_ns")));
   VALUE otel_context_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("otel_context_enabled")));
   VALUE native_filenames_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("native_filenames_enabled")));
+  VALUE show_classes = rb_hash_fetch(options, ID2SYM(rb_intern("show_classes")));
   VALUE overhead_filename = rb_hash_fetch(options, ID2SYM(rb_intern("overhead_filename")));
 
   ENFORCE_TYPE(max_frames, T_FIXNUM);
   ENFORCE_BOOLEAN(endpoint_collection_enabled);
   ENFORCE_TYPE(waiting_for_gvl_threshold_ns, T_FIXNUM);
   ENFORCE_BOOLEAN(native_filenames_enabled);
+  ENFORCE_BOOLEAN(show_classes);
   ENFORCE_TYPE(overhead_filename, T_STRING);
 
   uint16_t max_frame_int = sampling_buffer_check_max_frames(NUM2INT(max_frames));
@@ -607,12 +610,12 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   // Update this when modifying state struct
-  state->locations.len = max_frame_int;
-  state->locations.ptr = ruby_xcalloc(max_frame_int, sizeof(ddog_prof_Location));
+  sample_locations_initialize(&state->locations, max_frame_int, show_classes == Qtrue);
   state->recorder_instance = enforce_recorder_instance(recorder_instance);
   recorder_install_on_serialize(recorder_instance, self_instance);
   state->endpoint_collection_enabled = (endpoint_collection_enabled == Qtrue);
   state->native_filenames_enabled = (native_filenames_enabled == Qtrue);
+  state->show_classes = (show_classes == Qtrue);
   state->overhead_filename = overhead_filename;
   if (otel_context_enabled == Qfalse || otel_context_enabled == Qnil) {
     state->otel_context_enabled = OTEL_CONTEXT_ENABLED_FALSE;
@@ -949,7 +952,7 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
 
   // Update cpu-time accounting so it doesn't include the cpu-time spent in GC during the next sample.
   // We don't do the same for wall-time, because GC is just like any other reason a thread didn't make
-  // progress -- time always goes forward regardless of the thread making progress on what it wanted. 
+  // progress -- time always goes forward regardless of the thread making progress on what it wanted.
   if (thread_context->cpu_time_at_previous_sample_ns != INVALID_TIME) {
     thread_context->cpu_time_at_previous_sample_ns += gc_cpu_time_elapsed_ns;
   }
@@ -1157,7 +1160,8 @@ static void trigger_sample_for_thread(
       .is_gvl_waiting_state = is_gvl_waiting_state,
     },
     state->native_filenames_enabled,
-    state->native_filenames_cache
+    state->native_filenames_cache,
+    state->show_classes
   );
 }
 
@@ -1329,6 +1333,7 @@ static VALUE _native_inspect(DDTRACE_UNUSED VALUE _self, VALUE collector_instanc
   rb_str_concat(result, rb_sprintf(" stats=%"PRIsVALUE, stats_to_ruby_hash(state, rb_hash_new())));
   rb_str_concat(result, rb_sprintf(" endpoint_collection_enabled=%"PRIsVALUE, state->endpoint_collection_enabled ? Qtrue : Qfalse));
   rb_str_concat(result, rb_sprintf(" native_filenames_enabled=%"PRIsVALUE, state->native_filenames_enabled ? Qtrue : Qfalse));
+  rb_str_concat(result, rb_sprintf(" show_classes=%"PRIsVALUE, state->show_classes ? Qtrue : Qfalse));
   // Note: `st_table_size()` is available from Ruby 3.2+ but not before
   rb_str_concat(result, rb_sprintf(" native_filenames_cache_size=%zu", state->native_filenames_cache->num_entries));
   rb_str_concat(result, rb_sprintf(" otel_context_enabled=%d", state->otel_context_enabled));

data/ext/datadog_profiling_native_extension/crashtracking_runtime_stacks.c

@@ -159,7 +159,7 @@ static void ruby_runtime_stack_callback(
     frame_info *info = &runtime_stack_buffer[i];
 
     if (info->is_ruby_frame) {
-      const void *iseq = (const void *)info->as.ruby_frame.iseq;
+      const rb_iseq_t *iseq = info->as.ruby_frame.iseq;
       ddog_CharSlice function_slice = DDOG_CHARSLICE_C("<unknown>");
       ddog_CharSlice file_slice = DDOG_CHARSLICE_C("<unknown>");
 
@@ -181,9 +181,10 @@ static void ruby_runtime_stack_callback(
       ddog_CharSlice function_slice = DDOG_CHARSLICE_C("<C method>");
       ddog_CharSlice file_slice = DDOG_CHARSLICE_C("<C extension>");
 
-      if (info->as.native_frame.method_id) {
-        const char *method_name = rb_id2name(info->as.native_frame.method_id);
-        if (is_pointer_readable(method_name, 256)) {
+      const rb_callable_method_entry_t *cme = info->cme;
+      if (cme && is_pointer_readable(cme, sizeof_rb_callable_method_entry_t())) {
+        const char *method_name = ddtrace_cme_original_method_name(cme);
+        if (method_name && is_pointer_readable(method_name, 256)) {
           size_t method_name_len = strnlen(method_name, 256);
           if (method_name_len > 0 && method_name_len < 256) {
             function_slice = char_slice_from_cstr(method_name);

data/ext/datadog_profiling_native_extension/datadog_ruby_common.c

@@ -6,19 +6,27 @@
 static ID telemetry_message_id;
 
 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
-      )
+  // All of the below come from `ENFORCE_TYPE` and are constant for their call-site
+  VALUE simple_message = rb_sprintf("wrong argument for '%s' (expected a %s) at %s:%d:in `%s'",
+    value_name,
+    type_name,
+    file,
+    line,
+    function_name
+  );
+  VALUE exception = 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
     )
   );
+  rb_ivar_set(exception, telemetry_message_id, simple_message);
+  rb_exc_raise(exception);
 }
 
 // Raises an exception with separate telemetry-safe and detailed messages.

data/ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -5,6 +5,13 @@
 #include <ruby.h>
 #include <datadog/common.h>
 
+// All recommended backward compatible macros for keyword argument functions can be found here:
+// https://github.com/ruby/ruby/blob/master/doc/extension.rdoc#defining-backward-compatible-macros-for-keyword-argument-functions
+#ifndef RB_PASS_KEYWORDS
+/* Only define macros on Ruby <2.7 */
+#define rb_funcallv_kw(o, m, c, v, kw) rb_funcallv(o, m, c, v)
+#endif
+
 // Must be called once during initialization
 void datadog_ruby_common_init(void);
 

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -94,7 +94,7 @@ append_cflags "-Wno-error=typedef-redefinition" if ENV["DATADOG_GEM_CI"] == "tru
 # * by msgpack, another datadog gem dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
 # @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
-append_cflags RUBY_PLATFORM.include?('darwin') ? '-std=gnu11' : '-std=gnu99'
+append_cflags RUBY_PLATFORM.include?("darwin") ? "-std=gnu11" : "-std=gnu99"
 
 # Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 append_cflags "-Wno-unused-function"
@@ -139,13 +139,6 @@ end
 
 have_func "malloc_stats"
 
-# Used to get native filenames (dladdr1 is preferred, so we only check for the other if not available)
-# Note it's possible none are available
-if have_header("dlfcn.h")
-  (have_struct_member("struct link_map", "l_name", "link.h") && have_func("dladdr1")) ||
-    have_func("dladdr")
-end
-
 # On older Rubies, there was no primitive mutex and condition variable implemented in `thread_sync.rb` (internal)
 $defs << "-DNO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE" if RUBY_VERSION < "4"
 
@@ -182,9 +175,18 @@ $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"
 
+# On older Rubies, rb_class_attached_object is not available
+$defs << "-DNO_CLASS_ATTACHED_OBJECT" if RUBY_VERSION < "3.2"
+
+# On older Rubies, rb_mod_name allocates (rb_str_dup); use rb_attr_get(__classpath__) instead
+$defs << "-DNO_ALLOC_FREE_MOD_NAME" if RUBY_VERSION < "2.7"
+
 # rb_internal_thread_specific_*()
 $defs << "-DHAVE_RUBY_THREAD_STORAGE_API" if RUBY_VERSION >= "3.3"
 
+# RCLASS_EXT(mod)->permanent_classpath
+$defs << "-DHAVE_PERMANENT_CLASSPATH" 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"
 
@@ -207,6 +209,9 @@ $defs << "-DNO_THREAD_TID" if RUBY_VERSION < "3.1"
 # On older Rubies, there was no jit_return member on the rb_control_frame_t struct
 $defs << "-DNO_JIT_RETURN" if RUBY_VERSION < "3.1"
 
+# internal/class.h is available since 3.0
+$defs << "-DNO_INTERNAL_CLASS_HEADER_INCLUDE" if RUBY_VERSION < "3"
+
 # On older Rubies, there are no Ractors
 $defs << "-DNO_RACTORS" if RUBY_VERSION < "3"
 

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -30,6 +30,13 @@
     #include <iseq.h>
   #pragma GCC diagnostic pop
 
+  #ifndef NO_INTERNAL_CLASS_HEADER_INCLUDE
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wunused-parameter"
+      #include <internal/class.h>
+    #pragma GCC diagnostic pop
+  #endif
+
   #include <ruby.h>
 
   #ifndef NO_RACTOR_HEADER_INCLUDE
@@ -38,6 +45,7 @@
       #include <ractor_core.h>
     #pragma GCC diagnostic pop
   #endif
+
 #endif
 
 // This file can't include datadog_ruby_common.h so we replicate this here
@@ -50,6 +58,8 @@
 #define PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
 #include "private_vm_api_access.h"
 
+static inline const rb_callable_method_entry_t* get_cfunc_method_entry(const rb_control_frame_t *cfp);
+
 // MRI has a similar rb_thread_ptr() function which we can't call it directly
 // because Ruby does not expose the thread_data_type publicly.
 // Instead, we have our own version of that function, and we lazily initialize the thread_data_type pointer
@@ -76,18 +86,6 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
-size_t sizeof_rb_iseq_t(void) {
-  return sizeof(rb_iseq_t);
-}
-
-VALUE ddtrace_iseq_base_label(const void *iseq) {
-  return rb_iseq_base_label((const rb_iseq_t *)iseq);
-}
-
-VALUE ddtrace_iseq_path(const void *iseq) {
-  return rb_iseq_path((const rb_iseq_t *)iseq);
-}
-
 // Queries if the current thread is the owner of the global VM lock.
 //
 // @ivoanjo: Ruby has a similarly-named `ruby_thread_has_gvl_p` but that API is insufficient for our needs because it can
@@ -514,48 +512,43 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
           // rb_profile_frames does not do this check, but `backtrace_each` (`vm_backtrace.c`) does. This frame is not
           // exposed by the Ruby backtrace APIs and for now we want to match its behavior 1:1
         }
+        else if (cfp->ep == NULL) {
+          // Do nothing -- this frame should not be used
+          //
+          // We're not sure this can ever happen, but we've seen a crash inside `VM_FRAME_RUBYFRAME_P` below (which
+          // dereferences `cfp->ep`), so "just in case" we're adding this extra sanity check to avoid crashing on a
+          // NULL `ep`.
+        }
         else if (VM_FRAME_RUBYFRAME_P(cfp)) {
             if (start > 0) {
                 start--;
                 continue;
             }
 
+            cme = rb_vm_frame_method_entry(cfp);
+
+            // Upstream (Ruby 4.0) does:
+            // if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ) {
+            //   buff[i] = (VALUE)cme;
+            // } else {
+            //   buff[i] = (VALUE)cfp->iseq;
+            // }
+            // We get both the iseq and CME because we need both to format like Ruby backtraces
+
             stack_buffer[i].same_frame =
               stack_buffer[i].is_ruby_frame &&
-              stack_buffer[i].as.ruby_frame.iseq == (VALUE) cfp->iseq &&
-              stack_buffer[i].as.ruby_frame.caching_pc == cfp->pc;
+              stack_buffer[i].as.ruby_frame.iseq == cfp->iseq &&
+              stack_buffer[i].as.ruby_frame.caching_pc == cfp->pc &&
+              stack_buffer[i].cme == cme;
 
             if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
               i++;
               continue;
             }
 
-            // dd-trace-rb NOTE:
-            // Upstream Ruby has code here to retrieve the rb_callable_method_entry_t (cme) and in some cases to use it
-            // instead of the iseq.
-            // In practice, they are usually the same; the difference is that when you have e.g. block, one gets you a
-            // reference to the block, and the other to the method containing the block.
-            // This would be important if we used `rb_profile_frame_label` and wanted the "block in foo" label instead
-            // of just "foo". But we're currently using `rb_profile_frame_base_label` which I believe is always the same
-            // between the rb_callable_method_entry_t and the iseq. Thus, to simplify a bit our logic and reduce a bit
-            // the overhead, we always use the iseq here.
-            //
-            // @ivoanjo: I've left the upstream Ruby code commented out below for reference, so it's more obvious that
-            // we're diverging, and we can easily compare and experiment with the upstream version in the future.
-            //
-            // cme = rb_vm_frame_method_entry(cfp);
-
-            // if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ &&
-            //   // Fix: Do not use callable method entry when iseq is for an eval.
-            //   // TL;DR: This fix is needed for us to match the Ruby reference API information in the
-            //   // "when sampling an eval/instance eval inside an object" spec.
-            //   cfp->iseq->body->type != ISEQ_TYPE_EVAL) {
-            //     buff[i] = (VALUE)cme;
-            // }
-            // else {
-            stack_buffer[i].as.ruby_frame.iseq = (VALUE)cfp->iseq;
+            stack_buffer[i].as.ruby_frame.iseq = cfp->iseq;
             stack_buffer[i].as.ruby_frame.caching_pc = (void *) cfp->pc;
-            // }
+            stack_buffer[i].cme = cme;
 
             // The topmost frame may not have an updated PC because the JIT
             // may not have set one.  The JIT compiler will update the PC
@@ -575,7 +568,7 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
             i++;
         }
         else {
-            cme = rb_vm_frame_method_entry(cfp);
+            cme = get_cfunc_method_entry(cfp);
             if (cme && cme->def->type == VM_METHOD_TYPE_CFUNC) {
                 if (start > 0) {
                     start--;
@@ -584,16 +577,14 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
 
                 stack_buffer[i].same_frame =
                   !stack_buffer[i].is_ruby_frame &&
-                  stack_buffer[i].as.native_frame.caching_cme == (VALUE) cme;
+                  stack_buffer[i].cme == cme;
 
                 if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
                   i++;
                   continue;
                 }
 
-                stack_buffer[i].as.native_frame.caching_cme = (VALUE)cme;
-                stack_buffer[i].as.native_frame.method_id = cme->def->original_id;
-                stack_buffer[i].as.native_frame.function = cme->def->body.cfunc.func;
+                stack_buffer[i].cme = cme;
                 stack_buffer[i].is_ruby_frame = false;
                 i++;
             }
@@ -629,24 +620,24 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
 // to support our custom rb_profile_frames (see above)
 // Modifications:
 // * Removed debug checks (they were ifdef'd out anyway)
+// * Optimized to avoid recursion
 static rb_callable_method_entry_t *
-check_method_entry(VALUE obj, int can_be_svar)
-{
-    if (obj == Qfalse) return NULL;
-
-    switch (imemo_type(obj)) {
-      case imemo_ment:
-        return (rb_callable_method_entry_t *)obj;
-      case imemo_cref:
-        return NULL;
-      case imemo_svar:
-        if (can_be_svar) {
-            return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
-        }
-        // fallthrough
-      default:
-        return NULL;
+check_method_entry(VALUE obj, int can_be_svar) {
+  if (obj == Qfalse) {
+    return NULL;
+  }
+
+  enum imemo_type type = imemo_type(obj);
+  if (type == imemo_ment) {
+    return (rb_callable_method_entry_t *)obj;
+  } else if (can_be_svar && type == imemo_svar) {
+    VALUE cref_or_me = ((struct vm_svar *)obj)->cref_or_me;
+    if (imemo_type(cref_or_me) == imemo_ment) {
+      return (rb_callable_method_entry_t *)cref_or_me;
     }
+  }
+
+  return NULL;
 }
 
 // Taken from upstream vm_insnhelper.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
@@ -664,7 +655,9 @@ rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
     rb_callable_method_entry_t *me;
 
     while (!VM_ENV_LOCAL_P(ep)) {
-        if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
+        if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) {
+            return me;
+        }
         ep = VM_ENV_PREV_EP(ep);
     }
 
@@ -672,6 +665,16 @@ rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
 }
 #endif // RUBY_MJIT_HEADER
 
+// Optimized version of rb_vm_frame_method_entry() for cfunc frames.
+// Cfunc frames always have VM_ENV_FLAG_LOCAL set, so ep[-2] is the cme directly
+// with no EP chain walk needed. The only complication is cfuncs that set $~ or $_
+// (e.g. Regexp#match, String#gsub) which replace ep[-2] with an imemo_svar wrapping
+// the cme - in that case svar->cref_or_me is always the cme (never a cref).
+static inline const rb_callable_method_entry_t *
+get_cfunc_method_entry(const rb_control_frame_t *cfp) {
+  return check_method_entry(cfp->ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
+}
+
 #ifndef NO_RACTORS
   // This API and definition are exported as a public symbol by the VM BUT the function header is not defined in any public header, so we
   // repeat it here to be able to use in our code.
@@ -743,7 +746,7 @@ VALUE invoke_location_for(VALUE thread, int *line_location) {
   if (iseq == NULL) return Qnil;
 
   *line_location = NUM2INT(rb_iseq_first_lineno(iseq));
-  return rb_iseq_path(iseq);
+  return ddtrace_iseq_path(iseq);
 }
 
 void self_test_mn_enabled(void) {
@@ -872,7 +875,198 @@ bool is_raised_flag_set(VALUE thread) { return thread_struct_from_object(thread)
   void self_test_current_fiber_for(void) { } // Nothing to do
 #endif
 
-bool pathobj_is_null(VALUE iseq) {
-  const rb_iseq_t *iseq_ptr = (const rb_iseq_t *) iseq;
-  return ISEQ_BODY(iseq_ptr)->location.pathobj == 0;
+// Variant of functions related to Thread::Backtrace::Location#label in Ruby 4.0
+// (location_label(), rb_gen_method_name(), calculate_iseq_label()),
+// but formatting using a C buffer instead of allocating Ruby Strings.
+// Also, those functions are static functions in vm_backtrace.c so not reusable.
+// There is also AFAIK no reasonable way to create a rb_backtrace_location_t from outside that file.
+
+// Return true if a given location is a C method or supposed to behave like one.
+static bool location_cfunc_p(const rb_callable_method_entry_t *cme) {
+  if (!cme) return false;
+
+  switch (cme->def->type) {
+    case VM_METHOD_TYPE_CFUNC:
+      return true;
+    // Upstream, but we don't want that behavior:
+    // case VM_METHOD_TYPE_ISEQ:
+    //   return is_internal_location(loc->cme->def->body.iseq.iseqptr);
+    default:
+      return false;
+  }
+}
+
+// RCLASS_SINGLETON_P() is only defined on Ruby 3.4+, so we have a copy for older versions
+static bool ddtrace_RCLASS_SINGLETON_P(VALUE klass) {
+  return RB_TYPE_P(klass, T_CLASS) && FL_TEST_RAW(klass, FL_SINGLETON);
+}
+
+static VALUE get_class_attached_object(VALUE klass) {
+#ifndef NO_CLASS_ATTACHED_OBJECT
+  return rb_class_attached_object(klass);
+#else
+  return rb_ivar_get(klass, rb_intern("__attached__"));
+#endif
+}
+
+static bool is_metaclass(VALUE mod, VALUE* attached) {
+  if (ddtrace_RCLASS_SINGLETON_P(mod)) {
+    VALUE attached_object = get_class_attached_object(mod);
+    if (RB_TYPE_P(attached_object, T_CLASS) || RB_TYPE_P(attached_object, T_MODULE)) {
+      *attached = attached_object;
+      return true;
+    }
+  }
+  return false;
+}
+
+static VALUE alloc_free_rb_mod_name(VALUE mod) {
+#ifdef NO_ALLOC_FREE_MOD_NAME
+  return rb_attr_get(mod, rb_intern("__classpath__"));
+#else
+  return rb_mod_name(mod);
+#endif
+}
+
+// Ruby 3.3+ has a `permanent_classpath` flag on rb_classext_struct.
+// Checking for '#' in the name is equivalent on older Rubies:
+// non-permanent names contain '#' from `#<Module:0x...>` or `#<Class:0x...>` prefixes.
+static bool has_permanent_classpath(DDTRACE_UNUSED VALUE mod, DDTRACE_UNUSED VALUE mod_name) {
+#if defined(RCLASS_PERMANENT_CLASSPATH_P) // 4.0+
+  return RCLASS_PERMANENT_CLASSPATH_P(mod);
+#elif defined(HAVE_PERMANENT_CLASSPATH) // 3.3 - 3.4
+  return RCLASS_EXT(mod)->permanent_classpath;
+#else // 3.2 and older
+  return memchr(RSTRING_PTR(mod_name), '#', RSTRING_LEN(mod_name)) == NULL;
+#endif
+}
+
+#define ONLY_METHOD_NAME ((ssize_t) -1)
+#define BUFFER_OUT_OF_SPACE ((ssize_t) -2)
+
+static ssize_t rb_gen_method_name(VALUE owner, VALUE method_name, char *buf, size_t buf_size) {
+  if (!(RB_TYPE_P(owner, T_CLASS) || RB_TYPE_P(owner, T_MODULE))) {
+    return ONLY_METHOD_NAME;
+  }
+
+  VALUE mod = owner;
+  char separator = '#';
+  if (is_metaclass(owner, &mod)) {
+    separator = '.';
+  }
+  VALUE mod_name = alloc_free_rb_mod_name(mod);
+
+  // Exclude non-permanent names (e.g. `#<Module:0x0123>::Foo`) which break flamegraph aggregation
+  // since they contain addresses that differ across processes/runs.
+  if (NIL_P(mod_name) || !has_permanent_classpath(mod, mod_name)) {
+    return ONLY_METHOD_NAME;
+  }
+
+  size_t mod_name_len = RSTRING_LEN(mod_name);
+  size_t method_name_len = RSTRING_LEN(method_name);
+  size_t total = mod_name_len + 1 + method_name_len;
+  if (total <= buf_size) {
+    memcpy(buf, RSTRING_PTR(mod_name), mod_name_len);
+    buf[mod_name_len] = separator;
+    memcpy(buf + mod_name_len + 1, RSTRING_PTR(method_name), method_name_len);
+    return total;
+  } else {
+    return BUFFER_OUT_OF_SPACE;
+  }
+}
+
+static ssize_t calculate_iseq_label(VALUE owner, const rb_iseq_t *iseq, char *buf, size_t buf_size) {
+  switch (ISEQ_BODY(iseq)->type) {
+    case ISEQ_TYPE_TOP:
+    case ISEQ_TYPE_CLASS:
+    case ISEQ_TYPE_MAIN:
+      // Just the method name, not `Object#<top (required)>`
+      return ONLY_METHOD_NAME;
+
+    case ISEQ_TYPE_METHOD:
+      return rb_gen_method_name(owner, ISEQ_BODY(iseq)->location.label, buf, buf_size);
+
+#ifdef ISEQ_TYPE_PLAIN /* 2.5 does not have it */
+    case ISEQ_TYPE_PLAIN:
+#endif
+    case ISEQ_TYPE_BLOCK: {
+      // CRuby uses "block in Foo#bar" and ""block (N levels) in Foo#bar" in backtraces.
+      // We use "Foo#bar (block)" because it's much faster and looks better in the UI.
+      const rb_iseq_t* method_iseq = ISEQ_BODY(iseq)->local_iseq;
+
+      static const char suffix[] = " (block)";
+      size_t suffix_len = sizeof(suffix) - 1;
+
+      // Only use the result if there is enough space for both parts
+      ssize_t written = calculate_iseq_label(owner, method_iseq, buf, buf_size);
+      if (written > 0 && (written + suffix_len) <= buf_size) {
+        memcpy(buf + written, suffix, suffix_len);
+        return written + suffix_len;
+      } else if (written == ONLY_METHOD_NAME) {
+        VALUE method_name = rb_iseq_base_label(method_iseq);
+        size_t method_name_len = RSTRING_LEN(method_name);
+        if ((method_name_len + suffix_len) <= buf_size) {
+          memcpy(buf, RSTRING_PTR(method_name), method_name_len);
+          memcpy(buf + method_name_len, suffix, suffix_len);
+          return method_name_len + suffix_len;
+        }
+      }
+
+      return BUFFER_OUT_OF_SPACE;
+    }
+
+    case ISEQ_TYPE_RESCUE:
+    case ISEQ_TYPE_ENSURE:
+    case ISEQ_TYPE_EVAL:
+      iseq = ISEQ_BODY(iseq)->parent_iseq;
+      return calculate_iseq_label(owner, iseq, buf, buf_size);
+
+    default:
+      // Upstream: rb_bug("calculate_iseq_label: unreachable");
+      return ONLY_METHOD_NAME;
+  }
+}
+
+// MRI: location_label()
+// C methods don't have an iseq, only Ruby methods have
+ssize_t ddtrace_location_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq, char *buf, size_t buf_size) {
+  if (location_cfunc_p(cme)) {
+    VALUE method_name = rb_id2str(cme->def->original_id);
+    return rb_gen_method_name(cme->owner, method_name, buf, buf_size);
+  } else {
+    VALUE owner = cme ? cme->owner : Qnil;
+    return calculate_iseq_label(owner, iseq, buf, buf_size);
+  }
+}
+
+VALUE ddtrace_location_base_label(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq) {
+  if (location_cfunc_p(cme)) {
+    return rb_id2str(cme->def->original_id);
+  } else {
+    return rb_iseq_base_label(iseq);
+  }
+}
+
+VALUE ddtrace_iseq_base_label(const rb_iseq_t *iseq) {
+  return rb_iseq_base_label(iseq);
+}
+
+VALUE ddtrace_iseq_path(const rb_iseq_t *iseq) {
+  return rb_iseq_path(iseq);
+}
+
+size_t sizeof_rb_iseq_t(void) {
+  return sizeof(rb_iseq_t);
+}
+
+size_t sizeof_rb_callable_method_entry_t(void) {
+  return sizeof(rb_callable_method_entry_t);
+}
+
+void* ddtrace_cme_cfunc_func(const rb_callable_method_entry_t *cme) {
+  return cme->def->body.cfunc.func;
+}
+
+const char *ddtrace_cme_original_method_name(const rb_callable_method_entry_t *cme) {
+  return rb_id2name(cme->def->original_id);
 }