datadog 2.39.0 → 2.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 738a49f1b7d7068adaa2e6237046870eb9868fe5fcbebdc8f136d2c99f880b00
-  data.tar.gz: 19c8e8c4c05ad009beceb84afc161c7012c75f6dc26987ae6a599d33d7212a98
+  metadata.gz: 4894d3cc2404bab418412c2a96b2f15c2337f6e31dc567c6fd8d1ceafd372230
+  data.tar.gz: e31bdb882385e48f731b925496b75964a02e17c4eb9c7b4a858083740009954c
 SHA512:
-  metadata.gz: c48d6c1506eeb45ed203a7aaab7877370b35a0d0902935dcb9f5eaeb69ac40bc03e1bd55e78c414b89a71d6ea50c4e30191d1dff29160ba79f27c91b116cecc4
-  data.tar.gz: 93037c1ea2179bac9db492a8410520fc96ff3184ca005df577960d452f783fb7a6ed2397ccfbb76dff3dc0d8d37bdd954ec8c1e2e44fbdaa197e4c54eb975971
+  metadata.gz: 488fc94df9bda0fd8485f42934a08660a342617602e61a0fb999cb337239f98f226fc51e021df954ab74af985a6abfa38cc0b17069c00b0541c5100e8c961810
+  data.tar.gz: '0197b5995f7861ddae8677caa96d419c89e2b25bb702d3c05e99e594562771c2c3193d8e9cc367bde5ebbd3fbd78362f55ea25fb1c071442b01d37a22c8d631e'

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [2.40.0] - 2026-08-04
+
+### Added
+
+* Profiling: Add experimental profiling setting to show class/module names in stack frames. Fix crash in `rb_iseq_path()` caused by incorrect GC marking. ([#6024][])
+* Tracing: Add an experimental native (`libdatadog`-backed) trace transport, selectable via `tracing.native_transport` ([#5971][])
+
+### Changed
+
+* Core: Deprecate `time_now_provider` setting for removal; it no longer does anything. Please remove it from your `Datadog.configure block`. The datadog gem always uses the real non-mocked time, even when the timecop gem monkey-patches `Time` ([#6010][])
+
+### Fixed
+
+* AppSec: Fix standalone billing issues for partially flushed traces ([#6116][])
+* Dynamic Instrumentation: Limit dynamic instrumentation regular expression evaluation time to 500ms ([#5908][])
+* Profiling: Fix missing native filename for static Ruby binaries ([#6097][])
+* Tracing: Fix missing or zero Kafka producer and connection span tags like `kafka.message_count` and `kafka.request_size` in the `ruby-kafka` integration. ([#6104][])
+
 ## [2.39.0] - 2026-07-22
 
 ### Added
@@ -3716,7 +3734,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.39.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.40.0...master
+[2.40.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.39.0...v2.40.0
 [2.39.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.38.0...v2.39.0
 [2.38.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.37.0...v2.38.0
 [2.37.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.36.0...v2.37.0
@@ -5496,6 +5515,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5890]: https://github.com/DataDog/dd-trace-rb/issues/5890
 [#5894]: https://github.com/DataDog/dd-trace-rb/issues/5894
 [#5907]: https://github.com/DataDog/dd-trace-rb/issues/5907
+[#5908]: https://github.com/DataDog/dd-trace-rb/issues/5908
 [#5911]: https://github.com/DataDog/dd-trace-rb/issues/5911
 [#5916]: https://github.com/DataDog/dd-trace-rb/issues/5916
 [#5920]: https://github.com/DataDog/dd-trace-rb/issues/5920
@@ -5506,6 +5526,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5955]: https://github.com/DataDog/dd-trace-rb/issues/5955
 [#5960]: https://github.com/DataDog/dd-trace-rb/issues/5960
 [#5970]: https://github.com/DataDog/dd-trace-rb/issues/5970
+[#5971]: https://github.com/DataDog/dd-trace-rb/issues/5971
 [#5973]: https://github.com/DataDog/dd-trace-rb/issues/5973
 [#5975]: https://github.com/DataDog/dd-trace-rb/issues/5975
 [#5981]: https://github.com/DataDog/dd-trace-rb/issues/5981
@@ -5513,16 +5534,21 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5990]: https://github.com/DataDog/dd-trace-rb/issues/5990
 [#5991]: https://github.com/DataDog/dd-trace-rb/issues/5991
 [#5993]: https://github.com/DataDog/dd-trace-rb/issues/5993
+[#6010]: https://github.com/DataDog/dd-trace-rb/issues/6010
 [#6014]: https://github.com/DataDog/dd-trace-rb/issues/6014
 [#6020]: https://github.com/DataDog/dd-trace-rb/issues/6020
 [#6022]: https://github.com/DataDog/dd-trace-rb/issues/6022
 [#6023]: https://github.com/DataDog/dd-trace-rb/issues/6023
+[#6024]: https://github.com/DataDog/dd-trace-rb/issues/6024
 [#6047]: https://github.com/DataDog/dd-trace-rb/issues/6047
 [#6050]: https://github.com/DataDog/dd-trace-rb/issues/6050
 [#6056]: https://github.com/DataDog/dd-trace-rb/issues/6056
 [#6060]: https://github.com/DataDog/dd-trace-rb/issues/6060
 [#6064]: https://github.com/DataDog/dd-trace-rb/issues/6064
 [#6072]: https://github.com/DataDog/dd-trace-rb/issues/6072
+[#6097]: https://github.com/DataDog/dd-trace-rb/issues/6097
+[#6104]: https://github.com/DataDog/dd-trace-rb/issues/6104
+[#6116]: https://github.com/DataDog/dd-trace-rb/issues/6116
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -3,17 +3,10 @@
 #include <ruby/st.h>
 #include <stdatomic.h>
 
-#include "extconf.h" // This is needed for the HAVE_DLADDR and friends below
-
-#if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
-  #ifndef _GNU_SOURCE
-    #define _GNU_SOURCE
-  #endif
-  #include <dlfcn.h>
-  #if defined(HAVE_DLADDR1) && HAVE_DLADDR1
-    #include <link.h>
-  #endif
+#ifndef _GNU_SOURCE
+  #define _GNU_SOURCE // Needed for dlfcn.h/dladdr
 #endif
+#include <dlfcn.h>
 
 #include "datadog_ruby_common.h"
 #include "private_vm_api_access.h"
@@ -21,11 +14,16 @@
 #include "stack_recorder.h"
 #include "collectors_stack.h"
 
+// An estimation of how much bytes we need on average for qualified method names.
+// This is an "average" and not a "max" because frames can use more than that,
+// we just fall back to unqualified method names if the buffer is full.
+#define QUALIFIED_NAME_AVG_SIZE 64
+
 // Gathers stack traces from running threads, storing them in a StackRecorder instance
 // This file implements the native bits of the Datadog::Profiling::Collectors::Stack class
 
-static VALUE _native_filenames_available(DDTRACE_UNUSED VALUE self);
 static VALUE _native_ruby_native_filename(DDTRACE_UNUSED VALUE self);
+static VALUE _native_set_file_info_for_cfunc(DDTRACE_UNUSED VALUE self, VALUE new_static_ruby_actual_filename);
 static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE native_sample_do(VALUE args);
 static VALUE native_sample_ensure(VALUE args);
@@ -40,56 +38,51 @@ static void set_file_info_for_cfunc(
   st_table *native_filenames_cache
 );
 static const char *get_or_compute_native_filename(void *function, st_table *native_filenames_cache);
+static void initialize_static_ruby_actual_filename(VALUE profiling_module);
 static void add_truncated_frames_placeholder(ddog_prof_Location *locations);
 static void record_placeholder_stack_in_native_code(VALUE recorder_instance, sample_values values, sample_labels labels);
 static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_CharSlice *filename_slice);
 
-// These two functions are exposed as symbols by the VM but are not in any header.
-// Their signatures actually take a `const rb_iseq_t *iseq` but it gets casted back and forth between VALUE.
-extern VALUE rb_iseq_path(const VALUE);
-extern VALUE rb_iseq_base_label(const VALUE);
-
-// NULL if dladdr is not available or we weren't able to get the native filename for the Ruby VM
+// NULL if we weren't able to get the native filename for the Ruby VM.
+// On a static Ruby without libruby.so, `get_or_compute_native_filename` returns `ruby_native_filename` but
+// `static_ruby_actual_filename` (below) is what we want to show instead.
 static const char *ruby_native_filename = NULL;
+// Qnil unless we're running on a static Ruby
+static VALUE static_ruby_actual_filename = Qnil;
 
 void collectors_stack_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
   VALUE collectors_stack_class = rb_define_class_under(collectors_module, "Stack", rb_cObject);
 
-  rb_define_singleton_method(collectors_stack_class, "_native_filenames_available?", _native_filenames_available, 0);
   rb_define_singleton_method(collectors_stack_class, "_native_ruby_native_filename", _native_ruby_native_filename, 0);
 
   // Hosts methods used for testing the native code using RSpec
   VALUE testing_module = rb_define_module_under(collectors_stack_class, "Testing");
 
   rb_define_singleton_method(testing_module, "_native_sample", _native_sample, -1);
+  rb_define_singleton_method(testing_module, "_native_set_file_info_for_cfunc", _native_set_file_info_for_cfunc, 1);
 
-  #if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
-    // To be able to detect when a frame is coming from Ruby, we record here its filename as returned by dladdr.
-    // We expect this same pointer to be returned by dladdr for all frames coming from Ruby.
-    //
-    // Small note: Creating/deleting the cache is a bit awkward here, but it seems like a bigger footgun to allow
-    // `get_or_compute_native_filename` to run without a cache, since we never expect that to happen during sampling. So it seems
-    // like a reasonable trade-off to force callers to always figure that out.
-    st_table *temporary_cache = st_init_numtable();
-    const char *native_filename = get_or_compute_native_filename(rb_ary_new, temporary_cache);
-    if (native_filename != NULL && native_filename[0] != '\0') {
-      ruby_native_filename = native_filename;
-    }
-    st_free_table(temporary_cache);
-  #endif
-}
-
-static VALUE _native_filenames_available(DDTRACE_UNUSED VALUE self) {
-  #if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
-    return ruby_native_filename != NULL ? Qtrue : Qfalse;
-  #else
-    return Qfalse;
-  #endif
+  // To be able to detect when a frame is coming from Ruby, we record here its filename as returned by dladdr.
+  // We expect this same pointer to be returned by dladdr for all frames coming from Ruby.
+  //
+  // Small note: Creating/deleting the cache is a bit awkward here, but it seems like a bigger footgun to allow
+  // `get_or_compute_native_filename` to run without a cache, since we never expect that to happen during sampling. So it seems
+  // like a reasonable trade-off to force callers to always figure that out.
+  st_table *temporary_cache = st_init_numtable();
+  const char *native_filename = get_or_compute_native_filename(rb_ary_new, temporary_cache);
+  if (native_filename[0] != '\0') {
+    ruby_native_filename = native_filename;
+    initialize_static_ruby_actual_filename(profiling_module);
+  }
+  st_free_table(temporary_cache);
 }
 
 static VALUE _native_ruby_native_filename(DDTRACE_UNUSED VALUE self) {
-  return ruby_native_filename != NULL ? rb_utf8_str_new_cstr(ruby_native_filename) : Qnil;
+  if (static_ruby_actual_filename != Qnil) {
+    return static_ruby_actual_filename;
+  } else {
+    return ruby_native_filename != NULL ? rb_utf8_str_new_cstr(ruby_native_filename) : Qnil;
+  }
 }
 
 typedef struct {
@@ -102,6 +95,7 @@ typedef struct {
   sampling_buffer *buffer;
   bool native_filenames_enabled;
   st_table *native_filenames_cache;
+  bool show_classes;
 } native_sample_args;
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::Stack behavior using RSpec.
@@ -124,6 +118,7 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
   VALUE in_gc = rb_hash_lookup2(options, ID2SYM(rb_intern("in_gc")), Qfalse);
   VALUE is_gvl_waiting_state = rb_hash_lookup2(options, ID2SYM(rb_intern("is_gvl_waiting_state")), Qfalse);
   VALUE native_filenames_enabled = rb_hash_lookup2(options, ID2SYM(rb_intern("native_filenames_enabled")), Qfalse);
+  VALUE show_classes = rb_hash_lookup2(options, ID2SYM(rb_intern("show_classes")), Qtrue);
 
   ENFORCE_TYPE(metric_values_hash, T_HASH);
   ENFORCE_TYPE(labels_array, T_ARRAY);
@@ -132,6 +127,7 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
   ENFORCE_BOOLEAN(in_gc);
   ENFORCE_BOOLEAN(is_gvl_waiting_state);
   ENFORCE_BOOLEAN(native_filenames_enabled);
+  ENFORCE_BOOLEAN(show_classes);
 
   VALUE zero = INT2NUM(0);
   VALUE heap_sample = rb_hash_lookup2(metric_values_hash, rb_str_new_cstr("heap_sample"), Qfalse);
@@ -173,7 +169,8 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
 
   int max_frames_requested = sampling_buffer_check_max_frames(NUM2INT(max_frames));
 
-  ddog_prof_Location *locations = ruby_xcalloc(max_frames_requested, sizeof(ddog_prof_Location));
+  sample_locations locations;
+  sample_locations_initialize(&locations, max_frames_requested, show_classes == Qtrue);
   sampling_buffer buffer;
   sampling_buffer_initialize(&buffer, max_frames_requested);
 
@@ -185,10 +182,11 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
     .values = values,
     .labels = (sample_labels) {.labels = slice_labels, .state_label = state_label, .is_gvl_waiting_state = is_gvl_waiting_state == Qtrue},
     .thread = thread,
-    .locations = (sample_locations) {.ptr = locations, .len = max_frames_requested},
+    .locations = locations,
     .buffer = &buffer,
     .native_filenames_enabled = native_filenames_enabled == Qtrue,
     .native_filenames_cache = st_init_numtable(),
+    .show_classes = show_classes == Qtrue,
   };
 
   return rb_ensure(native_sample_do, (VALUE) &args_struct, native_sample_ensure, (VALUE) &args_struct);
@@ -213,7 +211,8 @@ static VALUE native_sample_do(VALUE args) {
       args_struct->values,
       args_struct->labels,
       args_struct->native_filenames_enabled,
-      args_struct->native_filenames_cache
+      args_struct->native_filenames_cache,
+      args_struct->show_classes
     );
   }
 
@@ -223,7 +222,7 @@ static VALUE native_sample_do(VALUE args) {
 static VALUE native_sample_ensure(VALUE args) {
   native_sample_args *args_struct = (native_sample_args *) args;
 
-  ruby_xfree(args_struct->locations.ptr);
+  sample_locations_free(&args_struct->locations);
   sampling_buffer_free(args_struct->buffer);
   st_free_table(args_struct->native_filenames_cache);
 
@@ -249,7 +248,8 @@ void sample_thread(
   sample_values values,
   sample_labels labels,
   bool native_filenames_enabled,
-  st_table *native_filenames_cache
+  st_table *native_filenames_cache,
+  bool show_classes
 ) {
   if (buffer->max_frames != locations.len) {
     // This shouldn't happen as thread_context_collector_reset_all_per_thread_contexts (which resizes every
@@ -268,11 +268,13 @@ void sample_thread(
     prepare_sample_thread(thread, buffer);
   }
 
-  buffer->pending_sample = false;
   int captured_frames = buffer->pending_sample_result;
 
   if (captured_frames == PLACEHOLDER_STACK_IN_NATIVE_CODE) {
     record_placeholder_stack_in_native_code(recorder_instance, values, labels);
+
+    // Done reading from the buffer -- allow GC to stop marking it.
+    buffer->pending_sample = false;
     return;
   }
 
@@ -309,45 +311,58 @@ void sample_thread(
   }
 
   int top_of_stack_position = captured_frames - 1;
+  char *qualified_name_buf = locations.qualified_name_buf;
+  size_t qualified_name_buf_size = locations.qualified_name_buf_size;
 
   for (int i = 0; i <= top_of_stack_position; i++) {
-    ddog_CharSlice name_slice, filename_slice;
+    ddog_CharSlice filename_slice;
     int line;
     bool top_of_the_stack = i == top_of_stack_position;
 
-    if (buffer->stack_buffer[i].is_ruby_frame) {
-      VALUE iseq = buffer->stack_buffer[i].as.ruby_frame.iseq;
-      VALUE name = rb_iseq_base_label(iseq);
-      VALUE filename =
-        // Note: We saw crash reports from a customer from dereferencing a null pointer inside `rb_iseq_path`.
-        // It's not clear in what situation would the pathobj ever be NULL, yet it seems harmless from our side to
-        // skip this information if we're ever in such a situation.
-        pathobj_is_null(iseq) ? Qnil : rb_iseq_path(iseq);
-
-      name_slice = NIL_P(name) ? DDOG_CHARSLICE_C("") : char_slice_from_ruby_string(name);
+    frame_info frame = buffer->stack_buffer[i];
+    const rb_callable_method_entry_t *cme = frame.cme;
+    const rb_iseq_t* iseq;
+    if (frame.is_ruby_frame) {
+      iseq = frame.as.ruby_frame.iseq;
+
+      VALUE filename = ddtrace_iseq_path(iseq);
       filename_slice = NIL_P(filename) ? DDOG_CHARSLICE_C("") : char_slice_from_ruby_string(filename);
-      line = buffer->stack_buffer[i].as.ruby_frame.line;
+      line = frame.as.ruby_frame.line;
 
       last_ruby_frame_filename = filename_slice;
       last_ruby_line = line;
     } else {
-      VALUE name = rb_id2str(buffer->stack_buffer[i].as.native_frame.method_id);
-
-      name_slice = NIL_P(name) ? DDOG_CHARSLICE_C("") : char_slice_from_ruby_string(name);
+      iseq = NULL;
 
       set_file_info_for_cfunc(
         &filename_slice,
         &line,
         last_ruby_frame_filename,
         last_ruby_line,
-        buffer->stack_buffer[i].as.native_frame.function,
+        ddtrace_cme_cfunc_func(cme),
         top_of_the_stack,
         native_filenames_enabled,
         native_filenames_cache
       );
     }
 
-    maybe_trim_template_random_ids(&name_slice, &filename_slice);
+    VALUE name = ddtrace_location_base_label(cme, iseq);
+    // TODO: name_slice is currently the unqualified method name
+    // because we don't always use qualified method names yet, so we don't always compute it,
+    // and checks below need to compare to something stable until we always qualified method names.
+    ddog_CharSlice name_slice = char_slice_from_ruby_string(name);
+
+    ddog_CharSlice qualified_name = DDOG_CHARSLICE_C("");
+    if (show_classes) {
+      ssize_t written = ddtrace_location_label(cme, iseq, qualified_name_buf, qualified_name_buf_size);
+      if (written > 0) {
+        qualified_name = (ddog_CharSlice) {.ptr = qualified_name_buf, .len = written};
+        qualified_name_buf += written;
+        qualified_name_buf_size -= written;
+      } else {
+        qualified_name = name_slice; // just the method name
+      }
+    }
 
     // When there's only wall-time in a sample, this means that the thread was not active in the sampled period.
     if (top_of_the_stack && only_wall_time) {
@@ -358,7 +373,7 @@ void sample_thread(
       // Otherwise, we try to categorize what the thread was doing based on what we observe at the top of the stack. This is a very rough
       // approximation, and in the future we hope to replace this with a more accurate approach (such as using the
       // GVL instrumentation API.)
-      } else if (!buffer->stack_buffer[i].is_ruby_frame) {
+      } else if (!frame.is_ruby_frame) {
         // We know that known versions of Ruby implement these using native code; thus if we find a method with the
         // same name that is not native code, we ignore it, as it's probably a user method that coincidentally
         // has the same name. Thus, even though "matching just by method name" is kinda weak,
@@ -408,11 +423,20 @@ void sample_thread(
       }
     }
 
+    ddog_CharSlice frame_name;
+    if (show_classes) {
+      frame_name = qualified_name;
+    } else {
+      frame_name = name_slice;
+    }
+
+    maybe_trim_template_random_ids(&frame_name, &filename_slice);
+
     int libdatadog_stores_stacks_flipped_from_rb_profile_frames_index = top_of_stack_position - i;
 
     locations.ptr[libdatadog_stores_stacks_flipped_from_rb_profile_frames_index] = (ddog_prof_Location) {
       .mapping = {.filename = DDOG_CHARSLICE_C(""), .build_id = DDOG_CHARSLICE_C(""), .build_id_id = {}},
-      .function = (ddog_prof_Function) {.name = name_slice, .filename = filename_slice},
+      .function = (ddog_prof_Function) {.name = frame_name, .filename = filename_slice},
       .line = line,
     };
   }
@@ -429,95 +453,81 @@ void sample_thread(
     values,
     labels
   );
+
+  // Done reading from the buffer -- allow GC to stop marking it.
+  // This needs to be done last in this function in case anything above triggers a GC
+  // (remember that `ruby_xmalloc` for instance can do that too...)
+  buffer->pending_sample = false;
 }
 
-#if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
-  static void set_file_info_for_cfunc(
-    ddog_CharSlice *filename_slice,
-    int *line,
-    ddog_CharSlice last_ruby_frame_filename,
-    int last_ruby_line,
-    void *function,
-    bool top_of_the_stack,
-    bool native_filenames_enabled,
-    st_table *native_filenames_cache
-  ) {
-    if (native_filenames_enabled) {
-      const char *native_filename = get_or_compute_native_filename(function, native_filenames_cache);
-      if (native_filename && native_filename[0] != '\0' &&
-        // Using the ruby_native_filename at the top of the stack has a weird effect on the "top methods" table because
-        // e.g. we don't have classnames for methods. This is especially visible in the allocations profile, e.g.
-        // what a surprise, you're telling me "libruby.so:new" is the top method always?
-        //
-        // Until we have a better way of dealing with that, we don't do this replacement for the top frame.
-        //
-        // Also, dladdr is expected to always return the same pointer to the ruby_native_filename, so that's why we're
-        // comparing only pointer values and not the string contents.
-        (native_filename != ruby_native_filename || !top_of_the_stack)
-      ) {
+static void set_file_info_for_cfunc(
+  ddog_CharSlice *filename_slice,
+  int *line,
+  ddog_CharSlice last_ruby_frame_filename,
+  int last_ruby_line,
+  void *function,
+  bool top_of_the_stack,
+  bool native_filenames_enabled,
+  st_table *native_filenames_cache
+) {
+  if (native_filenames_enabled) {
+    const char *native_filename = get_or_compute_native_filename(function, native_filenames_cache);
+    if (native_filename[0] != '\0' &&
+      // TODO: Using the ruby_native_filename at the top of the stack has a weird effect on the "top methods" table because
+      // e.g. we don't have classnames for methods. This is especially visible in the allocations profile, e.g.
+      // what a surprise, you're telling me "libruby.so:new" is the top method always?
+      // Until we have a better way of dealing with that, we don't do this replacement for the top frame.
+      // (Bonus TODO note: This might be fixed by using full class/module names in frames?)
+      //
+      // dladdr is expected to always return the same pointer to the ruby_native_filename, so that's why we're
+      // comparing only pointer values and not the string contents.
+      (native_filename != ruby_native_filename || !top_of_the_stack)
+    ) {
+      // On a static Ruby without libruby.so, we show `static_ruby_actual_filename` instead of `ruby_native_filename`
+      if (native_filename == ruby_native_filename && static_ruby_actual_filename != Qnil) {
+        *filename_slice = char_slice_from_ruby_string(static_ruby_actual_filename);
+      } else {
         *filename_slice = (ddog_CharSlice) {.ptr = native_filename, .len = strlen(native_filename)};
-        // Explicitly set the line to 0 as it has no meaning on a native library (e.g. an .so is built of many source files)
-        // and anyway often that debug info is not available.
-        *line = 0;
-        return;
       }
+      // Explicitly set the line to 0 as it has no meaning on a native library (e.g. an .so is built of many source files)
+      // and anyway often that debug info is not available.
+      *line = 0;
+      return;
     }
-
-    *filename_slice = last_ruby_frame_filename;
-    *line = last_ruby_line;
   }
 
-  // `native_filenames_cache` is used to cache native filename lookup results (Map[void *function_pointer, char *filename])
-  //
-  // Caching this information is safe because there's no API in Ruby to "unrequire" a native extension. Thus, if we see a
-  // frame on the **Ruby** stack with a given `function`, then that `function` was registered with the Ruby VM and
-  // belongs to a Ruby extension, so a lot of other bad things would happen if it was dlclosed.
-  static const char *get_or_compute_native_filename(void *function, st_table *native_filenames_cache) {
-    const char *cached_filename = NULL;
-    st_lookup(native_filenames_cache, (st_data_t) function, (st_data_t *) &cached_filename);
-    if (cached_filename != NULL) return cached_filename;
-
-    Dl_info info;
-    const char *native_filename = NULL;
-    #if defined(HAVE_DLADDR1) && HAVE_DLADDR1
-      struct link_map *extra_info = NULL;
-      if (dladdr1(function, &info, (void **) &extra_info, RTLD_DL_LINKMAP) != 0 && extra_info != NULL) {
-        native_filename = extra_info->l_name != NULL ? extra_info->l_name : info.dli_fname;
-      }
-    #elif defined(HAVE_DLADDR) && HAVE_DLADDR
-      if (dladdr(function, &info) != 0) {
-        native_filename = info.dli_fname;
-      }
-    #endif
-
-    // We explicitly use an empty string here so as to cache lookups that somehow "failed". Otherwise we would keep trying them every time.
-    if (native_filename == NULL) native_filename = "";
-
-    // An st_table is what Ruby uses for its own hashtables. This allows us to get an easy estimate of the size of the cache:
-    // `ObjectSpace.memsize_of((0..100000).map { |it| [it, nil] }.to_h)` => 4194400 bytes as of Ruby 3.2 so that seems reasonable?
-    // Note: `st_table_size()` is available from Ruby 3.2+ but not before
-    if (native_filenames_cache->num_entries >= 100000) {
-      st_clear(native_filenames_cache);
-    }
+  *filename_slice = last_ruby_frame_filename;
+  *line = last_ruby_line;
+}
 
-    st_insert(native_filenames_cache, (st_data_t) function, (st_data_t) native_filename);
-    return native_filename;
-  }
-#else
-  static void set_file_info_for_cfunc(
-    ddog_CharSlice *filename_slice,
-    int *line,
-    ddog_CharSlice last_ruby_frame_filename,
-    int last_ruby_line,
-    DDTRACE_UNUSED void *function,
-    DDTRACE_UNUSED bool top_of_the_stack,
-    DDTRACE_UNUSED bool native_filenames_enabled,
-    DDTRACE_UNUSED st_table *native_filenames_cache
-  ) {
-    *filename_slice = last_ruby_frame_filename;
-    *line = last_ruby_line;
+// `native_filenames_cache` is used to cache native filename lookup results (Map[void *function_pointer, char *filename])
+//
+// Caching this information is safe because there's no API in Ruby to "unrequire" a native extension. Thus, if we see a
+// frame on the **Ruby** stack with a given `function`, then that `function` was registered with the Ruby VM and
+// belongs to a Ruby extension, so a lot of other bad things would happen if it was dlclosed.
+//
+// Returns "" if not found. Never returns NULL.
+static const char *get_or_compute_native_filename(void *function, st_table *native_filenames_cache) {
+  const char *cached_filename = NULL;
+  st_lookup(native_filenames_cache, (st_data_t) function, (st_data_t *) &cached_filename);
+  if (cached_filename != NULL) return cached_filename;
+
+  Dl_info info;
+  const char *native_filename = dladdr(function, &info) != 0 ? info.dli_fname : NULL;
+
+  // We explicitly use an empty string here so as to cache lookups that somehow "failed". Otherwise we would keep trying them every time.
+  if (native_filename == NULL) native_filename = "";
+
+  // An st_table is what Ruby uses for its own hashtables. This allows us to get an easy estimate of the size of the cache:
+  // `ObjectSpace.memsize_of((0..100000).map { |it| [it, nil] }.to_h)` => 4194400 bytes as of Ruby 3.2 so that seems reasonable?
+  // Note: `st_table_size()` is available from Ruby 3.2+ but not before
+  if (native_filenames_cache->num_entries >= 100000) {
+    st_clear(native_filenames_cache);
   }
-#endif
+
+  st_insert(native_filenames_cache, (st_data_t) function, (st_data_t) native_filename);
+  return native_filename;
+}
 
 // Rails's ActionView likes to dynamically generate method names with suffixed hashes/ids, resulting in methods with
 // names such as:
@@ -633,6 +643,28 @@ bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
   return true;
 }
 
+void sample_locations_initialize(sample_locations *locations, uint16_t max_frames, bool show_classes) {
+  locations->len = max_frames;
+  locations->ptr = ruby_xcalloc(max_frames, sizeof(ddog_prof_Location));
+  if (show_classes) {
+    locations->qualified_name_buf_size = QUALIFIED_NAME_AVG_SIZE * max_frames;
+    locations->qualified_name_buf = ruby_xmalloc(locations->qualified_name_buf_size);
+  } else {
+    locations->qualified_name_buf_size = 0;
+    locations->qualified_name_buf = NULL;
+  }
+}
+
+void sample_locations_free(sample_locations *locations) {
+  ruby_xfree(locations->ptr);
+  ruby_xfree(locations->qualified_name_buf);
+
+  locations->ptr = NULL;
+  locations->len = 0;
+  locations->qualified_name_buf = NULL;
+  locations->qualified_name_buf_size = 0;
+}
+
 uint16_t sampling_buffer_check_max_frames(int max_frames) {
   if (max_frames < 5) raise_error(rb_eArgError, "Invalid max_frames: value must be >= 5");
   if (max_frames > MAX_FRAMES_LIMIT) raise_error(rb_eArgError, "Invalid max_frames: value must be <= " MAX_FRAMES_LIMIT_AS_STRING);
@@ -675,8 +707,9 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
   atomic_signal_fence(memory_order_seq_cst);
 
   for (int i = 0; i < buffer->pending_sample_result; i++) {
+    rb_gc_mark((VALUE) buffer->stack_buffer[i].cme);
     if (buffer->stack_buffer[i].is_ruby_frame) {
-      rb_gc_mark(buffer->stack_buffer[i].as.ruby_frame.iseq);
+      rb_gc_mark((VALUE) buffer->stack_buffer[i].as.ruby_frame.iseq);
     }
   }
 
@@ -684,3 +717,41 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
   atomic_signal_fence(memory_order_seq_cst);
   buffer->is_marking = false;
 }
+
+// On a static Ruby without libruby.so the `ruby_native_filename` returned from `dladdr` is in practice `argv[0]`
+// (e.g. can be rspec, rake, etc), so here we find the actual Ruby binary to use instead
+static void initialize_static_ruby_actual_filename(VALUE profiling_module) {
+  static_ruby_actual_filename = rb_const_get(profiling_module, rb_intern("STATIC_RUBY_PATH"));
+  if (NIL_P(static_ruby_actual_filename)) {
+    return;
+  }
+  // Makes this object immortal + pinned in-place (no moving)
+  rb_gc_register_mark_object(static_ruby_actual_filename);
+}
+
+static VALUE _native_set_file_info_for_cfunc(DDTRACE_UNUSED VALUE self, VALUE new_static_ruby_actual_filename) {
+  if (new_static_ruby_actual_filename != Qnil) ENFORCE_TYPE(new_static_ruby_actual_filename, T_STRING);
+
+  VALUE previous_static_ruby_actual_filename = static_ruby_actual_filename;
+  static_ruby_actual_filename = new_static_ruby_actual_filename;
+
+  ddog_CharSlice filename_slice;
+  int line;
+  st_table *native_filenames_cache = st_init_numtable();
+
+  set_file_info_for_cfunc(
+    &filename_slice,
+    &line,
+    DDOG_CHARSLICE_C("(not used when testing)"),
+    0,
+    rb_ary_new, // Symbol inside Ruby VM to trigger comparison logic
+    false,
+    true,
+    native_filenames_cache
+  );
+
+  st_free_table(native_filenames_cache);
+  static_ruby_actual_filename = previous_static_ruby_actual_filename;
+
+  return rb_utf8_str_new(filename_slice.ptr, filename_slice.len);
+}