datadog 2.38.0 → 2.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a10640edadba480a4014cb7861ed0eaa21dac0718709266f59fc1307b8fa64bd
-  data.tar.gz: cb0b0bcc5423c0e0398277c3535ea52b485967879cf0ede20eedcfb513f1389f
+  metadata.gz: 4894d3cc2404bab418412c2a96b2f15c2337f6e31dc567c6fd8d1ceafd372230
+  data.tar.gz: e31bdb882385e48f731b925496b75964a02e17c4eb9c7b4a858083740009954c
 SHA512:
-  metadata.gz: c77d4b07287c8ee87feb82d541269faa5213861509b99d9e66948022f8c98c005d5b8a8205a263d1d020b8fe8b12306e89fff032d1076f652232133db5c985f2
-  data.tar.gz: 5799211f54f368537792d441af52dbd41403da2699f2c503d56b46a533df4b9bef6ef9abf56476f330067c8c555db79a3b1163090cc2267199d937576d210e98
+  metadata.gz: 488fc94df9bda0fd8485f42934a08660a342617602e61a0fb999cb337239f98f226fc51e021df954ab74af985a6abfa38cc0b17069c00b0541c5100e8c961810
+  data.tar.gz: '0197b5995f7861ddae8677caa96d419c89e2b25bb702d3c05e99e594562771c2c3193d8e9cc367bde5ebbd3fbd78362f55ea25fb1c071442b01d37a22c8d631e'

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [2.40.0] - 2026-08-04
+
+### Added
+
+* Profiling: Add experimental profiling setting to show class/module names in stack frames. Fix crash in `rb_iseq_path()` caused by incorrect GC marking. ([#6024][])
+* Tracing: Add an experimental native (`libdatadog`-backed) trace transport, selectable via `tracing.native_transport` ([#5971][])
+
+### Changed
+
+* Core: Deprecate `time_now_provider` setting for removal; it no longer does anything. Please remove it from your `Datadog.configure block`. The datadog gem always uses the real non-mocked time, even when the timecop gem monkey-patches `Time` ([#6010][])
+
+### Fixed
+
+* AppSec: Fix standalone billing issues for partially flushed traces ([#6116][])
+* Dynamic Instrumentation: Limit dynamic instrumentation regular expression evaluation time to 500ms ([#5908][])
+* Profiling: Fix missing native filename for static Ruby binaries ([#6097][])
+* Tracing: Fix missing or zero Kafka producer and connection span tags like `kafka.message_count` and `kafka.request_size` in the `ruby-kafka` integration. ([#6104][])
+
+## [2.39.0] - 2026-07-22
+
+### Added
+
+* Tracing: Integrations: Add database name and host to Sequel spans and infer `peer.service` so datastore dependencies appear in the service map. ([#6072][])
+
+### Fixed
+
+* AppSec: Fix error in `devise` contrib for non-standard Warden session serialization. ([#6064][])
+* Dynamic Instrumentation: Fix dynamic instrumentation line probes failing to install when dynamic instrumentation is enabled remotely after application startup. ([#6050][])
+* Profiling: Fix crash when trying to sample during GC compaction ([#6056][])
+* Tracing: Integrations: Fix an `ArgumentError` (and the resulting `Kafka::BufferOverflow`) raised by the Kafka producer integration on Ruby 2.5 and 2.6. ([#6060][])
+
 ## [2.38.0] - 2026-07-16
 
 ### Added
@@ -3703,7 +3734,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.38.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.40.0...master
+[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
 [2.38.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.37.0...v2.38.0
 [2.37.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.36.0...v2.37.0
 [2.36.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.35.0...v2.36.0
@@ -5482,6 +5515,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5890]: https://github.com/DataDog/dd-trace-rb/issues/5890
 [#5894]: https://github.com/DataDog/dd-trace-rb/issues/5894
 [#5907]: https://github.com/DataDog/dd-trace-rb/issues/5907
+[#5908]: https://github.com/DataDog/dd-trace-rb/issues/5908
 [#5911]: https://github.com/DataDog/dd-trace-rb/issues/5911
 [#5916]: https://github.com/DataDog/dd-trace-rb/issues/5916
 [#5920]: https://github.com/DataDog/dd-trace-rb/issues/5920
@@ -5492,6 +5526,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5955]: https://github.com/DataDog/dd-trace-rb/issues/5955
 [#5960]: https://github.com/DataDog/dd-trace-rb/issues/5960
 [#5970]: https://github.com/DataDog/dd-trace-rb/issues/5970
+[#5971]: https://github.com/DataDog/dd-trace-rb/issues/5971
 [#5973]: https://github.com/DataDog/dd-trace-rb/issues/5973
 [#5975]: https://github.com/DataDog/dd-trace-rb/issues/5975
 [#5981]: https://github.com/DataDog/dd-trace-rb/issues/5981
@@ -5499,11 +5534,21 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5990]: https://github.com/DataDog/dd-trace-rb/issues/5990
 [#5991]: https://github.com/DataDog/dd-trace-rb/issues/5991
 [#5993]: https://github.com/DataDog/dd-trace-rb/issues/5993
+[#6010]: https://github.com/DataDog/dd-trace-rb/issues/6010
 [#6014]: https://github.com/DataDog/dd-trace-rb/issues/6014
 [#6020]: https://github.com/DataDog/dd-trace-rb/issues/6020
 [#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
 [#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
+[#6060]: https://github.com/DataDog/dd-trace-rb/issues/6060
+[#6064]: https://github.com/DataDog/dd-trace-rb/issues/6064
+[#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
+[#6116]: https://github.com/DataDog/dd-trace-rb/issues/6116
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/bin/ddprofrb

@@ -1,13 +1,13 @@
 #!/usr/bin/env ruby
-require 'datadog/profiling/tasks/exec'
-require 'datadog/profiling/tasks/help'
+require "datadog/profiling/tasks/exec"
+require "datadog/profiling/tasks/help"
 
 command = ARGV.shift
 
 case command
-when 'exec'
+when "exec"
   Datadog::Profiling::Tasks::Exec.new(ARGV).run
-when 'help', '--help'
+when "help", "--help"
   Datadog::Profiling::Tasks::Help.new.run
 else
   puts "Command '#{command}' is not valid for ddprofrb."

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -220,6 +220,7 @@ static VALUE _native_failure_exception_during_operation(DDTRACE_UNUSED VALUE sel
 static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 static VALUE _native_install_testing_signal_handler(DDTRACE_UNUSED VALUE self);
 static VALUE _native_remove_testing_signal_handler(DDTRACE_UNUSED VALUE self);
+static VALUE _native_install_sigprof_handler_on_altstack(DDTRACE_UNUSED VALUE self);
 static VALUE _native_trigger_sample(DDTRACE_UNUSED VALUE self);
 static VALUE _native_gc_tracepoint(DDTRACE_UNUSED VALUE self, VALUE instance);
 static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused);
@@ -292,6 +293,15 @@ static VALUE active_sampler_instance = Qnil;
 static cpu_and_wall_time_worker_state *active_sampler_instance_state = NULL;
 static VALUE clock_failure_exception_class = Qnil;
 
+// Stats that live outside of any particular `cpu_and_wall_time_worker_state`, so that they can always be safely
+// touched, even when we're not sure it's safe to touch the state (e.g. signal handler, no GVL, etc).
+typedef struct {
+  // How many times we skipped sampling because we were running on the alternate  signal stack (e.g. nested inside
+  // another signal handler, presumably GC compaction).
+  unsigned int signal_handler_skipped_sample_on_altstack;
+} global_stats_t;
+static global_stats_t global_stats;
+
 // See handle_sampling_signal for details on what this does
 #ifdef NO_POSTPONED_TRIGGER
   static void *gc_finalize_deferred_workaround;
@@ -357,6 +367,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_resume_signals", _native_resume_signals, 0);
   rb_define_singleton_method(testing_module, "_native_install_testing_signal_handler", _native_install_testing_signal_handler, 0);
   rb_define_singleton_method(testing_module, "_native_remove_testing_signal_handler", _native_remove_testing_signal_handler, 0);
+  rb_define_singleton_method(testing_module, "_native_install_sigprof_handler_on_altstack", _native_install_sigprof_handler_on_altstack, 0);
   rb_define_singleton_method(testing_module, "_native_trigger_sample", _native_trigger_sample, 0);
   rb_define_singleton_method(testing_module, "_native_gc_tracepoint", _native_gc_tracepoint, 1);
   rb_define_singleton_method(testing_module, "_native_simulate_handle_sampling_signal", _native_simulate_handle_sampling_signal, 0);
@@ -638,10 +649,50 @@ static VALUE stop(VALUE self_instance, VALUE optional_exception, const char *opt
   return Qtrue;
 }
 
+// Our SIGPROF handler is not installed with SA_ONSTACK (see `install_sigprof_signal_handler`).
+// If we detect our signal handler is running on the alt stack, it means we interrupted another signal handler
+// that IS running on the alt stack -- in practice, Ruby's GC compaction read-barrier handler.
+#ifdef __APPLE__
+  // On macOS, `ucontext->uc_stack.ss_sp` reports the (live) stack pointer near the top of the alt stack rather than the
+  // alt-stack base like Linux does, and `ss_size` is the full alt-stack size. Thus the linux version of the check
+  // didn't work for macOS.
+  // As an alternative, we query `sigaltstack()`; we save/restore errno since `sigaltstack()` may clobber it.
+  static bool is_running_on_alternate_signal_stack(DDTRACE_UNUSED void *ucontext) {
+    int old_errno = errno;
+    stack_t current_alt_stack;
+    bool on_alt_stack = sigaltstack(NULL, &current_alt_stack) == 0 && (current_alt_stack.ss_flags & SS_ONSTACK) != 0;
+    errno = old_errno;
+    return on_alt_stack;
+  }
+#else
+  // NOTE: On Linux we use the alt-stack bounds from the `ucontext` rather than `sigaltstack()`, allowing us to avoid one syscall.
+  static bool is_running_on_alternate_signal_stack(void *ucontext) {
+    if (ucontext == NULL) return false;
+
+    stack_t alt_stack = ((ucontext_t *) ucontext)->uc_stack;
+    if (alt_stack.ss_size == 0) return false; // No alternate signal stack registered on this thread
+
+    char stack_local;
+    uintptr_t current_sp = (uintptr_t) &stack_local;
+    uintptr_t alt_stack_start = (uintptr_t) alt_stack.ss_sp;
+
+    return current_sp >= alt_stack_start && current_sp < alt_stack_start + alt_stack.ss_size;
+  }
+#endif
+
 // NOTE: Remember that this will run in the thread and within the scope of user code, including user C code.
 // We need to be careful not to change any state that may be observed OR to restore it if we do. For instance, if anything
 // we do here can set `errno`, then we must be careful to restore the old `errno` after the fact.
-static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
+static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, void *ucontext) {
+  // If we're running on the alternate signal stack, we've interrupted another signal handler that's running
+  // there -- in practice, Ruby's GC compaction read-barrier handler.
+  // During GC compaction, Ruby protects pages containing Ruby objects, so many of the checks we do below are unsafe
+  // since they can touch those pages, and thus we just bail out here in this situation to avoid crashes.
+  if (is_running_on_alternate_signal_stack(ucontext)) {
+    global_stats.signal_handler_skipped_sample_on_altstack++;
+    return;
+  }
+
   // We must first check that we landed on the correct thread and can proceed.
   // We must never touch the state before we confirm that we have landed on the thread that is holding the GVL on the main
   // ractor as otherwise we may be concurrent with the profiler shutting down and removing its state.
@@ -940,6 +991,28 @@ static VALUE _native_remove_testing_signal_handler(DDTRACE_UNUSED VALUE self) {
   return Qtrue;
 }
 
+// Reproduces a profiler sample being taken in the middle of GC compaction: during compaction a SIGPROF can be
+// delivered while nested inside Ruby's read-barrier signal handler, which runs on the alternate signal stack. We
+// simulate that here by re-installing the production `handle_sampling_signal` with the `SA_ONSTACK` flag, so it runs
+// on the alternate signal stack just like it would in that scenario.
+//
+// The `SA_ONSTACK` will be undone by any next `replace_sigprof_signal_handler_with_empty_handler` /
+// `install_sigprof_signal_handler_internal` / `remove_sigprof_signal_handle` so this doesn't need a specific, symmetric
+// `uninstall` to undo this.
+static VALUE _native_install_sigprof_handler_on_altstack(DDTRACE_UNUSED VALUE self) {
+  struct sigaction signal_handler_config = {
+    .sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK,
+    .sa_sigaction = handle_sampling_signal,
+  };
+  sigemptyset(&signal_handler_config.sa_mask);
+
+  if (sigaction(SIGPROF, &signal_handler_config, NULL) != 0) {
+    rb_sys_fail("Failed to install SA_ONSTACK SIGPROF signal handler for testing");
+  }
+
+  return Qtrue;
+}
+
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_trigger_sample(DDTRACE_UNUSED VALUE self) {
@@ -1109,6 +1182,7 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
     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),
     ID2SYM(rb_intern("signal_handler_prepared_sample")),             /* => */ UINT2NUM(state->stats.signal_handler_prepared_sample),
+    ID2SYM(rb_intern("signal_handler_skipped_sample_on_altstack")),  /* => */ UINT2NUM(global_stats.signal_handler_skipped_sample_on_altstack),
     ID2SYM(rb_intern("interrupt_thread_attempts")),                  /* => */ UINT2NUM(state->stats.interrupt_thread_attempts),
 
     // CPU Stats
@@ -1178,6 +1252,7 @@ static void reset_stats_not_thread_safe(cpu_and_wall_time_worker_state *state) {
   //       * Included in the following stats window (writes after stats retrieval and reset).
   //       Given the expected infrequency of resetting (~once per 60s profile) and the auxiliary/non-critical nature of these stats
   //       this momentary loss of accuracy is deemed acceptable to keep overhead to a minimum.
+
   state->stats = (struct stats) {
     // All these values are initialized to their highest value possible since we always take the min between existing and latest sample
     .cpu_sampling_time_ns_min        = UINT64_MAX,
@@ -1185,6 +1260,7 @@ static void reset_stats_not_thread_safe(cpu_and_wall_time_worker_state *state) {
     .gvl_sampling_time_ns_min        = UINT64_MAX,
     // Other fields are reset to 0
   };
+  global_stats = (global_stats_t) {0};
 }
 
 static void sleep_for(uint64_t time_ns) {