datadog 2.46.0 → 2.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90e55c02331cafb4d96cd0dedf6edb09fc5a6c7f993ffd611d8ca13f12d42cdb
-  data.tar.gz: a99ea41f5975708838075815674c78e47a46ef8368188186d2e20653a8372b19
+  metadata.gz: ac4a0fce689b8c65bbe4c00847dbaf3e84bf7eda13ea48fc40cab57d5332a04f
+  data.tar.gz: dbf9526b321135b7e9e014578a5abe92a89e339a4ba2d9f7997718194e76a302
 SHA512:
-  metadata.gz: 4061492c8bba7bf1238b6442d9275bbd7172978ecdbe4d4a92b53f0c67c2ca2d7b20947aaa42247fdc37ccbe81502710b4d69733e420e18fcd1e13d6e27b9864
-  data.tar.gz: 6fe366c5fcb305780a575c830bc77967be48605478071c1d16975242a95cb5c178b81dac776306f5b082b27770140174d29ad0c4dd7df3c9522b4a048883303f
+  metadata.gz: dbbbc2ca84a95852a6614ba6cbc21c0fc68c4badef35c34dc29059ef6feffb0307ac0d19ffc955d8b7ac3f807007d4ea9577490dee99e0bb9f98f4d158ac8093
+  data.tar.gz: 3ec630b843cd8e57b14a227afe815c1e07f8a5c5bcbbffd62a41a19c57c5f204e8302059dd9bce0c7d89d1667f7a93ae6219686ec55aef5961ee23082ff56f26

