datadog 2.22.0 → 2.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 495f03c8c90a6786ec765ac781553fe5197d9511586a41964382b73bb69ccca9
-  data.tar.gz: 81c46a4063b395a010ad1a028289b74c2d55bdaa6dff36ce61085d066a9b1a19
+  metadata.gz: a1e3df0d4845537939ee39a49f98f9645cf0b5f3cd8f62cd9b7c8dd7f7cf112f
+  data.tar.gz: e84c39b5b0d3b464aa5d9c1d050a215374520575832bee48671549bbf9696973
 SHA512:
-  metadata.gz: 2d4ab14bf55177e33f186c762b5156dd8cb8c17471c6277e1e0d1bce444212c98d221e00a2150fb3358203c898bb40fe431e9ebca0ef8fd22feec80758f8e922
-  data.tar.gz: 505dd3f5f5a08a18a95aef5cb7ae979c63bee58b22d36b8d77b21b0b5998ef775ec8c437895633355664a5ac0c31a9c2624b73ef08b63fa4154712508411b172
+  metadata.gz: f00d5556de98278dc5f80d1146374b378e6d21e32c041239e0e6a6237f4169d79061f1e94df1f8221255a2a807ed6a3ff6f80668ff3421030737c6ec7bf35f76
+  data.tar.gz: 94a76fd5432c238ee71c261419cb99e943143e802092ba0ec4aa9391e988f5ed6e9c307295211f0c16951d47e060633b62b40f982c83834aa179b6e66b03af91

data/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 ## [Unreleased]
 
