datadog 2.42.0 → 2.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfc982d67dbb768eb43d510dd6322ee484bc0a0fdacf20deb40196aa13821e51
-  data.tar.gz: be416fd9f34cbdf7ead90fa03d273f1739e90008cb82b6a0d22d5f62f17e1660
+  metadata.gz: c60f4ef57b9508827fac3387bd07b4233666ed9d22684c0d063187d05dcfc449
+  data.tar.gz: 6e795bd6f5fc8b5f59d040a4da62e636a15d12024ff4e6b5c2b10d0989c047ec
 SHA512:
-  metadata.gz: 80d39181feb3e02e4f022d06f0c6bab26e993f48521c2fb5e526d3b81a5b4a68e7069d92af90638700f2e0a0af24efbd0df63de311c7561cb02c1270d63cbaaa
-  data.tar.gz: 44932c7f87c3a52e1790b44ae2c4f13ae63006360a0846c240ec0b6ac3ffe4b1c98ff33426b19f27f51ce5105770ab263870601ebe5b33788381debd85a04b37
+  metadata.gz: 27f955e40d920907b2af84f36f8671f4e306235dce525be84da5221e2c66b852183974095afbbcc4acff4148e9202f585067e676d897b20da08c41e535846e9c
+  data.tar.gz: 29f4f51331feb1e0a6e70437490b8067b9e4a6f561b55c7f1b5fff58ae326964d92cf8e2dcf16c31466b5f654b851a25e8b683322795573e5ee3742fb395f519

