ddtrace 1.9.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ba4a81593411a12abfa1665b3910e49e35429b1b266779e93accb0f84a478d2
-  data.tar.gz: e72362dc1a1e682a3c52b8af8017fcd12e60d353843cdd129f65a55dbb0c312d
+  metadata.gz: 005fcbaaa9553287f8652a9f437abd144c2ba2ca0f26c83f67de171646f5aae3
+  data.tar.gz: 032c0d3f09ea01779b17ba45a95086ab890b3869208c84b82b548b3cbd41a977
 SHA512:
-  metadata.gz: a083b23cfadccc78e67a5aa2a3ae067bc868e4721d92d1fb9fcbadc7536332fabd20f6638fb157712e5e909afd3e3e505a2011838a4f0e98dbebaa64a38f7db6
-  data.tar.gz: 81b27dbbf685c01ee99ab79a8774aefca4a2feb93363a41e1a3465b01b1b07f571d5bdd75a73880658ae05254a3d742651bdf8df98fd48c040f73bb6a16702d0
+  metadata.gz: bc868d2e56e5282771cbc7e9447f1fa7504212d31b5bc94db4db9e5f029a00b0a9f988bcab7111f1889eb1f203fffcd81b73700c69f433be4bdaa2045dbfba72
+  data.tar.gz: d2679f725e7991bfa2e34dc6de650e928a59aa02124239d340a396ea40f331ff0a4a2159067df5ade22c1c36daab8e7cbe25db3ddaf55b8c8cb14137e7b2d220

data/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [1.10.1] - 2023-03-10
+
+### Fixed
+
+* CI: Update TeamCity environment variable support ([#2668][])
+* Core: Fix spurious dependency on AppSec when loading CI with `require 'datadog/ci'` ([#2679][])
+* Core: Allow multiple headers and multiple IPs per header for client IP ([#2665][])
+* AppSec: prevent side-effect on AppSec login event tracking method arguments ([#2663][]) ([@coneill-enhance][])
+
+## [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 +2323,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/v1.9.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.1...master
+[1.10.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.10.0...v1.10.1
+[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 +3298,43 @@ 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
+[#2663]: https://github.com/DataDog/dd-trace-rb/issues/2663
+[#2665]: https://github.com/DataDog/dd-trace-rb/issues/2665
+[#2668]: https://github.com/DataDog/dd-trace-rb/issues/2668
+[#2679]: https://github.com/DataDog/dd-trace-rb/issues/2679
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3304,6 +3379,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@cjford]: https://github.com/cjford
 [@ck3g]: https://github.com/ck3g
 [@components]: https://github.com/components
+[@coneill-enhance]: https://github.com/coneill-enhance
 [@cswatt]: https://github.com/cswatt
 [@cwoodcox]: https://github.com/cwoodcox
 [@danhodge]: https://github.com/danhodge

data/LICENSE-3rdparty.csv

@@ -5,3 +5,4 @@ lib/datadog/tracing/contrib/utils/quantization/http.rb,https://github.com/ruby/u
 ext/ddtrace_profiling_native_extension/private_vm_api_access,https://github.com/ruby/ruby,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"
 debase-ruby_core_source,https://rubygems.org/gems/debase-ruby_core_source,MIT for gem and BSD-2-Clause for Ruby sources,"Copyright (c) 2012 Gabriel Horner. Files from Ruby sources are Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved."
+lib/datadog/core/vendor/ipaddr,https://github.com/ruby/ipaddr/blob/master/lib/ipaddr.rb,BSD 2-Clause "Simplified" License,"Copyright (c) 2002 Hajimu UMEMOTO <ume@mahoroba.org> Copyright (c) 2007-2017 Akinori MUSHA <knu@iDaemons.org>"

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) {