ddtrace 1.14.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae7238650b45da9d8bf8f5834af2a29153081e798c2c8733c9bffb8768b6c430
-  data.tar.gz: b9bc8f36d37b91d18754892bd8dbc92cd515b9e38caf8561e23b665f14ee5e9e
+  metadata.gz: 59aaa9c3c11af9219405c9eee4e318df4cafdaae57eb42c7b5105d46764d3293
+  data.tar.gz: ef0d6766221287a4e9d42bf42f43fd5ddd81990ea381e536b5083be8a3f0b94d
 SHA512:
-  metadata.gz: 4b4cdffa9d4ee39e6763be4a87dbdf3e351fd29915d4eaea45dc9c800543c65c8eb21375138422280cfed5715d8f23e95e58190752af6631c14453d39b29b263
-  data.tar.gz: fbc970e48e5e5038775368618e672ab7b2405cd6ea9b899136b34e9ae776f26a92436087fb0810ef7d66574c2f694cdea03197cf980b08dc35a9defcf4c3dc74
+  metadata.gz: 0201e1fd1e96ea0a076cf88af3824cb02f15862312eb26688db474caec2698bdfee9381b947e4ab278bbaa752aeb8a92df2f2188aa7e4ba988e5cdc31331f138
+  data.tar.gz: 2a034e4187f41b85a29d7003fbe1098552cdddf0be663e490ab2ca71c4da40a8ad122f3357b11286af10df988f0891cc8d2d71ca59d9949db790dda6011033d0

data/CHANGELOG.md

@@ -2,6 +2,91 @@
 
 ## [Unreleased]
 
