datadog 2.28.0 → 2.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ec2ddb3720f61843ee7526cd4e3493a646ab7afaf3d6e4cce71019d1dfd582
-  data.tar.gz: d0996f8b1eb568aea751a1e781fa4d9dcc7e1d436911fd579c7aa43947340f32
+  metadata.gz: 6f762ad624ddb0a21d753a524132de0f59e617e63f723fabc6c305949a77554d
+  data.tar.gz: 217159cbaea1102ba47a97deb73927919d8152264701322719aad722391d75aa
 SHA512:
-  metadata.gz: fb8da926cd9a09a500c781f60ad5fb35c72c9b3162acc067229f88d01281c63c6753c4230a2cf56f803fb0174994707b159e31f5d584e6682313a13e2187b61e
-  data.tar.gz: 8c93304f737b5798af5d6ed520f7006d7aa2e7644243fbfcd38994d66dde0aefb53084bca96024e61a7cbebcb72e60f958715fe4864c1e7fe90733103f9cb527
+  metadata.gz: 711466d29940c6b22b5964744e7d1b6dbf5a002ca5992dbc01d61718f16cc66b33dcc7bee2604c4c2ba64a9efb8014114d015d44a109e1b5f55b1375d36c927a
+  data.tar.gz: 1490e2ab41fdf0c7ce673bbb7eaa1ccc28073cd757576a30734ce3674bef89fd58aa2876b2e9d2e26e12119e45b1d90f787e260d86cfc6e1fa5055bf14ba16b0

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [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 +3514,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.28.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.29.0...master
+[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 +5182,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
@@ -5166,6 +5196,20 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5273]: https://github.com/DataDog/dd-trace-rb/issues/5273
 [#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
+[#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
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5320,4 +5364,4 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@y-yagi]: https://github.com/y-yagi
 [@yujideveloper]: https://github.com/yujideveloper
 [@yukimurasawa]: https://github.com/yukimurasawa
-[@zachmccormick]: https://github.com/zachmccormick
+[@zachmccormick]: https://github.com/zachmccormick

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
@@ -138,6 +139,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,6 +232,7 @@ 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);
@@ -243,9 +247,11 @@ static VALUE _native_gvl_profiling_hook_active(DDTRACE_UNUSED VALUE self, VALUE
 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_allocation(VALUE self_instance, VALUE exception);
 static VALUE handle_sampling_failure_rescued_after_gvl_running_from_postponed_job(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 +299,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)");
     }
@@ -713,7 +721,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 +1060,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 +1324,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;
 }
@@ -1470,11 +1490,52 @@ static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instan
   return Qnil;
 }
 
+static VALUE handle_sampling_failure_rescued_after_allocation(VALUE self_instance, VALUE exception) {
+  stop(self_instance, exception, "rescued_after_allocation");
+  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");
   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.
+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);
+}
+
 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

@@ -1339,6 +1339,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 +1493,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 +1568,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 +1585,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 +1594,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; }

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

@@ -144,6 +144,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.