datadog 2.28.0 → 2.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ec2ddb3720f61843ee7526cd4e3493a646ab7afaf3d6e4cce71019d1dfd582
-  data.tar.gz: d0996f8b1eb568aea751a1e781fa4d9dcc7e1d436911fd579c7aa43947340f32
+  metadata.gz: f2983471f43d0c9b3473b3c65d0ca656514c6cf8cd7a32e35ec26826193fe533
+  data.tar.gz: 687d088d90ce4ee0ae5af66d9e604135f058bd7609641f4c7963f1ba32a2bb37
 SHA512:
-  metadata.gz: fb8da926cd9a09a500c781f60ad5fb35c72c9b3162acc067229f88d01281c63c6753c4230a2cf56f803fb0174994707b159e31f5d584e6682313a13e2187b61e
-  data.tar.gz: 8c93304f737b5798af5d6ed520f7006d7aa2e7644243fbfcd38994d66dde0aefb53084bca96024e61a7cbebcb72e60f958715fe4864c1e7fe90733103f9cb527
+  metadata.gz: 96f3744eadab0292666e18beac7deab2a6b7ef61b0da216ab4490e7621b0cec7839d18a519079b5b0563e2a260388b63ef59b5243a65c3d6ba997f3c7981986c
+  data.tar.gz: a82f01f50d499f1a08309f23144e5453cb9cf79bdc5b0c7daa9b3c9c373e3a41983babe3f86dc027f2dd2e9f056bc4b7645a49f799531e40eae9455ab7e00a6d

data/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 ## [Unreleased]
 