data/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [2.44.0] - 2026-10-07
+
+### Added
+
+* AI Guard: Add sensitive-data redaction to evaluated messages, enabled by default; configure it with `ai_guard.redaction_enabled` or `DD_AI_GUARD_REDACTION_ENABLED`. ([#6394][])
+* Open Feature: Add agentless Feature Flags configuration delivery and settings for selecting agentless, Remote Configuration, or offline delivery. ([#6291][])
+
+### Changed
+
+* AI Guard: Require `ruby_llm` 2.0 or later for the `RubyLLM` integration. ([#6394][])
+* Dynamic Instrumentation: Condition evaluation error snapshots are now subject to the process-wide Dynamic Instrumentation snapshot rate limit in addition to the per-probe limit. ([#6250][])
+* OpenTelemetry: Emit `deployment.environment.name` instead of `deployment.environment` for Logs and Metrics resources, and accept it as the Datadog environment while retaining `deployment.environment` as a fallback. ([#6261][])
+
+### Fixed
+
+* Core: Fix native extension build failures when installing gems in a directory whose path contains spaces. ([#6371][])
+* Core: Fix Remote Configuration polling remaining stopped in forked web workers when application warmup started it before the fork. ([#6427][])
+* Tracing: Fix the `grape` integration creating no `grape.endpoint_run` span on Grape 4, which moved the API class, HTTP verb and route path off `Grape::Endpoint#options`. ([#6354][]) ([@dduugg][])
+* Tracing: Fix an empty `http.route` tag on spans for 405 responses when running `grape` versions 2.3 through 3.0. ([#6358][])
+* Profiling: Fix the profiler stopping with `BUG: Unexpected CPU time going backwards between samples`. ([#6364][])
+* Profiling: Fix a sampling race condition during profiler shutdown. ([#6375][])
+* Profiling: Fix a potential crash during garbage collection compaction when profiling is enabled. ([#6395][])
+* Profiling: Stop profiling if `thread_name_for`/`rb_thread_t` changes. ([#6398][])
+* Profiling: Fix native extension build breaking when trying to log %. ([#6407][])
+* Dynamic Instrumentation: Fix methods disappearing from code search and source lookup when method logpoints are already installed. ([#6339][])
+* Dynamic Instrumentation: Fix missing condition evaluation error snapshots for method probes with a `when` condition; errors raised while evaluating the condition are now reported to the backend. ([#6250][])
+
+## [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
@@ -3776,7 +3820,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.42.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.44.0...master
+[2.44.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...v2.44.0
+[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
@@ -5610,6 +5656,24 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#6250]: https://github.com/DataDog/dd-trace-rb/issues/6250
+[#6261]: https://github.com/DataDog/dd-trace-rb/issues/6261
+[#6286]: https://github.com/DataDog/dd-trace-rb/issues/6286
+[#6291]: https://github.com/DataDog/dd-trace-rb/issues/6291
+[#6316]: https://github.com/DataDog/dd-trace-rb/issues/6316
+[#6320]: https://github.com/DataDog/dd-trace-rb/issues/6320
+[#6339]: https://github.com/DataDog/dd-trace-rb/issues/6339
+[#6350]: https://github.com/DataDog/dd-trace-rb/issues/6350
+[#6354]: https://github.com/DataDog/dd-trace-rb/issues/6354
+[#6358]: https://github.com/DataDog/dd-trace-rb/issues/6358
+[#6364]: https://github.com/DataDog/dd-trace-rb/issues/6364
+[#6371]: https://github.com/DataDog/dd-trace-rb/issues/6371
+[#6375]: https://github.com/DataDog/dd-trace-rb/issues/6375
+[#6394]: https://github.com/DataDog/dd-trace-rb/issues/6394
+[#6395]: https://github.com/DataDog/dd-trace-rb/issues/6395
+[#6398]: https://github.com/DataDog/dd-trace-rb/issues/6398
+[#6407]: https://github.com/DataDog/dd-trace-rb/issues/6407
+[#6427]: https://github.com/DataDog/dd-trace-rb/issues/6427
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5662,6 +5726,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@cwoodcox]: https://github.com/cwoodcox
 [@danhodge]: https://github.com/danhodge
 [@dasch]: https://github.com/dasch
+[@dduugg]: https://github.com/dduugg
 [@dim]: https://github.com/dim
 [@dirk]: https://github.com/dirk
 [@djmb]: https://github.com/djmb
@@ -5765,4 +5830,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/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/collectors_cpu_and_wall_time_worker.c

@@ -228,6 +228,7 @@ static VALUE _native_new(VALUE klass);
 static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr);
 static VALUE _native_sampling_loop(VALUE self, VALUE instance);
+static VALUE _native_profiler_internal_thread_done(VALUE self_instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE worker_thread);
 static VALUE stop(VALUE self_instance, VALUE optional_exception, const char *optional_exception_during_operation);
 static void stop_state(cpu_and_wall_time_worker_state *state, VALUE optional_exception, const char *optional_operation_name);
@@ -289,6 +290,7 @@ static VALUE handle_sampling_failure_rescued_sample_allocation(VALUE self_instan
 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 VALUE during_sample_exit_rescue(VALUE state_ptr);
 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
@@ -380,6 +382,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
 
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, -1);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_sampling_loop", _native_sampling_loop, 1);
+  rb_define_method(collectors_cpu_and_wall_time_worker_class, "_native_profiler_internal_thread_done", _native_profiler_internal_thread_done, 0);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stop", _native_stop, 2);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stats", _native_stats, 1);
@@ -650,6 +653,17 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   return Qnil;
 }
 
+static VALUE _native_profiler_internal_thread_done(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);
+
+  during_sample_enter(state);
+  return rb_ensure(
+    thread_context_collector_profiler_internal_thread_done, state->thread_context_collector_instance,
+    during_sample_exit_rescue, (VALUE) state
+  );
+}
+
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE worker_thread) {
   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);
@@ -740,6 +754,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++;
 
@@ -749,11 +765,20 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
     !state->during_sample;
 
   if (sample_from_signal_handler) {
-    // Buffer current stack trace. Note that this will not actually record the sample, for that we still need to wait
-    // until the postponed job below gets run.
-    bool prepared = thread_context_collector_prepare_sample_inside_signal_handler();
+    if (rb_during_gc()) {
+      // During GC Ruby might be marking our buffer or compacting (moving) where iseqs live so we skip preparing the
+      // sample immediately, and instead ask on_gc_finish to do the job when GC is at its end.
+      //
+      // When GC profiling is disabled, we just fall back to sampling the stack after GC finishes, e.g. it's the
+      // equivalent of disabling `sample_from_signal_handler` for samples that happen during GC.
+      thread_context_collector_request_prepare_on_gc_finish();
+    } else {
+      // Buffer current stack trace. Note that this will not actually record the sample, for that we still need to wait
+      // until the postponed job below gets run.
+      bool prepared = thread_context_collector_prepare_sample_inside_signal_handler();
 
-    if (prepared) state->stats.signal_handler_prepared_sample++;
+      if (prepared) state->stats.signal_handler_prepared_sample++;
+    }
   }
 
   #ifndef NO_POSTPONED_TRIGGER // Ruby 3.3+
@@ -1094,7 +1119,10 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
   if (event == RUBY_INTERNAL_EVENT_GC_ENTER) {
     thread_context_collector_on_gc_start(state->thread_context_collector_instance);
   } else if (event == RUBY_INTERNAL_EVENT_GC_EXIT) {
-    bool should_flush = thread_context_collector_on_gc_finish(state->thread_context_collector_instance);
+    bool allow_prepare_sample = !state->during_sample;
+    if (allow_prepare_sample) during_sample_enter(state);
+    bool should_flush = thread_context_collector_on_gc_finish(state->thread_context_collector_instance, allow_prepare_sample);
+    if (allow_prepare_sample) during_sample_exit(state);
 
     // We use rb_postponed_job_register_one to ask Ruby to run thread_context_collector_sample_after_gc when the
     // thread collector flags it's time to flush.
@@ -1279,11 +1307,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
 }
 
@@ -1765,3 +1801,8 @@ static inline void during_sample_exit(cpu_and_wall_time_worker_state* state) {
   atomic_signal_fence(memory_order_seq_cst);
   state->during_sample = false;
 }
+
+static VALUE during_sample_exit_rescue(VALUE state_ptr) {
+  during_sample_exit((cpu_and_wall_time_worker_state *) state_ptr);
+  return Qnil;
+}

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -31,9 +31,9 @@ typedef struct {
 
 static VALUE _native_new(VALUE klass);
 static void reset_state(idle_sampling_loop_state *state);
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance);
 static VALUE idle_sampling_loop_body(VALUE self_instance);
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance);
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static void *run_idle_sampling_loop(void *state_ptr);
 static void interrupt_idle_sampling_loop(void *state_ptr);
@@ -112,8 +112,8 @@ static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance) {
-  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance) {
+  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, cpu_and_wall_time_worker_instance);
 }
 
 static VALUE idle_sampling_loop_body(VALUE self_instance) {
@@ -128,9 +128,8 @@ static VALUE idle_sampling_loop_body(VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance) {
-  thread_context_collector_profiler_internal_thread_done(thread_context_collector_instance);
-  return Qnil;
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance) {
+  return rb_funcall(cpu_and_wall_time_worker_instance, rb_intern("_native_profiler_internal_thread_done"), 0);
 }
 
 static void *run_idle_sampling_loop(void *state_ptr) {

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -642,8 +642,8 @@ void record_placeholder_stack(
 }
 
 bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
-  // Since this can get called from inside a signal handler, we don't want to touch the buffer if
-  // the thread was actually in the middle of marking it.
+  // While the signal handler checks if there's GC going on, it's actually possible for `sampling_buffer_mark` to
+  // still run outside of GC (see comments on that function) and thus we guard for it here.
   if (buffer->is_marking) return false;
 
   buffer->pending_sample = true;
@@ -705,12 +705,11 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
   }
 
   buffer->is_marking = true;
-  // Tell the compiler it's not allowed to reorder the `is_marking` flag with the iteration below.
-  //
-  // Specifically, in the middle of `sampling_buffer_mark` a signal handler may execute and call
-  // `prepare_sample_thread` to add a new sample to the buffer. This flag is here to prevent that BUT we need to
-  // make sure the signal handler actually sees the flag being set.
+  // The sampling buffer isn't supposed to be touched during GC. Yet, marking can happen outside of GC -- in particular
+  // ObjectSpace.dump/dump_all and reachable_objects_from invoke mark callbacks outside GC to enumerate references.
+  // Thus we keep this flag to tell the signal handler "hey you're still not allowed to touch the buffer at this time".
   //
+  // The fences ensure the compiler doesn't reorder the flags and a signal handler observes them
   // See https://github.com/ruby/ruby/pull/11036 for a similar change made to the Ruby VM with more context.
   atomic_signal_fence(memory_order_seq_cst);
 

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -13,7 +13,7 @@ typedef struct {
   uint16_t max_frames;
   frame_info *stack_buffer;
   bool pending_sample;
-  bool is_marking; // Used to avoid recording a sample when marking
+  bool is_marking; // Used to avoid recording a sample when marking (marking can happen outside of GC as well)
   int pending_sample_result;
 } sampling_buffer;