datadog 2.41.0 → 2.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9770ef0d02b2ecf56734c823b89ea642beb8512dae612904f0bc3d050852b44
-  data.tar.gz: b1e359c8eb8d26528b21c963c775b7cf8e5e227ca2cf7b88b322337d32c7283c
+  metadata.gz: 154c126111f9b92cc59626264fc83b954b36317f96798bc33a0bcb7784516968
+  data.tar.gz: 4098225f4c88a0c3e31b069ca1a17231af4298ca149ce530d0dc4ccc9a8d8db5
 SHA512:
-  metadata.gz: 21335b21c2d0be965d3f3c972efab822767ddd6f28e3a1263497335300cf7a34b3fe1872d9037c1e40af909a897296e3946fac7ecd7b8e7b92c21c1ecdfc7a77
-  data.tar.gz: a2ee7baf6f4e6e45f6116629d09806db7d0bd171bb5aaa36f4cf65e2f7c53038be18e04b84b25f1a26bd87031ea223a8e6ced8f91cceb62f8a292bfd4fd76875
+  metadata.gz: a566b1ab03efdf8c881ff7a6af93aff5fc946dc213ea1ccfabc554458ae733769ab98002ea14f039e3b2a19c150b2e208083e35fd0519f34b77ff239247412dd
+  data.tar.gz: 3a9f8574b7325c9f6e77da1a7f8ad65b8b6a74426b9dab829db84c8adbe8757c1f09d57d8232085c51d074c60e4a77e017cbdd9bfaa5d9f84efba0ad66869866

data/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## [Unreleased]
 
