ddtrace 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 583531c81dd828631484d4d0d312b77fda75ee12b2a6a4e60c1d235a2743394d
-  data.tar.gz: c398e707e66269cc1857d0da25932ec89b943d14202206d5e540c0b9d449f1b8
+  metadata.gz: 38409b6f228216767057d98b4acb4cc0effeecd34e6b98e202dde946aa4aec99
+  data.tar.gz: 6a5b909f6a73516c965c1125b7c70fe212972bf89ac829e0cabc356d82a353a0
 SHA512:
-  metadata.gz: ef70965d60a3bd97e474b74a59e3d88eeea026a2cc8c843ca96f2aa2e137d4a5a6dcf9a9bc1b1ba282cabf9fa73bc54038b698c06ec2769ffe50e767802cb0eb
-  data.tar.gz: b3c24f7d7322a1a3b080b2decc8262f8cf62ba9ccd59629345696c3b3285f8404ad6a42b3dad6c359d37623ce2a30b392c720d70164605162487ee5cf2a5e483
+  metadata.gz: 73d2114938c7a420a6846042c3172f4b08b5a9fb5b68efc6aa155441fa80d6221201ff1a09afbcbd8ccb12655590622326510cf17995443cd1e5cadca0fedbb3
+  data.tar.gz: 6c8005ac09cb122bbcf32ee569799f61ada81f8e7a735b2b754e0b0f2969a77980b95a1d8871440efe8e617a3c53c77b4f286dceb98be00dd446684ed5bec43b

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [1.7.0] - 2022-11-29
+
+### Added
+* Integrations: Support que 2 ([#2382][]) ([@danhodge][])
+* Tracing: Unified tagging `span.kind` as `server` and `client` ([#2365][])
+* Tracing: Adds `span.kind` tag for `kafka`, `sidekiq`, `racecar`,  `que`, `shoryuken`, `sneakers`, and `resque` ([#2420][], [#2419][], [#2413][], [#2394][])
+* Tracing: Adds `span.kind` with values `producer` and `consumer` for `delayed_job` ([#2393][])
+* Tracing: Adds `span.kind` as `client` for `redis` ([#2392][])
+* Appsec: Pass HTTP client IP to WAF ([#2316][])
+* Unified tagging `process_id` ([#2276][])
+
+### Changed
+* Allow `debase-ruby_core_source` 0.10.18 to be used ([#2435][])
+* Update AppSec ruleset to v1.4.2 ([#2390][])
+* Refactored clearing of profile data after Ruby app forks ([#2362][], [#2367][])
+* Tracing: Move distributed propagation to Contrib ([#2352][])
+
+### Fixed
+* Fix ddtrace installation issue when users have CI=true ([#2378][])
+
+## [1.6.1] - 2022-11-16
+
+### Changed
+
+* Limit `redis` version support to less than 5
+
+### Fixed
+
+* [redis]: Fix frozen input for `Redis.new(...)`
+
 ## [1.6.0] - 2022-11-15
 
 ### Added
@@ -2188,7 +2218,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.6.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.7.0...master
+[1.7.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.6.1...v1.7.0
+[1.6.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.5.2...v1.6.0
 [1.5.2]: https://github.com/DataDog/dd-trace-rb/compare/v1.5.1...v1.5.2
 [1.5.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.5.0...v1.5.1
@@ -3091,6 +3123,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2260]: https://github.com/DataDog/dd-trace-rb/issues/2260
 [#2265]: https://github.com/DataDog/dd-trace-rb/issues/2265
 [#2267]: https://github.com/DataDog/dd-trace-rb/issues/2267
+[#2276]: https://github.com/DataDog/dd-trace-rb/issues/2276
 [#2279]: https://github.com/DataDog/dd-trace-rb/issues/2279
 [#2283]: https://github.com/DataDog/dd-trace-rb/issues/2283
 [#2289]: https://github.com/DataDog/dd-trace-rb/issues/2289
@@ -3103,6 +3136,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2310]: https://github.com/DataDog/dd-trace-rb/issues/2310
 [#2311]: https://github.com/DataDog/dd-trace-rb/issues/2311
 [#2313]: https://github.com/DataDog/dd-trace-rb/issues/2313
+[#2316]: https://github.com/DataDog/dd-trace-rb/issues/2316
 [#2317]: https://github.com/DataDog/dd-trace-rb/issues/2317
 [#2318]: https://github.com/DataDog/dd-trace-rb/issues/2318
 [#2319]: https://github.com/DataDog/dd-trace-rb/issues/2319
@@ -3113,7 +3147,21 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2331]: https://github.com/DataDog/dd-trace-rb/issues/2331
 [#2335]: https://github.com/DataDog/dd-trace-rb/issues/2335
 [#2339]: https://github.com/DataDog/dd-trace-rb/issues/2339
+[#2352]: https://github.com/DataDog/dd-trace-rb/issues/2352
+[#2362]: https://github.com/DataDog/dd-trace-rb/issues/2362
 [#2363]: https://github.com/DataDog/dd-trace-rb/issues/2363
+[#2365]: https://github.com/DataDog/dd-trace-rb/issues/2365
+[#2367]: https://github.com/DataDog/dd-trace-rb/issues/2367
+[#2378]: https://github.com/DataDog/dd-trace-rb/issues/2378
+[#2382]: https://github.com/DataDog/dd-trace-rb/issues/2382
+[#2390]: https://github.com/DataDog/dd-trace-rb/issues/2390
+[#2392]: https://github.com/DataDog/dd-trace-rb/issues/2392
+[#2393]: https://github.com/DataDog/dd-trace-rb/issues/2393
+[#2394]: https://github.com/DataDog/dd-trace-rb/issues/2394
+[#2413]: https://github.com/DataDog/dd-trace-rb/issues/2413
+[#2419]: https://github.com/DataDog/dd-trace-rb/issues/2419
+[#2420]: https://github.com/DataDog/dd-trace-rb/issues/2420
+[#2435]: https://github.com/DataDog/dd-trace-rb/issues/2435
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3159,6 +3207,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@components]: https://github.com/components
 [@cswatt]: https://github.com/cswatt
 [@cwoodcox]: https://github.com/cwoodcox
+[@danhodge]: https://github.com/danhodge
 [@dasch]: https://github.com/dasch
 [@dim]: https://github.com/dim
 [@dirk]: https://github.com/dirk

data/ext/ddtrace_profiling_loader/extconf.rb

@@ -26,7 +26,7 @@ end
 
 # Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
 # But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
-add_compiler_flag '-Werror' if ENV['CI'] == 'true'
+add_compiler_flag '-Werror' if ENV['DDTRACE_CI'] == 'true'
 
 # Older gcc releases may not default to C99 and we need to ask for this. This is also used:
 # * by upstream Ruby -- search for gnu99 in the codebase

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time.c

@@ -66,10 +66,12 @@
 #define IS_NOT_WALL_TIME false
 #define MISSING_TRACER_CONTEXT_KEY 0
 
-static ID at_active_trace_id; // id of :@active_trace in Ruby
-static ID at_root_span_id;    // id of :@root_span in Ruby
 static ID at_active_span_id;  // id of :@active_span in Ruby
+static ID at_active_trace_id; // id of :@active_trace in Ruby
 static ID at_id_id;           // id of :@id in Ruby
+static ID at_resource_id;     // id of :@resource in Ruby
+static ID at_root_span_id;    // id of :@root_span in Ruby
+static ID at_type_id;         // id of :@type in Ruby
 
 // Contains state for a single CpuAndWallTime instance
 struct cpu_and_wall_time_collector_state {
@@ -91,7 +93,7 @@ struct cpu_and_wall_time_collector_state {
   // is not (just) a stat.
   unsigned int sample_count;
 
-  struct {
+  struct stats {
     // Track how many garbage collection samples we've taken.
     unsigned int gc_samples;
     // See cpu_and_wall_time_collector_on_gc_start for details
@@ -129,6 +131,7 @@ struct trace_identifiers {
   ddog_CharSlice span_id;
   char local_root_span_id_buffer[MAXIMUM_LENGTH_64_BIT_IDENTIFIER];
   char span_id_buffer[MAXIMUM_LENGTH_64_BIT_IDENTIFIER];
+  VALUE trace_endpoint;
 };
 
 static void cpu_and_wall_time_collector_typed_data_mark(void *state_ptr);
@@ -165,6 +168,8 @@ static long wall_time_now_ns(bool raise_on_failure);
 static long thread_id_for(VALUE thread);
 static VALUE _native_stats(VALUE self, VALUE collector_instance);
 static void trace_identifiers_for(struct cpu_and_wall_time_collector_state *state, VALUE thread, struct trace_identifiers *trace_identifiers_result);
+static bool is_type_web(VALUE root_span_type);
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE collector_instance);
 
 void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
@@ -184,6 +189,7 @@ void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
 
   rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_initialize", _native_initialize, 4);
   rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_inspect", _native_inspect, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
   rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 1);
   rb_define_singleton_method(testing_module, "_native_on_gc_start", _native_on_gc_start, 1);
   rb_define_singleton_method(testing_module, "_native_on_gc_finish", _native_on_gc_finish, 1);
@@ -192,10 +198,12 @@ void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
   rb_define_singleton_method(testing_module, "_native_per_thread_context", _native_per_thread_context, 1);
   rb_define_singleton_method(testing_module, "_native_stats", _native_stats, 1);
 
-  at_active_trace_id = rb_intern_const("@active_trace");
-  at_root_span_id = rb_intern_const("@root_span");
   at_active_span_id = rb_intern_const("@active_span");
+  at_active_trace_id = rb_intern_const("@active_trace");
   at_id_id = rb_intern_const("@id");
+  at_resource_id = rb_intern_const("@resource");
+  at_root_span_id = rb_intern_const("@root_span");
+  at_type_id = rb_intern_const("@type");
 }
 
 // This structure is used to define a Ruby object that stores a pointer to a struct cpu_and_wall_time_collector_state
@@ -570,12 +578,29 @@ static void trigger_sample_for_thread(
     };
   }
 
-  struct trace_identifiers trace_identifiers_result = {.valid = false};
+  struct trace_identifiers trace_identifiers_result = {.valid = false, .trace_endpoint = Qnil};
   trace_identifiers_for(state, thread, &trace_identifiers_result);
 
   if (trace_identifiers_result.valid) {
     labels[label_pos++] = (ddog_Label) {.key = DDOG_CHARSLICE_C("local root span id"), .str = trace_identifiers_result.local_root_span_id};
     labels[label_pos++] = (ddog_Label) {.key = DDOG_CHARSLICE_C("span id"), .str = trace_identifiers_result.span_id};
+
+    if (trace_identifiers_result.trace_endpoint != Qnil) {
+      // The endpoint gets recorded in a different way because it is mutable in the tracer and can change during a
+      // trace.
+      //
+      // Instead of each sample for the same local_root_span_id getting a potentially-different endpoint,
+      // `record_endpoint` (via libdatadog) keeps a list of local_root_span_id values and their most-recently-seen
+      // endpoint values, and at serialization time the most-recently-seen endpoint is applied to all relevant samples.
+      //
+      // This is why the endpoint is not directly added in this function to the labels array, although it will later
+      // show up in the array in the output pprof.
+      record_endpoint(
+        state->recorder_instance,
+        trace_identifiers_result.local_root_span_id,
+        char_slice_from_ruby_string(trace_identifiers_result.trace_endpoint)
+      );
+    }
   }
 
   // The number of times `label_pos++` shows up in this function needs to match `max_label_count`. To avoid "oops I
@@ -862,4 +887,39 @@ static void trace_identifiers_for(struct cpu_and_wall_time_collector_state *stat
   };
 
   trace_identifiers_result->valid = true;
+
+  VALUE root_span_type = rb_ivar_get(root_span, at_type_id /* @type */);
+  if (root_span_type == Qnil || !is_type_web(root_span_type)) return;
+
+  VALUE trace_resource = rb_ivar_get(active_trace, at_resource_id /* @resource */);
+  if (RB_TYPE_P(trace_resource, T_STRING)) {
+    trace_identifiers_result->trace_endpoint = trace_resource;
+  } else if (trace_resource == Qnil) {
+    // Fall back to resource from span, if any
+    trace_identifiers_result->trace_endpoint = rb_ivar_get(root_span, at_resource_id /* @resource */);
+  }
+}
+
+static bool is_type_web(VALUE root_span_type) {
+  ENFORCE_TYPE(root_span_type, T_STRING);
+
+  return RSTRING_LEN(root_span_type) == strlen("web") &&
+    (memcmp("web", StringValuePtr(root_span_type), strlen("web")) == 0);
+}
+
+// After the Ruby VM forks, this method gets called in the child process to clean up any leftover state from the parent.
+//
+// Assumption: This method gets called BEFORE restarting profiling -- e.g. there are no components attempting to
+// trigger samples at the same time.
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE collector_instance) {
+  struct cpu_and_wall_time_collector_state *state;
+  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+
+  st_clear(state->hash_map_per_thread_context);
+
+  state->stats = (struct stats) {}; // Resets all stats back to zero
+
+  rb_funcall(state->recorder_instance, rb_intern("reset_after_fork"), 0);
+
+  return Qtrue;
 }

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -8,6 +8,7 @@
 #include "ruby_helpers.h"
 #include "collectors_cpu_and_wall_time.h"
 #include "private_vm_api_access.h"
+#include "setup_signal_handler.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.
@@ -29,7 +30,7 @@
 // internals, we may be able to figure out a way of overcoming it. But it's definitely going to be hard so for now
 // we're considering it as a given.
 //
-// ### Flow for triggering samples
+// ### Flow for triggering CPU/Wall-time samples
 //
 // The flow for triggering samples is as follows:
 //
@@ -56,6 +57,16 @@
 // 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`.
 //
+// ### TracePoints and Forking
+//
+// When the Ruby VM forks, the CPU/Wall-time profiling stops naturally because it's triggered by a background thread
+// that doesn't get automatically restarted by the VM on the child process. (The profiler does trigger its restart at
+// some point -- see `Profiling::Tasks::Setup` for details).
+//
+// But this doesn't apply to any `TracePoint`s this class may use, which will continue to be active. Thus, we need to
+// always remember consider this case of -- the worker thread may not be alive but the `TracePoint`s can continue to
+// trigger samples.
+//
 // ---
 
 // Contains state for a single CpuAndWallTimeWorker instance
@@ -86,9 +97,6 @@ static void cpu_and_wall_time_worker_typed_data_mark(void *state_ptr);
 static VALUE _native_sampling_loop(VALUE self, VALUE instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance);
 static VALUE stop(VALUE self_instance, VALUE optional_exception);
-static void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *));
-static void remove_sigprof_signal_handler(void);
-static void block_sigprof_signal_handler_from_running_in_current_thread(void);
 static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 static void *run_sampling_trigger_loop(void *state_ptr);
 static void interrupt_sampling_trigger_loop(void *state_ptr);
@@ -107,6 +115,7 @@ static void after_gc_from_postponed_job(DDTRACE_UNUSED void *_unused);
 static void safely_call(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg, VALUE instance);
 static VALUE _native_simulate_handle_sampling_signal(DDTRACE_UNUSED VALUE self);
 static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE self);
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE instance);
 
 // Global state -- be very careful when accessing or modifying it
 
@@ -139,6 +148,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
   rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_initialize", _native_initialize, 3);
   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, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_worker_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
   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);
@@ -235,7 +245,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
 
   block_sigprof_signal_handler_from_running_in_current_thread(); // We want to interrupt the thread with the global VM lock, never this one
 
-  install_sigprof_signal_handler(handle_sampling_signal);
+  install_sigprof_signal_handler(handle_sampling_signal, "handle_sampling_signal");
   if (state->gc_profiling_enabled) rb_tracepoint_enable(state->gc_tracepoint);
 
   // Release GVL, get to the actual work!
@@ -245,7 +255,18 @@ 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);
-  remove_sigprof_signal_handler();
+
+  // Why replace and not use remove the signal handler? We do this because when a process receives a SIGPROF without
+  // having an explicit signal handler set up, the process will instantly terminate with a confusing
+  // "Profiling timer expired" message left behind. (This message doesn't come from us -- it's the default message for
+  // an unhandled SIGPROF. Pretty confusing UNIX/POSIX behavior...)
+  //
+  // Unfortunately, because signal delivery is asynchronous, there's no way to guarantee that there are no pending
+  // profiler-sent signals by the time we get here and want to clean up.
+  // @ivoanjo: I suspect this will never happen, but the cost of getting it wrong is really high (VM terminates) so this
+  // is a just-in-case situation.
+  replace_sigprof_signal_handler_with_empty_handler(handle_sampling_signal);
+
   active_sampler_instance = Qnil;
   active_sampler_owner_thread = Qnil;
 
@@ -274,53 +295,6 @@ static VALUE stop(VALUE self_instance, VALUE optional_exception) {
   return Qtrue;
 }
 
-static void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *)) {
-  struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
-  struct sigaction signal_handler_config = {
-    .sa_flags = SA_RESTART | SA_SIGINFO,
-    .sa_sigaction = signal_handler_function
-  };
-  sigemptyset(&signal_handler_config.sa_mask);
-
-  if (sigaction(SIGPROF, &signal_handler_config, &existing_signal_handler_config) != 0) {
-    rb_sys_fail("Could not start CpuAndWallTimeWorker: Could not install signal handler");
-  }
-
-  // In some corner cases (e.g. after a fork), our signal handler may still be around, and that's ok
-  if (existing_signal_handler_config.sa_sigaction == handle_sampling_signal) return;
-
-  if (existing_signal_handler_config.sa_handler != NULL || existing_signal_handler_config.sa_sigaction != NULL) {
-    // A previous signal handler already existed. Currently we don't support this situation, so let's just back out
-    // of the installation.
-
-    if (sigaction(SIGPROF, &existing_signal_handler_config, NULL) != 0) {
-      rb_sys_fail(
-        "Could not start CpuAndWallTimeWorker: Could not re-install pre-existing SIGPROF signal handler. " \
-        "This may break the component had installed it."
-      );
-    }
-
-    rb_raise(rb_eRuntimeError, "Could not start CpuAndWallTimeWorker: There's a pre-existing SIGPROF signal handler");
-  }
-}
-
-static void remove_sigprof_signal_handler(void) {
-  struct sigaction signal_handler_config = {
-    .sa_handler = SIG_DFL, // Reset back to default
-    .sa_flags = SA_RESTART // TODO: Unclear if this is actually needed/does anything at all
-  };
-  sigemptyset(&signal_handler_config.sa_mask);
-
-  if (sigaction(SIGPROF, &signal_handler_config, NULL) != 0) rb_sys_fail("Failure while removing the signal handler");
-}
-
-static void block_sigprof_signal_handler_from_running_in_current_thread(void) {
-  sigset_t signals_to_block;
-  sigemptyset(&signals_to_block);
-  sigaddset(&signals_to_block, SIGPROF);
-  pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL);
-}
-
 // NOTE: Remember that this will run in the thread and within the scope of user code, including user C code.
 // We need to be careful not to change any state that may be observed OR to restore it if we do. For instance, if anything
 // we do here can set `errno`, then we must be careful to restore the old `errno` after the fact.
@@ -403,6 +377,8 @@ static VALUE _native_current_sigprof_signal_handler(DDTRACE_UNUSED VALUE self) {
 
   if (existing_signal_handler_config.sa_sigaction == handle_sampling_signal) {
     return ID2SYM(rb_intern("profiling"));
+  } else if (existing_signal_handler_config.sa_sigaction == empty_signal_handler) {
+    return ID2SYM(rb_intern("empty"));
   } else if (existing_signal_handler_config.sa_sigaction != NULL) {
     return ID2SYM(rb_intern("other"));
   } else {
@@ -437,7 +413,7 @@ static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED si
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTimeWorker behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
 static VALUE _native_install_testing_signal_handler(DDTRACE_UNUSED VALUE self) {
-  install_sigprof_signal_handler(testing_signal_handler);
+  install_sigprof_signal_handler(testing_signal_handler, "testing_signal_handler");
   return Qtrue;
 }
 
@@ -567,3 +543,24 @@ static VALUE _native_simulate_sample_from_postponed_job(DDTRACE_UNUSED VALUE sel
   sample_from_postponed_job(NULL);
   return Qtrue;
 }
+
+// After the Ruby VM forks, this method gets called in the child process to clean up any leftover state from the parent.
+//
+// Assumption: This method gets called BEFORE restarting profiling. Note that profiling-related tracepoints may still
+// be active, so we make sure to disable them before calling into anything else, so that there are no components
+// attempting to trigger samples at the same time as the reset is done.
+//
+// In the future, if we add more other components with tracepoints, we will need to coordinate stopping all such
+// tracepoints before doing the other cleaning steps.
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, 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);
+
+  // Disable all tracepoints, so that there are no more attempts to mutate the profile
+  rb_tracepoint_disable(state->gc_tracepoint);
+
+  // 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);
+
+  return Qtrue;
+}

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -144,11 +144,10 @@ void sample_thread(
 
   // Samples thread into recorder, including as a top frame in the stack a frame named "Garbage Collection"
   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_Line) {
-      .function = (ddog_Function) {
-        .name = DDOG_CHARSLICE_C(""),
-        .filename = DDOG_CHARSLICE_C("Garbage Collection")
-      },
+      .function = (ddog_Function) {.name = function_name, .filename = function_filename},
       .line = 0
     };
     // To avoid changing sample_thread_internal, we just prepare a new buffer struct that uses the same underlying storage as the
@@ -300,11 +299,10 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
 
   // Important note: `frames_omitted_message` MUST have a lifetime that is at least as long as the call to
   // `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_Line) {
-    .function = (ddog_Function) {
-      .name = DDOG_CHARSLICE_C(""),
-      .filename = ((ddog_CharSlice) {.ptr = frames_omitted_message, .len = strlen(frames_omitted_message)})
-    },
+    .function = (ddog_Function) {.name = function_name, .filename = function_filename},
     .line = 0,
   };
 }
@@ -337,11 +335,10 @@ static void record_placeholder_stack_in_native_code(
   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_Line) {
-    .function = (ddog_Function) {
-      .name = DDOG_CHARSLICE_C(""),
-      .filename = DDOG_CHARSLICE_C("In native code")
-    },
+    .function = (ddog_Function) {.name = function_name, .filename = function_filename},
     .line = 0
   };
 
@@ -373,7 +370,8 @@ sampling_buffer *sampling_buffer_new(unsigned int max_frames) {
   // 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++) {
-    buffer->locations[i] = (ddog_Location) {.lines = (ddog_Slice_line) {.ptr = &buffer->lines[i], .len = 1}};
+    ddog_Slice_line lines = (ddog_Slice_line) {.ptr = &buffer->lines[i], .len = 1};
+    buffer->locations[i] = (ddog_Location) {.lines = lines};
   }
 
   return buffer;

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -79,7 +79,7 @@ end
 
 # Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
 # But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
-add_compiler_flag '-Werror' if ENV['CI'] == 'true'
+add_compiler_flag '-Werror' if ENV['DDTRACE_CI'] == 'true'
 
 # Older gcc releases may not default to C99 and we need to ask for this. This is also used:
 # * by upstream Ruby -- search for gnu99 in the codebase

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -14,10 +14,11 @@
 #else
   // On older Rubies, use a copy of the VM internal headers shipped in the debase-ruby_core_source gem
 
-  // We can't do anything about warnings in VM headers, so we just use this technique to surpress them.
+  // We can't do anything about warnings in VM headers, so we just use this technique to suppress them.
   // See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wunused-parameter"
+  #pragma GCC diagnostic ignored "-Wattributes"
     #include <vm_core.h>
   #pragma GCC diagnostic pop
   #include <iseq.h>
@@ -35,7 +36,7 @@
 // if the argument passed in is not actually a `Thread` instance.
 static inline rb_thread_t *thread_struct_from_object(VALUE thread) {
   static const rb_data_type_t *thread_data_type = NULL;
-  if (thread_data_type == NULL) thread_data_type = RTYPEDDATA_TYPE(rb_thread_current());
+  if (UNLIKELY(thread_data_type == NULL)) thread_data_type = RTYPEDDATA_TYPE(rb_thread_current());
 
   return (rb_thread_t *) rb_check_typeddata(thread, thread_data_type);
 }

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.c

@@ -0,0 +1,96 @@
+#include <ruby.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdbool.h>
+
+#include "helpers.h"
+#include "setup_signal_handler.h"
+
+static void install_sigprof_signal_handler_internal(
+  void (*signal_handler_function)(int, siginfo_t *, void *),
+  const char *handler_pretty_name,
+  void (*signal_handler_to_replace)(int, siginfo_t *, void *)
+);
+
+void empty_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) { }
+
+void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *), const char *handler_pretty_name) {
+  install_sigprof_signal_handler_internal(signal_handler_function, handler_pretty_name, NULL);
+}
+
+void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *)) {
+  install_sigprof_signal_handler_internal(empty_signal_handler, "empty_signal_handler", expected_existing_handler);
+}
+
+static void install_sigprof_signal_handler_internal(
+  void (*signal_handler_function)(int, siginfo_t *, void *),
+  const char *handler_pretty_name,
+  void (*signal_handler_to_replace)(int, siginfo_t *, void *)
+) {
+  struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
+  struct sigaction signal_handler_config = {
+    .sa_flags = SA_RESTART | SA_SIGINFO,
+    .sa_sigaction = signal_handler_function
+  };
+  sigemptyset(&signal_handler_config.sa_mask);
+
+  if (sigaction(SIGPROF, &signal_handler_config, &existing_signal_handler_config) != 0) {
+    rb_exc_raise(rb_syserr_new_str(errno, rb_sprintf("Could not install profiling signal handler (%s)", handler_pretty_name)));
+  }
+
+  // Because signal handler functions are global, let's check if we're not stepping on someone else's toes.
+
+  // If the existing signal handler was our empty one, that's ok as well
+  if (existing_signal_handler_config.sa_sigaction == empty_signal_handler ||
+  // In some corner cases (e.g. after a fork), our signal handler may still be around, and that's ok
+    existing_signal_handler_config.sa_sigaction == signal_handler_function ||
+  // Are we replacing a known handler with another one?
+    (signal_handler_to_replace != NULL && existing_signal_handler_config.sa_sigaction == signal_handler_to_replace)
+  ) { return; }
+
+  if (existing_signal_handler_config.sa_handler != NULL || existing_signal_handler_config.sa_sigaction != NULL) {
+    // An unexpected/unknown signal handler already existed. Currently we don't support this situation, so let's just back out
+    // of the installation.
+
+    if (sigaction(SIGPROF, &existing_signal_handler_config, NULL) != 0) {
+      rb_exc_raise(
+        rb_syserr_new_str(
+          errno,
+          rb_sprintf(
+            "Failed to install profiling signal handler (%s): " \
+            "While installing a SIGPROF signal handler, the profiler detected that another software/library/gem had " \
+            "previously installed a different SIGPROF signal handler. " \
+            "The profiler tried to restore the previous SIGPROF signal handler, but this failed. " \
+            "The other software/library/gem may have been left in a broken state. ",
+            handler_pretty_name
+          )
+        )
+      );
+    }
+
+    rb_raise(
+      rb_eRuntimeError,
+      "Could not install profiling signal handler (%s): There's a pre-existing SIGPROF signal handler",
+      handler_pretty_name
+    );
+  }
+}
+
+// Note: Be careful when using this; you probably want to use `replace_sigprof_signal_handler_with_empty_handler` instead.
+// (See comments on `collectors_cpu_and_wall_time_worker.c` for details)
+void remove_sigprof_signal_handler(void) {
+  struct sigaction signal_handler_config = {
+    .sa_handler = SIG_DFL, // Reset back to default
+    .sa_flags = SA_RESTART // TODO: Unclear if this is actually needed/does anything at all
+  };
+  sigemptyset(&signal_handler_config.sa_mask);
+
+  if (sigaction(SIGPROF, &signal_handler_config, NULL) != 0) rb_sys_fail("Failure while removing the signal handler");
+}
+
+void block_sigprof_signal_handler_from_running_in_current_thread(void) {
+  sigset_t signals_to_block;
+  sigemptyset(&signals_to_block);
+  sigaddset(&signals_to_block, SIGPROF);
+  pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL);
+}

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.h

@@ -0,0 +1,7 @@
+#pragma once
+
+void empty_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
+void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *), const char *handler_pretty_name);
+void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *));
+void remove_sigprof_signal_handler(void);
+void block_sigprof_signal_handler_from_running_in_current_thread(void);