+## [2.24.0] - 2026-01-08
+
+### Added
+
+* Core: Add support for installing the gem on Ruby 4.0.x stable ([#5157][])
+* Tracing: Add origin detection using extra headers and the `DD_EXTERNAL_ENV` variable. ([#5028][])
+* Dynamic Instrumentation: Add one-click enablement support ([#5150][])
+
+### Changed
+
+* Profiling: Remove profiler warning related to the Ractor issue ([#5194][])
+* Profiling: Disable heap profiling on Ruby 4 due to incompatibility ([#5148][])
+* Dynamic Instrumentation: Stop using customer-provided time provider for method duration calculation ([#5153][])
+* Live Debugger / Dynamic Instrumentation: Improve probe instrumentation ([#5165][])
+* Live Debugger / Dynamic Instrumentation: Improve instrumentation reliability for probes ([#5169][])
+
+### Fixed
+
+* Core: Improve reliability of worker shutdown ([#5176][])
+* Core: Fix RDoc error when installing the `datadog` gem ([#5145][])
+* Tracing: Ensure `Tracing.continue_from!` keeps the active trace for the full block duration. ([#4941][])
+* Profiling: Fix and refine profiler thread state categorization for Ruby 4 ([#5197][])
+* Profiling: Fix profiler error triggering `Bundler::PermissionError` ([#5146][])
+* Live Debugger / Dynamic Instrumentation: Fix Live Debugger and Dynamic Instrumentation UI for forking web servers ([#5159][])
+* Live Debugger / Dynamic Instrumentation: Fix method probe leak when a referenced class loads after the probe reaches the application ([#5168][])
+
+## [2.23.0] - 2025-12-11
+
+### Added
+
+* Tracing: Add process tags to trace payloads with `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED` environment variable ([#5033][])
+* Tracing: Integrations: Add Data Streams Monitoring (DSM) instrumentation to Waterdrop producers ([#5031][])
+* Tracing: Open Telemetry: Add OpenTelemetry metrics support with OTLP exporters using `DD_METRICS_OTEL_ENABLED` and standard OpenTelemetry environment variables ([#5021][])
+* Tracing: Add `http.endpoint` tag which contains the route whenever routing info is available, and falls back to route inferred from the request path ([#4995][])
+* Tracing: Add configuration of HTTP client and server error ranges via `DD_TRACE_HTTP_CLIENT_ERROR_STATUSES` and `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` ([#4991][])
+* Tracing: Integrations: Add Data Streams Monitoring for `ruby-kafka` and `karafka` consumers with optional manual instrumentation ([#4901][])
+* Dynamic Instrumentation: Add support for Hash length operations in expression language ([#5019][])
+* AppSec: Add unique security response identifier in the response body for blocked requests ([#5049][])
+* AppSec: Add support for processor overrides and custom data scanners ([#5044][])
+* Feature Flags: Add new component to support Open Feature SDK ([#5054][], [#5024][])
+
+### Changed
+
+* Core: Update minimum `datadog-ruby_core_source` dependency to 3.4.2 ([#5122][])
+* Core: Update `libdatadog` dependency to version 24.0.1 ([#5058][], [#5045][], [#5020][])
+* Tracing: Treat IPs from `100.65.0.0/10` range as private. ([#4975][])
+
+### Fixed
+
+* Live Debugger / Dynamic Instrumentation: Fix issues delivering large quantities of snapshots ([#5086][])
+* Tracing: Integrations: Fix `NoMethodError` in GraphQL integration when error has no `locations`. ([#5025][])
+* Tracing: Integrations: Fix `http.route` tag for Rack applications mounted inside Rails. ([#4988][])
+* Profiling: Fix profiler support for Ruby 4.0.0-preview2 ([#5091][])
+* Profiling: Fix profiler sleep and wait states not being categorized in timeline ([#5000][])
+* Profiling: Fix profiler not identifying executables with gems they belong to ([#4999][])
+* Stable Config: Fix potential segfault during configuration file parsing ([#5073][])
+* AppSec: Fix route extraction error for Rails 8.1.1+. ([#5042][])
+
 ## [2.22.0] - 2025-10-15
 
 ### Added
@@ -3360,7 +3418,9 @@ 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.22.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.24.0...master
+[2.24.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.23.0...v2.24.0
+[2.23.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.22.0...v2.23.0
 [2.22.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.21.0...v2.22.0
 [2.21.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.20.0...v2.21.0
 [2.20.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.19.0...v2.20.0
@@ -4967,6 +5027,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4893]: https://github.com/DataDog/dd-trace-rb/issues/4893
 [#4894]: https://github.com/DataDog/dd-trace-rb/issues/4894
 [#4900]: https://github.com/DataDog/dd-trace-rb/issues/4900
+[#4901]: https://github.com/DataDog/dd-trace-rb/issues/4901
 [#4902]: https://github.com/DataDog/dd-trace-rb/issues/4902
 [#4906]: https://github.com/DataDog/dd-trace-rb/issues/4906
 [#4907]: https://github.com/DataDog/dd-trace-rb/issues/4907
@@ -4976,9 +5037,47 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4914]: https://github.com/DataDog/dd-trace-rb/issues/4914
 [#4918]: https://github.com/DataDog/dd-trace-rb/issues/4918
 [#4919]: https://github.com/DataDog/dd-trace-rb/issues/4919
+[#4941]: https://github.com/DataDog/dd-trace-rb/issues/4941
 [#4957]: https://github.com/DataDog/dd-trace-rb/issues/4957
 [#4965]: https://github.com/DataDog/dd-trace-rb/issues/4965
 [#4969]: https://github.com/DataDog/dd-trace-rb/issues/4969
+[#4975]: https://github.com/DataDog/dd-trace-rb/issues/4975
+[#4988]: https://github.com/DataDog/dd-trace-rb/issues/4988
+[#4991]: https://github.com/DataDog/dd-trace-rb/issues/4991
+[#4995]: https://github.com/DataDog/dd-trace-rb/issues/4995
+[#4999]: https://github.com/DataDog/dd-trace-rb/issues/4999
+[#5000]: https://github.com/DataDog/dd-trace-rb/issues/5000
+[#5019]: https://github.com/DataDog/dd-trace-rb/issues/5019
+[#5020]: https://github.com/DataDog/dd-trace-rb/issues/5020
+[#5021]: https://github.com/DataDog/dd-trace-rb/issues/5021
+[#5024]: https://github.com/DataDog/dd-trace-rb/issues/5024
+[#5025]: https://github.com/DataDog/dd-trace-rb/issues/5025
+[#5028]: https://github.com/DataDog/dd-trace-rb/issues/5028
+[#5031]: https://github.com/DataDog/dd-trace-rb/issues/5031
+[#5033]: https://github.com/DataDog/dd-trace-rb/issues/5033
+[#5042]: https://github.com/DataDog/dd-trace-rb/issues/5042
+[#5044]: https://github.com/DataDog/dd-trace-rb/issues/5044
+[#5045]: https://github.com/DataDog/dd-trace-rb/issues/5045
+[#5049]: https://github.com/DataDog/dd-trace-rb/issues/5049
+[#5054]: https://github.com/DataDog/dd-trace-rb/issues/5054
+[#5058]: https://github.com/DataDog/dd-trace-rb/issues/5058
+[#5073]: https://github.com/DataDog/dd-trace-rb/issues/5073
+[#5086]: https://github.com/DataDog/dd-trace-rb/issues/5086
+[#5091]: https://github.com/DataDog/dd-trace-rb/issues/5091
+[#5122]: https://github.com/DataDog/dd-trace-rb/issues/5122
+[#5145]: https://github.com/DataDog/dd-trace-rb/issues/5145
+[#5146]: https://github.com/DataDog/dd-trace-rb/issues/5146
+[#5148]: https://github.com/DataDog/dd-trace-rb/issues/5148
+[#5150]: https://github.com/DataDog/dd-trace-rb/issues/5150
+[#5153]: https://github.com/DataDog/dd-trace-rb/issues/5153
+[#5157]: https://github.com/DataDog/dd-trace-rb/issues/5157
+[#5159]: https://github.com/DataDog/dd-trace-rb/issues/5159
+[#5165]: https://github.com/DataDog/dd-trace-rb/issues/5165
+[#5168]: https://github.com/DataDog/dd-trace-rb/issues/5168
+[#5169]: https://github.com/DataDog/dd-trace-rb/issues/5169
+[#5176]: https://github.com/DataDog/dd-trace-rb/issues/5176
+[#5194]: https://github.com/DataDog/dd-trace-rb/issues/5194
+[#5197]: https://github.com/DataDog/dd-trace-rb/issues/5197
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/LIBDATADOG_DEVELOPMENT.md

@@ -1,60 +1,3 @@
 # Libdatadog development
 
-These instructions can quickly get outdated, so feel free to open an issue if they're not working (and/or ping @ivoanjo).
-
-## Using libdatadog builds from CI or GitHub
-
-If you're developing inside docker/natively on Linux, you can use libdatadog builds from CI and GitHub.
-
-Here's what to do:
-
-1. Create a folder for extracting libdatadog into based on your ruby platform (for instance inside the dd-trace-rb repo):
-
-```bash
-export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
-echo "Current ruby platform: $DD_RUBY_PLATFORM"
-mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
-```
-
-2. Find a libdatadog build from CI or [GitHub releases](https://github.com/DataDog/libdatadog/releases). This should match the Ruby platform seen above.
-3. Extract the libdatadog build into the folder:
-
-```bash
-# In this example the build is in my downloads; notice the use of strip-components to get the correct folder structure
-tar zxvf ~/Downloads/libdatadog-x86_64-unknown-linux-gnu.tar.gz -C my-libdatadog-build/$DD_RUBY_PLATFORM/ --strip-components=1
-# Here's how it should look after
-ls my-libdatadog-build/$DD_RUBY_PLATFORM
-bin  cmake  include  lib  LICENSE  LICENSE-3rdparty.yml  NOTICE
-```
-
-6. Tell Ruby where to find libdatadog: ```export LIBDATADOG_VENDOR_OVERRIDE=`pwd`/my-libdatadog-build/``` (Notice no platform + use of pwd for full path here)
-7. From dd-trace-rb, run `bundle exec rake clean compile`
-8. For incremental builds, usually `bundle exec rake compile` is faster and `clean` is not needed
-
-If you additionally want to run the profiler test suite, also remember to `export DD_PROFILING_MACOS_TESTING=true` and re-run `rake clean compile`.
-
-## Native development on macOS
-
-As of this writing (August 2025), the libdatadog builds on rubygems.org only support Linux.
-
-We don't officially support using libdatadog for Ruby on other platforms yet, but it is possible to use it for local development on macOS.
-(**Note that you don't need these instructions if you develop inside docker.**)
-
-Here's how you can do so:
-
-1. [Install rust](https://www.rust-lang.org/tools/install)
-2. Install `cbindgen`: `cargo install cbindgen`
-3. Clone [libdatadog](https://github.com/datadog/libdatadog)
-4. Create a folder for building into based on your ruby platform:
-
-```bash
-export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
-mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
-```
-
-5. From inside of the libdatadog repo, build libdatadog into this folder: `./build-profiling-ffi.sh my-libdatadog-build/$DD_RUBY_PLATFORM`
-6. Tell Ruby where to find libdatadog: `export LIBDATADOG_VENDOR_OVERRIDE=/adjust/this/to/be/the/full/path/to/my-libdatadog-build/` (Notice no platform here)
-7. From dd-trace-rb, run `bundle exec rake clean compile`
-8. For incremental builds, usually `bundle exec rake compile` is faster and `clean` is not needed
-
-If you additionally want to run the profiler test suite, also remember to `export DD_PROFILING_MACOS_TESTING=true` and re-run `rake clean compile`.
+Moved to <../docs/LibdatadogDevelopment.md>!

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -347,13 +347,19 @@ void sample_thread(
         } else if (CHARSLICE_EQUALS("select", name_slice)) { // Expected to be Kernel.select
           state_label->str  = DDOG_CHARSLICE_C("waiting");
         } else if (
-            CHARSLICE_EQUALS("synchronize", name_slice) || // Expected to be Monitor/Mutex#synchronize
-            CHARSLICE_EQUALS("lock", name_slice) ||        // Expected to be Mutex#lock
+            CHARSLICE_EQUALS("synchronize", name_slice) || // Expected to be Monitor/Mutex#synchronize on Ruby 2 & 3, and Monitor#synchronize on 4 (Mutex becomes <internal:thread_sync>)
+            #ifdef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby < 4
+              CHARSLICE_EQUALS("lock", name_slice) ||        // Expected to be Mutex#lock
+            #endif
             CHARSLICE_EQUALS("join", name_slice)           // Expected to be Thread#join
         ) {
           state_label->str  = DDOG_CHARSLICE_C("blocked");
         } else if (CHARSLICE_EQUALS("wait_readable", name_slice)) { // Expected to be IO#wait_readable
           state_label->str  = DDOG_CHARSLICE_C("network");
+        } else if (CHARSLICE_EQUALS("_native_idle_sampling_loop", name_slice)) { // Expected to be Datadog::Profiler::Collectors::IdleSamplingHelper#_native_idle_sampling_loop
+          state_label->str  = DDOG_CHARSLICE_C("waiting");
+        } else if (CHARSLICE_EQUALS("_native_sampling_loop", name_slice)) { // Expected to be Datadog::Profiler::Collectors::CpuAndWallTimeWorker#_native_sampling_loop
+          state_label->str  = DDOG_CHARSLICE_C("sleeping");
         }
         #ifdef NO_PRIMITIVE_POP // Ruby < 3.2
           else if (CHARSLICE_EQUALS("pop", name_slice)) { // Expected to be Queue/SizedQueue#pop
@@ -362,9 +368,19 @@ void sample_thread(
         #endif
       } else {
         #ifndef NO_PRIMITIVE_POP // Ruby >= 3.2
-          // Unlike the above, Ruby actually treats this one specially and gives it a nice file name we can match on!
-          if (CHARSLICE_EQUALS("pop", name_slice) && CHARSLICE_EQUALS("<internal:thread_sync>", filename_slice)) { // Expected to be Queue/SizedQueue#pop
-            state_label->str  = DDOG_CHARSLICE_C("waiting");
+          if (CHARSLICE_EQUALS("<internal:thread_sync>", filename_slice)) {
+            if (CHARSLICE_EQUALS("pop", name_slice)) { // Expected to be Queue/SizedQueue#pop
+              state_label->str  = DDOG_CHARSLICE_C("waiting");
+            }
+            #ifndef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby >= 4
+              else if (CHARSLICE_EQUALS("synchronize", name_slice) || CHARSLICE_EQUALS("lock", name_slice)) { // Expected to be Mutex#lock/synchronize
+                state_label->str  = DDOG_CHARSLICE_C("blocked");
+              } else if (CHARSLICE_EQUALS("sleep", name_slice)) { // Expected to be Mutex#sleep
+                state_label->str  = DDOG_CHARSLICE_C("sleeping");
+              } else if (CHARSLICE_EQUALS("wait", name_slice)) { // Expected to be ConditionVariable#wait
+                state_label->str  = DDOG_CHARSLICE_C("waiting");
+              }
+            #endif
           }
         #endif
       }

data/ext/datadog_profiling_native_extension/crashtracking_runtime_stacks.c

@@ -0,0 +1,239 @@
+// NOTE: This file is a part of the profiling native extension even though the
+// runtime stacks feature is consumed by the crashtracker. The profiling
+// extension already carries all the Ruby VM private header access and build
+// plumbing required to safely poke at internal structures. Sharing that setup
+// avoids duplicating another native extension with the same (fragile) access
+// patterns, and keeps the overall install/build surface area smaller.
+//
+// This also means that this functionality is depend on the profiling native extension
+// being available and built
+#include "extconf.h"
+
+#if defined(__linux__)
+
+#include <datadog/crashtracker.h>
+#include "datadog_ruby_common.h"
+#include "private_vm_api_access.h"
+#include <sys/mman.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+static const rb_data_type_t *crashtracker_thread_data_type = NULL;
+
+static void ruby_runtime_stack_callback(
+  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*)
+);
+
+// Use a fixed, preallocated buffer for crash-time runtime stacks to avoid
+// heap allocation in the signal/crash path.
+#define RUNTIME_STACK_MAX_FRAMES 512
+static frame_info runtime_stack_buffer[RUNTIME_STACK_MAX_FRAMES];
+
+#if defined(__x86_64__)
+#  define SYS_MINCORE 0x1B
+#elif defined(__aarch64__)
+#  define SYS_MINCORE 0xE8
+#endif
+
+long syscall(long number, ...);
+
+// align down to power of two
+static inline uintptr_t align_down(uintptr_t x, uintptr_t align) {
+  return x & ~(align - 1u);
+}
+
+static uintptr_t cached_page_size = 0;
+
+// TODO: This function is not necessarily Ruby specific. This will be moved to
+// `libdatadog` in the future as a shared utility function.
+static inline bool is_pointer_readable(const void *ptr, size_t size) {
+  if (!ptr || size == 0) return false;
+
+  uintptr_t page_size = cached_page_size;
+
+  const uintptr_t start = align_down((uintptr_t)ptr, page_size);
+  const uintptr_t end   = ((uintptr_t)ptr + size - 1u);
+  const uintptr_t last  = align_down(end, page_size);
+
+  // Number of pages spanned
+  size_t pages = 1u + (last != start);
+  if (pages > 2u) pages = 2u;
+
+  unsigned char vec[2];
+
+  int retries = 5;
+  for (;;) {
+      size_t len = pages * (size_t)page_size;
+      long rc = syscall(SYS_MINCORE, (void*)start, len, vec);
+
+      if (rc == 0) {
+          return true;
+      }
+
+      int e = errno;
+      if (e == ENOMEM || e == EFAULT) {
+          return false;
+      }
+
+      if (e == EAGAIN && retries-- > 0) {
+          continue;
+      }
+
+      // Unknown errno, we assume mapped to avoid cascading faults in crash path
+      return true;
+  }
+}
+
+static inline ddog_CharSlice char_slice_from_cstr(const char *cstr) {
+  if (cstr == NULL) {
+    return (ddog_CharSlice){.ptr = NULL, .len = 0};
+  }
+  return (ddog_CharSlice){.ptr = cstr, .len = strlen(cstr)};
+}
+
+static ddog_CharSlice safe_string_value(VALUE str) {
+  if (str == Qnil) return DDOG_CHARSLICE_C("<nil>");
+
+  // Validate object and payload readability in one check
+  if (!is_pointer_readable((const void *)str, sizeof(struct RString))) return DDOG_CHARSLICE_C("<corrupted>");
+  if (!RB_TYPE_P(str, T_STRING)) return DDOG_CHARSLICE_C("<not_string>");
+
+  long len = RSTRING_LEN(str);
+  if (len < 0 || len > 1024) return DDOG_CHARSLICE_C("<length_over_limit>");
+
+  const char *ptr = RSTRING_PTR(str);
+  if (!ptr) return DDOG_CHARSLICE_C("<null>");
+
+  if (!is_pointer_readable(ptr, len > 0 ? len : 1)) return DDOG_CHARSLICE_C("<unreadable>");
+
+  return (ddog_CharSlice){.ptr = ptr, .len = (size_t)len};
+}
+
+static void emit_placeholder_frame(
+  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*),
+  const char *label
+) {
+  ddog_crasht_RuntimeStackFrame frame = {
+    .type_name = DDOG_CHARSLICE_C(""),
+    .function = char_slice_from_cstr(label),
+    .file = DDOG_CHARSLICE_C("<unknown>"),
+    .line = 0,
+    .column = 0
+  };
+  emit_frame(&frame);
+}
+
+// Collect the crashing thread's frames via ddtrace_rb_profile_frames into a static buffer, then emit
+// them newest-first. If corruption is detected, emit placeholder frames so the crash report still
+// completes. We lean on the Ruby VM helpers we already use for profiling and rely on crashtracker's
+// safety nets so a failure here should not impact customers.
+static void ruby_runtime_stack_callback(
+  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*)
+) {
+  // Grab the Ruby thread we crashed on; crashtracker only runs once.
+  VALUE current_thread = rb_thread_current();
+  if (current_thread == Qnil) return;
+
+  if (crashtracker_thread_data_type == NULL) return;
+
+  if (!rb_typeddata_is_kind_of(current_thread, crashtracker_thread_data_type)) {
+    emit_placeholder_frame(emit_frame, "<runtime stack not found>");
+    return;
+  }
+
+  // Use the profiling helper to gather frames into our static buffer.
+  int frame_count = ddtrace_rb_profile_frames(
+    current_thread,
+    0,
+    RUNTIME_STACK_MAX_FRAMES,
+    runtime_stack_buffer
+  );
+
+  if (frame_count <= 0) {
+    emit_placeholder_frame(emit_frame, "<runtime stack not found>");
+    return;
+  }
+
+  for (int i = frame_count - 1; i >= 0; i--) {
+    frame_info *info = &runtime_stack_buffer[i];
+
+    if (info->is_ruby_frame) {
+      const void *iseq = (const void *)info->as.ruby_frame.iseq;
+      ddog_CharSlice function_slice = DDOG_CHARSLICE_C("<unknown>");
+      ddog_CharSlice file_slice = DDOG_CHARSLICE_C("<unknown>");
+
+      if (iseq && is_pointer_readable(iseq, sizeof_rb_iseq_t())) {
+        function_slice = safe_string_value(ddtrace_iseq_base_label(iseq));
+        file_slice = safe_string_value(ddtrace_iseq_path(iseq));
+      }
+
+      ddog_crasht_RuntimeStackFrame frame = {
+        .type_name = DDOG_CHARSLICE_C(""),
+        .function = function_slice,
+        .file = file_slice,
+        .line = info->as.ruby_frame.line,
+        .column = 0
+      };
+
+      emit_frame(&frame);
+    } else {
+      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)) {
+          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);
+          }
+        }
+      }
+
+      ddog_crasht_RuntimeStackFrame frame = {
+        .type_name = DDOG_CHARSLICE_C(""),
+        .function = function_slice,
+        .file = file_slice,
+        .line = 0,
+        .column = 0
+      };
+
+      emit_frame(&frame);
+    }
+  }
+
+  if (frame_count == RUNTIME_STACK_MAX_FRAMES) {
+    emit_placeholder_frame(emit_frame, "<truncated frames>");
+  }
+}
+
+void crashtracking_runtime_stacks_init(void) {
+  cached_page_size = (uintptr_t)sysconf(_SC_PAGESIZE);
+  if (cached_page_size == 0 || (cached_page_size & (cached_page_size - 1u))) {
+    cached_page_size = 4096;
+  }
+
+  if (crashtracker_thread_data_type == NULL) {
+    VALUE current_thread = rb_thread_current();
+    if (current_thread == Qnil) {
+      rb_raise(rb_eRuntimeError, "crashtracking_runtime_stacks_init: rb_thread_current returned Qnil");
+    }
+
+    const rb_data_type_t *thread_data_type = RTYPEDDATA_TYPE(current_thread);
+    if (!thread_data_type) {
+      rb_raise(rb_eRuntimeError, "crashtracking_runtime_stacks_init: RTYPEDDATA_TYPE returned NULL");
+    }
+
+    crashtracker_thread_data_type = thread_data_type;
+  }
+
+  // Register immediately so Ruby doesn't need to manage this explicitly.
+  ddog_crasht_register_runtime_frame_callback(ruby_runtime_stack_callback);
+}
+
+#else
+// Keep init symbol to satisfy linkage on non linux platforms, but do nothing
+void crashtracking_runtime_stacks_init(void) {}
+#endif
+

data/ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -3,7 +3,7 @@
 // IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
 
 #include <ruby.h>
-#include <datadog/profiling.h>
+#include <datadog/common.h>
 
 // Used to mark symbols to be exported to the outside of the extension.
 // Consider very carefully before tagging a function with this.

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -138,11 +138,16 @@ if have_header("dlfcn.h")
     have_func("dladdr")
 end
 
-# On Ruby 3.5, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
-$defs << "-DNO_IMEMO_OBJECT_ID" unless RUBY_VERSION < "3.5"
+# 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"
 
-# On Ruby 2.5 and 3.3, this symbol was not visible. It is on 2.6 to 3.2, as well as 3.4+
-$defs << "-DNO_RB_OBJ_INFO" if RUBY_VERSION.start_with?("2.5", "3.3")
+# On Ruby 4, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
+$defs << "-DNO_IMEMO_OBJECT_ID" unless RUBY_VERSION < "4"
+
+# This symbol is exclusively visible on certain Ruby versions: 2.6 to 3.2, as well as 3.4 (but not 4.0+)
+# It's only used to get extra information about an object when a failure happens, so it's a "very nice to have" but not
+# actually required for correct behavior of the profiler.
+$defs << "-DNO_RB_OBJ_INFO" if RUBY_VERSION.start_with?("2.5", "3.3", "4.")
 
 # On older Rubies, rb_postponed_job_preregister/rb_postponed_job_trigger did not exist
 $defs << "-DNO_POSTPONED_TRIGGER" if RUBY_VERSION < "3.3"

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -305,7 +305,7 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
 
   if (++heap_recorder->num_recordings_skipped < heap_recorder->sample_rate ||
       #ifdef NO_IMEMO_OBJECT_ID
-        // On Ruby 3.5, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
+        // On Ruby 4, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
         RB_BUILTIN_TYPE(new_obj) == RUBY_T_IMEMO
       #else
         false

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -76,6 +76,18 @@ 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

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -47,6 +47,10 @@ VALUE thread_name_for(VALUE thread);
 
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 
+size_t sizeof_rb_iseq_t(void);
+VALUE ddtrace_iseq_base_label(const void *iseq);
+VALUE ddtrace_iseq_path(const void *iseq);
+
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 

data/ext/datadog_profiling_native_extension/profiling.c

@@ -23,6 +23,7 @@ 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);
+void crashtracking_runtime_stacks_init(void);
 
 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);
@@ -65,6 +66,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   encoded_profile_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
+  crashtracking_runtime_stacks_init();
   unsafe_api_calls_check_init();
 
   // Hosts methods used for testing the native code using RSpec

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -3,7 +3,7 @@
 // IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
 
 #include <ruby.h>
-#include <datadog/profiling.h>
+#include <datadog/common.h>
 
 // Used to mark symbols to be exported to the outside of the extension.
 // Consider very carefully before tagging a function with this.