+## [2.43.0] - 2026-09-22
+
+### Added
+
+* Core: Add an experimental `libdatadog`-backed native trace transport with full feature parity. Opt in with `DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED=true`. ([#5971][])
+* SSI: Support `force_ruby_platform` during Ruby dependency resolution. ([#6316][])
+
+### Fixed
+
+* SSI: Respect transitive application dependencies during Ruby injection. ([#6316][])
+* SSI: Preserve checksums in injected Ruby lockfiles. ([#6320][])
+* SSI: Preserve Bundler selection and `RUBYOPT` options during injection. ([#6316][])
+* SSI: Support versioned and symlinked Bundler launchers. ([#6316][])
+* SSI: Restore Ruby injection for deployment and vendored bundles. ([#6316][])
+* Profiling: Fix a potential sampling race when Ruby is idle. ([#6286][])
+* Profiling: Fix profiler not starting on Ruby 4 due to `undefined symbol: rb_current_box`. ([#6350][])
+
+## [2.42.0] - 2026-08-31
+
+### Added
+
+* Tracing: Add sampling probability compatibility with OTel-instrumented services ([#6111][])
+* Dynamic Instrumentation: Honor organization- and environment-level remote enablement for Ruby services. ([#6234][])
+* Dynamic Instrumentation: Add per-process runtime id for snapshots to distinguish process restarts within a container ([#6232][])
+* Open Feature: OpenFeature provider sends the serial ID of the assigned split on exposure events ([#6220][])
+
+### Changed
+
+* Profiling: Drop usage of MJIT headers for Ruby 2.6 to 3.1 ([#6135][])
+* Profiling: Re-enable heap live size profiling for Ruby 4+ ([#6176][])
+* Dynamic Instrumentation: Enforce process-wide rate limit across all probes ([#6043][])
+
+### Fixed
+
+* Core: Ignore `SignalException` from crashtracker as unhandled exception errors ([#6219][])
+* Tracing: Fix missing peer tags for database queries traced through `ActiveRecord` ([#6213][])
+* Profiling: Fix bug in `sample_after_gc` leading to profiler stopping ([#6242][])
+* Profiling: Improve stability of heap profiling by using `ObjectSpace::WeakMap` instead of `_id2ref` ([#6176][])
+* Profiling: VM-internal objects are no longer sampled for heap profiling ([#6176][])
+
 ## [2.41.0] - 2026-08-13
 
 ### Added
@@ -3753,7 +3793,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.41.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...master
+[2.43.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.42.0...v2.43.0
+[2.42.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.41.0...v2.42.0
 [2.41.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.40.0...v2.41.0
 [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
@@ -5560,6 +5602,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#6043]: https://github.com/DataDog/dd-trace-rb/issues/6043
 [#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
@@ -5568,14 +5611,27 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#6111]: https://github.com/DataDog/dd-trace-rb/issues/6111
 [#6116]: https://github.com/DataDog/dd-trace-rb/issues/6116
 [#6126]: https://github.com/DataDog/dd-trace-rb/issues/6126
 [#6130]: https://github.com/DataDog/dd-trace-rb/issues/6130
 [#6132]: https://github.com/DataDog/dd-trace-rb/issues/6132
 [#6133]: https://github.com/DataDog/dd-trace-rb/issues/6133
+[#6135]: https://github.com/DataDog/dd-trace-rb/issues/6135
 [#6138]: https://github.com/DataDog/dd-trace-rb/issues/6138
 [#6142]: https://github.com/DataDog/dd-trace-rb/issues/6142
 [#6173]: https://github.com/DataDog/dd-trace-rb/issues/6173
+[#6176]: https://github.com/DataDog/dd-trace-rb/issues/6176
+[#6213]: https://github.com/DataDog/dd-trace-rb/issues/6213
+[#6219]: https://github.com/DataDog/dd-trace-rb/issues/6219
+[#6220]: https://github.com/DataDog/dd-trace-rb/issues/6220
+[#6232]: https://github.com/DataDog/dd-trace-rb/issues/6232
+[#6234]: https://github.com/DataDog/dd-trace-rb/issues/6234
+[#6242]: https://github.com/DataDog/dd-trace-rb/issues/6242
+[#6286]: https://github.com/DataDog/dd-trace-rb/issues/6286
+[#6316]: https://github.com/DataDog/dd-trace-rb/issues/6316
+[#6320]: https://github.com/DataDog/dd-trace-rb/issues/6320
+[#6350]: https://github.com/DataDog/dd-trace-rb/issues/6350
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/README.md

@@ -17,8 +17,11 @@ For descriptions of terminology used in APM, take a look at the [APM Terms and C
 
 For contributing, checkout the [contribution guidelines][contribution docs] and [development guide][development docs].
 
+To check that a downloaded gem file was published by this repository, see [how to verify gem provenance][provenance docs].
+
 [public docs]: https://docs.datadoghq.com/tracing/setup/ruby/
 [api docs]: https://datadog.github.io/dd-trace-rb/
 [APM glossary]: https://docs.datadoghq.com/tracing/glossary/
 [contribution docs]: https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md
 [development docs]: https://github.com/DataDog/dd-trace-rb/blob/master/docs/DevelopmentGuide.md
+[provenance docs]: https://github.com/DataDog/dd-trace-rb/blob/master/docs/Provenance.md

data/ext/datadog_profiling_native_extension/NativeExtensionDesign.md

@@ -65,38 +65,26 @@ Non-exhaustive list of APIs that cause exceptions to be raised:
 To implement some of the features below, we sometimes require access to private Ruby header files (that describe VM
 internal types, structures and functions).
 
-Because these private header files are not included in regular Ruby installations, we have two different workarounds:
-
-1. for Ruby versions 2.6 to 3.2 we make use use the Ruby private MJIT header
-2. for Ruby versions < 2.6 and > 3.2 we make use of the `datadog-ruby_core_source` gem
+Because these private header files are not included in regular Ruby installations, we make use of the
+[`datadog-ruby_core_source`](https://github.com/DataDog/datadog-ruby_core_source) gem, which contains almost no code
+of its own; instead, it just contains per-Ruby-version folders with the private VM headers (`.h`) files for that
+version. Thus, even though a regular Ruby installation does not include these files, we can access the copy inside
+this gem.
 
 Functions which make use of these headers are defined in the <private_vm_api_acccess.c> file.
 
-There is currently no way for disabling usage of the private MJIT header for Ruby 2.6 to 3.2.
-
 **Important Note**: Our medium/long-term plan is to stop relying on all private Ruby headers, and instead request and
 contribute upstream changes so that they become official public VM APIs.
 
-### Approach 1: Using the Ruby private MJIT header
-
-Ruby versions 2.6 to 3.2 shipped a JIT compiler called MJIT. This compiler does not directly generate machine code;
-instead it generates C code and uses the system C compiler to turn it into machine code.
-
-The generated C code `#include`s a private header -- which we call "the MJIT header".
-The MJIT header gets shipped with all MJIT-enabled Rubies and includes the layout of many internal VM structures;
-and of course the intention is that it is only used by the Ruby MJIT compiler.
-
-This header is placed inside the `include/` directory in a Ruby installation, and is named for that specific Ruby
-version. e.g. `rb_mjit_min_header-2.7.4.h`.
-
-This header was removed in Ruby 3.3.
-
-### Approach 2: Using the `datadog-ruby_core_source` gem
+### Historical note: the Ruby private MJIT header
 
-The [`datadog-ruby_core_source`](https://github.com/DataDog/datadog-ruby_core_source) contains almost no code;
-instead, it just contains per-Ruby-version folders with the private VM headers (`.h`) files for that version.
+Ruby versions 2.6 to 3.2 shipped a JIT compiler called MJIT. This compiler did not directly generate machine code;
+instead it generated C code and used the system C compiler to turn it into machine code.
 
-Thus, even though a regular Ruby installation does not include these files, we can access the copy inside this gem.
+The generated C code `#include`d a private header -- which we called "the MJIT header". In the past we used to
+rely on it for Ruby versions 2.6 to 3.2.
+This header was removed in Ruby 3.3, and we have since moved all supported Ruby versions over to using the
+`datadog-ruby_core_source` gem instead.
 
 ## Feature: Getting thread CPU-time clock_ids
 

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -68,14 +68,24 @@
 // 4. The Ruby VM calls our `sample_from_postponed_job` from a thread holding the global VM lock. A sample is recorded by
 // calling `thread_context_collector_sample`.
 //
-// ### TracePoints and Forking
+//
+// ### Hooks and TracePoints
+//
+// This class uses various hooks:
+// * A RUBY_INTERNAL_EVENT_GC_ENTER & RUBY_INTERNAL_EVENT_GC_EXIT TracePoint
+// * A RUBY_INTERNAL_EVENT_NEWOBJ "event hook"/internal tracepoint
+// * A GVL thread event hook
+//
+// We refer to those collectively as "hooks".
+//
+// ### Hooks and Forking
 //
 // When the Ruby VM forks, the CPU/Wall-time profiling stops naturally because it's triggered by a background thread
 // that doesn't get automatically restarted by the VM on the child process. (The profiler does trigger its restart at
 // some point -- see `Profiling::Tasks::Setup` for details).
 //
-// But this doesn't apply to any `TracePoint`s this class may use, which will continue to be active. Thus, we need to
-// always remember consider this case of -- the worker thread may not be alive but the `TracePoint`s can continue to
+// But this doesn't apply to any hooks this class may use, which will continue to be active. Thus, we need to
+// always remember consider this case of -- the worker thread may not be alive but the hooks can continue to
 // trigger samples.
 //
 // ---
@@ -91,7 +101,7 @@ unsigned int MAX_ALLOC_WEIGHT = 10000;
   static rb_postponed_job_handle_t sample_from_postponed_job_handle;
   static rb_postponed_job_handle_t after_gc_from_postponed_job_handle;
   static rb_postponed_job_handle_t after_gvl_running_from_postponed_job_handle;
-  static rb_postponed_job_handle_t after_allocation_from_postponed_job_handle;
+  static rb_postponed_job_handle_t commit_heap_recordings_from_postponed_job_may_lose_gvl_handle;
 #endif
 
 // Contains state for a single CpuAndWallTimeWorker instance
@@ -107,6 +117,8 @@ typedef struct {
   bool skip_idle_samples_for_testing;
   bool sighandler_sampling_enabled;
   uint32_t cpu_sampling_interval_ms;
+  // Minimum duration of a "Waiting for GVL" period to trigger a sample
+  uint32_t waiting_for_gvl_threshold_ns;
   VALUE self_instance;
   VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
@@ -127,9 +139,20 @@ typedef struct {
 
   // Others
 
-  // Used to detect/avoid nested sampling, e.g. when on_newobj_event gets triggered by a memory allocation
-  // that happens during another sample, or when the signal handler gets triggered while we're already in the middle of
-  // sampling.
+  // Used to detect/avoid nested sampling, and intended to behave as a lock to ensure the profiler doesn't recurse on itself,
+  // e.g. when on_newobj_event gets triggered by a memory allocation that happens during another sample, or when the
+  // signal handler gets triggered while we're already in the middle of sampling.
+  //
+  // It's not an actual lock because we rely on the GVL for correct synchronization
+  // (and thus this flag is only valid when we know we have the GVL).
+  //
+  // Similar to a lock, it should not be held across long-running operations,
+  // **in particular it MUST NEVER be held during operations where we might lose the GVL**
+  // because effectively that would stop the profiler from working until control
+  // goes back to that special thread, which on a contended Ruby app, can take hundreds of ms (or more).
+  //
+  // Because what we want is "profiler doesn't recurse on itself" we want this to behave as a non-reentrant lock
+  // (FIXME: We should have checks for this)
   //
   // @ivoanjo: Right now we always sample inside `safely_call`; if that ever changes, this flag may need to become
   // volatile/atomic/have some barriers to ensure it's visible during e.g. signal handlers.
@@ -243,10 +266,10 @@ static void reset_stats_not_thread_safe(cpu_and_wall_time_worker_state *state);
 static void sleep_for(uint64_t time_ns);
 static VALUE _native_allocation_count(DDTRACE_UNUSED VALUE self);
 static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *unused2);
-static void disable_tracepoints(cpu_and_wall_time_worker_state *state);
+static void disable_hooks(cpu_and_wall_time_worker_state *state);
 static VALUE _native_with_blocked_sigprof(DDTRACE_UNUSED VALUE self);
 static VALUE rescued_sample_allocation(VALUE tracepoint_data);
-static VALUE rescued_after_allocation(VALUE self_instance);
+static VALUE rescued_commit_heap_recordings_may_lose_gvl(VALUE self_instance);
 static void delayed_error(cpu_and_wall_time_worker_state *state, const char *error);
 static void delayed_error_clock_failure(cpu_and_wall_time_worker_state *state);
 static VALUE _native_delayed_error(DDTRACE_UNUSED VALUE self, VALUE instance, VALUE error_msg);
@@ -261,11 +284,12 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self);
 static VALUE _native_gvl_profiling_hook_active(DDTRACE_UNUSED VALUE self, VALUE instance);
 static VALUE handle_sampling_failure_rescued_sample_from_postponed_job(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_thread_context_collector_sample_after_gc(VALUE self_instance, VALUE exception);
+static VALUE handle_sampling_failure_thread_context_collector_heap_update(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instance, VALUE exception);
-static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instance, VALUE exception);
+static VALUE handle_sampling_failure_rescued_commit_heap_recordings(VALUE self_instance, VALUE exception);
 static inline void during_sample_enter(cpu_and_wall_time_worker_state* state);
 static inline void during_sample_exit(cpu_and_wall_time_worker_state* state);
-static void after_allocation_from_postponed_job(DDTRACE_UNUSED void *_unused);
+static void commit_heap_recordings_from_postponed_job_may_lose_gvl(DDTRACE_UNUSED void *_unused);
 
 // We're using `on_newobj_event` function with `rb_add_event_hook2`, which requires in its public signature a function
 // with signature `rb_event_hook_func_t` which doesn't match `on_newobj_event`.
@@ -322,13 +346,14 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
     sample_from_postponed_job_handle = rb_postponed_job_preregister(unused_flags, sample_from_postponed_job, NULL);
     after_gc_from_postponed_job_handle = rb_postponed_job_preregister(unused_flags, after_gc_from_postponed_job, NULL);
     after_gvl_running_from_postponed_job_handle = rb_postponed_job_preregister(unused_flags, after_gvl_running_from_postponed_job, NULL);
-    after_allocation_from_postponed_job_handle = rb_postponed_job_preregister(unused_flags, after_allocation_from_postponed_job, NULL);
+    commit_heap_recordings_from_postponed_job_may_lose_gvl_handle =
+      rb_postponed_job_preregister(unused_flags, commit_heap_recordings_from_postponed_job_may_lose_gvl, NULL);
 
     if (
       sample_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID ||
       after_gc_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID ||
       after_gvl_running_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID ||
-      after_allocation_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID
+      commit_heap_recordings_from_postponed_job_may_lose_gvl_handle == POSTPONED_JOB_HANDLE_INVALID
     ) {
       raise_error(rb_eRuntimeError, "Failed to register profiler postponed jobs (got POSTPONED_JOB_HANDLE_INVALID)");
     }
@@ -408,6 +433,7 @@ static VALUE _native_new(VALUE klass) {
   state->skip_idle_samples_for_testing = false;
   state->sighandler_sampling_enabled = false;
   state->cpu_sampling_interval_ms = 10;
+  state->waiting_for_gvl_threshold_ns = 10 * 1000 * 1000;
   state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
@@ -453,6 +479,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE skip_idle_samples_for_testing = rb_hash_fetch(options, ID2SYM(rb_intern("skip_idle_samples_for_testing")));
   VALUE sighandler_sampling_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("sighandler_sampling_enabled")));
   VALUE cpu_sampling_interval_ms = rb_hash_fetch(options, ID2SYM(rb_intern("cpu_sampling_interval_ms")));
+  VALUE waiting_for_gvl_threshold_ns = rb_hash_fetch(options, ID2SYM(rb_intern("waiting_for_gvl_threshold_ns")));
 
   ENFORCE_BOOLEAN(gc_profiling_enabled);
   ENFORCE_BOOLEAN(no_signals_workaround_enabled);
@@ -464,6 +491,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ENFORCE_BOOLEAN(skip_idle_samples_for_testing)
   ENFORCE_BOOLEAN(sighandler_sampling_enabled)
   ENFORCE_TYPE(cpu_sampling_interval_ms, T_FIXNUM);
+  ENFORCE_TYPE(waiting_for_gvl_threshold_ns, T_FIXNUM);
 
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
@@ -477,6 +505,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   state->skip_idle_samples_for_testing = (skip_idle_samples_for_testing == Qtrue);
   state->sighandler_sampling_enabled = (sighandler_sampling_enabled == Qtrue);
   state->cpu_sampling_interval_ms = NUM2INT(cpu_sampling_interval_ms);
+  state->waiting_for_gvl_threshold_ns = NUM2UINT(waiting_for_gvl_threshold_ns);
 
   double total_overhead_target_percentage = NUM2DBL(dynamic_sampling_rate_overhead_target_percentage);
   if (!state->allocation_profiling_enabled) {
@@ -515,7 +544,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
 
   // If we already got a delayed exception registered even before starting, raise before starting
   if (state->failure_exception != Qnil) {
-    disable_tracepoints(state);
+    disable_hooks(state);
     rb_exc_raise(state->failure_exception);
   }
 
@@ -525,13 +554,13 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
       raise_error(rb_eRuntimeError, "Could not start CpuAndWallTimeWorker: There's already another instance of CpuAndWallTimeWorker active in a different thread");
     } else {
       // The previously active thread seems to have died without cleaning up after itself.
-      // In this case, we can still go ahead and start the profiler BUT we make sure to disable any existing tracepoint
+      // In this case, we can still go ahead and start the profiler BUT we make sure to disable any existing hooks
       // first as:
-      // a) If this is a new instance of the CpuAndWallTimeWorker, we don't want the tracepoint from the old instance
+      // a) If this is a new instance of the CpuAndWallTimeWorker, we don't want the hooks from the old instance
       //    being kept around
       // b) If this is the same instance of the CpuAndWallTimeWorker if we call enable on a tracepoint that is already
       //    enabled, it will start firing more than once, see https://bugs.ruby-lang.org/issues/19114 for details.
-      disable_tracepoints(old_state);
+      disable_hooks(old_state);
     }
   }
 
@@ -549,7 +578,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   // Reset per-thread state, if any. This ensures there's no leftover state from a previous profiler run that would
   // affect or be included in samples taken by this profiler about to run.
   //
-  // NOTE: This needs to be called before we enable any tracepoints or anything that could trigger samples (e.g.
+  // NOTE: This needs to be called before we enable any hooks or anything that could trigger samples (e.g.
   // reset cannot be concurrent with any sampling activity)
   thread_context_collector_reset_all_per_thread_contexts(state->thread_context_collector_instance);
 
@@ -576,7 +605,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
 
   // The sample trigger loop finished (either cleanly or with an error); let's clean up
 
-  disable_tracepoints(state);
+  disable_hooks(state);
 
   active_sampler_instance_state = NULL;
   active_sampler_instance = Qnil;
@@ -636,8 +665,8 @@ static void stop_state(cpu_and_wall_time_worker_state *state, VALUE optional_exc
   state->failure_exception = optional_exception;
   state->failure_exception_during_operation = optional_exception_during_operation;
 
-  // Disable the tracepoints as soon as possible, so the VM doesn't keep on calling them
-  disable_tracepoints(state);
+  // Disable the hooks as soon as possible, so the VM doesn't keep on calling them
+  disable_hooks(state);
 }
 
 static VALUE stop(VALUE self_instance, VALUE optional_exception, const char *optional_exception_during_operation) {
@@ -711,6 +740,8 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
   // a) we get triggered using SIGPROF, and the docs state a second SIGPROF will not interrupt an existing one (see sigaction docs on sa_mask)
   // b) we validate we are in the thread that has the global VM lock; if a different thread gets a signal, it will return early
   //    because it will not have the global VM lock
+  // c) `simulate_sampling_signal_delivery` calls us directly instead of via a real SIGPROF, and blocks SIGPROF delivery on its
+  //    thread for the duration of that call, so it can't be nested into by a real SIGPROF either
 
   state->stats.signal_handler_enqueued_sample++;
 
@@ -848,7 +879,7 @@ static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
   during_sample_enter(state);
 
   // Rescue against any exceptions that happen during sampling
-  safely_call(
+  VALUE needs_otel_span_key = safely_call(
     rescued_sample_from_postponed_job,
     state->self_instance,
     state->self_instance,
@@ -856,6 +887,12 @@ static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
   );
 
   during_sample_exit(state);
+
+  // Extracting the otel span key can lose the GVL, so we move it outside `during_sample`
+  // (It can't raise: it rescues its own exceptions)
+  if (needs_otel_span_key == Qtrue) {
+    thread_context_collector_resolve_otel_span_key_may_lose_gvl(state->thread_context_collector_instance);
+  }
 }
 
 static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
@@ -866,12 +903,13 @@ static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
 
   if (state->dynamic_sampling_rate_enabled && !dynamic_sampling_rate_should_sample(&state->cpu_dynamic_sampling_rate, wall_time_ns_before_sample)) {
     state->stats.cpu_skipped++;
-    return Qnil;
+    return Qfalse;
   }
 
   state->stats.cpu_sampled++;
 
-  thread_context_collector_sample(state->thread_context_collector_instance, wall_time_ns_before_sample);
+  bool needs_otel_span_key =
+    thread_context_collector_sample(state->thread_context_collector_instance, wall_time_ns_before_sample);
 
   long wall_time_ns_after_sample = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
   long delta_ns = wall_time_ns_after_sample - wall_time_ns_before_sample;
@@ -885,8 +923,7 @@ static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
 
   dynamic_sampling_rate_after_sample(&state->cpu_dynamic_sampling_rate, wall_time_ns_after_sample, sampling_time_ns);
 
-  // Return a dummy VALUE because we're called from rb_rescue2 which requires it
-  return Qnil;
+  return needs_otel_span_key ? Qtrue : Qfalse;
 }
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
@@ -912,7 +949,7 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  // Final preparations: Setup signal handler and enable tracepoints. We run these here and not in `_native_sampling_loop`
+  // Final preparations: Setup signal handler and enable hooks. We run these here and not in `_native_sampling_loop`
   // because they may raise exceptions.
   install_sigprof_signal_handler(handle_sampling_signal, "handle_sampling_signal");
   if (state->gc_profiling_enabled) rb_tracepoint_enable(state->gc_tracepoint);
@@ -1095,6 +1132,15 @@ static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused) {
   );
 
   during_sample_exit(state);
+
+  // This part runs separately from above because it may lose the GVL and we don't want `during_sample` to be set in
+  // such a situation
+  safely_call(
+    thread_context_collector_heap_update_may_lose_gvl,
+    state->thread_context_collector_instance,
+    state->self_instance,
+    handle_sampling_failure_thread_context_collector_heap_update
+  );
 }
 
 // Equivalent to Ruby begin/rescue call, where we call a C function and jump to the exception handler if an
@@ -1132,12 +1178,12 @@ static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE sel
 
 // After the Ruby VM forks, this method gets called in the child process to clean up any leftover state from the parent.
 //
-// Assumption: This method gets called BEFORE restarting profiling. Note that profiling-related tracepoints may still
+// Assumption: This method gets called BEFORE restarting profiling. Note that profiling-related hooks may still
 // be active, so we make sure to disable them before calling into anything else, so that there are no components
 // attempting to trigger samples at the same time as the reset is done.
 //
-// In the future, if we add more other components with tracepoints, we will need to coordinate stopping all such
-// tracepoints before doing the other cleaning steps.
+// In the future, if we add more other components with hooks, we will need to coordinate stopping all such
+// hooks before doing the other cleaning steps.
 //
 // Note that tests call this method directly in the same process without forking,
 // and in such a case non-current Threads keep running.
@@ -1145,8 +1191,8 @@ static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance)
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  // Disable all tracepoints, so that there are no more attempts to mutate the profile
-  disable_tracepoints(state);
+  // Disable all hooks, so that there are no more attempts to mutate the profile
+  disable_hooks(state);
 
   reset_stats_not_thread_safe(state);
 
@@ -1235,11 +1281,19 @@ void *simulate_sampling_signal_delivery(DDTRACE_UNUSED void *_unused) {
   // This can potentially happen if the CpuAndWallTimeWorker was stopped while the IdleSamplingHelper was trying to execute this action
   if (state == NULL) return NULL;
 
+  // Since this is not a real signal firing, we need to block SIGPROF delivery on this thread to avoid an actual SIGPROF
+  // signal coming in nested and interrupting us on this thread. Thus we respect the invariant of "no nesting" for `handle_sampling_signal`.
+  //
+  // Not needed when `no_signals_workaround_enabled` is set: no SIGPROFs are ever sent in that mode, so there's nothing to mask.
+  if (!state->no_signals_workaround_enabled) block_sigprof_signal_handler_from_running_in_current_thread();
+
   state->stats.simulated_signal_delivery++;
 
   // `handle_sampling_signal` does a few things extra on top of `sample_from_postponed_job` so that's why we don't shortcut here
   handle_sampling_signal(0, NULL, NULL);
 
+  if (!state->no_signals_workaround_enabled) unblock_sigprof_signal_handler_from_running_in_current_thread();
+
   return NULL; // Unused
 }
 
@@ -1301,6 +1355,9 @@ static VALUE _native_allocation_count(DDTRACE_UNUSED VALUE self) {
 // Implements memory-related profiling events. This function is called by Ruby via the `rb_add_event_hook2`
 // when the RUBY_INTERNAL_EVENT_NEWOBJ event is triggered.
 //
+// This function is called from the RUBY_INTERNAL_EVENT_NEWOBJ tracepoint so it should neither allocate in the
+// Ruby heap nor release the GVL (https://github.com/DataDog/dd-trace-rb/pull/4240).
+//
 // When allocation sampling is enabled, this function gets called for almost all* objects allocated by the Ruby VM.
 // (*In some weird cases the VM may skip this tracepoint.)
 //
@@ -1411,7 +1468,7 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
   during_sample_exit(state);
 }
 
-static void disable_tracepoints(cpu_and_wall_time_worker_state *state) {
+static void disable_hooks(cpu_and_wall_time_worker_state *state) {
   if (state->gc_tracepoint != Qnil) {
     rb_tracepoint_disable(state->gc_tracepoint);
   }
@@ -1459,18 +1516,18 @@ static VALUE rescued_sample_allocation(VALUE arg) {
   // To control bias from sampling, we clamp the maximum weight attributed to a single allocation sample. This avoids
   // assigning a very large number to a sample, if for instance the dynamic sampling mechanism chose a really big interval.
   unsigned int weight = allocations_since_last_sample > MAX_ALLOC_WEIGHT ? MAX_ALLOC_WEIGHT : (unsigned int) allocations_since_last_sample;
-  bool needs_after_allocation = thread_context_collector_sample_allocation(state->thread_context_collector_instance, thread_context, weight, new_object);
+  bool needs_commit = thread_context_collector_sample_allocation(state->thread_context_collector_instance, thread_context, weight, new_object);
   // ...but we still represent the skipped samples in the profile, thus the data will account for all allocations.
   if (weight < allocations_since_last_sample) {
     uint32_t skipped_samples = (uint32_t) uint64_min_of(allocations_since_last_sample - weight, UINT32_MAX);
     thread_context_collector_sample_skipped_allocation_samples(state->thread_context_collector_instance, skipped_samples);
   }
 
-  if (needs_after_allocation) {
+  if (needs_commit) {
     #ifndef NO_POSTPONED_TRIGGER
-      rb_postponed_job_trigger(after_allocation_from_postponed_job_handle);
+      rb_postponed_job_trigger(commit_heap_recordings_from_postponed_job_may_lose_gvl_handle);
     #else
-      // Not needed on legacy rubies
+      rb_postponed_job_register_one(0, commit_heap_recordings_from_postponed_job_may_lose_gvl, NULL);
     #endif
   }
 
@@ -1545,10 +1602,11 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
     } else if (event_id == RUBY_INTERNAL_THREAD_EVENT_READY) { /* waiting for gvl */
       thread_context_collector_on_gvl_waiting(thread_context);
     } else if (event_id == RUBY_INTERNAL_THREAD_EVENT_RESUMED) { /* running/runnable */
-      // Interesting note: A RUBY_INTERNAL_THREAD_EVENT_RESUMED is guaranteed to be called with the GVL being acquired
-      // and on the event thread.
-      // However, on_gvl_event() is called while holding the scheduler lock, so we do as little work as possible here,
-      // and perform the sample in a postponed_job.
+      // We must only use async-signal-safe functions here and not call arbitrary Ruby APIs and not allocate!
+      // One might assume RUBY_INTERNAL_THREAD_EVENT_RESUMED means having the GVL and running that thread.
+      // However, the reality is more complicated (https://bugs.ruby-lang.org/issues/22098),
+      // it only "sort of" has the GVL but not fully, and it's called while holding the scheduler lock,
+      // so we do as little work as possible here, and perform the sample in a postponed_job.
       cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
       if (state == NULL) return; // This should not happen, but just in case...
 
@@ -1560,7 +1618,8 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
       // that next.
       during_sample_enter(state);
 
-      on_gvl_running_result result = thread_context_collector_on_gvl_running(state->thread_context_collector_instance, target_thread, thread_context);
+      on_gvl_running_result result =
+        thread_context_collector_on_gvl_running(target_thread, thread_context, state->waiting_for_gvl_threshold_ns);
 
       during_sample_exit(state);
 
@@ -1650,54 +1709,54 @@ static VALUE handle_sampling_failure_thread_context_collector_sample_after_gc(VA
   return Qnil;
 }
 
+static VALUE handle_sampling_failure_thread_context_collector_heap_update(VALUE self_instance, VALUE exception) {
+  stop(self_instance, exception, "thread_context_collector_heap_update_may_lose_gvl");
+  return Qnil;
+}
+
 static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instance, VALUE exception) {
   stop(self_instance, exception, "rescued_sample_allocation");
   return Qnil;
 }
 
-static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instance, VALUE exception) {
-  stop(self_instance, exception, "rescued_after_allocation");
+static VALUE handle_sampling_failure_rescued_commit_heap_recordings(VALUE self_instance, VALUE exception) {
+  stop(self_instance, exception, "rescued_commit_heap_recordings_may_lose_gvl");
   return Qnil;
 }
 
-static VALUE rescued_after_allocation(VALUE self_instance) {
+static VALUE rescued_commit_heap_recordings_may_lose_gvl(VALUE self_instance) {
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  thread_context_collector_after_allocation(state->thread_context_collector_instance);
+  thread_context_collector_commit_heap_recordings_may_lose_gvl(state->thread_context_collector_instance);
 
   // Return a dummy VALUE because we're called from rb_rescue2 which requires it
   return Qnil;
 }
 
-// This postponed job callback is used to finalize heap allocation recordings on Ruby 4+.
-// During on_newobj_event, calling rb_obj_id() is unsafe because it mutates the object.
-// So we defer getting the object_id until after the event completes.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function" // This is only used for some Rubies, but we want to build on all to make it easier to dev
-static void after_allocation_from_postponed_job(DDTRACE_UNUSED void *_unused) {
+// This postponed job callback is used to commit heap allocation recordings.
+// During on_newobj_event, we can't take the weak reference the heap recorder needs to track the object, so we defer
+// that until after the event completes.
+static void commit_heap_recordings_from_postponed_job_may_lose_gvl(DDTRACE_UNUSED void *_unused) {
   cpu_and_wall_time_worker_state *state = active_sampler_instance_state;
 
   if (state == NULL || !ddtrace_rb_ractor_main_p()) return;
 
-  // Protect against nested operations
-  if (state->during_sample) return;
-
-  during_sample_enter(state);
+  if (state->during_sample) {
+    delayed_error(state, "commit_heap_recordings_from_postponed_job_may_lose_gvl called during_sample");
+    return;
+  }
 
   // NOTE: We're not updating the allocation_sampler here.
   // This means work done in this function isn't accounted for as profiler overhead.
   // This is acceptable as the amount of work done here is expected to be small.
   safely_call(
-    rescued_after_allocation,
+    rescued_commit_heap_recordings_may_lose_gvl,
     state->self_instance,
     state->self_instance,
-    handle_sampling_failure_rescued_after_allocation
+    handle_sampling_failure_rescued_commit_heap_recordings
   );
-
-  during_sample_exit(state);
 }
-#pragma GCC diagnostic pop
 
 static inline void during_sample_enter(cpu_and_wall_time_worker_state* state) {
   // Tell the compiler it's not allowed to reorder the `during_sample` flag with anything that happens after.