datadog 2.18.0 → 2.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a05fd61c1cac65f510b1e6d180ce2bc0552d63218f4fb837284ab9e509b071cb
-  data.tar.gz: 29b4e928bb96d57d3fa4820e91ec030ea21973868cfdb906ebce5304c0955f22
+  metadata.gz: 9c533682b9a96989e1ad8d4eb96339af4bffdb5fd9cbfe447bd0a034bc387c03
+  data.tar.gz: 5d7808aa6b7fd5f9c68e453fef4fff8c5345c62fb26a7f7839d630ec0da2fe9f
 SHA512:
-  metadata.gz: 9590ee74f91ecf5cf304627790069b6347f63ae050acfc6d79ad29d9155b5e8dde3243a47049eed5c023ad2b1dd6dc78ff4a0813d16d942d83df2db981b5511c
-  data.tar.gz: 22892adf3a7520629a4907738aa31125f00a97cdf263fb2edc85568f86096031de8038e78b6933e3a859d0f52aff3b67955e00109bbdc18a2e7e2d3f66602497
+  metadata.gz: 6b35d7ef1ce2f9e565727037f9e5b329d019202ff20c01a15bb5096cf14253b3ab9812d4fc84fc23e265ec2e7e0096e34acc6a845ad510b215ef7df4093107e7
+  data.tar.gz: 72fff247b51de201e4373638627fa419a3a679979f880dfa44c73d1c9a7c062991746045d41cbe5fa47d824b025fb9cad2f34c0139e034df1b85ddb4a07bccd9

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [2.19.0] - 2025-07-24
+
+### Added
+
+* AppSec: Added Business Logic Events SDK v2. ([#4802][])
+* Tracing: Add `record_exception` API to capture and attach error information to spans via span events. ([#4771][])
+* Tracing: Add `:cache_store` option to ActiveSupport integration to allow tracing only specified cache backends. ([#4693][])
+* SSI: Rework SSI from the ground up. ([#4366][])
+
+### Changed
+
+* Profiling: Switch profiler stack truncation strategy and improve sampling performance ([#4819][])
+* Profiling: Report GC tuning environment variables with profiles ([#4813][])
+* Profiling: Tag profiles with sequence number ([#4794][])
+* Profiling: Enable sample from inside signal handler by default on modern Rubies ([#4786][], [#4785][])
+
+### Fixed
+
+* Core: Fix emitting duplicate warnings on agent configuration mismatch ([#4814][])
+* Appsec: Fix an error in AppSec route extractor for not-found routes in Rails 8 ([#4793][])
+* Profiling: Add workaround for Ruby VM bug ([#4787][])
+* Profiling: Fix checking for dladdr in profiling ([#4783][])
+* Profiling: Fix potential profiler compilation issue. ([#4783][])
+* Tracing: The mysql integration now only sets the `db.name` tag if there is a valid value ([#4776][])
+* Tracing: The Rails Runner instrumentation should now create Rails Runner spans. ([#4681][])
+* Tracing: Fix sampling rules and sample rate reporting in environment logger. ([#4772][])
+
+### Removed
+
 ## [2.18.0] - 2025-07-03
 
 ### Added
@@ -3268,7 +3297,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.18.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.19.0...master
+[2.19.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.18.0...v2.19.0
 [2.18.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.17.0...v2.18.0
 [2.17.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.16.0...v2.17.0
 [2.16.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.15.0...v2.16.0
@@ -4770,6 +4800,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4353]: https://github.com/DataDog/dd-trace-rb/issues/4353
 [#4360]: https://github.com/DataDog/dd-trace-rb/issues/4360
 [#4363]: https://github.com/DataDog/dd-trace-rb/issues/4363
+[#4366]: https://github.com/DataDog/dd-trace-rb/issues/4366
 [#4391]: https://github.com/DataDog/dd-trace-rb/issues/4391
 [#4398]: https://github.com/DataDog/dd-trace-rb/issues/4398
 [#4399]: https://github.com/DataDog/dd-trace-rb/issues/4399
@@ -4827,7 +4858,9 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4673]: https://github.com/DataDog/dd-trace-rb/issues/4673
 [#4678]: https://github.com/DataDog/dd-trace-rb/issues/4678
 [#4679]: https://github.com/DataDog/dd-trace-rb/issues/4679
+[#4681]: https://github.com/DataDog/dd-trace-rb/issues/4681
 [#4688]: https://github.com/DataDog/dd-trace-rb/issues/4688
+[#4693]: https://github.com/DataDog/dd-trace-rb/issues/4693
 [#4697]: https://github.com/DataDog/dd-trace-rb/issues/4697
 [#4699]: https://github.com/DataDog/dd-trace-rb/issues/4699
 [#4718]: https://github.com/DataDog/dd-trace-rb/issues/4718
@@ -4838,6 +4871,19 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4745]: https://github.com/DataDog/dd-trace-rb/issues/4745
 [#4756]: https://github.com/DataDog/dd-trace-rb/issues/4756
 [#4757]: https://github.com/DataDog/dd-trace-rb/issues/4757
+[#4771]: https://github.com/DataDog/dd-trace-rb/issues/4771
+[#4772]: https://github.com/DataDog/dd-trace-rb/issues/4772
+[#4776]: https://github.com/DataDog/dd-trace-rb/issues/4776
+[#4783]: https://github.com/DataDog/dd-trace-rb/issues/4783
+[#4785]: https://github.com/DataDog/dd-trace-rb/issues/4785
+[#4786]: https://github.com/DataDog/dd-trace-rb/issues/4786
+[#4787]: https://github.com/DataDog/dd-trace-rb/issues/4787
+[#4793]: https://github.com/DataDog/dd-trace-rb/issues/4793
+[#4794]: https://github.com/DataDog/dd-trace-rb/issues/4794
+[#4802]: https://github.com/DataDog/dd-trace-rb/issues/4802
+[#4813]: https://github.com/DataDog/dd-trace-rb/issues/4813
+[#4814]: https://github.com/DataDog/dd-trace-rb/issues/4814
+[#4819]: https://github.com/DataDog/dd-trace-rb/issues/4819
 [@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

@@ -102,6 +102,7 @@ typedef struct {
   bool allocation_counting_enabled;
   bool gvl_profiling_enabled;
   bool skip_idle_samples_for_testing;
+  bool sighandler_sampling_enabled;
   VALUE self_instance;
   VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
@@ -142,8 +143,10 @@ typedef struct {
     unsigned int trigger_simulated_signal_delivery_attempts;
     // How many times we actually simulated signal delivery
     unsigned int simulated_signal_delivery;
-    // How many times we actually called rb_postponed_job_register_one from a signal handler
+    // How many times we actually called rb_postponed_job_register_one from the signal handler
     unsigned int signal_handler_enqueued_sample;
+    // How many times we prepared a sample (sampled directly) from the signal handler
+    unsigned int signal_handler_prepared_sample;
     // How many times the signal handler was called from the wrong thread
     unsigned int signal_handler_wrong_thread;
     // How many times we actually tried to interrupt a thread for sampling
@@ -232,6 +235,8 @@ static void after_gvl_running_from_postponed_job(DDTRACE_UNUSED void *_unused);
 #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 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);
 
 // 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`.
@@ -356,6 +361,7 @@ static VALUE _native_new(VALUE klass) {
   state->allocation_counting_enabled = false;
   state->gvl_profiling_enabled = false;
   state->skip_idle_samples_for_testing = false;
+  state->sighandler_sampling_enabled = false;
   state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
@@ -366,7 +372,7 @@ static VALUE _native_new(VALUE klass) {
   state->failure_exception = Qnil;
   state->stop_thread = Qnil;
 
-  state->during_sample = false;
+  during_sample_exit(state);
 
   #ifndef NO_GVL_INSTRUMENTATION
     state->gvl_profiling_hook = NULL;
@@ -398,6 +404,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE allocation_counting_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("allocation_counting_enabled")));
   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")));
 
   ENFORCE_BOOLEAN(gc_profiling_enabled);
   ENFORCE_BOOLEAN(no_signals_workaround_enabled);
@@ -407,6 +414,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ENFORCE_BOOLEAN(allocation_counting_enabled);
   ENFORCE_BOOLEAN(gvl_profiling_enabled);
   ENFORCE_BOOLEAN(skip_idle_samples_for_testing)
+  ENFORCE_BOOLEAN(sighandler_sampling_enabled)
 
   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);
@@ -418,6 +426,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   state->allocation_counting_enabled = (allocation_counting_enabled == Qtrue);
   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);
 
   double total_overhead_target_percentage = NUM2DBL(dynamic_sampling_rate_overhead_target_percentage);
   if (!state->allocation_profiling_enabled) {
@@ -590,6 +599,19 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 
   state->stats.signal_handler_enqueued_sample++;
 
+  bool sample_from_signal_handler =
+    state->sighandler_sampling_enabled &&
+    // Don't sample if we're already in the middle of processing a sample
+    !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(state->thread_context_collector_instance);
+
+    if (prepared) state->stats.signal_handler_prepared_sample++;
+  }
+
   #ifndef NO_POSTPONED_TRIGGER // Ruby 3.3+
     rb_postponed_job_trigger(sample_from_postponed_job_handle);
   #else
@@ -701,12 +723,12 @@ static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
     return; // We're not on the main Ractor; we currently don't support profiling non-main Ractors
   }
 
-  state->during_sample = true;
+  during_sample_enter(state);
 
   // Rescue against any exceptions that happen during sampling
   safely_call(rescued_sample_from_postponed_job, state->self_instance, state->self_instance);
 
-  state->during_sample = false;
+  during_sample_exit(state);
 }
 
 static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
@@ -912,11 +934,11 @@ static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused) {
     return; // We're not on the main Ractor; we currently don't support profiling non-main Ractors
   }
 
-  state->during_sample = true;
+  during_sample_enter(state);
 
   safely_call(thread_context_collector_sample_after_gc, state->thread_context_collector_instance, state->self_instance);
 
-  state->during_sample = false;
+  during_sample_exit(state);
 }
 
 // Equivalent to Ruby begin/rescue call, where we call a C function and jump to the exception handler if an
@@ -994,6 +1016,7 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
     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),
+    ID2SYM(rb_intern("signal_handler_prepared_sample")),             /* => */ UINT2NUM(state->stats.signal_handler_prepared_sample),
     ID2SYM(rb_intern("signal_handler_wrong_thread")),                /* => */ UINT2NUM(state->stats.signal_handler_wrong_thread),
     ID2SYM(rb_intern("interrupt_thread_attempts")),                  /* => */ UINT2NUM(state->stats.interrupt_thread_attempts),
 
@@ -1177,7 +1200,7 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
     &state->allocation_sampler, HANDLE_CLOCK_FAILURE(monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE))
   );
 
-  state->during_sample = true;
+  during_sample_enter(state);
 
   // Rescue against any exceptions that happen during sampling
   safely_call(rescued_sample_allocation, Qnil, state->self_instance);
@@ -1198,7 +1221,7 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
 
   state->stats.allocation_sampled++;
 
-  state->during_sample = false;
+  during_sample_exit(state);
 }
 
 static void disable_tracepoints(cpu_and_wall_time_worker_state *state) {
@@ -1339,12 +1362,12 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
     // This can potentially happen if the CpuAndWallTimeWorker was stopped while the postponed job was waiting to be executed; nothing to do
     if (state == NULL) return;
 
-    state->during_sample = true;
+    during_sample_enter(state);
 
     // Rescue against any exceptions that happen during sampling
     safely_call(rescued_after_gvl_running_from_postponed_job, state->self_instance, state->self_instance);
 
-    state->during_sample = false;
+    during_sample_exit(state);
   }
 
   static VALUE rescued_after_gvl_running_from_postponed_job(VALUE self_instance) {
@@ -1380,3 +1403,21 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
     return Qfalse;
   }
 #endif
+
+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.
+  //
+  // In a few cases, we may be checking this flag from a signal handler, so we need to make sure the compiler didn't
+  // get clever and reordered things in such a way that makes us miss the flag update.
+  //
+  // See https://github.com/ruby/ruby/pull/11036 for a similar change made to the Ruby VM with more context.
+  state->during_sample = true;
+  atomic_signal_fence(memory_order_seq_cst);
+}
+
+static inline void during_sample_exit(cpu_and_wall_time_worker_state* state) {
+  // See `during_sample_enter` for more context; in this case we set the fence before to make sure anything that
+  // happens before the fence is not reordered with the flag update.
+  atomic_signal_fence(memory_order_seq_cst);
+  state->during_sample = false;
+}

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -1,16 +1,16 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 #include <ruby/st.h>
+#include <stdatomic.h>
 
 #include "extconf.h" // This is needed for the HAVE_DLADDR and friends below
 
-// For dladdr/dladdr1
-#if defined(HAVE_DLADDR1) || defined(HAVE_DLADDR)
+#if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
   #ifndef _GNU_SOURCE
     #define _GNU_SOURCE
   #endif
   #include <dlfcn.h>
-  #ifdef HAVE_DLADDR1
+  #if defined(HAVE_DLADDR1) && HAVE_DLADDR1
     #include <link.h>
   #endif
 #endif
@@ -39,7 +39,7 @@ static void set_file_info_for_cfunc(
   st_table *native_filenames_cache
 );
 static const char *get_or_compute_native_filename(void *function, st_table *native_filenames_cache);
-static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size);
+static void add_truncated_frames_placeholder(sampling_buffer* buffer);
 static void record_placeholder_stack_in_native_code(VALUE recorder_instance, sample_values values, sample_labels labels);
 static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_CharSlice *filename_slice);
 
@@ -63,24 +63,24 @@ void collectors_stack_init(VALUE profiling_module) {
 
   rb_define_singleton_method(testing_module, "_native_sample", _native_sample, -1);
 
-  #if defined(HAVE_DLADDR1) || defined(HAVE_DLADDR)
-  // To be able to detect when a frame is coming from Ruby, we record here its filename as returned by dladdr.
-  // We expect this same pointer to be returned by dladdr for all frames coming from Ruby.
-  //
-  // Small note: Creating/deleting the cache is a bit awkward here, but it seems like a bigger footgun to allow
-  // `get_or_compute_native_filename` to run without a cache, since we never expect that to happen during sampling. So it seems
-  // like a reasonable trade-off to force callers to always figure that out.
-  st_table *temporary_cache = st_init_numtable();
-  const char *native_filename = get_or_compute_native_filename(rb_ary_new, temporary_cache);
-  if (native_filename != NULL && native_filename[0] != '\0') {
-    ruby_native_filename = native_filename;
-  }
-  st_free_table(temporary_cache);
+  #if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
+    // To be able to detect when a frame is coming from Ruby, we record here its filename as returned by dladdr.
+    // We expect this same pointer to be returned by dladdr for all frames coming from Ruby.
+    //
+    // Small note: Creating/deleting the cache is a bit awkward here, but it seems like a bigger footgun to allow
+    // `get_or_compute_native_filename` to run without a cache, since we never expect that to happen during sampling. So it seems
+    // like a reasonable trade-off to force callers to always figure that out.
+    st_table *temporary_cache = st_init_numtable();
+    const char *native_filename = get_or_compute_native_filename(rb_ary_new, temporary_cache);
+    if (native_filename != NULL && native_filename[0] != '\0') {
+      ruby_native_filename = native_filename;
+    }
+    st_free_table(temporary_cache);
   #endif
 }
 
 static VALUE _native_filenames_available(DDTRACE_UNUSED VALUE self) {
-  #if defined(HAVE_DLADDR1) || defined(HAVE_DLADDR)
+  #if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
     return ruby_native_filename != NULL ? Qtrue : Qfalse;
   #else
     return Qfalse;
@@ -271,7 +271,8 @@ void sample_thread(
   // The convention in Kernel#caller_locations is to instead use the path and line number of the first Ruby frame
   // on the stack that is below (e.g. directly or indirectly has called) the native method.
   // Thus, we keep that frame here to able to replicate that behavior.
-  // (This is why we also iterate the sampling buffers backwards below -- so that it's easier to keep the last_ruby_frame_filename)
+  // (This is why we also iterate the sampling buffers backwards from what libdatadog uses below -- so that it's easier
+  // to keep the last_ruby_frame_filename)
   ddog_CharSlice last_ruby_frame_filename = DDOG_CHARSLICE_C("");
   int last_ruby_line = 0;
 
@@ -290,10 +291,12 @@ void sample_thread(
     if (labels.is_gvl_waiting_state) rb_raise(rb_eRuntimeError, "BUG: Unexpected combination of cpu-time with is_gvl_waiting");
   }
 
-  for (int i = captured_frames - 1; i >= 0; i--) {
+  int top_of_stack_position = captured_frames - 1;
+
+  for (int i = 0; i <= top_of_stack_position; i++) {
     ddog_CharSlice name_slice, filename_slice;
     int line;
-    bool top_of_the_stack = i == 0;
+    bool top_of_the_stack = i == top_of_stack_position;
 
     if (buffer->stack_buffer[i].is_ruby_frame) {
       VALUE name = rb_iseq_base_label(buffer->stack_buffer[i].as.ruby_frame.iseq);
@@ -324,7 +327,6 @@ void sample_thread(
 
     maybe_trim_template_random_ids(&name_slice, &filename_slice);
 
-
     // When there's only wall-time in a sample, this means that the thread was not active in the sampled period.
     if (top_of_the_stack && only_wall_time) {
       // Did the caller already provide the state?
@@ -368,21 +370,19 @@ void sample_thread(
       }
     }
 
-    buffer->locations[i] = (ddog_prof_Location) {
+    int libdatadog_stores_stacks_flipped_from_rb_profile_frames_index = top_of_stack_position - i;
+
+    buffer->locations[libdatadog_stores_stacks_flipped_from_rb_profile_frames_index] = (ddog_prof_Location) {
       .mapping = {.filename = DDOG_CHARSLICE_C(""), .build_id = DDOG_CHARSLICE_C(""), .build_id_id = {}},
       .function = (ddog_prof_Function) {.name = name_slice, .filename = filename_slice},
       .line = line,
     };
   }
 
-  // Used below; since we want to stack-allocate this, we must do it here rather than in maybe_add_placeholder_frames_omitted
-  const int frames_omitted_message_size = sizeof(MAX_FRAMES_LIMIT_AS_STRING " frames omitted");
-  char frames_omitted_message[frames_omitted_message_size];
-
   // If we filled up the buffer, some frames may have been omitted. In that case, we'll add a placeholder frame
   // with that info.
   if (captured_frames == (long) buffer->max_frames) {
-    maybe_add_placeholder_frames_omitted(thread, buffer, frames_omitted_message, frames_omitted_message_size);
+    add_truncated_frames_placeholder(buffer);
   }
 
   record_sample(
@@ -393,7 +393,7 @@ void sample_thread(
   );
 }
 
-#if defined(HAVE_DLADDR1) || defined(HAVE_DLADDR)
+#if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
   static void set_file_info_for_cfunc(
     ddog_CharSlice *filename_slice,
     int *line,
@@ -441,12 +441,12 @@ void sample_thread(
 
     Dl_info info;
     const char *native_filename = NULL;
-    #ifdef HAVE_DLADDR1
+    #if defined(HAVE_DLADDR1) && HAVE_DLADDR1
       struct link_map *extra_info = NULL;
       if (dladdr1(function, &info, (void **) &extra_info, RTLD_DL_LINKMAP) != 0 && extra_info != NULL) {
         native_filename = extra_info->l_name != NULL ? extra_info->l_name : info.dli_fname;
       }
-    #elif defined(HAVE_DLADDR)
+    #elif defined(HAVE_DLADDR) && HAVE_DLADDR
       if (dladdr(function, &info) != 0) {
         native_filename = info.dli_fname;
       }
@@ -521,24 +521,12 @@ static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_Char
   name_slice->len = pos;
 }
 
-static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size) {
-  ptrdiff_t frames_omitted = stack_depth_for(thread) - buffer->max_frames;
-
-  if (frames_omitted == 0) return; // Perfect fit!
-
-  // The placeholder frame takes over a space, so if 10 frames were left out and we consume one other space for the
-  // placeholder, then 11 frames are omitted in total
-  frames_omitted++;
-
-  snprintf(frames_omitted_message, frames_omitted_message_size, "%td frames omitted", frames_omitted);
-
-  // Important note: `frames_omitted_message` MUST have a lifetime that is at least as long as the call to
-  // `record_sample`. So be careful where it gets allocated. (We do have tests for this, at least!)
-  ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
-  ddog_CharSlice function_filename = {.ptr = frames_omitted_message, .len = strlen(frames_omitted_message)};
-  buffer->locations[buffer->max_frames - 1] = (ddog_prof_Location) {
+static void add_truncated_frames_placeholder(sampling_buffer* buffer) {
+  // Important note: The strings below are static so we don't need to worry about their lifetime. If we ever want to change
+  // this to non-static strings, don't forget to check that lifetimes are properly respected.
+  buffer->locations[0] = (ddog_prof_Location) {
     .mapping = {.filename = DDOG_CHARSLICE_C(""), .build_id = DDOG_CHARSLICE_C(""), .build_id_id = {}},
-    .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
+    .function = {.name = DDOG_CHARSLICE_C("Truncated Frames"), .filename = DDOG_CHARSLICE_C(""), .filename_id = {}},
     .line = 0,
   };
 }
@@ -597,9 +585,14 @@ void record_placeholder_stack(
   );
 }
 
-void prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
+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.
+  if (buffer->is_marking) return false;
+
   buffer->pending_sample = true;
   buffer->pending_sample_result = ddtrace_rb_profile_frames(thread, 0, buffer->max_frames, buffer->stack_buffer);
+  return true;
 }
 
 uint16_t sampling_buffer_check_max_frames(int max_frames) {
@@ -615,6 +608,7 @@ void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, dd
   buffer->locations = locations;
   buffer->stack_buffer = ruby_xcalloc(max_frames, sizeof(frame_info));
   buffer->pending_sample = false;
+  buffer->is_marking = false;
   buffer->pending_sample_result = 0;
 }
 
@@ -630,6 +624,7 @@ void sampling_buffer_free(sampling_buffer *buffer) {
   buffer->locations = NULL;
   buffer->stack_buffer = NULL;
   buffer->pending_sample = false;
+  buffer->is_marking = false;
   buffer->pending_sample_result = 0;
 }
 
@@ -638,9 +633,23 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
     rb_bug("sampling_buffer_mark called with no pending sample. `sampling_buffer_needs_marking` should be used before calling mark.");
   }
 
+  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.
+  //
+  // 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);
+
   for (int i = 0; i < buffer->pending_sample_result; i++) {
     if (buffer->stack_buffer[i].is_ruby_frame) {
       rb_gc_mark(buffer->stack_buffer[i].as.ruby_frame.iseq);
     }
   }
+
+  // Make sure iteration completes before `is_marking` is unset...
+  atomic_signal_fence(memory_order_seq_cst);
+  buffer->is_marking = false;
 }

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -14,6 +14,7 @@ typedef struct {
   ddog_prof_Location *locations;
   frame_info *stack_buffer;
   bool pending_sample;
+  bool is_marking; // Used to avoid recording a sample when marking
   int pending_sample_result;
 } sampling_buffer;
 
@@ -32,7 +33,7 @@ void record_placeholder_stack(
   sample_labels labels,
   ddog_CharSlice placeholder_stack
 );
-void prepare_sample_thread(VALUE thread, sampling_buffer *buffer);
+bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer);
 
 uint16_t sampling_buffer_check_max_frames(int max_frames);
 void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, ddog_prof_Location *locations);

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -1469,17 +1469,17 @@ static VALUE thread_list(thread_context_collector_state *state) {
 // expected to be called from a signal handler and to be async-signal-safe.
 //
 // Also, no allocation (Ruby or malloc) can happen.
-void thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance) {
+bool thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance) {
   thread_context_collector_state *state;
-  if (!rb_typeddata_is_kind_of(self_instance, &thread_context_collector_typed_data)) return;
+  if (!rb_typeddata_is_kind_of(self_instance, &thread_context_collector_typed_data)) return false;
   // This should never fail if the above check passes
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   VALUE current_thread = rb_thread_current();
   per_thread_context *thread_context = get_context_for(current_thread, state);
-  if (thread_context == NULL) return;
+  if (thread_context == NULL) return false;
 
-  prepare_sample_thread(current_thread, &thread_context->sampling_buffer);
+  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) {
@@ -2217,6 +2217,5 @@ static VALUE _native_system_epoch_time_now_ns(DDTRACE_UNUSED VALUE self, VALUE c
 }
 
 static VALUE _native_prepare_sample_inside_signal_handler(DDTRACE_UNUSED VALUE self, VALUE collector_instance) {
-  thread_context_collector_prepare_sample_inside_signal_handler(collector_instance);
-  return Qtrue;
+  return thread_context_collector_prepare_sample_inside_signal_handler(collector_instance) ? Qtrue : Qfalse;
 }

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -10,7 +10,7 @@ void thread_context_collector_sample(
   long current_monotonic_wall_time_ns,
   VALUE profiler_overhead_stack_thread
 );
-void thread_context_collector_prepare_sample_inside_signal_handler(VALUE self_instance);
+__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);
 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);