data/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [2.48.0] - 2026-11-03
+
+### Added
+
+* Dynamic Instrumentation: Limit condition, capture-expression, and template evaluation CPU time with `DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS` (default `50`); over-budget evaluation is reported as an evaluation error. ([#6223][])
+* Open Feature: Add onboarding diagnostics for configuration delivery, provider readiness, flag evaluations, and exposures with `DD_TRACE_DEBUG=true`. Evaluation logs include raw data that may contain personal or sensitive information. ([#6519][])
+
+### Changed
+
+* Core: Require C11 (`-std=gnu11`) support to build native extensions on Linux. ([#6596][])
+* Profiling: Show class and module names in profiler stack frames by default, e.g. `Foo::Bar#baz` instead of `baz`, making methods easier to identify. ([#6537][])
+* Dynamic Instrumentation: Lower the per-call limit of the `matches` expression operator from 500 ms to 50 ms of wall time; a slow regular expression in a probe now delays the instrumented method by at most 50 ms per call and reports an evaluation error. ([#6223][])
+* Data Streams: Start a new pathway when a consume and the produce that follows it run on different threads; to keep one pathway across the hand-off, pass the context with `set_produce_checkpoint` and `set_consume_checkpoint`. ([#6532][])
+
+### Fixed
+
+* Tracing: Fix the `_dd.rc.client_id` span tag occasionally carrying the client id of a different remote-configuration connection during component reconnection. ([#6601][])
+* AppSec: Fix missing SQL injection detection in applications using `ActiveRecord` 8.0 and later. ([#6581][])
+* AI Guard: Fix a rare crash when building the AI Guard client endpoint while the Datadog site setting changes concurrently. ([#6601][])
+* Data Streams: Fix full-pathway latency inflated by minutes, and messages linked to the wrong pathway, in multi-threaded or forking apps such as `Karafka` consumers and `ActiveJob` workers. ([#6532][])
+
+## [2.47.0] - 2026-10-26
+
+### Added
+
+* Tracing: Add quantized request paths to outbound HTTP client resource names, such as `GET /users/*`; enable with `DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE=true`. ([#6298][])
+* Open Feature: Let evaluations opt out of flag evaluation events, metrics, and span tags with `dd_evaluation_telemetry_opt_out: true` in the evaluation context; enable it with `DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED=true`. ([#6486][])
+
+### Changed
+
+* AppSec: Update `libddwaf` to 1.30.0.1.0. ([#6548][])
+
+### Fixed
+
+* Core: Fix forked processes, such as Puma and Unicorn workers, reporting no runtime metrics when the parent process traced before forking. ([#6500][]) ([@dduugg][])
+* Profiling: Fix the "no signals" workaround being enabled when `mysql2` uses MariaDB Connector/C 3.x. ([#6543][])
+* AppSec: Fix ruleset updates with Remote Configuration. ([#6547][])
+* AppSec: Fix duplicate JSON serialization of Rails and Sinatra response objects when application security is enabled. ([#6548][])
+
 ## [2.46.0] - 2026-10-19
 
 ### Added
@@ -3851,7 +3890,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.46.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.48.0...master
+[2.48.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.47.0...v2.48.0
+[2.47.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.46.0...v2.47.0
 [2.46.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.45.0...v2.46.0
 [2.45.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.44.0...v2.45.0
 [2.44.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.43.0...v2.44.0
@@ -5687,6 +5728,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6213]: https://github.com/DataDog/dd-trace-rb/issues/6213
 [#6219]: https://github.com/DataDog/dd-trace-rb/issues/6219
 [#6220]: https://github.com/DataDog/dd-trace-rb/issues/6220
+[#6223]: https://github.com/DataDog/dd-trace-rb/issues/6223
 [#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
@@ -5694,6 +5736,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#6298]: https://github.com/DataDog/dd-trace-rb/issues/6298
 [#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
@@ -5721,7 +5764,18 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#6474]: https://github.com/DataDog/dd-trace-rb/issues/6474
 [#6481]: https://github.com/DataDog/dd-trace-rb/issues/6481
 [#6485]: https://github.com/DataDog/dd-trace-rb/issues/6485
+[#6486]: https://github.com/DataDog/dd-trace-rb/issues/6486
 [#6488]: https://github.com/DataDog/dd-trace-rb/issues/6488
+[#6500]: https://github.com/DataDog/dd-trace-rb/issues/6500
+[#6519]: https://github.com/DataDog/dd-trace-rb/issues/6519
+[#6532]: https://github.com/DataDog/dd-trace-rb/issues/6532
+[#6537]: https://github.com/DataDog/dd-trace-rb/issues/6537
+[#6543]: https://github.com/DataDog/dd-trace-rb/issues/6543
+[#6547]: https://github.com/DataDog/dd-trace-rb/issues/6547
+[#6548]: https://github.com/DataDog/dd-trace-rb/issues/6548
+[#6581]: https://github.com/DataDog/dd-trace-rb/issues/6581
+[#6596]: https://github.com/DataDog/dd-trace-rb/issues/6596
+[#6601]: https://github.com/DataDog/dd-trace-rb/issues/6601
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -5878,4 +5932,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/LICENSE-3rdparty.csv

@@ -5,3 +5,4 @@
 "lib/datadog/tracing/contrib/active_record/vendor","https://github.com/rails/rails/","MIT","Copyright (c) 2005-2018 David Heinemeier Hansson"
 "lib/datadog/tracing/contrib/utils/quantization/http.rb","https://github.com/ruby/uri","BSD-2-Clause","Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved."
 "msgpack","https://rubygems.org/gems/msgpack","Apache-2.0","Copyright (c) 2008-2015 Sadayuki Furuhashi"
+"rubocop/custom_cops/trailing_comma_in_arguments_cop.rb","https://github.com/rubocop/rubocop","MIT","Copyright (c) 2012-25 Bozhidar Batsov"

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -41,7 +41,7 @@ static const char *get_or_compute_native_filename(void *function, st_table *nati
 static void initialize_static_ruby_actual_filename(VALUE profiling_module);
 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);
+static void maybe_trim_template_random_ids(ddog_CharSlice *frame_name, ddog_CharSlice filename, bool frame_name_in_scratch_buffer);
 
 // NULL if we weren't able to get the native filename for the Ruby VM.
 // On a static Ruby without libruby.so, `get_or_compute_native_filename` returns `ruby_native_filename` but
@@ -180,7 +180,7 @@ static VALUE _native_sample(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
   sample_locations locations;
   sample_locations_initialize(&locations, max_frames_requested, show_classes == Qtrue);
   sampling_buffer buffer;
-  sampling_buffer_initialize(&buffer, max_frames_requested);
+  sampling_buffer_initialize(&buffer, max_frames_requested, show_classes == Qtrue);
 
   ddog_prof_Slice_Label slice_labels = {.ptr = labels, .len = labels_count};
 
@@ -239,6 +239,83 @@ static VALUE native_sample_ensure(VALUE args) {
 
 #define CHARSLICE_EQUALS(must_be_a_literal, charslice) (strlen("" must_be_a_literal) == charslice.len && strncmp(must_be_a_literal, charslice.ptr, charslice.len) == 0)
 
+// The method name on its own, without any class/module name
+static inline ddog_CharSlice unqualified_name(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq) {
+  VALUE name = ddtrace_location_base_label(cme, iseq);
+  return (name == Qfalse) ? DDOG_CHARSLICE_C("") : char_slice_from_ruby_string(name);
+}
+
+// When there's only wall-time in a sample, this means that the thread was not active in the sampled period, so we try
+// to tell what it was doing instead.
+//
+// TODO: `method` is the unqualified method name
+// because we don't always use qualified method names yet,
+// and the checks below need something stable to compare to until we always do.
+static void categorize_sample_state(
+  sample_labels labels,
+  frame_info frame,
+  ddog_CharSlice method,
+  DDTRACE_UNUSED ddog_CharSlice filename
+) {
+  ddog_prof_Label *state_label = labels.state_label;
+
+  // Did the caller already provide the state?
+  if (labels.is_gvl_waiting_state) {
+    state_label->str = DDOG_CHARSLICE_C("waiting for gvl");
+
+  // Otherwise, we try to categorize what the thread was doing based on what we observe at the top of the stack. This is a very rough
+  // approximation, and in the future we hope to replace this with a more accurate approach (such as using the
+  // GVL instrumentation API.)
+  } else if (!frame.is_ruby_frame) {
+    // We know that known versions of Ruby implement these using native code; thus if we find a method with the
+    // same name that is not native code, we ignore it, as it's probably a user method that coincidentally
+    // has the same name. Thus, even though "matching just by method name" is kinda weak,
+    // "matching by method name" + is native code seems actually to be good enough for a lot of cases.
+
+    if (CHARSLICE_EQUALS("sleep", method)) { // Expected to be Kernel.sleep
+      state_label->str  = DDOG_CHARSLICE_C("sleeping");
+    } else if (CHARSLICE_EQUALS("select", method)) { // Expected to be Kernel.select
+      state_label->str  = DDOG_CHARSLICE_C("waiting");
+    } else if (
+        CHARSLICE_EQUALS("synchronize", method) || // Expected to be Monitor/Mutex#synchronize on Ruby 2 & 3, and Monitor#synchronize on 4 (Mutex becomes <internal:thread_sync>)
+        #ifdef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby < 4
+          CHARSLICE_EQUALS("lock", method) ||        // Expected to be Mutex#lock
+        #endif
+        CHARSLICE_EQUALS("join", method)           // Expected to be Thread#join
+    ) {
+      state_label->str  = DDOG_CHARSLICE_C("blocked");
+    } else if (CHARSLICE_EQUALS("wait_readable", method)) { // Expected to be IO#wait_readable
+      state_label->str  = DDOG_CHARSLICE_C("network");
+    } else if (CHARSLICE_EQUALS("_native_idle_sampling_loop", method)) { // Expected to be Datadog::Profiler::Collectors::IdleSamplingHelper#_native_idle_sampling_loop
+      state_label->str  = DDOG_CHARSLICE_C("waiting");
+    } else if (CHARSLICE_EQUALS("_native_sampling_loop", method)) { // Expected to be Datadog::Profiler::Collectors::CpuAndWallTimeWorker#_native_sampling_loop
+      state_label->str  = DDOG_CHARSLICE_C("sleeping");
+    }
+    #ifdef NO_PRIMITIVE_POP // Ruby < 3.2
+      else if (CHARSLICE_EQUALS("pop", method)) { // Expected to be Queue/SizedQueue#pop
+        state_label->str  = DDOG_CHARSLICE_C("waiting");
+      }
+    #endif
+  } else {
+    #ifndef NO_PRIMITIVE_POP // Ruby >= 3.2
+      if (CHARSLICE_EQUALS("<internal:thread_sync>", filename)) {
+        if (CHARSLICE_EQUALS("pop", method)) { // Expected to be Queue/SizedQueue#pop
+          state_label->str  = DDOG_CHARSLICE_C("waiting");
+        }
+        #ifndef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby >= 4
+          else if (CHARSLICE_EQUALS("synchronize", method) || CHARSLICE_EQUALS("lock", method)) { // Expected to be Mutex#lock/synchronize
+            state_label->str  = DDOG_CHARSLICE_C("blocked");
+          } else if (CHARSLICE_EQUALS("sleep", method)) { // Expected to be Mutex#sleep
+            state_label->str  = DDOG_CHARSLICE_C("sleeping");
+          } else if (CHARSLICE_EQUALS("wait", method)) { // Expected to be ConditionVariable#wait
+            state_label->str  = DDOG_CHARSLICE_C("waiting");
+          }
+        #endif
+      }
+    #endif
+  }
+}
+
 // Idea: Should we release the global vm lock (GVL) after we get the data from `rb_profile_frames`? That way other Ruby threads
 // could continue making progress while the sample was ingested into the profile.
 //
@@ -354,91 +431,45 @@ void sample_thread(
       );
     }
 
-    VALUE name = ddtrace_location_base_label(cme, iseq);
-    // TODO: name_slice is currently the unqualified method name
-    // because we don't always use qualified method names yet, so we don't always compute it,
-    // and checks below need to compare to something stable until we always qualified method names.
-    ddog_CharSlice name_slice = (name == Qfalse) ? DDOG_CHARSLICE_C("") : char_slice_from_ruby_string(name);
+    // This frame kept the name we composed for it in an earlier sample, so there's nothing to compose or trim again
+    char *cached_name = buffer->cached_names == NULL ? NULL : buffer->cached_names + (i * MAX_CACHED_FRAME_NAME);
+    // The length is only ever set together with the name it describes, and frames start out zeroed
+    bool name_is_cached = frame.cached_name_len > 0;
 
-    ddog_CharSlice qualified_name = DDOG_CHARSLICE_C("");
-    if (show_classes) {
+    ddog_CharSlice frame_name;
+    // We only keep a name we managed to compose: ddtrace_location_label() also fails when this stack used up the
+    // scratch buffer, and keeping the unqualified name it falls back to would stick to the frame even once there's
+    // room for it again.
+    bool name_is_cacheable = false;
+    if (name_is_cached) {
+      frame_name = (ddog_CharSlice) {.ptr = cached_name, .len = frame.cached_name_len};
+    } else if (show_classes) {
       ssize_t written = ddtrace_location_label(cme, iseq, qualified_name_buf, qualified_name_buf_size);
       if (written > 0) {
-        qualified_name = (ddog_CharSlice) {.ptr = qualified_name_buf, .len = written};
+        frame_name = (ddog_CharSlice) {.ptr = qualified_name_buf, .len = written};
         qualified_name_buf += written;
         qualified_name_buf_size -= written;
+        name_is_cacheable = true;
       } else {
-        qualified_name = name_slice; // just the method name
+        frame_name = unqualified_name(cme, iseq); // just the method name
       }
+    } else {
+      frame_name = unqualified_name(cme, iseq);
     }
 
-    // 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?
-      if (labels.is_gvl_waiting_state) {
-        state_label->str = DDOG_CHARSLICE_C("waiting for gvl");
-
-      // Otherwise, we try to categorize what the thread was doing based on what we observe at the top of the stack. This is a very rough
-      // approximation, and in the future we hope to replace this with a more accurate approach (such as using the
-      // GVL instrumentation API.)
-      } else if (!frame.is_ruby_frame) {
-        // We know that known versions of Ruby implement these using native code; thus if we find a method with the
-        // same name that is not native code, we ignore it, as it's probably a user method that coincidentally
-        // has the same name. Thus, even though "matching just by method name" is kinda weak,
-        // "matching by method name" + is native code seems actually to be good enough for a lot of cases.
-
-        if (CHARSLICE_EQUALS("sleep", name_slice)) { // Expected to be Kernel.sleep
-          state_label->str  = DDOG_CHARSLICE_C("sleeping");
-        } else if (CHARSLICE_EQUALS("select", name_slice)) { // Expected to be Kernel.select
-          state_label->str  = DDOG_CHARSLICE_C("waiting");
-        } else if (
-            CHARSLICE_EQUALS("synchronize", name_slice) || // Expected to be Monitor/Mutex#synchronize on Ruby 2 & 3, and Monitor#synchronize on 4 (Mutex becomes <internal:thread_sync>)
-            #ifdef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby < 4
-              CHARSLICE_EQUALS("lock", name_slice) ||        // Expected to be Mutex#lock
-            #endif
-            CHARSLICE_EQUALS("join", name_slice)           // Expected to be Thread#join
-        ) {
-          state_label->str  = DDOG_CHARSLICE_C("blocked");
-        } else if (CHARSLICE_EQUALS("wait_readable", name_slice)) { // Expected to be IO#wait_readable
-          state_label->str  = DDOG_CHARSLICE_C("network");
-        } else if (CHARSLICE_EQUALS("_native_idle_sampling_loop", name_slice)) { // Expected to be Datadog::Profiler::Collectors::IdleSamplingHelper#_native_idle_sampling_loop
-          state_label->str  = DDOG_CHARSLICE_C("waiting");
-        } else if (CHARSLICE_EQUALS("_native_sampling_loop", name_slice)) { // Expected to be Datadog::Profiler::Collectors::CpuAndWallTimeWorker#_native_sampling_loop
-          state_label->str  = DDOG_CHARSLICE_C("sleeping");
-        }
-        #ifdef NO_PRIMITIVE_POP // Ruby < 3.2
-          else if (CHARSLICE_EQUALS("pop", name_slice)) { // Expected to be Queue/SizedQueue#pop
-            state_label->str  = DDOG_CHARSLICE_C("waiting");
-          }
-        #endif
-      } else {
-        #ifndef NO_PRIMITIVE_POP // Ruby >= 3.2
-          if (CHARSLICE_EQUALS("<internal:thread_sync>", filename_slice)) {
-            if (CHARSLICE_EQUALS("pop", name_slice)) { // Expected to be Queue/SizedQueue#pop
-              state_label->str  = DDOG_CHARSLICE_C("waiting");
-            }
-            #ifndef NO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE // Ruby >= 4
-              else if (CHARSLICE_EQUALS("synchronize", name_slice) || CHARSLICE_EQUALS("lock", name_slice)) { // Expected to be Mutex#lock/synchronize
-                state_label->str  = DDOG_CHARSLICE_C("blocked");
-              } else if (CHARSLICE_EQUALS("sleep", name_slice)) { // Expected to be Mutex#sleep
-                state_label->str  = DDOG_CHARSLICE_C("sleeping");
-              } else if (CHARSLICE_EQUALS("wait", name_slice)) { // Expected to be ConditionVariable#wait
-                state_label->str  = DDOG_CHARSLICE_C("waiting");
-              }
-            #endif
-          }
-        #endif
-      }
+      categorize_sample_state(labels, frame, unqualified_name(cme, iseq), filename_slice);
     }
 
-    ddog_CharSlice frame_name;
-    if (show_classes) {
-      frame_name = qualified_name;
-    } else {
-      frame_name = name_slice;
-    }
+    if (!name_is_cached) {
+      maybe_trim_template_random_ids(&frame_name, filename_slice, name_is_cacheable);
 
-    maybe_trim_template_random_ids(&frame_name, &filename_slice);
+      // Keep this name for as long as the frame stays in the buffer
+      if (cached_name != NULL && name_is_cacheable && frame_name.len <= MAX_CACHED_FRAME_NAME) {
+        memcpy(cached_name, frame_name.ptr, frame_name.len);
+        buffer->stack_buffer[i].cached_name_len = frame_name.len;
+      }
+    }
 
     int libdatadog_stores_stacks_flipped_from_rb_profile_frames_index = top_of_stack_position - i;
 
@@ -548,33 +579,56 @@ static const char *get_or_compute_native_filename(void *function, st_table *nati
 //  the extra "_".)
 //
 // This method trims these suffixes, so that we keep less data + the names correctly aggregate together.
-static void maybe_trim_template_random_ids(ddog_CharSlice *name_slice, ddog_CharSlice *filename_slice) {
+//
+// The ids end `frame_name`, or sit right before DDTRACE_BLOCK_SUFFIX
+// ("Foo#_app_views_articles_index_html_erb__123_456 (block)"); in that case we move the suffix left over the ids.
+// That write needs a name we composed ourselves, which is what `frame_name_in_scratch_buffer` tells us.
+static void maybe_trim_template_random_ids(
+  ddog_CharSlice *frame_name,
+  ddog_CharSlice filename,
+  bool frame_name_in_scratch_buffer
+) {
   // Check filename doesn't end with ".rb"; templates are usually along the lines of .html.erb/.html.haml/...
-  if (filename_slice->len < 3 || memcmp(filename_slice->ptr + filename_slice->len - 3, ".rb", 3) == 0) return;
+  if (filename.len < 3 || memcmp(filename.ptr + filename.len - 3, ".rb", 3) == 0) return;
+
+  if (frame_name->len > 1024) return;
+  if (frame_name->len == 0) return;
+
+  static const char block_suffix[] = DDTRACE_BLOCK_SUFFIX;
+  size_t block_suffix_len = sizeof(block_suffix) - 1;
 
-  if (name_slice->len > 1024) return;
-  if (name_slice->len == 0) return;
+  size_t len = frame_name->len;
+  bool has_block_suffix =
+    frame_name_in_scratch_buffer &&
+    len > block_suffix_len &&
+    memcmp(frame_name->ptr + len - block_suffix_len, block_suffix, block_suffix_len) == 0;
+  if (has_block_suffix) len -= block_suffix_len;
 
-  int pos = ((int) name_slice->len) - 1;
+  int pos = ((int) len) - 1;
 
   // Let's match on something__number_number:
   // Find start of id suffix from the end...
-  if (name_slice->ptr[pos] < '0' || name_slice->ptr[pos] > '9') return;
+  if (frame_name->ptr[pos] < '0' || frame_name->ptr[pos] > '9') return;
 
   // ...now match a bunch of numbers and interspersed underscores
   for (int underscores = 0; pos >= 0 && underscores < 2; pos--) {
-    if (name_slice->ptr[pos] == '_') underscores++;
-    else if (name_slice->ptr[pos] < '0' || name_slice->ptr[pos] > '9') return;
+    if (frame_name->ptr[pos] == '_') underscores++;
+    else if (frame_name->ptr[pos] < '0' || frame_name->ptr[pos] > '9') return;
   }
 
   // Make sure there's something left before the underscores (hence the <= instead of <) + match the last underscore
-  if (pos <= 0 || name_slice->ptr[pos] != '_') return;
+  if (pos <= 0 || frame_name->ptr[pos] != '_') return;
 
   // Does it have the optional third underscore? If so, remove it as well
-  if (pos > 1 && name_slice->ptr[pos-1] == '_') pos--;
+  if (pos > 1 && frame_name->ptr[pos-1] == '_') pos--;
 
   // If we got here, we matched on our pattern. Let's slice the length of the string to exclude it.
-  name_slice->len = pos;
+  if (has_block_suffix) {
+    memcpy((char *) frame_name->ptr + pos, block_suffix, block_suffix_len);
+    frame_name->len = pos + block_suffix_len;
+  } else {
+    frame_name->len = pos;
+  }
 }
 
 static void add_truncated_frames_placeholder(ddog_prof_Location *locations) {
@@ -680,7 +734,7 @@ uint16_t sampling_buffer_check_max_frames(int max_frames) {
   return max_frames;
 }
 
-void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames) {
+void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, bool cache_names) {
   sampling_buffer_check_max_frames(max_frames);
 
   buffer->max_frames = max_frames;
@@ -688,16 +742,19 @@ void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames) {
   buffer->pending_sample = false;
   buffer->is_marking = false;
   buffer->pending_sample_result = 0;
+  buffer->cached_names = cache_names ? ruby_xcalloc(max_frames, MAX_CACHED_FRAME_NAME) : NULL;
 }
 
 void sampling_buffer_free(sampling_buffer *buffer) {
   ruby_xfree(buffer->stack_buffer);
+  ruby_xfree(buffer->cached_names);
 
   buffer->max_frames = 0;
   buffer->stack_buffer = NULL;
   buffer->pending_sample = false;
   buffer->is_marking = false;
   buffer->pending_sample_result = 0;
+  buffer->cached_names = NULL;
 }
 
 void sampling_buffer_mark(sampling_buffer *buffer) {

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -8,6 +8,10 @@
 #define MAX_FRAMES_LIMIT            3000
 #define MAX_FRAMES_LIMIT_AS_STRING "3000"
 
+// Longest qualified frame name we keep per frame in `sampling_buffer`. Longer names are still reported, they just get
+// composed again on every sample; this bounds the per-thread memory the cache costs (max_frames * this).
+#define MAX_CACHED_FRAME_NAME 96
+
 // Per thread, where we store the stack sample
 typedef struct {
   uint16_t max_frames;
@@ -15,6 +19,10 @@ typedef struct {
   bool pending_sample;
   bool is_marking; // Used to avoid recording a sample when marking (marking can happen outside of GC as well)
   int pending_sample_result;
+  // Qualified frame names from the last sample, MAX_CACHED_FRAME_NAME bytes per frame (NULL when not qualifying names).
+  // A frame keeps its name for as long as it stays in `stack_buffer`, which is most of the time: between two samples
+  // of a thread, usually only the frames close to the top of the stack change.
+  char *cached_names;
 } sampling_buffer;
 
 // 1 per ThreadContext so effectively global.
@@ -55,7 +63,7 @@ void sample_locations_initialize(sample_locations *locations, uint16_t max_frame
 void sample_locations_free(sample_locations *locations);
 
 uint16_t sampling_buffer_check_max_frames(int max_frames);
-void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames);
+void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, bool cache_names);
 void sampling_buffer_free(sampling_buffer *buffer);
 void sampling_buffer_mark(sampling_buffer *buffer);
 static inline bool sampling_buffer_needs_marking(sampling_buffer *buffer) {

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -122,6 +122,10 @@ static ID otel_fiber_context_storage_id; // id of :@opentelemetry_context in Rub
 // in settings.rb. See `initialize_context` for details on why this is needed/used.
 static uint16_t latest_max_frames = 400;
 
+// Same as `latest_max_frames`, for deciding whether new sampling buffers need room to cache qualified frame names.
+// Should be kept in sync with the default for DD_PROFILING_EXPERIMENTAL_SHOW_CLASSES_ENABLED in settings.rb.
+static bool latest_show_classes = true;
+
 // Global tracepoint for RUBY_EVENT_THREAD_BEGIN. Created and enabled once when the first ThreadContext collector is initialized.
 static VALUE thread_begin_tracepoint = Qnil;
 
@@ -1265,7 +1269,7 @@ static void initialize_context(VALUE thread, per_thread_context *thread_context,
   // We always create per_thread_context's with latest_max_frames; that value is kept in sync with the
   // active profiler's max_frames by the global reset that runs when profiling starts
   // so we expect to always see here the latest correct value to be used.
-  sampling_buffer_initialize(&thread_context->sampling_buffer, latest_max_frames);
+  sampling_buffer_initialize(&thread_context->sampling_buffer, latest_max_frames, latest_show_classes);
 
   snprintf(thread_context->thread_id, THREAD_ID_LIMIT_CHARS, "%"PRIu64" (%lu)", native_thread_id_for(thread), (unsigned long) thread_id_for(thread));
   thread_context->thread_id_char_slice = (ddog_CharSlice) {.ptr = thread_context->thread_id, .len = strlen(thread_context->thread_id)};
@@ -1327,6 +1331,7 @@ void thread_context_collector_reset_all_per_thread_contexts(VALUE self_instance)
   }
 
   latest_max_frames = state->locations.len;
+  latest_show_classes = state->show_classes;
 
   long current_monotonic_wall_time_ns = monotonic_wall_time_now_ns();
 

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -20,7 +20,7 @@ def skip_building_extension!(reason)
     Datadog::Profiling::NativeExtensionHelpers::Supported.failure_banner_for(
       **reason,
       fail_install: fail_install_if_missing_extension,
-    )
+    ),
   )
 
   File.write(
@@ -32,7 +32,7 @@ def skip_building_extension!(reason)
     require "mkmf"
     Logging.message(
       "[datadog] Failure cause: " \
-      "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
+      "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n",
     )
   else
     File.write("Makefile", "all install clean: # dummy makefile that does nothing")
@@ -63,7 +63,7 @@ $stderr.puts(
 | Thanks for using datadog! You rock!                                          |
 +------------------------------------------------------------------------------+
 
-)
+),
 )
 
 # NOTE: we MUST NOT require 'mkmf' before we check the #skip_building_extension? because the require triggers checks
@@ -89,12 +89,10 @@ append_cflags "-Werror" if ENV["DATADOG_GEM_CI"] == "true"
 # header lands upstream in libdatadog/libdatadog-rb. Remove this once that ships.
 append_cflags "-Wno-error=typedef-redefinition" if ENV["DATADOG_GEM_CI"] == "true"
 
-# Older gcc releases may not default to C99 and we need to ask for this. This is also used:
-# * by upstream Ruby -- search for gnu99 in the codebase
-# * by msgpack, another datadog gem dependency
-#   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
-# @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
-append_cflags RUBY_PLATFORM.include?("darwin") ? "-std=gnu11" : "-std=gnu99"
+unless try_cflags("-std=gnu11") && have_type("atomic_int", ["stdatomic.h"])
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_C11_MISSING)
+end
+$CFLAGS += " -std=gnu11"
 
 # Gets really noisy when we include the private VM headers, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 append_cflags "-Wno-unused-function"
@@ -225,10 +223,6 @@ end
 
 Datadog::LibdatadogExtconfHelpers.add_libdatadog_version_define
 
-unless have_type("atomic_int", ["stdatomic.h"])
-  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
-end
-
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -94,9 +94,9 @@ module Datadog
         )
 
         # Validation for this check is done in extconf.rb because it relies on mkmf
-        COMPILER_ATOMIC_MISSING = explain_issue(
-          "your C compiler is missing support for the <stdatomic.h> header.",
-          "This issue can usually be fixed by upgrading to a later version of your",
+        COMPILER_C11_MISSING = explain_issue(
+          "your C compiler does not support C11 (-std=gnu11).",
+          "This issue can be fixed by upgrading to a later version of your",
           "operating system image or compiler.",
           suggested: CONTACT_SUPPORT,
         )