ddtrace 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ba4a81593411a12abfa1665b3910e49e35429b1b266779e93accb0f84a478d2
-  data.tar.gz: e72362dc1a1e682a3c52b8af8017fcd12e60d353843cdd129f65a55dbb0c312d
+  metadata.gz: 1d6ef41c3e2f14b483d24a4aca9955a2a4b0ddf850d25e5e19932e62299c3905
+  data.tar.gz: de145f2e113f13e6d5d3360967e5fc3dc0273fb62c47dc6fae5d455e9c5f088c
 SHA512:
-  metadata.gz: a083b23cfadccc78e67a5aa2a3ae067bc868e4721d92d1fb9fcbadc7536332fabd20f6638fb157712e5e909afd3e3e505a2011838a4f0e98dbebaa64a38f7db6
-  data.tar.gz: 81b27dbbf685c01ee99ab79a8774aefca4a2feb93363a41e1a3465b01b1b07f571d5bdd75a73880658ae05254a3d742651bdf8df98fd48c040f73bb6a16702d0
+  metadata.gz: a3d6558cd4d7bbc1d8c6cdcb0500dec28eb8d451b9a92086db9cb70fec0ebf6f183c5a0b2b31287c364f9f322b3c9ad303f12b9826c808723684bab713e79563
+  data.tar.gz: 7ed0b3255a67e3d8016dc0a6a0769cbd95f960f6a6324ec79a27f16026e08dd3b3e9bb8e28d728797a72e6eca8b1ab73646ff815bae32a52358481c0501b864d

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [1.10.0] - 2023-03-06
+
+### Added
+
+* Support Ruby 3.2 ([#2601][])
+* Publish init container image (beta) for `dd-trace-rb` injection through K8s admission controller ([#2606][])
+* Tracing: Support 128 bits trace id  ([#2543][])
+* Tracing: Add tags to integrations (`que` / `racecar` / `resque`/ `shoryken` / `sneakers` / `qless` / `delayed_job` / `kafka` / `sidekiq` / `dalli` / `presto` / `elasticsearch`) ([#2619][],  [#2613][] , [#2608][], [#2590][])
+* Appsec: Introduce `AppSec::Instrumentation::Gateway::Argument` ([#2648][])
+* Appsec: Block request when user ID matches rules  ([#2642][])
+* Appsec: Block request base on response addresses matches ([#2605][])
+* Appsec: Allow to set user id denylist ([#2612][])
+* Profiling: Show profiler overhead in flamegraph for CPU Profiling 2.0 ([#2607][])
+* Profiling: Add support for allocation samples to `ThreadContext` ([#2657][])
+* Profiling: Exclude disabled profiling sample value types from output ([#2634][])
+* Profiling: Extend stack collector to record the alloc-samples metric ([#2618][])
+* Profiling: Add `Profiling.allocation_count` API for new profiler ([#2635][])
+
+### Changed
+
+* Tracing: `rack` instrumentation counts time spent in queue as part of the `http_server.queue` span ([#2591][]) ([@agrobbin][])
+* Appsec: Update ruleset to 1.5.2 ([#2662][], [#2659][], [#2598][])
+* Appsec: Update `libddwaf` version to 1.6.2.0.0 ([#2614][])
+* Profiling: Upgrade profiler to use `libdatadog` v2.0.0 ([#2599][])
+* Profiling: Remove support for profiling Ruby 2.2 ([#2592][])
+
+### Fixed
+
+* Fix broken Ruby VM statistics for Ruby 3.2 ([#2600][])
+* Tracing: Fix 'uninitialized constant GRPC::Interceptor' error with 'gapic-common' gem ([#2649][])
+* Profiling: Fix profiler not adding the "In native code" placeholder ([#2594][])
+* Fix profiler detection for google-protobuf installation ([#2595][])
+
 ## [1.9.0] - 2023-01-30
 
 As of ddtrace 1.9.0, CPU Profiling 2.0 is now in opt-in (that is, disabled by default) public beta. For more details, check the release notes.
@@ -2281,7 +2314,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/v1.9.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.0...master
+[1.10.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.9.0...v1.10.0
 [1.9.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.8.0...v1.9.0
 [1.8.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.7.0...v1.8.0
 [1.7.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.6.1...v1.7.0
@@ -3254,12 +3288,39 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2530]: https://github.com/DataDog/dd-trace-rb/issues/2530
 [#2531]: https://github.com/DataDog/dd-trace-rb/issues/2531
 [#2541]: https://github.com/DataDog/dd-trace-rb/issues/2541
+[#2543]: https://github.com/DataDog/dd-trace-rb/issues/2543
 [#2557]: https://github.com/DataDog/dd-trace-rb/issues/2557
 [#2562]: https://github.com/DataDog/dd-trace-rb/issues/2562
 [#2573]: https://github.com/DataDog/dd-trace-rb/issues/2573
 [#2576]: https://github.com/DataDog/dd-trace-rb/issues/2576
 [#2580]: https://github.com/DataDog/dd-trace-rb/issues/2580
 [#2586]: https://github.com/DataDog/dd-trace-rb/issues/2586
+[#2590]: https://github.com/DataDog/dd-trace-rb/issues/2590
+[#2591]: https://github.com/DataDog/dd-trace-rb/issues/2591
+[#2592]: https://github.com/DataDog/dd-trace-rb/issues/2592
+[#2594]: https://github.com/DataDog/dd-trace-rb/issues/2594
+[#2595]: https://github.com/DataDog/dd-trace-rb/issues/2595
+[#2598]: https://github.com/DataDog/dd-trace-rb/issues/2598
+[#2599]: https://github.com/DataDog/dd-trace-rb/issues/2599
+[#2600]: https://github.com/DataDog/dd-trace-rb/issues/2600
+[#2601]: https://github.com/DataDog/dd-trace-rb/issues/2601
+[#2605]: https://github.com/DataDog/dd-trace-rb/issues/2605
+[#2606]: https://github.com/DataDog/dd-trace-rb/issues/2606
+[#2607]: https://github.com/DataDog/dd-trace-rb/issues/2607
+[#2608]: https://github.com/DataDog/dd-trace-rb/issues/2608
+[#2612]: https://github.com/DataDog/dd-trace-rb/issues/2612
+[#2613]: https://github.com/DataDog/dd-trace-rb/issues/2613
+[#2614]: https://github.com/DataDog/dd-trace-rb/issues/2614
+[#2618]: https://github.com/DataDog/dd-trace-rb/issues/2618
+[#2619]: https://github.com/DataDog/dd-trace-rb/issues/2619
+[#2634]: https://github.com/DataDog/dd-trace-rb/issues/2634
+[#2635]: https://github.com/DataDog/dd-trace-rb/issues/2635
+[#2642]: https://github.com/DataDog/dd-trace-rb/issues/2642
+[#2648]: https://github.com/DataDog/dd-trace-rb/issues/2648
+[#2649]: https://github.com/DataDog/dd-trace-rb/issues/2649
+[#2657]: https://github.com/DataDog/dd-trace-rb/issues/2657
+[#2659]: https://github.com/DataDog/dd-trace-rb/issues/2659
+[#2662]: https://github.com/DataDog/dd-trace-rb/issues/2662
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3405,4 +3466,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/ext/ddtrace_profiling_loader/extconf.rb

@@ -1,5 +1,3 @@
-# typed: ignore
-
 # rubocop:disable Style/StderrPuts
 # rubocop:disable Style/GlobalVars
 

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -9,15 +9,15 @@
 
 #include "helpers.h"
 #include "ruby_helpers.h"
-#include "collectors_cpu_and_wall_time.h"
+#include "collectors_thread_context.h"
 #include "collectors_dynamic_sampling_rate.h"
 #include "collectors_idle_sampling_helper.h"
 #include "private_vm_api_access.h"
 #include "setup_signal_handler.h"
 #include "time_helpers.h"
 
-// Used to trigger the periodic execution of Collectors::CpuAndWallTime, which implements all of the sampling logic
-// itself; this class only implements the "doing it periodically" part.
+// Used to trigger the execution of Collectors::ThreadState, which implements all of the sampling logic
+// itself; this class only implements the "when to do it" part.
 //
 // This file implements the native bits of the Datadog::Profiling::Collectors::CpuAndWallTimeWorker class
 
@@ -61,7 +61,7 @@
 // "as soon as it can".
 //
 // 4. The Ruby VM calls our `sample_from_postponed_job` from a thread holding the global VM lock. A sample is recorded by
-// calling `cpu_and_wall_time_collector_sample`.
+// calling `thread_context_collector_sample`.
 //
 // ### TracePoints and Forking
 //
@@ -80,8 +80,9 @@ struct cpu_and_wall_time_worker_state {
   atomic_bool should_run;
 
   bool gc_profiling_enabled;
+  bool allocation_counting_enabled;
   VALUE self_instance;
-  VALUE cpu_and_wall_time_collector_instance;
+  VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
   VALUE owner_thread;
   dynamic_sampling_rate_state dynamic_sampling_rate;
@@ -95,6 +96,8 @@ struct cpu_and_wall_time_worker_state {
   // Used to get gc start/finish information
   VALUE gc_tracepoint;
 
+  VALUE object_allocation_tracepoint;
+
   struct stats {
     // How many times we tried to trigger a sample
     unsigned int trigger_sample_attempts;
@@ -119,9 +122,10 @@ static VALUE _native_new(VALUE klass);
 static VALUE _native_initialize(
   DDTRACE_UNUSED VALUE _self,
   VALUE self_instance,
-  VALUE cpu_and_wall_time_collector_instance,
+  VALUE thread_context_collector_instance,
   VALUE gc_profiling_enabled,
-  VALUE idle_sampling_helper_instance
+  VALUE idle_sampling_helper_instance,
+  VALUE allocation_counting_enabled
 );
 static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr);
 static VALUE _native_sampling_loop(VALUE self, VALUE instance);
@@ -153,6 +157,9 @@ void *simulate_sampling_signal_delivery(DDTRACE_UNUSED void *_unused);
 static void grab_gvl_and_sample(void);
 static void reset_stats(struct cpu_and_wall_time_worker_state *state);
 static void sleep_for(uint64_t time_ns);
+static VALUE _native_allocation_count(DDTRACE_UNUSED VALUE self);
+static void on_newobj_event(DDTRACE_UNUSED VALUE tracepoint_data, DDTRACE_UNUSED void *unused);
+static void disable_tracepoints(struct cpu_and_wall_time_worker_state *state);
 
 // Note on sampler global state safety:
 //
@@ -163,7 +170,14 @@ static void sleep_for(uint64_t time_ns);
 // This global state is needed because a bunch of functions on this file need to access it from situations
 // (e.g. signal handler) where it's impossible or just awkward to pass it as an argument.
 static VALUE active_sampler_instance = Qnil;
-struct cpu_and_wall_time_worker_state *active_sampler_instance_state = NULL;
+static struct cpu_and_wall_time_worker_state *active_sampler_instance_state = NULL;
+
+// Used to implement CpuAndWallTimeWorker._native_allocation_count . To be able to use cheap thread-local variables
+// (here with `__thread`, see https://gcc.gnu.org/onlinedocs/gcc/Thread-Local.html), this needs to be global.
+//
+// Carryover of state between profiler instances can happen and is not considered to be a problem -- see expectations for this
+// API documented in profiling.rb .
+__thread uint64_t allocation_count = 0;
 
 void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   rb_global_variable(&active_sampler_instance);
@@ -183,11 +197,12 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   // https://bugs.ruby-lang.org/issues/18007 for a discussion around this.
   rb_define_alloc_func(collectors_cpu_and_wall_time_worker_class, _native_new);
 
-  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 4);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 5);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_sampling_loop", _native_sampling_loop, 1);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stop", _native_stop, 2);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_stats", _native_stats, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_allocation_count", _native_allocation_count, 0);
   rb_define_singleton_method(testing_module, "_native_current_sigprof_signal_handler", _native_current_sigprof_signal_handler, 0);
   rb_define_singleton_method(testing_module, "_native_is_running?", _native_is_running, 1);
   rb_define_singleton_method(testing_module, "_native_install_testing_signal_handler", _native_install_testing_signal_handler, 0);
@@ -217,13 +232,15 @@ static VALUE _native_new(VALUE klass) {
 
   atomic_init(&state->should_run, false);
   state->gc_profiling_enabled = false;
-  state->cpu_and_wall_time_collector_instance = Qnil;
+  state->allocation_counting_enabled = false;
+  state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
   dynamic_sampling_rate_init(&state->dynamic_sampling_rate);
   state->failure_exception = Qnil;
   state->stop_thread = Qnil;
   state->gc_tracepoint = Qnil;
+  state->object_allocation_tracepoint = Qnil;
   reset_stats(state);
 
   return state->self_instance = TypedData_Wrap_Struct(klass, &cpu_and_wall_time_worker_typed_data, state);
@@ -232,19 +249,23 @@ static VALUE _native_new(VALUE klass) {
 static VALUE _native_initialize(
   DDTRACE_UNUSED VALUE _self,
   VALUE self_instance,
-  VALUE cpu_and_wall_time_collector_instance,
+  VALUE thread_context_collector_instance,
   VALUE gc_profiling_enabled,
-  VALUE idle_sampling_helper_instance
+  VALUE idle_sampling_helper_instance,
+  VALUE allocation_counting_enabled
 ) {
   ENFORCE_BOOLEAN(gc_profiling_enabled);
+  ENFORCE_BOOLEAN(allocation_counting_enabled);
 
   struct cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(self_instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
   state->gc_profiling_enabled = (gc_profiling_enabled == Qtrue);
-  state->cpu_and_wall_time_collector_instance = enforce_cpu_and_wall_time_collector_instance(cpu_and_wall_time_collector_instance);
+  state->allocation_counting_enabled = (allocation_counting_enabled == Qtrue);
+  state->thread_context_collector_instance = enforce_thread_context_collector_instance(thread_context_collector_instance);
   state->idle_sampling_helper_instance = idle_sampling_helper_instance;
   state->gc_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_GC_ENTER | RUBY_INTERNAL_EVENT_GC_EXIT, on_gc_event, NULL /* unused */);
+  state->object_allocation_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, on_newobj_event, NULL /* unused */);
 
   return Qtrue;
 }
@@ -253,12 +274,13 @@ static VALUE _native_initialize(
 static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr) {
   struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
 
-  rb_gc_mark(state->cpu_and_wall_time_collector_instance);
+  rb_gc_mark(state->thread_context_collector_instance);
   rb_gc_mark(state->idle_sampling_helper_instance);
   rb_gc_mark(state->owner_thread);
   rb_gc_mark(state->failure_exception);
   rb_gc_mark(state->stop_thread);
   rb_gc_mark(state->gc_tracepoint);
+  rb_gc_mark(state->object_allocation_tracepoint);
 }
 
 // Called in a background thread created in CpuAndWallTimeWorker#start
@@ -275,14 +297,13 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
       );
     } else {
       // The previously active thread seems to have died without cleaning up after itself.
-      // In this case, we can still go ahead and start the profiler BUT we make sure to disable any existing GC tracepoint
+      // In this case, we can still go ahead and start the profiler BUT we make sure to disable any existing tracepoint
       // first as:
       // a) If this is a new instance of the CpuAndWallTimeWorker, we don't want the tracepoint from the old instance
       //    being kept around
       // b) If this is the same instance of the CpuAndWallTimeWorker if we call enable on a tracepoint that is already
       //    enabled, it will start firing more than once, see https://bugs.ruby-lang.org/issues/19114 for details.
-
-      rb_tracepoint_disable(old_state->gc_tracepoint);
+      disable_tracepoints(old_state);
     }
   }
 
@@ -308,7 +329,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
 
   // The sample trigger loop finished (either cleanly or with an error); let's clean up
 
-  rb_tracepoint_disable(state->gc_tracepoint);
+  disable_tracepoints(state);
 
   active_sampler_instance_state = NULL;
   active_sampler_instance = Qnil;
@@ -360,8 +381,8 @@ static VALUE stop(VALUE self_instance, VALUE optional_exception) {
   atomic_store(&state->should_run, false);
   state->failure_exception = optional_exception;
 
-  // Disable the GC tracepoint as soon as possible, so the VM doesn't keep on calling it
-  rb_tracepoint_disable(state->gc_tracepoint);
+  // Disable the tracepoints as soon as possible, so the VM doesn't keep on calling them
+  disable_tracepoints(state);
 
   return Qtrue;
 }
@@ -481,7 +502,8 @@ static VALUE rescued_sample_from_postponed_job(VALUE self_instance) {
 
   state->stats.sampled++;
 
-  cpu_and_wall_time_collector_sample(state->cpu_and_wall_time_collector_instance, wall_time_ns_before_sample);
+  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);
 
   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;
@@ -527,10 +549,11 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
   struct cpu_and_wall_time_worker_state *state;
   TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
-  // Final preparations: Setup signal handler and enable tracepoint. We run these here and not in `_native_sampling_loop`
+  // Final preparations: Setup signal handler and enable tracepoints. We run these here and not in `_native_sampling_loop`
   // because they may raise exceptions.
   install_sigprof_signal_handler(handle_sampling_signal, "handle_sampling_signal");
   if (state->gc_profiling_enabled) rb_tracepoint_enable(state->gc_tracepoint);
+  if (state->allocation_counting_enabled) rb_tracepoint_enable(state->object_allocation_tracepoint);
 
   rb_thread_call_without_gvl(run_sampling_trigger_loop, state, interrupt_sampling_trigger_loop, state);
 
@@ -586,9 +609,9 @@ static VALUE _native_gc_tracepoint(DDTRACE_UNUSED VALUE self, VALUE instance) {
 // when the RUBY_INTERNAL_EVENT_GC_ENTER and RUBY_INTERNAL_EVENT_GC_EXIT events are triggered.
 //
 // See the comments on
-// * cpu_and_wall_time_collector_on_gc_start
-// * cpu_and_wall_time_collector_on_gc_finish
-// * cpu_and_wall_time_collector_sample_after_gc
+// * thread_context_collector_on_gc_start
+// * thread_context_collector_on_gc_finish
+// * thread_context_collector_sample_after_gc
 //
 // For the expected times in which to call them, and their assumptions.
 //
@@ -610,11 +633,11 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
   if (state == NULL) return;
 
   if (event == RUBY_INTERNAL_EVENT_GC_ENTER) {
-    cpu_and_wall_time_collector_on_gc_start(state->cpu_and_wall_time_collector_instance);
+    thread_context_collector_on_gc_start(state->thread_context_collector_instance);
   } else if (event == RUBY_INTERNAL_EVENT_GC_EXIT) {
     // Design: In an earlier iteration of this feature (see https://github.com/DataDog/dd-trace-rb/pull/2308) we
-    // actually had a single method to implement the behavior of both cpu_and_wall_time_collector_on_gc_finish
-    // and cpu_and_wall_time_collector_sample_after_gc (the latter is called via after_gc_from_postponed_job).
+    // actually had a single method to implement the behavior of both thread_context_collector_on_gc_finish
+    // and thread_context_collector_sample_after_gc (the latter is called via after_gc_from_postponed_job).
     //
     // Unfortunately, then we discovered the safety issue around no allocations, and thus decided to separate them -- so that
     // the sampling could run outside the tight safety constraints of the garbage collection process.
@@ -624,11 +647,11 @@ static void on_gc_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
     // it should be pointing at.
     // Alternatives to solve this would be to capture no stack for garbage collection (as we do for Java and .net);
     // making the sampling process allocation-safe (very hard); or separate stack sampling from sample recording,
-    // e.g. enabling us to capture the stack in cpu_and_wall_time_collector_on_gc_finish and do the rest later
+    // e.g. enabling us to capture the stack in thread_context_collector_on_gc_finish and do the rest later
     // (medium hard).
 
-    cpu_and_wall_time_collector_on_gc_finish(state->cpu_and_wall_time_collector_instance);
-    // We use rb_postponed_job_register_one to ask Ruby to run cpu_and_wall_time_collector_sample_after_gc after if
+    thread_context_collector_on_gc_finish(state->thread_context_collector_instance);
+    // We use rb_postponed_job_register_one to ask Ruby to run thread_context_collector_sample_after_gc after if
     // fully finishes the garbage collection, so that one is allowed to do allocations and throw exceptions as usual.
     //
     // Note: If we ever want to get rid of rb_postponed_job_register_one, remember not to clobber Ruby exceptions, as
@@ -649,8 +672,8 @@ 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
   }
 
-  // Trigger sampling using the Collectors::CpuAndWallTime; rescue against any exceptions that happen during sampling
-  safely_call(cpu_and_wall_time_collector_sample_after_gc, state->cpu_and_wall_time_collector_instance, state->self_instance);
+  // Trigger sampling using the Collectors::ThreadState; rescue against any exceptions that happen during sampling
+  safely_call(thread_context_collector_sample_after_gc, state->thread_context_collector_instance, state->self_instance);
 }
 
 // Equivalent to Ruby begin/rescue call, where we call a C function and jump to the exception handler if an
@@ -694,12 +717,12 @@ static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance)
   TypedData_Get_Struct(instance, struct cpu_and_wall_time_worker_state, &cpu_and_wall_time_worker_typed_data, state);
 
   // Disable all tracepoints, so that there are no more attempts to mutate the profile
-  rb_tracepoint_disable(state->gc_tracepoint);
+  disable_tracepoints(state);
 
   reset_stats(state);
 
-  // Remove all state from the `Collectors::CpuAndWallTime` and connected downstream components
-  rb_funcall(state->cpu_and_wall_time_collector_instance, rb_intern("reset_after_fork"), 0);
+  // Remove all state from the `Collectors::ThreadState` and connected downstream components
+  rb_funcall(state->thread_context_collector_instance, rb_intern("reset_after_fork"), 0);
 
   return Qtrue;
 }
@@ -774,3 +797,25 @@ static void sleep_for(uint64_t time_ns) {
     }
   }
 }
+
+static VALUE _native_allocation_count(DDTRACE_UNUSED VALUE self) {
+  bool is_profiler_running = active_sampler_instance_state != NULL;
+
+  return is_profiler_running ? ULL2NUM(allocation_count) : Qnil;
+}
+
+// Implements memory-related profiling events. This function is called by Ruby via the `object_allocation_tracepoint`
+// when the RUBY_INTERNAL_EVENT_NEWOBJ event is triggered.
+static void on_newobj_event(DDTRACE_UNUSED VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
+  // Update thread-local allocation count
+  if (RB_UNLIKELY(allocation_count == UINT64_MAX)) {
+    allocation_count = 0;
+  } else {
+    allocation_count++;
+  }
+}
+
+static void disable_tracepoints(struct cpu_and_wall_time_worker_state *state) {
+  rb_tracepoint_disable(state->gc_tracepoint);
+  rb_tracepoint_disable(state->object_allocation_tracepoint);
+}

data/ext/ddtrace_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -170,15 +170,15 @@ static void interrupt_idle_sampling_loop(void *state_ptr) {
   // ask the thread to stop, instead of exiting early.
 
   error = pthread_mutex_lock(&state->wakeup_mutex);
-  if (error) { fprintf(stderr, "[DDTRACE] Error during pthread_mutex_lock in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
+  if (error) { fprintf(stderr, "[ddtrace] Error during pthread_mutex_lock in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
 
   state->requested_action = ACTION_STOP;
 
   error = pthread_mutex_unlock(&state->wakeup_mutex);
-  if (error) { fprintf(stderr, "[DDTRACE] Error during pthread_mutex_unlock in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
+  if (error) { fprintf(stderr, "[ddtrace] Error during pthread_mutex_unlock in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
 
   error = pthread_cond_broadcast(&state->wakeup);
-  if (error) { fprintf(stderr, "[DDTRACE] Error during pthread_cond_broadcast in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
+  if (error) { fprintf(stderr, "[ddtrace] Error during pthread_cond_broadcast in interrupt_idle_sampling_loop (%s)\n", strerror(error)); }
 }
 
 static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance) {

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -32,6 +32,7 @@ static VALUE _native_sample(
   VALUE recorder_instance,
   VALUE metric_values_hash,
   VALUE labels_array,
+  VALUE numeric_labels_array,
   VALUE max_frames,
   VALUE in_gc
 );
@@ -39,7 +40,7 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
 static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_I64 metric_values,
+  sample_values values,
   ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
@@ -48,7 +49,7 @@ static void sample_thread_internal(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_I64 metric_values,
+  sample_values values,
   ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
@@ -60,7 +61,7 @@ void collectors_stack_init(VALUE profiling_module) {
   // Hosts methods used for testing the native code using RSpec
   VALUE testing_module = rb_define_module_under(collectors_stack_class, "Testing");
 
-  rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 6);
+  rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 7);
 
   missing_string = rb_str_new2("");
   rb_global_variable(&missing_string);
@@ -74,31 +75,26 @@ static VALUE _native_sample(
   VALUE recorder_instance,
   VALUE metric_values_hash,
   VALUE labels_array,
+  VALUE numeric_labels_array,
   VALUE max_frames,
   VALUE in_gc
 ) {
   ENFORCE_TYPE(metric_values_hash, T_HASH);
   ENFORCE_TYPE(labels_array, T_ARRAY);
+  ENFORCE_TYPE(numeric_labels_array, T_ARRAY);
+
+  VALUE zero = INT2NUM(0);
+  sample_values values = {
+    .cpu_time_ns   = NUM2UINT(rb_hash_lookup2(metric_values_hash, rb_str_new_cstr("cpu-time"),      zero)),
+    .cpu_samples   = NUM2UINT(rb_hash_lookup2(metric_values_hash, rb_str_new_cstr("cpu-samples"),   zero)),
+    .wall_time_ns  = NUM2UINT(rb_hash_lookup2(metric_values_hash, rb_str_new_cstr("wall-time"),     zero)),
+    .alloc_samples = NUM2UINT(rb_hash_lookup2(metric_values_hash, rb_str_new_cstr("alloc-samples"), zero)),
+  };
 
-  if (RHASH_SIZE(metric_values_hash) != ENABLED_VALUE_TYPES_COUNT) {
-    rb_raise(
-      rb_eArgError,
-      "Mismatched values for metrics; expected %lu values and got %lu instead",
-      ENABLED_VALUE_TYPES_COUNT,
-      RHASH_SIZE(metric_values_hash)
-    );
-  }
-
-  int64_t metric_values[ENABLED_VALUE_TYPES_COUNT];
-  for (unsigned int i = 0; i < ENABLED_VALUE_TYPES_COUNT; i++) {
-    VALUE metric_value = rb_hash_fetch(metric_values_hash, rb_str_new_cstr(enabled_value_types[i].type_.ptr));
-    metric_values[i] = NUM2LONG(metric_value);
-  }
-
-  long labels_count = RARRAY_LEN(labels_array);
+  long labels_count = RARRAY_LEN(labels_array) + RARRAY_LEN(numeric_labels_array);
   ddog_prof_Label labels[labels_count];
 
-  for (int i = 0; i < labels_count; i++) {
+  for (int i = 0; i < RARRAY_LEN(labels_array); i++) {
     VALUE key_str_pair = rb_ary_entry(labels_array, i);
 
     labels[i] = (ddog_prof_Label) {
@@ -106,6 +102,14 @@ static VALUE _native_sample(
       .str = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 1))
     };
   }
+  for (int i = 0; i < RARRAY_LEN(numeric_labels_array); i++) {
+    VALUE key_str_pair = rb_ary_entry(numeric_labels_array, i);
+
+    labels[i + RARRAY_LEN(labels_array)] = (ddog_prof_Label) {
+      .key = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 0)),
+      .num = NUM2ULL(rb_ary_entry(key_str_pair, 1))
+    };
+  }
 
   int max_frames_requested = NUM2INT(max_frames);
   if (max_frames_requested < 0) rb_raise(rb_eArgError, "Invalid max_frames: value must not be negative");
@@ -116,7 +120,7 @@ static VALUE _native_sample(
     thread,
     buffer,
     recorder_instance,
-    (ddog_Slice_I64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
+    values,
     (ddog_prof_Slice_Label) {.ptr = labels, .len = labels_count},
     RTEST(in_gc) ? SAMPLE_IN_GC : SAMPLE_REGULAR
   );
@@ -130,7 +134,7 @@ void sample_thread(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_I64 metric_values,
+  sample_values values,
   ddog_prof_Slice_Label labels,
   sample_type type
 ) {
@@ -138,7 +142,7 @@ void sample_thread(
   if (type == SAMPLE_REGULAR) {
     sampling_buffer *record_buffer = buffer;
     int extra_frames_in_record_buffer = 0;
-    sample_thread_internal(thread, buffer, recorder_instance, metric_values, labels, record_buffer, extra_frames_in_record_buffer);
+    sample_thread_internal(thread, buffer, recorder_instance, values, labels, record_buffer, extra_frames_in_record_buffer);
     return;
   }
 
@@ -162,7 +166,7 @@ void sample_thread(
     };
     sampling_buffer *record_buffer = buffer; // We pass in the original buffer as the record_buffer, but not as the regular buffer
     int extra_frames_in_record_buffer = 1;
-    sample_thread_internal(thread, &thread_in_gc_buffer, recorder_instance, metric_values, labels, record_buffer, extra_frames_in_record_buffer);
+    sample_thread_internal(thread, &thread_in_gc_buffer, recorder_instance, values, labels, record_buffer, extra_frames_in_record_buffer);
     return;
   }
 
@@ -192,7 +196,7 @@ static void sample_thread_internal(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_I64 metric_values,
+  sample_values values,
   ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
@@ -210,7 +214,7 @@ static void sample_thread_internal(
     record_placeholder_stack_in_native_code(
       buffer,
       recorder_instance,
-      metric_values,
+      values,
       labels,
       record_buffer,
       extra_frames_in_record_buffer
@@ -238,18 +242,7 @@ static void sample_thread_internal(
       filename = rb_profile_frame_path(buffer->stack_buffer[i]);
       line = buffer->lines_buffer[i];
     } else {
-      // **IMPORTANT**: Be very careful when calling any `rb_profile_frame_...` API with a non-Ruby frame, as legacy
-      // Rubies may assume that what's in a buffer will lead to a Ruby frame.
-      //
-      // In particular for Ruby 2.2 the buffer contains a Ruby string (see the notes on our custom
-      // rb_profile_frames for Ruby 2.2) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
-
-#ifndef USE_LEGACY_RB_PROFILE_FRAMES // Modern Rubies
       name = ddtrace_rb_profile_frame_method_name(buffer->stack_buffer[i]);
-#else // Ruby < 2.3
-      name = buffer->stack_buffer[i];
-#endif
-
       filename = NIL_P(last_ruby_frame) ? Qnil : rb_profile_frame_path(last_ruby_frame);
       line = last_ruby_line;
     }
@@ -278,11 +271,9 @@ static void sample_thread_internal(
 
   record_sample(
     recorder_instance,
-    (ddog_prof_Sample) {
-      .locations = (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = captured_frames + extra_frames_in_record_buffer},
-      .values = metric_values,
-      .labels = labels,
-    }
+    (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = captured_frames + extra_frames_in_record_buffer},
+    values,
+    labels
   );
 }
 
@@ -330,7 +321,7 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
 static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_I64 metric_values,
+  sample_values values,
   ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
@@ -344,11 +335,9 @@ static void record_placeholder_stack_in_native_code(
 
   record_sample(
     recorder_instance,
-    (ddog_prof_Sample) {
-      .locations = (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = 1 + extra_frames_in_record_buffer},
-      .values = metric_values,
-      .labels = labels,
-    }
+    (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = 1 + extra_frames_in_record_buffer},
+    values,
+    labels
   );
 }