datadog 2.35.0 → 2.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4029cb3d97dee5a685f9f34027d3f46c960d452eb82339f8a167227f597881aa
-  data.tar.gz: 3a108d7cb90cb00326d2f9ec563e0370855161ea21c270e31cfe8bbd16b9e154
+  metadata.gz: fd8fcd94fa20eb591676abd0f96d6ef69f475f10c08e53d7e4dad1c0cab35e7c
+  data.tar.gz: 6e3036aedb4b47ccb9d8c7ec74d070f52e755796e729d99f83c171ca1879ba59
 SHA512:
-  metadata.gz: c10991420b5026c39d0ca76529be13c276479236ebf01ab8e5050c110f687266620bfa04127f76cdb55c87b54e84c3cee5ffa39f1de46492f2dd90a58f8ed484
-  data.tar.gz: f7508958b880c20197ab687ff2eb98c29af51aadbc1835f8ae88a88b8858a520518aefb0d73797ae0728018fe871056c4fa4baccc86aa77b9ec0e1d20a8df298
+  metadata.gz: 8de4af357d5807e1855eb4dc078d291af8b601bda3fac1d44d442634dd1b241c7a6b27397095f54a9d931110b503398a43de70878e62c9525629c2b17bcbd97a
+  data.tar.gz: 6f8acf814a862cfe261b6a3e97f40c37d0cb86b36deeadf253b14c0b17647e570eca9fca2a4d3dc86126a63d9fa5c0d83f750d495d0f6df0e1d23f43493dad6b

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [2.36.0] - 2026-06-24
+
+### Added
+
+* Tracing: Add `DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT` to control trace extraction behavior with `continue`, `restart`, and `ignore` modes ([#5844][])
+* AppSec: Add `DD_APPSEC_BODY_PARSING_SIZE_LIMIT` to control processing of request and response body size; set to 0 to disable ([#5877][])
+* AppSec: Detect attacks from inline fragments in GraphQL queries ([#5916][])
+* Dynamic Instrumentation: Show lazily loaded classes in UI ([#5697][])
+
+### Changed
+
+* Dynamic Instrumentation: Reduce peak memory usage during Symbol Database extraction ([#5883][])
+* Profiling: Reduce profiler overhead by up to 50% by skipping redundant samples for threads without the GVL ([#5777][])
+* Profiling: Remove overhead when cleaning up dead threads ([#5816][])
+
+### Fixed
+
+* Tracing: Workaround Ruby VM bug causing segmentation faults inside CachingResolver ([#5719][], [#5890][])
+* Dynamic Instrumentation: Prevent uploading stale class definitions for apps using `remove_const`-then-redefine patterns ([#5872][])
+* Profiling: Fix GC profiling being incorrectly disabled on Ruby 3.2.10 and 3.2.11 ([#5894][])
+* Profiling: Fix over-counting of the first allocation sample at profiler startup ([#5881][])
+* Profiling: Fix rare profiler crash during shutdown in heap profiling cleanup ([#5920][])
+* Core: Fix exception message formatting from native extensions ([#5857][])
+
 ## [2.35.0] - 2026-06-03
 
 ### Added
@@ -3634,7 +3658,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.35.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.36.0...master
+[2.36.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.35.0...v2.36.0
 [2.35.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.34.0...v2.35.0
 [2.34.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.33.0...v2.34.0
 [2.33.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.32.0...v2.33.0
@@ -5379,8 +5404,10 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5681]: https://github.com/DataDog/dd-trace-rb/issues/5681
 [#5687]: https://github.com/DataDog/dd-trace-rb/issues/5687
 [#5689]: https://github.com/DataDog/dd-trace-rb/issues/5689
+[#5697]: https://github.com/DataDog/dd-trace-rb/issues/5697
 [#5705]: https://github.com/DataDog/dd-trace-rb/issues/5705
 [#5717]: https://github.com/DataDog/dd-trace-rb/issues/5717
+[#5719]: https://github.com/DataDog/dd-trace-rb/issues/5719
 [#5723]: https://github.com/DataDog/dd-trace-rb/issues/5723
 [#5724]: https://github.com/DataDog/dd-trace-rb/issues/5724
 [#5750]: https://github.com/DataDog/dd-trace-rb/issues/5750
@@ -5389,10 +5416,22 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#5762]: https://github.com/DataDog/dd-trace-rb/issues/5762
 [#5768]: https://github.com/DataDog/dd-trace-rb/issues/5768
 [#5773]: https://github.com/DataDog/dd-trace-rb/issues/5773
+[#5777]: https://github.com/DataDog/dd-trace-rb/issues/5777
 [#5811]: https://github.com/DataDog/dd-trace-rb/issues/5811
 [#5812]: https://github.com/DataDog/dd-trace-rb/issues/5812
+[#5816]: https://github.com/DataDog/dd-trace-rb/issues/5816
 [#5830]: https://github.com/DataDog/dd-trace-rb/issues/5830
 [#5836]: https://github.com/DataDog/dd-trace-rb/issues/5836
+[#5844]: https://github.com/DataDog/dd-trace-rb/issues/5844
+[#5857]: https://github.com/DataDog/dd-trace-rb/issues/5857
+[#5872]: https://github.com/DataDog/dd-trace-rb/issues/5872
+[#5877]: https://github.com/DataDog/dd-trace-rb/issues/5877
+[#5881]: https://github.com/DataDog/dd-trace-rb/issues/5881
+[#5883]: https://github.com/DataDog/dd-trace-rb/issues/5883
+[#5890]: https://github.com/DataDog/dd-trace-rb/issues/5890
+[#5894]: https://github.com/DataDog/dd-trace-rb/issues/5894
+[#5916]: https://github.com/DataDog/dd-trace-rb/issues/5916
+[#5920]: https://github.com/DataDog/dd-trace-rb/issues/5920
 [@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

@@ -182,6 +182,11 @@ typedef struct {
     unsigned int allocations_during_sample;
 
     // # GVL profiling stats
+    // Note that this tracks two kind of samples from RESUMED:
+    // * samples when Waiting for GVL for more than the threshold
+    // * samples for the skip-samples-while-without-GVL optimization,
+    //   which are needed to attribute the time without GVL to the correct Ruby stack
+
     // How many times we triggered the after_gvl_running sampling
     unsigned int after_gvl_running;
     // How many times we skipped the after_gvl_running sampling
@@ -659,7 +664,7 @@ static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
   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);
+    bool prepared = thread_context_collector_prepare_sample_inside_signal_handler();
 
     if (prepared) state->stats.signal_handler_prepared_sample++;
   }
@@ -808,8 +813,7 @@ static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
 
   state->stats.cpu_sampled++;
 
-  VALUE profiler_overhead_stack_thread = state->owner_thread; // Used to attribute profiler overhead to a different stack
-  thread_context_collector_sample(state->thread_context_collector_instance, wall_time_ns_before_sample, profiler_overhead_stack_thread);
+  thread_context_collector_sample(state->thread_context_collector_instance, wall_time_ns_before_sample);
 
   long wall_time_ns_after_sample = monotonic_wall_time_now_ns(RAISE_ON_FAILURE);
   long delta_ns = wall_time_ns_after_sample - wall_time_ns_before_sample;
@@ -865,15 +869,12 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
 
   if (state->gvl_profiling_enabled) {
     #ifndef NO_GVL_INSTRUMENTATION
-      #ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS
-        gvl_profiling_state_thread_tracking_workaround();
-      #endif
-
       state->gvl_profiling_hook = rb_internal_thread_add_event_hook(
         on_gvl_event,
         (
           // For now we're only asking for these events, even though there's more
           // (e.g. check docs or gvl-tracing gem)
+          RUBY_INTERNAL_THREAD_EVENT_SUSPENDED | /* released gvl */
           RUBY_INTERNAL_THREAD_EVENT_READY /* waiting for gvl */ |
           RUBY_INTERNAL_THREAD_EVENT_RESUMED /* running/runnable */
         ),
@@ -1055,6 +1056,9 @@ static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE sel
 //
 // In the future, if we add more other components with tracepoints, we will need to coordinate stopping all such
 // tracepoints before doing the other cleaning steps.
+//
+// Note that tests call this method directly in the same process without forking,
+// and in such a case non-current Threads keep running.
 static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance) {
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
@@ -1129,6 +1133,9 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
     ID2SYM(rb_intern("gvl_waiting_time_ns_total")),  /* => */ state->gvl_profiling_enabled ? ULL2NUM(state->stats.vm_metrics.gvl_waiting_time_ns_total) : Qnil,
   };
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(stats_as_hash, arguments[i], arguments[i+1]);
+
+  thread_context_collector_stats(state->thread_context_collector_instance, stats_as_hash);
+
   return stats_as_hash;
 }
 
@@ -1136,6 +1143,7 @@ static VALUE _native_stats_reset_not_thread_safe(DDTRACE_UNUSED VALUE self, VALU
   cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
   reset_stats_not_thread_safe(state);
+  thread_context_collector_stats_reset_not_thread_safe(state->thread_context_collector_instance);
   return Qnil;
 }
 
@@ -1245,13 +1253,23 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
     return;
   }
 
+  VALUE current_thread = rb_thread_current();
+
   // If Ruby is in the middle of raising an exception, we don't want to try to sample. This is because if we accidentally
   // trigger an exception inside the profiler code, bad things will happen (specifically, Ruby will try to kill off the
   // thread even though we may try to catch the exception).
   //
   // Note that "in the middle of raising an exception" means the exception itself has already been allocated.
   // What's getting allocated now is probably the backtrace objects (@ivoanjo or at least that's what I've observed)
-  if (is_raised_flag_set(rb_thread_current())) {
+  if (is_raised_flag_set(current_thread)) {
+    return;
+  }
+
+  per_thread_context *thread_context = get_per_thread_context(current_thread);
+  if (!thread_context) {
+    // No per_thread_context yet on this Thread, we can't use get_or_create_context_for() as that allocates,
+    // and we are inside on_newobj_event where we MUST NOT allocate.
+    // So we don't sample allocations until another hook allocates the per_thread_context.
     return;
   }
 
@@ -1286,7 +1304,7 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE unused1, DDTRACE_UNUSED void *u
   // Rescue against any exceptions that happen during sampling
   safely_call(
     rescued_sample_allocation,
-    Qnil,
+    (VALUE) thread_context,
     state->self_instance,
     handle_sampling_failure_rescued_sample_allocation
   );
@@ -1338,7 +1356,8 @@ static VALUE _native_with_blocked_sigprof(DDTRACE_UNUSED VALUE self) {
   }
 }
 
-static VALUE rescued_sample_allocation(DDTRACE_UNUSED VALUE unused) {
+static VALUE rescued_sample_allocation(VALUE arg) {
+  per_thread_context *thread_context = (per_thread_context*) arg;
   cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
 
   // This should not happen in a normal situation because on_newobj_event already checked for this, but just in case...
@@ -1357,7 +1376,7 @@ 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;
-  bool needs_after_allocation = 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, thread_context, 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);
@@ -1414,30 +1433,49 @@ 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) {
     // Be very careful about touching the `state` here or doing anything at all:
-    // This function gets called without the GVL, and potentially from background Ractors!
-    //
-    // In fact, the `target_thread` that this event is about may not even be the current thread. (So be careful with thread locals that
-    // are not directly tied to the `target_thread` object and the like)
-    gvl_profiling_thread target_thread = thread_from_event(event_data);
+    // This function gets called without the GVL, and potentially from non-main Ractors!
 
-    if (event_id == RUBY_INTERNAL_THREAD_EVENT_READY) { /* waiting for gvl */
-      thread_context_collector_on_gvl_waiting(target_thread);
-    } else if (event_id == RUBY_INTERNAL_THREAD_EVENT_RESUMED) { /* running/runnable */
-      // Interesting note: A RUBY_INTERNAL_THREAD_EVENT_RESUMED is guaranteed to be called with the GVL being acquired.
-      // (And... I think target_thread will be == rb_thread_current()?)
-      //
-      // But we're not sure if we're on the main Ractor yet. The thread context collector can actually help here:
-      // it tags threads it's tracking, so if a thread is tagged then by definition we know that thread belongs to the main
-      // Ractor. Thus, if we get a ON_GVL_RUNNING_UNKNOWN result we shouldn't touch any state, but otherwise we're good to go.
+    // The thread that this event is about may not be the current thread
+    // (as documented on rb_internal_thread_add_event_hook(), and this is notably the case for READY on Ruby 4.0),
+    // so be careful with native thread locals that are not directly tied to the thread object and the like.
 
-      #ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS
-        target_thread = gvl_profiling_state_maybe_initialize();
-      #endif
+    // On Ruby 3.2 the event does not carry the thread, but all events always fire on the event thread on Ruby 3.2.
+    // However, during early thread startup rb_thread_current() can crash because the execution context (Fiber) isn't
+    // stored in TLS yet; ruby_native_thread_p() guards against this.
+    #ifdef HAVE_RUBY_THREAD_STORAGE_API
+      VALUE target_thread = event_data->thread;
+    #else
+      if (!ruby_native_thread_p()) return;
+      VALUE target_thread = rb_thread_current();
+    #endif
 
+    per_thread_context* thread_context = get_per_thread_context(target_thread);
+    if (!thread_context) return;
+    // If non-NULL the thread is profiled and from the main Ractor
+
+    if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED) { /* released gvl */
+      thread_context_collector_on_gvl_released(thread_context);
+    } else if (event_id == RUBY_INTERNAL_THREAD_EVENT_READY) { /* waiting for gvl */
+      thread_context_collector_on_gvl_waiting(thread_context);
+    } else if (event_id == RUBY_INTERNAL_THREAD_EVENT_RESUMED) { /* running/runnable */
+      // Interesting note: A RUBY_INTERNAL_THREAD_EVENT_RESUMED is guaranteed to be called with the GVL being acquired
+      // and on the event thread.
+      // However, on_gvl_event() is called while holding the scheduler lock, so we do as little work as possible here,
+      // and perform the sample in a postponed_job.
       cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
       if (state == NULL) return; // This should not happen, but just in case...
 
-      on_gvl_running_result result = thread_context_collector_on_gvl_running(target_thread);
+      // on_gvl_running prepares a stack sample so we need to gate it with `during_sample_enter` to avoid a
+      // SIGPROF signal coming in during that function and potentially causing a corrupted final state.
+      //
+      // TODO: Currently, the sample prepared in on_gvl_running can still be clobbered if the signal handler runs
+      // after `during_sample_exit` but before `after_gvl_running_from_postponed_job` gets to run. We'll need to fix
+      // that next.
+      during_sample_enter(state);
+
+      on_gvl_running_result result = thread_context_collector_on_gvl_running(state->thread_context_collector_instance, target_thread, thread_context);
+
+      during_sample_exit(state);
 
       if (result.waiting_for_gvl_duration_ns > 0) {
         state->stats.vm_metrics.gvl_waiting_time_ns_total += (uint64_t) result.waiting_for_gvl_duration_ns;
@@ -1453,8 +1491,7 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
         state->stats.gvl_dont_sample++;
       }
     } else {
-      // This is a very delicate time and it's hard for us to raise an exception so let's at least complain to stderr
-      fprintf(stderr, "[ddtrace] Unexpected value in on_gvl_event (%d)\n", event_id);
+      rb_bug("[ddtrace] Unexpected value in on_gvl_event (%d)\n", event_id);
     }
   }
 

data/ext/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.c

@@ -6,7 +6,7 @@
 #include "ruby_helpers.h"
 
 #define BASE_OVERHEAD_PCT 1.0
-#define BASE_SAMPLING_INTERVAL 50
+#define BASE_SAMPLING_INTERVAL 1
 
 #define ADJUSTMENT_WINDOW_NS SECONDS_AS_NS(1)
 #define ADJUSTMENT_WINDOW_SAMPLES 100

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -208,7 +208,7 @@ void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_
   if (!rb_typeddata_is_kind_of(self_instance, &idle_sampling_helper_typed_data)) {
     grab_gvl_and_raise(rb_eTypeError, "Wrong argument for idle_sampling_helper_request_action");
   }
-  // This should never fail the the above check passes
+  // This should never fail when the above check passes
   TypedData_Get_Struct(self_instance, idle_sampling_loop_state, &idle_sampling_helper_typed_data, state);
 
   ENFORCE_SUCCESS_NO_GVL(pthread_mutex_lock(&state->wakeup_mutex));

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -40,7 +40,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 add_truncated_frames_placeholder(sampling_buffer* buffer);
+static void add_truncated_frames_placeholder(ddog_prof_Location *locations);
 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);
 
@@ -98,7 +98,7 @@ typedef struct {
   sample_values values;
   sample_labels labels;
   VALUE thread;
-  ddog_prof_Location *locations;
+  sample_locations locations;
   sampling_buffer *buffer;
   bool native_filenames_enabled;
   st_table *native_filenames_cache;
@@ -175,7 +175,7 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
 
   ddog_prof_Location *locations = ruby_xcalloc(max_frames_requested, sizeof(ddog_prof_Location));
   sampling_buffer buffer;
-  sampling_buffer_initialize(&buffer, max_frames_requested, locations);
+  sampling_buffer_initialize(&buffer, max_frames_requested);
 
   ddog_prof_Slice_Label slice_labels = {.ptr = labels, .len = labels_count};
 
@@ -185,7 +185,7 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
     .values = values,
     .labels = (sample_labels) {.labels = slice_labels, .state_label = state_label, .is_gvl_waiting_state = is_gvl_waiting_state == Qtrue},
     .thread = thread,
-    .locations = locations,
+    .locations = (sample_locations) {.ptr = locations, .len = max_frames_requested},
     .buffer = &buffer,
     .native_filenames_enabled = native_filenames_enabled == Qtrue,
     .native_filenames_cache = st_init_numtable(),
@@ -208,6 +208,7 @@ static VALUE native_sample_do(VALUE args) {
     sample_thread(
       args_struct->thread,
       args_struct->buffer,
+      args_struct->locations,
       args_struct->recorder_instance,
       args_struct->values,
       args_struct->labels,
@@ -222,7 +223,7 @@ static VALUE native_sample_do(VALUE args) {
 static VALUE native_sample_ensure(VALUE args) {
   native_sample_args *args_struct = (native_sample_args *) args;
 
-  ruby_xfree(args_struct->locations);
+  ruby_xfree(args_struct->locations.ptr);
   sampling_buffer_free(args_struct->buffer);
   st_free_table(args_struct->native_filenames_cache);
 
@@ -243,6 +244,7 @@ static VALUE native_sample_ensure(VALUE args) {
 void sample_thread(
   VALUE thread,
   sampling_buffer* buffer,
+  sample_locations locations,
   VALUE recorder_instance,
   sample_values values,
   sample_labels labels,
@@ -250,11 +252,21 @@ void sample_thread(
   st_table *native_filenames_cache
 ) {
   // If we already prepared a sample, we use it below; if not, we prepare it now.
-  if (!buffer->pending_sample) prepare_sample_thread(thread, buffer);
+  if (!buffer->pending_sample) {
+    // Reconcile the sampling_buffer's max_frames with the locations size
+    if (buffer->max_frames != locations.len) {
+      sampling_buffer_reinitialize(buffer, locations.len);
+    }
+    prepare_sample_thread(thread, buffer);
+  }
 
   buffer->pending_sample = false;
   int captured_frames = buffer->pending_sample_result;
 
+  // The per_thread_context's sampling_buffer may have been created by a previous collector with a
+  // different (larger) max_frames. Cap to the locations array size to prevent out-of-bounds writes.
+  if (captured_frames > (int) locations.len) captured_frames = (int) locations.len;
+
   if (captured_frames == PLACEHOLDER_STACK_IN_NATIVE_CODE) {
     record_placeholder_stack_in_native_code(recorder_instance, values, labels);
     return;
@@ -389,25 +401,30 @@ void sample_thread(
 
     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) {
+    locations.ptr[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,
     };
   }
 
-  // If we filled up the buffer, some frames may have been omitted. In that case, we'll add a placeholder frame
+  // If we filled up the locations, 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) {
-    add_truncated_frames_placeholder(buffer);
+  if (captured_frames == (long) locations.len) {
+    add_truncated_frames_placeholder(locations.ptr);
   }
 
   record_sample(
     recorder_instance,
-    (ddog_prof_Slice_Location) {.ptr = buffer->locations, .len = captured_frames},
+    (ddog_prof_Slice_Location) {.ptr = locations.ptr, .len = captured_frames},
     values,
     labels
   );
+
+  // Reconcile the sampling_buffer's max_frames with the locations size for future samples
+  if (buffer->max_frames != locations.len) {
+    sampling_buffer_reinitialize(buffer, locations.len);
+  }
 }
 
 #if (defined(HAVE_DLADDR1) && HAVE_DLADDR1) || (defined(HAVE_DLADDR) && HAVE_DLADDR)
@@ -538,10 +555,10 @@ static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_Char
   name_slice->len = pos;
 }
 
-static void add_truncated_frames_placeholder(sampling_buffer* buffer) {
+static void add_truncated_frames_placeholder(ddog_prof_Location *locations) {
   // 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) {
+  locations[0] = (ddog_prof_Location) {
     .mapping = {.filename = DDOG_CHARSLICE_C(""), .build_id = DDOG_CHARSLICE_C(""), .build_id_id = {}},
     .function = {.name = DDOG_CHARSLICE_C("Truncated Frames"), .filename = DDOG_CHARSLICE_C(""), .filename_id = {}},
     .line = 0,
@@ -618,27 +635,29 @@ uint16_t sampling_buffer_check_max_frames(int max_frames) {
   return max_frames;
 }
 
-void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, ddog_prof_Location *locations) {
+void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames) {
   sampling_buffer_check_max_frames(max_frames);
 
   buffer->max_frames = max_frames;
-  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;
 }
 
+void sampling_buffer_reinitialize(sampling_buffer *buffer, uint16_t max_frames) {
+  sampling_buffer_free(buffer);
+  sampling_buffer_initialize(buffer, max_frames);
+}
+
 void sampling_buffer_free(sampling_buffer *buffer) {
-  if (buffer->max_frames == 0 || buffer->locations == NULL || buffer->stack_buffer == NULL) {
+  if (buffer->max_frames == 0 || buffer->stack_buffer == NULL) {
     raise_error(rb_eArgError, "sampling_buffer_free called with invalid buffer");
   }
 
   ruby_xfree(buffer->stack_buffer);
-  // Note: buffer->locations are owned by whoever called sampling_buffer_initialize, not by the buffer itself
 
   buffer->max_frames = 0;
-  buffer->locations = NULL;
   buffer->stack_buffer = NULL;
   buffer->pending_sample = false;
   buffer->is_marking = false;

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -11,16 +11,21 @@
 // Used as scratch space during sampling
 typedef struct {
   uint16_t max_frames;
-  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;
 
+typedef struct {
+  ddog_prof_Location *ptr;
+  uint16_t len;
+} sample_locations;
+
 void sample_thread(
   VALUE thread,
   sampling_buffer* buffer,
+  sample_locations locations,
   VALUE recorder_instance,
   sample_values values,
   sample_labels labels,
@@ -36,7 +41,8 @@ void record_placeholder_stack(
 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);
+void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames);
+void sampling_buffer_reinitialize(sampling_buffer *buffer, uint16_t max_frames);
 void sampling_buffer_free(sampling_buffer *buffer);
 void sampling_buffer_mark(sampling_buffer *buffer);
 static inline bool sampling_buffer_needs_marking(sampling_buffer *buffer) {