+## [2.30.0] - 2026-03-19
+
+### Added
+
+* Core: Enable `libdatadog`-based features and tests on macOS ([#5351][])
+* Tracing: Add `_dd.p.ksr` propagated tag to transmit Knuth sampling rate for backend resampling ([#5436][])
+* Tracing: Integrations: Add `DD_TRACE_<INTEGRATION>_DISTRIBUTED_TRACING` environment variables to control distributed tracing per integration ([#5396][])
+* Profiling: Add profiler setting `experimental_use_system_dns` to use system DNS resolver (defaults to true) ([#5425][], [#5449][])
+* Profiling: Allow lowering CPU profiling sampling interval with `experimental_cpu_sampling_interval_ms` setting ([#5424][])
+
+### Changed
+
+* Core: Enable process tags by default by setting `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED`, expanding tag collection for Tracing, Database Monitoring, Data Streams Monitoring, Profiling, Runtime Metrics, Process Discovery, Remote Configuration, Telemetry, Dynamic Instrumentation, and CrashTracking ([#5432][])
+* Core: Upgrade `libdatadog` dependency to version 29.0.0 ([#5274][], [#5461][])
+* Core: Remove dependency on `pkg-config` system tool for native extension builds ([#5469][])
+* Profiling: Improve profiling error message when another profiler is present ([#5375][])
+
+### Fixed
+
+* Tracing: Integrations: Fix `endpoint_render.grape` ActiveSupport notification instrumentation for `grape` 3.x ([#5414][])
+* Tracing: Integrations: Fix compatibility with `dalli` version 5.x and later ([#5435][])
+* Dynamic Instrumentation: Fix JSON serialization failures when snapshots contain binary data and invalid UTF-8 strings ([#5434][])
+* Dynamic Instrumentation: Show ERROR probe status when custom serializers produce non-JSON-encodable data instead of silent failures ([#5448][])
+* Data Streams: Fix Data Streams Monitoring to correctly report the configured environment instead of showing `env:none` ([#5427][])
+
+## [2.29.0] - 2026-02-20
+
+
+### Added
+
+* AppSec: Add analysis for downstream request with redirects ([#5347][])
+* AppSec: Add downstream request body analysis. ([#5320][])
+* SSI: Add support for Bundler vendored mode (`BUNDLE_PATH`) ([#5368][])
+* SSI: Default to local dependency resolution ([#5368][])
+* Dynamic Instrumentation: Added circuit breaker to automatically disable probes consuming excessive CPU time ([#5335][])
+* Crashtracking: Add reporting of unhandled exceptions ([#5321][])
+* Tracing: Add support for the `kicks` gem ([#5305][])
+* Profiling: Add heap profiling for ruby 4.x ([#5201][])
+* Tracing: Add simple method tracing API ([#5294][])
+* Tracing: Add `trace_singleton_class_method` for tracing singleton class methods. ([#5334][])
+
+### Changed
+
+* Dynamic Instrumentation: Improve error reporting when instrumentation fails or is removed due to circuit breaker ([#5371][])
+* SSI: Reduce SSI package size ([#5352][])
+* Core: Change default logger output from stdout to stderr ([#5342][])
+* AppSec: Make AppSec blocking page more friendly for vulnerability scanners ([#5341][])
+* Core: Add process tags and container id to process discovery payloads when the experimental setting `DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED=true` is enabled. ([#5336][])
+
+### Fixed
+
+* Dynamic Instrumentation: Fix Live Debugger UI for forking web servers with more than one worker process ([#5304][])
+
 ## [2.28.0] - 2026-02-04
 
 ### Added
@@ -3486,7 +3539,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.28.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.30.0...master
+[2.30.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.29.0...v2.30.0
+[2.29.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.28.0...v2.29.0
 [2.28.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.27.0...v2.28.0
 [2.27.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.26.0...v2.27.0
 [2.26.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.25.0...v2.26.0
@@ -5153,6 +5208,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#5201]: https://github.com/DataDog/dd-trace-rb/issues/5201
 [#5206]: https://github.com/DataDog/dd-trace-rb/issues/5206
 [#5210]: https://github.com/DataDog/dd-trace-rb/issues/5210
 [#5215]: https://github.com/DataDog/dd-trace-rb/issues/5215
@@ -5164,8 +5220,38 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5247]: https://github.com/DataDog/dd-trace-rb/issues/5247
 [#5254]: https://github.com/DataDog/dd-trace-rb/issues/5254
 [#5273]: https://github.com/DataDog/dd-trace-rb/issues/5273
+[#5274]: https://github.com/DataDog/dd-trace-rb/issues/5274
 [#5278]: https://github.com/DataDog/dd-trace-rb/issues/5278
 [#5283]: https://github.com/DataDog/dd-trace-rb/issues/5283
+[#5294]: https://github.com/DataDog/dd-trace-rb/issues/5294
+[#5304]: https://github.com/DataDog/dd-trace-rb/issues/5304
+[#5305]: https://github.com/DataDog/dd-trace-rb/issues/5305
+[#5320]: https://github.com/DataDog/dd-trace-rb/issues/5320
+[#5321]: https://github.com/DataDog/dd-trace-rb/issues/5321
+[#5334]: https://github.com/DataDog/dd-trace-rb/issues/5334
+[#5335]: https://github.com/DataDog/dd-trace-rb/issues/5335
+[#5336]: https://github.com/DataDog/dd-trace-rb/issues/5336
+[#5341]: https://github.com/DataDog/dd-trace-rb/issues/5341
+[#5342]: https://github.com/DataDog/dd-trace-rb/issues/5342
+[#5347]: https://github.com/DataDog/dd-trace-rb/issues/5347
+[#5351]: https://github.com/DataDog/dd-trace-rb/issues/5351
+[#5352]: https://github.com/DataDog/dd-trace-rb/issues/5352
+[#5368]: https://github.com/DataDog/dd-trace-rb/issues/5368
+[#5371]: https://github.com/DataDog/dd-trace-rb/issues/5371
+[#5375]: https://github.com/DataDog/dd-trace-rb/issues/5375
+[#5396]: https://github.com/DataDog/dd-trace-rb/issues/5396
+[#5414]: https://github.com/DataDog/dd-trace-rb/issues/5414
+[#5424]: https://github.com/DataDog/dd-trace-rb/issues/5424
+[#5425]: https://github.com/DataDog/dd-trace-rb/issues/5425
+[#5427]: https://github.com/DataDog/dd-trace-rb/issues/5427
+[#5432]: https://github.com/DataDog/dd-trace-rb/issues/5432
+[#5434]: https://github.com/DataDog/dd-trace-rb/issues/5434
+[#5435]: https://github.com/DataDog/dd-trace-rb/issues/5435
+[#5436]: https://github.com/DataDog/dd-trace-rb/issues/5436
+[#5448]: https://github.com/DataDog/dd-trace-rb/issues/5448
+[#5449]: https://github.com/DataDog/dd-trace-rb/issues/5449
+[#5461]: https://github.com/DataDog/dd-trace-rb/issues/5461
+[#5469]: https://github.com/DataDog/dd-trace-rb/issues/5469
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -87,6 +87,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;
 #endif
 
 // Contains state for a single CpuAndWallTimeWorker instance
@@ -101,6 +102,7 @@ typedef struct {
   bool gvl_profiling_enabled;
   bool skip_idle_samples_for_testing;
   bool sighandler_sampling_enabled;
+  uint32_t cpu_sampling_interval_ms;
   VALUE self_instance;
   VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
@@ -138,6 +140,8 @@ typedef struct {
     // # Generic stats
     // How many times we tried to trigger a sample
     unsigned int trigger_sample_attempts;
+    // How many times extra sleep was triggered by dynamic sampling rate
+    unsigned int trigger_sample_extra_sleep;
     // How many times we tried to simulate signal delivery
     unsigned int trigger_simulated_signal_delivery_attempts;
     // How many times we actually simulated signal delivery
@@ -229,23 +233,26 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
 static void disable_tracepoints(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 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);
 static VALUE _native_hold_signals(DDTRACE_UNUSED VALUE self);
 static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self);
 #ifndef NO_GVL_INSTRUMENTATION
-static void on_gvl_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *event_data, DDTRACE_UNUSED void *_unused);
-static void after_gvl_running_from_postponed_job(DDTRACE_UNUSED void *_unused);
+  static void on_gvl_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *event_data, DDTRACE_UNUSED void *_unused);
+  static void after_gvl_running_from_postponed_job(DDTRACE_UNUSED void *_unused);
+  static VALUE rescued_after_gvl_running_from_postponed_job(VALUE self_instance);
+  static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception);
 #endif
-static VALUE rescued_after_gvl_running_from_postponed_job(VALUE self_instance);
 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_rescued_sample_allocation(VALUE self_instance, VALUE exception);
-static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception);
+static VALUE handle_sampling_failure_rescued_after_allocation(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);
 
 // 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`.
@@ -293,11 +300,13 @@ 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);
 
     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_gvl_running_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID ||
+      after_allocation_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID
     ) {
       raise_error(rb_eRuntimeError, "Failed to register profiler postponed jobs (got POSTPONED_JOB_HANDLE_INVALID)");
     }
@@ -375,6 +384,7 @@ static VALUE _native_new(VALUE klass) {
   state->gvl_profiling_enabled = false;
   state->skip_idle_samples_for_testing = false;
   state->sighandler_sampling_enabled = false;
+  state->cpu_sampling_interval_ms = 10;
   state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
@@ -419,6 +429,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE gvl_profiling_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("gvl_profiling_enabled")));
   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")));
 
   ENFORCE_BOOLEAN(gc_profiling_enabled);
   ENFORCE_BOOLEAN(no_signals_workaround_enabled);
@@ -429,6 +440,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ENFORCE_BOOLEAN(gvl_profiling_enabled);
   ENFORCE_BOOLEAN(skip_idle_samples_for_testing)
   ENFORCE_BOOLEAN(sighandler_sampling_enabled)
+  ENFORCE_TYPE(cpu_sampling_interval_ms, 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);
@@ -441,6 +453,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   state->gvl_profiling_enabled = (gvl_profiling_enabled == Qtrue);
   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);
 
   double total_overhead_target_percentage = NUM2DBL(dynamic_sampling_rate_overhead_target_percentage);
   if (!state->allocation_profiling_enabled) {
@@ -548,8 +561,9 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   // @ivoanjo: I suspect this will never happen, but the cost of getting it wrong is really high (VM terminates) so this
   // is a just-in-case situation.
   //
-  // Note 2: This can raise exceptions as well, so make sure that all cleanups are done by the time we get here.
-  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal);
+  // Note 2: If exception_state is set, we have a pending exception that we'll re-raise below.
+  // In that case, we don't want replace_sigprof_signal_handler_with_empty_handler to raise another exception.
+  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal, !exception_state);
 
   // Ensure that instance is not garbage collected while the native sampling loop is running; this is probably not needed, but just in case
   RB_GC_GUARD(instance);
@@ -660,7 +674,7 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 static void *run_sampling_trigger_loop(void *state_ptr) {
   cpu_and_wall_time_worker_state *state = (cpu_and_wall_time_worker_state *) state_ptr;
 
-  uint64_t minimum_time_between_signals = MILLIS_AS_NS(10);
+  uint64_t minimum_time_between_signals = MILLIS_AS_NS(state->cpu_sampling_interval_ms);
 
   while (atomic_load(&state->should_run)) {
     state->stats.trigger_sample_attempts++;
@@ -713,7 +727,10 @@ static void *run_sampling_trigger_loop(void *state_ptr) {
     // `dynamic_sampling_rate_get_sleep` may have changed while the above sleep was ongoing.
     uint64_t extra_sleep =
       dynamic_sampling_rate_get_sleep(&state->cpu_dynamic_sampling_rate, monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE));
-    if (state->dynamic_sampling_rate_enabled && extra_sleep > 0) sleep_for(extra_sleep);
+    if (state->dynamic_sampling_rate_enabled && extra_sleep > 0) {
+      state->stats.trigger_sample_extra_sleep++;
+      sleep_for(extra_sleep);
+    }
   }
 
   return NULL; // Unused
@@ -1049,6 +1066,7 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
   VALUE stats_as_hash = rb_hash_new();
   VALUE arguments[] = {
     ID2SYM(rb_intern("trigger_sample_attempts")),                    /* => */ UINT2NUM(state->stats.trigger_sample_attempts),
+    ID2SYM(rb_intern("trigger_sample_extra_sleep")),                 /* => */ UINT2NUM(state->stats.trigger_sample_extra_sleep),
     ID2SYM(rb_intern("trigger_simulated_signal_delivery_attempts")), /* => */ UINT2NUM(state->stats.trigger_simulated_signal_delivery_attempts),
     ID2SYM(rb_intern("simulated_signal_delivery")),                  /* => */ UINT2NUM(state->stats.simulated_signal_delivery),
     ID2SYM(rb_intern("signal_handler_enqueued_sample")),             /* => */ UINT2NUM(state->stats.signal_handler_enqueued_sample),
@@ -1312,13 +1330,21 @@ static VALUE rescued_sample_allocation(DDTRACE_UNUSED VALUE unused) {
   // 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;
-  thread_context_collector_sample_allocation(state->thread_context_collector_instance, weight, new_object);
+  bool needs_after_allocation = thread_context_collector_sample_allocation(state->thread_context_collector_instance, 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) {
+    #ifndef NO_POSTPONED_TRIGGER
+      rb_postponed_job_trigger(after_allocation_from_postponed_job_handle);
+    #else
+      // Not needed on legacy rubies
+    #endif
+  }
+
   // Return a dummy VALUE because we're called from rb_rescue2 which requires it
   return Qnil;
 }
@@ -1449,6 +1475,11 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
 
     return state->gvl_profiling_hook != NULL ? Qtrue : Qfalse;
   }
+
+  static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception) {
+    stop(self_instance, exception, "rescued_after_gvl_running_from_postponed_job");
+    return Qnil;
+  }
 #else
   static VALUE _native_gvl_profiling_hook_active(DDTRACE_UNUSED VALUE self, DDTRACE_UNUSED VALUE instance) {
     return Qfalse;
@@ -1470,11 +1501,50 @@ static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instan
   return Qnil;
 }
 
-static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(VALUE self_instance, VALUE exception) {
-  stop(self_instance, exception, "rescued_after_gvl_running_from_postponed_job");
+static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instance, VALUE exception) {
+  stop(self_instance, exception, "rescued_after_allocation");
+  return Qnil;
+}
+
+static VALUE rescued_after_allocation(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);
+
+  // 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) {
+  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);
+
+  // 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,
+    state->self_instance,
+    state->self_instance,
+    handle_sampling_failure_rescued_after_allocation
+  );
+
+  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.
   //

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -290,11 +290,13 @@ static bool handle_gvl_waiting(
   sampling_buffer* sampling_buffer,
   long current_cpu_time_ns
 );
-static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_on_gvl_running(DDTRACE_UNUSED VALUE self, VALUE thread);
-static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception);
-static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE delta_ns);
+#ifndef NO_GVL_INSTRUMENTATION
+  static VALUE _native_on_gvl_waiting(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_gvl_waiting_at_for(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_on_gvl_running(DDTRACE_UNUSED VALUE self, VALUE thread);
+  static VALUE _native_sample_after_gvl_running(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE allow_exception);
+  static VALUE _native_apply_delta_to_cpu_time_at_previous_sample_ns(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE thread, VALUE delta_ns);
+#endif
 static void otel_without_ddtrace_trace_identifiers_for(
   thread_context_collector_state *state,
   VALUE thread,
@@ -1339,6 +1341,16 @@ VALUE enforce_thread_context_collector_instance(VALUE object) {
   return object;
 }
 
+// Finalize any pending heap allocation recordings.
+// On Ruby 4+, heap allocations are recorded in two phases: during on_newobj_event we capture
+// the object reference, then later we safely call rb_obj_id() to get the object ID.
+void thread_context_collector_after_allocation(VALUE self_instance) {
+  thread_context_collector_state *state;
+  TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
+
+  recorder_after_sample(state->recorder_instance);
+}
+
 // This method exists only to enable testing Datadog::Profiling::Collectors::ThreadContext behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_stats(DDTRACE_UNUSED VALUE _self, VALUE collector_instance) {
@@ -1483,7 +1495,12 @@ bool thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_in
   return prepare_sample_thread(current_thread, &thread_context->sampling_buffer);
 }
 
-void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object) {
+// This method gets called from inside the RUBY_INTERNAL_EVENT_NEWOBJ tracepoint so it should never allocate in the
+// Ruby heap.
+//
+// Returns true if the after_allocation needs to be called (to do work that can't be done from inside the
+// tracepoint, such as allocate new objects), and false if it doesn't
+bool thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object) {
   thread_context_collector_state *state;
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
@@ -1553,7 +1570,7 @@ void thread_context_collector_sample_allocation(VALUE self_instance, unsigned in
     class_name = ruby_vm_type; // For other weird internal things we just use the VM type
   }
 
-  track_object(state->recorder_instance, new_object, sample_weight, class_name);
+  bool needs_after_allocation = track_object(state->recorder_instance, new_object, sample_weight, class_name);
 
   per_thread_context *thread_context = get_or_create_context_for(current_thread, state);
 
@@ -1570,6 +1587,8 @@ void thread_context_collector_sample_allocation(VALUE self_instance, unsigned in
     /* is_gvl_waiting_state: */ false,
     /* is_safe_to_allocate_objects: */ false // Not safe to allocate further inside the NEWOBJ tracepoint
   );
+
+  return needs_after_allocation;
 }
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::ThreadContext behavior using RSpec.
@@ -1577,11 +1596,13 @@ void thread_context_collector_sample_allocation(VALUE self_instance, unsigned in
 static VALUE _native_sample_allocation(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE sample_weight, VALUE new_object) {
   debug_enter_unsafe_context();
 
-  thread_context_collector_sample_allocation(collector_instance, NUM2UINT(sample_weight), new_object);
+  bool needs_after_allocation = thread_context_collector_sample_allocation(collector_instance, NUM2UINT(sample_weight), new_object);
 
   debug_leave_unsafe_context();
 
-  return Qtrue;
+  // We could instead choose to automatically trigger the after allocation here; yet, it seems kinda nice to keep it manual for
+  // the tests so we can pull on each lever separately and observe "the sausage being made" in steps
+  return needs_after_allocation ? Qtrue : Qfalse;
 }
 
 static VALUE new_empty_thread_inner(DDTRACE_UNUSED void *arg) { return Qnil; }
@@ -1799,7 +1820,7 @@ static void otel_without_ddtrace_trace_identifiers_for(
   VALUE otel_current_span_key = get_otel_current_span_key(state, is_safe_to_allocate_objects);
   if (otel_current_span_key == Qnil) return;
 
-  int active_context_index = RARRAY_LEN(context_storage) - 1;
+  long active_context_index = RARRAY_LEN(context_storage) - 1;
   if (active_context_index < 0) return;
 
   otel_span active_span = otel_span_from(rb_ary_entry(context_storage, active_context_index), otel_current_span_key);
@@ -1808,7 +1829,7 @@ static void otel_without_ddtrace_trace_identifiers_for(
   otel_span local_root_span = active_span;
 
   // Now find the oldest span starting from the active span that still has the same trace id as the active span
-  for (int i = active_context_index - 1; i >= 0; i--) {
+  for (long i = active_context_index - 1; i >= 0; i--) {
     otel_span checking_span = otel_span_from(rb_ary_entry(context_storage, i), otel_current_span_key);
     if (checking_span.span == Qnil) return;
 

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -11,13 +11,15 @@ void thread_context_collector_sample(
   VALUE profiler_overhead_stack_thread
 );
 __attribute__((warn_unused_result)) bool thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance);
-void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object);
+__attribute__((warn_unused_result)) bool thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight, VALUE new_object);
+void thread_context_collector_after_allocation(VALUE self_instance);
 void thread_context_collector_sample_skipped_allocation_samples(VALUE self_instance, unsigned int skipped_samples);
 VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
 void thread_context_collector_on_gc_start(VALUE self_instance);
 __attribute__((warn_unused_result)) bool thread_context_collector_on_gc_finish(VALUE self_instance);
 VALUE enforce_thread_context_collector_instance(VALUE object);
 
+
 #ifndef NO_GVL_INSTRUMENTATION
   typedef enum {
     ON_GVL_RUNNING_UNKNOWN, // Thread is not known, it may not even be from the current Ractor

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -82,7 +82,8 @@ append_cflags "-Werror" if ENV["DATADOG_GEM_CI"] == "true"
 # * by upstream Ruby -- search for gnu99 in the codebase
 # * by msgpack, another datadog gem dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
-append_cflags "-std=gnu99"
+# @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
+append_cflags RUBY_PLATFORM.include?('darwin') ? '-std=gnu11' : '-std=gnu99'
 
 # Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 append_cflags "-Wno-unused-function"
@@ -144,6 +145,11 @@ $defs << "-DNO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE" if RUBY_VERSION < "4"
 # 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"
 
+# On Ruby 4, we need to defer calling rb_obj_id during heap allocation recording
+# because it's not safe to mutate objects during the newobj tracepoint
+# (see https://bugs.ruby-lang.org/issues/21710)
+$defs << "-DUSE_DEFERRED_HEAP_ALLOCATION_RECORDING" 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.
@@ -205,37 +211,16 @@ $defs << "-DNO_GVL_OWNER" if RUBY_VERSION < "2.6"
 $defs << "-DNO_THREAD_INVOKE_ARG" if RUBY_VERSION < "2.6"
 
 # If we got here, libdatadog is available and loaded
-ENV["PKG_CONFIG_PATH"] = "#{ENV["PKG_CONFIG_PATH"]}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV["PKG_CONFIG_PATH"].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config("datadog_profiling_with_rpath")
-  Logging.message("[datadog] Ruby detected the pkg-config command is #{$PKGCONFIG.inspect}\n")
-
-  skip_building_extension!(
-    if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
-      Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
-    else
-      # Less specific error message
-      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG
-    end
-  )
+unless Datadog::LibdatadogExtconfHelpers.configure_libdatadog(extconf_folder: __dir__)
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG)
 end
 
 unless have_type("atomic_int", ["stdatomic.h"])
   skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
 end
 
-# See comments on the helper methods being used for why we need to additionally set this.
-# The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
-# experimentation. We need to get these special characters across a lot of tools untouched...
-extra_relative_rpaths = [
-  Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_native_lib_folder(current_folder: __dir__),
-  *Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
-]
-extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
-Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
-
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.