+## [1.16.0] - 2023-11-03
+
+**This release includes a security change for the Tracing Redis integration:**
+
+Currently, the Datadog Agent removes command arguments from the resource name. However there are cases, like Redis compressed keys, where this obfuscation cannot correctly remove command arguments. To safeguard that situation, the resource name set by the tracer will only be the command (e.g. `SET`) with no arguments. To retain the previous behavior and keep arguments in the span resource, with the potential risk of some command arguments not being fully obfuscated, set ``DD_REDIS_COMMAND_ARGS=true`` or set the option `c.instrument :redis, command_args: true`.
+
+### Added
+
+* Tracing: Propagate trace through `Concurrent::Promises.future` ([#1522][])
+* Core: Name `Datadog::Core::Remote::Worker` thread ([#3207][])
+
+### Changed
+
+* Tracing: Redis - Omit command arguments from span.resource by default ([#3235][])
+* Ci-app: Bump `datadog-ci` dependency from 0.2.0 to 0.3.0 ([#3223][])
+
+### Fixed
+
+* Appsec: ASM parse response body  ([#3153][])
+* Appsec: ASM make sure to append content type and length information ([#3204][])
+* Appsec: Make sure function that checks content-type header value accepts nil content-type header value ([#3234][])
+* Profiling: Shut down profiler if any components failed ([#3197][])
+* Tracing: Fix `ActiveSupport` instrumentation of custom cache stores ([#3206][])
+
+## [1.15.0] - 2023-10-09
+
+### Highlights
+
+* Timeline view for Profiler beta
+* Configure AppSec blocking responses via configuration or Remote Configuration
+* CI visibility to configure with agentless mode
+
+For more details, check the [release notes](https://github.com/DataDog/dd-trace-rb/releases/tag/v1.15.0)
+
+### Added
+
+* Enable allocation counting feature by default for some Ruby 3 versions ([#3176][])
+* Detect `WebMock` `Cucumber` and `Rails.env` to disable telemetry and remote configuration for development environment ([#3065][], [#3062][], [#3145][])
+* Profiling: Import java-profiler PID controller and port it to C ([#3190][])
+* Profiling: Record allocation type when sampling objects ([#3096][])
+* Profiling: Include `ruby vm type` in profiler allocation samples ([#3074][])
+* Tracing: Support `Rack` 3 ([#3132][])
+* Tracing: Support `Opensearch` 3 ([#3189][])
+* Tracing: `grpc` adds `client_error_handler` option ([#3095][])
+* Tracing: Add `async` option for `test_mode` configuration ([#3158][])
+* Tracing: Implements `_dd.base_service` tag ([#3018][])
+* Appsec: Allow blocking response template configuration via ENV variables  ([#2975][])
+* Appsec: ASM API security. Schema extraction ([#3131][], [#3166][], [#3177][])
+* Appsec: Enable configuring blocking response via Remote Configuration  ([#3099][])
+* Ci-app: Validate git tags ([#3100][])
+* Ci-app: Add agentless mode ([#3186][])
+
+### Changed
+
+* Appsec: Skip passing waf addresses when the value is empty ([#3188][])
+* Profiling: Restore support for Ruby 3.3 ([#3167][])
+* Profiling: Add approximate thread state categorization for timeline ([#3162][])
+* Profiling: Wire up allocation sampling into `CpuAndWallTimeWorker` ([#3103][])
+* Tracing: `dalli` disable memcached command tag by default ([#3171][])
+* Tracing: Use first valid extracted style for distributed tracing ([#2879][])
+* Tracing: Rename configuration option `on_set` to `after_set` ([#3107][])
+* Tracing: Rename `experimental_default_proc` to `default_proc` ([#3091][])
+* Tracing: Use `peer.service` for sql comment propagation ([#3127][])
+* Ci-app: Fix `Datadog::CI::Environment` to support the new CI specs ([#3080][])
+* Bump `datadog-ci` dependency to 0.2 ([#3186][])
+* Bump `debase-ruby_core_source` dependency to 3.2.2 ([#3163][])
+* Upgrade `libdatadog` 5 ([#3169][], [#3104][])
+* Upgrade `libddwaf-rb` 1.11.0 ([#3087][])
+* Update AppSec rules to 1.8.0 ([#3140][], [#3139][])
+
+### Fixed
+
+* Profiling: Add workaround for incorrect invoke location when logging gem is in use ([#3183][])
+* Profiling: Fix missing endpoint profiling when `request_queuing` is enabled in `rack` instrumentation ([#3109][])
+* Appsec: Span tags reporting the number of WAF failed loaded rules ([#3106][])
+* Tracing: Fix tagging with empty data ([#3102][])
+* Tracing: Fix `rails.cache.backend` span tag with multiple stores ([#3060][])
+
+### Removed
+
+* Profiling: Remove legacy profiler codepath ([#3172][])
+* Ci-app: Remove CI module and add a dependency on [`datadog-ci` gem](https://github.com/DataDog/datadog-ci-rb) ([#3128][])
+* Tracing: Remove `depends_on` option from configuration DSL ([#3085][])
+* Tracing: Remove `delegate_to` option from configuration DSL ([#3086][])
+
 ## [1.14.0] - 2023-08-24
 
 ### Added
@@ -2534,7 +2619,10 @@ 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.14.0...master
+
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.16.0...master
+[1.16.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.15.0...v1.16.0
+[1.15.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.14.0...v1.15.0
 [1.14.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.1...1.14.0
 [1.13.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.0...1.13.1
 [1.13.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.12.1...v1.13.0
@@ -3271,6 +3359,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#1509]: https://github.com/DataDog/dd-trace-rb/issues/1509
 [#1510]: https://github.com/DataDog/dd-trace-rb/issues/1510
 [#1511]: https://github.com/DataDog/dd-trace-rb/issues/1511
+[#1522]: https://github.com/DataDog/dd-trace-rb/issues/1522
 [#1523]: https://github.com/DataDog/dd-trace-rb/issues/1523
 [#1524]: https://github.com/DataDog/dd-trace-rb/issues/1524
 [#1529]: https://github.com/DataDog/dd-trace-rb/issues/1529
@@ -3624,6 +3713,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2874]: https://github.com/DataDog/dd-trace-rb/issues/2874
 [#2875]: https://github.com/DataDog/dd-trace-rb/issues/2875
 [#2877]: https://github.com/DataDog/dd-trace-rb/issues/2877
+[#2879]: https://github.com/DataDog/dd-trace-rb/issues/2879
 [#2882]: https://github.com/DataDog/dd-trace-rb/issues/2882
 [#2883]: https://github.com/DataDog/dd-trace-rb/issues/2883
 [#2890]: https://github.com/DataDog/dd-trace-rb/issues/2890
@@ -3659,6 +3749,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2972]: https://github.com/DataDog/dd-trace-rb/issues/2972
 [#2973]: https://github.com/DataDog/dd-trace-rb/issues/2973
 [#2974]: https://github.com/DataDog/dd-trace-rb/issues/2974
+[#2975]: https://github.com/DataDog/dd-trace-rb/issues/2975
 [#2977]: https://github.com/DataDog/dd-trace-rb/issues/2977
 [#2978]: https://github.com/DataDog/dd-trace-rb/issues/2978
 [#2982]: https://github.com/DataDog/dd-trace-rb/issues/2982
@@ -3671,6 +3762,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3005]: https://github.com/DataDog/dd-trace-rb/issues/3005
 [#3007]: https://github.com/DataDog/dd-trace-rb/issues/3007
 [#3011]: https://github.com/DataDog/dd-trace-rb/issues/3011
+[#3018]: https://github.com/DataDog/dd-trace-rb/issues/3018
 [#3019]: https://github.com/DataDog/dd-trace-rb/issues/3019
 [#3020]: https://github.com/DataDog/dd-trace-rb/issues/3020
 [#3022]: https://github.com/DataDog/dd-trace-rb/issues/3022
@@ -3685,8 +3777,60 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3054]: https://github.com/DataDog/dd-trace-rb/issues/3054
 [#3056]: https://github.com/DataDog/dd-trace-rb/issues/3056
 [#3057]: https://github.com/DataDog/dd-trace-rb/issues/3057
+[#3060]: https://github.com/DataDog/dd-trace-rb/issues/3060
 [#3061]: https://github.com/DataDog/dd-trace-rb/issues/3061
+[#3062]: https://github.com/DataDog/dd-trace-rb/issues/3062
+[#3065]: https://github.com/DataDog/dd-trace-rb/issues/3065
 [#3070]: https://github.com/DataDog/dd-trace-rb/issues/3070
+[#3074]: https://github.com/DataDog/dd-trace-rb/issues/3074
+[#3080]: https://github.com/DataDog/dd-trace-rb/issues/3080
+[#3085]: https://github.com/DataDog/dd-trace-rb/issues/3085
+[#3086]: https://github.com/DataDog/dd-trace-rb/issues/3086
+[#3087]: https://github.com/DataDog/dd-trace-rb/issues/3087
+[#3091]: https://github.com/DataDog/dd-trace-rb/issues/3091
+[#3095]: https://github.com/DataDog/dd-trace-rb/issues/3095
+[#3096]: https://github.com/DataDog/dd-trace-rb/issues/3096
+[#3099]: https://github.com/DataDog/dd-trace-rb/issues/3099
+[#3100]: https://github.com/DataDog/dd-trace-rb/issues/3100
+[#3102]: https://github.com/DataDog/dd-trace-rb/issues/3102
+[#3103]: https://github.com/DataDog/dd-trace-rb/issues/3103
+[#3104]: https://github.com/DataDog/dd-trace-rb/issues/3104
+[#3106]: https://github.com/DataDog/dd-trace-rb/issues/3106
+[#3107]: https://github.com/DataDog/dd-trace-rb/issues/3107
+[#3109]: https://github.com/DataDog/dd-trace-rb/issues/3109
+[#3127]: https://github.com/DataDog/dd-trace-rb/issues/3127
+[#3128]: https://github.com/DataDog/dd-trace-rb/issues/3128
+[#3131]: https://github.com/DataDog/dd-trace-rb/issues/3131
+[#3132]: https://github.com/DataDog/dd-trace-rb/issues/3132
+[#3139]: https://github.com/DataDog/dd-trace-rb/issues/3139
+[#3140]: https://github.com/DataDog/dd-trace-rb/issues/3140
+[#3145]: https://github.com/DataDog/dd-trace-rb/issues/3145
+[#3148]: https://github.com/DataDog/dd-trace-rb/issues/3148
+[#3150]: https://github.com/DataDog/dd-trace-rb/issues/3150
+[#3152]: https://github.com/DataDog/dd-trace-rb/issues/3152
+[#3153]: https://github.com/DataDog/dd-trace-rb/issues/3153
+[#3158]: https://github.com/DataDog/dd-trace-rb/issues/3158
+[#3162]: https://github.com/DataDog/dd-trace-rb/issues/3162
+[#3163]: https://github.com/DataDog/dd-trace-rb/issues/3163
+[#3166]: https://github.com/DataDog/dd-trace-rb/issues/3166
+[#3167]: https://github.com/DataDog/dd-trace-rb/issues/3167
+[#3169]: https://github.com/DataDog/dd-trace-rb/issues/3169
+[#3171]: https://github.com/DataDog/dd-trace-rb/issues/3171
+[#3172]: https://github.com/DataDog/dd-trace-rb/issues/3172
+[#3176]: https://github.com/DataDog/dd-trace-rb/issues/3176
+[#3177]: https://github.com/DataDog/dd-trace-rb/issues/3177
+[#3183]: https://github.com/DataDog/dd-trace-rb/issues/3183
+[#3186]: https://github.com/DataDog/dd-trace-rb/issues/3186
+[#3188]: https://github.com/DataDog/dd-trace-rb/issues/3188
+[#3189]: https://github.com/DataDog/dd-trace-rb/issues/3189
+[#3190]: https://github.com/DataDog/dd-trace-rb/issues/3190
+[#3197]: https://github.com/DataDog/dd-trace-rb/issues/3197
+[#3204]: https://github.com/DataDog/dd-trace-rb/issues/3204
+[#3206]: https://github.com/DataDog/dd-trace-rb/issues/3206
+[#3207]: https://github.com/DataDog/dd-trace-rb/issues/3207
+[#3223]: https://github.com/DataDog/dd-trace-rb/issues/3223
+[#3234]: https://github.com/DataDog/dd-trace-rb/issues/3234
+[#3235]: https://github.com/DataDog/dd-trace-rb/issues/3235
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3838,4 +3982,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_native_extension/NativeExtensionDesign.md

@@ -16,8 +16,7 @@ the gem. Setting `DD_PROFILING_NO_EXTENSION` at installation time skips compilat
 
 (If you're a customer and needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.)
 
-In past releases, it was possible for the profiler to run without the native extension, but that's no longer the case,
-and disabling the extension will disable profiling.
+Disabling the profiler extension will disable profiling.
 
 ## Who is this page for?
 
@@ -83,7 +82,7 @@ contribute upstream changes so that they become official public VM APIs.
 Ruby versions 2.6 to 3.2 shipped a JIT compiler called MJIT. This compiler does not directly generate machine code;
 instead it generates C code and uses the system C compiler to turn it into machine code.
 
-The generated C code `#include`s a private header -- which we reference as "the MJIT header" everywhere.
+The generated C code `#include`s a private header -- which we call "the MJIT header".
 The MJIT header gets shipped with all MJIT-enabled Rubies and includes the layout of many internal VM structures;
 and of course the intention is that it is only used by the Ruby MJIT compiler.
 
@@ -104,8 +103,7 @@ Thus, even though a regular Ruby installation does not include these files, we c
 * **OS support**: Linux
 
 To enable CPU-time profiling, we use the `pthread_getcpuclockid(pthread_t thread, clockid_t *clockid)` C function to
-obtain a `clockid_t` that can then be used with the `Process.clock_gettime` method (or directly with the
-`clock_gettime()` C function).
+obtain a `clockid_t` that can then be used with the `clock_gettime` function.
 
 The challenge with using `pthread_getcpuclockid()` is that we need to get the `pthread_t` for a given Ruby `Thread`
 object. We previously did this with a weird combination of monkey patching and `pthread_self()` (effectively patching

data/ext/ddtrace_profiling_native_extension/clock_id.h

@@ -17,9 +17,6 @@ typedef struct thread_cpu_time {
 
 void self_test_clock_id(void);
 
-// TODO: Remove this after the OldStack profiler gets removed
-VALUE clock_id_for(VALUE self, VALUE thread);
-
 // Safety: This function is assumed never to raise exceptions by callers
 thread_cpu_time_id thread_cpu_time_id_for(VALUE thread);
 thread_cpu_time thread_cpu_time_for(thread_cpu_time_id time_id);

data/ext/ddtrace_profiling_native_extension/clock_id_from_pthread.c

@@ -22,28 +22,6 @@ void self_test_clock_id(void) {
   if (expected_pthread_id != actual_pthread_id) rb_raise(rb_eRuntimeError, "pthread_id_for() self-test failed");
 }
 
-// TODO: Remove this after the OldStack profiler gets removed
-VALUE clock_id_for(DDTRACE_UNUSED VALUE _self, VALUE thread) {
-  rb_nativethread_id_t thread_id = pthread_id_for(thread);
-
-  clockid_t clock_id;
-  int error = pthread_getcpuclockid(thread_id, &clock_id);
-
-  if (error == 0) {
-    return CLOCKID2NUM(clock_id);
-  } else {
-    switch(error) {
-      // The more specific error messages are based on the pthread_getcpuclockid(3) man page
-      case ENOENT:
-        rb_exc_raise(rb_syserr_new(error, "Failed to get clock_id for given thread: Per-thread CPU time clocks are not supported by the system."));
-      case ESRCH:
-        rb_exc_raise(rb_syserr_new(error, "Failed to get clock_id for given thread: No thread could be found."));
-      default:
-        rb_exc_raise(rb_syserr_new(error, "Failed to get clock_id for given thread"));
-    }
-  }
-}
-
 // Safety: This function is assumed never to raise exceptions by callers
 thread_cpu_time_id thread_cpu_time_id_for(VALUE thread) {
   rb_nativethread_id_t thread_id = pthread_id_for(thread);

data/ext/ddtrace_profiling_native_extension/clock_id_noop.c

@@ -10,7 +10,6 @@
 #include "helpers.h"
 
 void self_test_clock_id(void) { } // Nothing to check
-VALUE clock_id_for(DDTRACE_UNUSED VALUE _self, DDTRACE_UNUSED VALUE _thread) { return Qnil; } // Nothing to return
 
 thread_cpu_time_id thread_cpu_time_id_for(DDTRACE_UNUSED VALUE _thread) {
   return (thread_cpu_time_id) {.valid = false};

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -83,6 +83,7 @@ struct cpu_and_wall_time_worker_state {
   bool allocation_counting_enabled;
   bool no_signals_workaround_enabled;
   bool dynamic_sampling_rate_enabled;
+  int allocation_sample_every; // Temporarily used for development/testing of allocation profiling
   VALUE self_instance;
   VALUE thread_context_collector_instance;
   VALUE idle_sampling_helper_instance;
@@ -150,7 +151,8 @@ static VALUE _native_initialize(
   VALUE idle_sampling_helper_instance,
   VALUE allocation_counting_enabled,
   VALUE no_signals_workaround_enabled,
-  VALUE dynamic_sampling_rate_enabled
+  VALUE dynamic_sampling_rate_enabled,
+  VALUE allocation_sample_every
 );
 static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr);
 static VALUE _native_sampling_loop(VALUE self, VALUE instance);
@@ -183,9 +185,10 @@ 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 on_newobj_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused);
 static void disable_tracepoints(struct cpu_and_wall_time_worker_state *state);
 static VALUE _native_with_blocked_sigprof(DDTRACE_UNUSED VALUE self);
+static VALUE rescued_sample_allocation(VALUE tracepoint_data);
 
 // Note on sampler global state safety:
 //
@@ -223,7 +226,7 @@ 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, 7);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 8);
   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);
@@ -257,10 +260,14 @@ static const rb_data_type_t cpu_and_wall_time_worker_typed_data = {
 static VALUE _native_new(VALUE klass) {
   struct cpu_and_wall_time_worker_state *state = ruby_xcalloc(1, sizeof(struct cpu_and_wall_time_worker_state));
 
+  // Note: Any exceptions raised from this note until the TypedData_Wrap_Struct call will lead to the state memory
+  // being leaked.
+
   state->gc_profiling_enabled = false;
   state->allocation_counting_enabled = false;
   state->no_signals_workaround_enabled = false;
   state->dynamic_sampling_rate_enabled = true;
+  state->allocation_sample_every = 0;
   state->thread_context_collector_instance = Qnil;
   state->idle_sampling_helper_instance = Qnil;
   state->owner_thread = Qnil;
@@ -287,12 +294,14 @@ static VALUE _native_initialize(
   VALUE idle_sampling_helper_instance,
   VALUE allocation_counting_enabled,
   VALUE no_signals_workaround_enabled,
-  VALUE dynamic_sampling_rate_enabled
+  VALUE dynamic_sampling_rate_enabled,
+  VALUE allocation_sample_every
 ) {
   ENFORCE_BOOLEAN(gc_profiling_enabled);
   ENFORCE_BOOLEAN(allocation_counting_enabled);
   ENFORCE_BOOLEAN(no_signals_workaround_enabled);
   ENFORCE_BOOLEAN(dynamic_sampling_rate_enabled);
+  ENFORCE_TYPE(allocation_sample_every, T_FIXNUM);
 
   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);
@@ -301,6 +310,12 @@ static VALUE _native_initialize(
   state->allocation_counting_enabled = (allocation_counting_enabled == Qtrue);
   state->no_signals_workaround_enabled = (no_signals_workaround_enabled == Qtrue);
   state->dynamic_sampling_rate_enabled = (dynamic_sampling_rate_enabled == Qtrue);
+  state->allocation_sample_every = NUM2INT(allocation_sample_every);
+
+  if (state->allocation_sample_every < 0) {
+    rb_raise(rb_eArgError, "Unexpected value for allocation_sample_every: %d. This value must be >= 0.", state->allocation_sample_every);
+  }
+
   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 */);
@@ -880,7 +895,7 @@ static VALUE _native_allocation_count(DDTRACE_UNUSED VALUE self) {
 
 // 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) {
+static void on_newobj_event(VALUE tracepoint_data, DDTRACE_UNUSED void *unused) {
   // Update thread-local allocation count
   if (RB_UNLIKELY(allocation_count == UINT64_MAX)) {
     allocation_count = 0;
@@ -907,7 +922,12 @@ static void on_newobj_event(DDTRACE_UNUSED VALUE tracepoint_data, DDTRACE_UNUSED
   // defined as not being able to allocate) sets this.
   state->during_sample = true;
 
-  // TODO: Sampling goes here (calling into `thread_context_collector_sample_allocation`)
+  // TODO: This is a placeholder sampling decision strategy. We plan to replace it with a better one soon (e.g. before
+  // beta), and having something here allows us to test the rest of feature, sampling decision aside.
+  if (state->allocation_sample_every > 0 && ((allocation_count % state->allocation_sample_every) == 0)) {
+    // Rescue against any exceptions that happen during sampling
+    safely_call(rescued_sample_allocation, tracepoint_data, state->self_instance);
+  }
 
   state->during_sample = false;
 }
@@ -929,3 +949,18 @@ static VALUE _native_with_blocked_sigprof(DDTRACE_UNUSED VALUE self) {
     return result;
   }
 }
+
+static VALUE rescued_sample_allocation(VALUE tracepoint_data) {
+  struct cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
+
+  // This should not happen in a normal situation because on_newobj_event already checked for this, but just in case...
+  if (state == NULL) return Qnil;
+
+  rb_trace_arg_t *data = rb_tracearg_from_tracepoint(tracepoint_data);
+  VALUE new_object = rb_tracearg_object(data);
+
+  thread_context_collector_sample_allocation(state->thread_context_collector_instance, state->allocation_sample_every, new_object);
+
+  // Return a dummy VALUE because we're called from rb_rescue2 which requires it
+  return Qnil;
+}

data/ext/ddtrace_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -78,6 +78,9 @@ static const rb_data_type_t idle_sampling_helper_typed_data = {
 static VALUE _native_new(VALUE klass) {
   struct idle_sampling_loop_state *state = ruby_xcalloc(1, sizeof(struct idle_sampling_loop_state));
 
+  // Note: Any exceptions raised from this note until the TypedData_Wrap_Struct call will lead to the state memory
+  // being leaked.
+
   reset_state(state);
 
   return TypedData_Wrap_Struct(klass, &idle_sampling_helper_typed_data, state);

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -23,7 +23,6 @@ struct sampling_buffer {
   int *lines_buffer;
   bool *is_ruby_frame;
   ddog_prof_Location *locations;
-  ddog_prof_Line *lines;
 }; // Note: typedef'd in the header to sampling_buffer
 
 static VALUE _native_sample(
@@ -41,7 +40,7 @@ static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
   sample_values values,
-  ddog_prof_Slice_Label labels,
+  sample_labels labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 );
@@ -50,7 +49,7 @@ static void sample_thread_internal(
   sampling_buffer* buffer,
   VALUE recorder_instance,
   sample_values values,
-  ddog_prof_Slice_Label labels,
+  sample_labels labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 );
@@ -86,13 +85,14 @@ static VALUE _native_sample(
   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)),
+    .cpu_or_wall_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)),
   };
 
   long labels_count = RARRAY_LEN(labels_array) + RARRAY_LEN(numeric_labels_array);
   ddog_prof_Label labels[labels_count];
+  ddog_prof_Label *state_label = NULL;
 
   for (int i = 0; i < RARRAY_LEN(labels_array); i++) {
     VALUE key_str_pair = rb_ary_entry(labels_array, i);
@@ -101,6 +101,10 @@ static VALUE _native_sample(
       .key = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 0)),
       .str = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 1))
     };
+
+    if (rb_str_equal(rb_ary_entry(key_str_pair, 0), rb_str_new_cstr("state"))) {
+      state_label = &labels[i];
+    }
   }
   for (int i = 0; i < RARRAY_LEN(numeric_labels_array); i++) {
     VALUE key_str_pair = rb_ary_entry(numeric_labels_array, i);
@@ -116,12 +120,14 @@ static VALUE _native_sample(
 
   sampling_buffer *buffer = sampling_buffer_new(max_frames_requested);
 
+  ddog_prof_Slice_Label slice_labels = {.ptr = labels, .len = labels_count};
+
   sample_thread(
     thread,
     buffer,
     recorder_instance,
     values,
-    (ddog_prof_Slice_Label) {.ptr = labels, .len = labels_count},
+    (sample_labels) {.labels = slice_labels, .state_label = state_label},
     RTEST(in_gc) ? SAMPLE_IN_GC : SAMPLE_REGULAR
   );
 
@@ -135,7 +141,7 @@ void sample_thread(
   sampling_buffer* buffer,
   VALUE recorder_instance,
   sample_values values,
-  ddog_prof_Slice_Label labels,
+  sample_labels labels,
   sample_type type
 ) {
   // Samples thread into recorder
@@ -150,7 +156,7 @@ void sample_thread(
   if (type == SAMPLE_IN_GC) {
     ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
     ddog_CharSlice function_filename = DDOG_CHARSLICE_C("Garbage Collection");
-    buffer->lines[0] = (ddog_prof_Line) {
+    buffer->locations[0] = (ddog_prof_Location) {
       .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
       .line = 0
     };
@@ -162,7 +168,6 @@ void sample_thread(
       .lines_buffer = buffer->lines_buffer + 1,
       .is_ruby_frame = buffer->is_ruby_frame + 1,
       .locations = buffer->locations + 1,
-      .lines = buffer->lines + 1
     };
     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;
@@ -173,6 +178,8 @@ void sample_thread(
   rb_raise(rb_eArgError, "Unexpected value for sample_type: %d", type);
 }
 
+#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)
+
 // 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.
 //
@@ -197,7 +204,7 @@ static void sample_thread_internal(
   sampling_buffer* buffer,
   VALUE recorder_instance,
   sample_values values,
-  ddog_prof_Slice_Label labels,
+  sample_labels labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 ) {
@@ -230,6 +237,15 @@ static void sample_thread_internal(
   VALUE last_ruby_frame = Qnil;
   int last_ruby_line = 0;
 
+  ddog_prof_Label *state_label = labels.state_label;
+  bool cpu_or_wall_sample = values.cpu_or_wall_samples > 0;
+  bool has_cpu_time = cpu_or_wall_sample && values.cpu_time_ns > 0;
+  bool only_wall_time = cpu_or_wall_sample && values.cpu_time_ns == 0 && values.wall_time_ns > 0;
+
+  if (cpu_or_wall_sample && state_label == NULL) rb_raise(rb_eRuntimeError, "BUG: Unexpected missing state_label");
+
+  if (has_cpu_time) state_label->str = DDOG_CHARSLICE_C("had cpu");
+
   for (int i = captured_frames - 1; i >= 0; i--) {
     VALUE name, filename;
     int line;
@@ -250,10 +266,55 @@ static void sample_thread_internal(
     name = NIL_P(name) ? missing_string : name;
     filename = NIL_P(filename) ? missing_string : filename;
 
-    buffer->lines[i] = (ddog_prof_Line) {
+    ddog_CharSlice name_slice = char_slice_from_ruby_string(name);
+    ddog_CharSlice filename_slice = char_slice_from_ruby_string(filename);
+
+    bool top_of_the_stack = i == 0;
+
+    // When there's only wall-time in a sample, this means that the thread was not active in the sampled period.
+    //
+    // We try to categorize what it 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.)
+    if (top_of_the_stack && only_wall_time) {
+      if (!buffer->is_ruby_frame[i]) {
+        // 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
+            CHARSLICE_EQUALS("lock", name_slice) ||        // Expected to be Mutex#lock
+            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");
+        }
+        #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
+          // Unlike the above, Ruby actually treats this one specially and gives it a nice file name we can match on!
+          if (CHARSLICE_EQUALS("pop", name_slice) && CHARSLICE_EQUALS("<internal:thread_sync>", filename_slice)) { // Expected to be Queue/SizedQueue#pop
+            state_label->str  = DDOG_CHARSLICE_C("waiting");
+          }
+        #endif
+      }
+    }
+
+    buffer->locations[i] = (ddog_prof_Location) {
       .function = (ddog_prof_Function) {
-        .name = char_slice_from_ruby_string(name),
-        .filename = char_slice_from_ruby_string(filename)
+        .name = name_slice,
+        .filename = filename_slice,
       },
       .line = line,
     };
@@ -292,7 +353,7 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
   // `record_sample`. So be careful where it gets allocated. (We do have tests for this, at least!)
   ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
   ddog_CharSlice function_filename = {.ptr = frames_omitted_message, .len = strlen(frames_omitted_message)};
-  buffer->lines[buffer->max_frames - 1] = (ddog_prof_Line) {
+  buffer->locations[buffer->max_frames - 1] = (ddog_prof_Location) {
     .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
     .line = 0,
   };
@@ -322,13 +383,13 @@ static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
   sample_values values,
-  ddog_prof_Slice_Label labels,
+  sample_labels labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 ) {
   ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
   ddog_CharSlice function_filename = DDOG_CHARSLICE_C("In native code");
-  buffer->lines[0] = (ddog_prof_Line) {
+  buffer->locations[0] = (ddog_prof_Location) {
     .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
     .line = 0
   };
@@ -354,14 +415,6 @@ sampling_buffer *sampling_buffer_new(unsigned int max_frames) {
   buffer->lines_buffer  = ruby_xcalloc(max_frames, sizeof(int));
   buffer->is_ruby_frame = ruby_xcalloc(max_frames, sizeof(bool));
   buffer->locations     = ruby_xcalloc(max_frames, sizeof(ddog_prof_Location));
-  buffer->lines         = ruby_xcalloc(max_frames, sizeof(ddog_prof_Line));
-
-  // Currently we have a 1-to-1 correspondence between lines and locations, so we just initialize the locations once
-  // here and then only mutate the contents of the lines.
-  for (unsigned int i = 0; i < max_frames; i++) {
-    ddog_prof_Slice_Line lines = (ddog_prof_Slice_Line) {.ptr = &buffer->lines[i], .len = 1};
-    buffer->locations[i] = (ddog_prof_Location) {.lines = lines};
-  }
 
   return buffer;
 }
@@ -373,7 +426,6 @@ void sampling_buffer_free(sampling_buffer *buffer) {
   ruby_xfree(buffer->lines_buffer);
   ruby_xfree(buffer->is_ruby_frame);
   ruby_xfree(buffer->locations);
-  ruby_xfree(buffer->lines);
 
   ruby_xfree(buffer);
 }