ddtrace 1.1.0 → 1.4.0

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -0,0 +1,391 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/thread_native.h>
+#include <ruby/debug.h>
+#include <stdbool.h>
+#include <signal.h>
+#include "helpers.h"
+#include "ruby_helpers.h"
+#include "collectors_cpu_and_wall_time.h"
+#include "private_vm_api_access.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.
+//
+// This file implements the native bits of the Datadog::Profiling::Collectors::CpuAndWallTimeWorker class
+
+// ---
+// Here be dragons: This component is quite fiddly and probably one of the more complex in the profiler as it deals with
+// multiple threads, signal handlers, global state, etc.
+//
+// ## Design notes for this class:
+//
+// ### Constraints
+//
+// Currently, sampling Ruby threads requires calling Ruby VM APIs that are only safe to call while holding on to the
+// global VM lock (and are not async-signal safe -- cannot be called from a signal handler).
+//
+// @ivoanjo: As a note, I don't think we should think of this constraint as set in stone. Since can reach into the Ruby
+// 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
+//
+// The flow for triggering samples is as follows:
+//
+// 1. Inside the `run_sampling_trigger_loop` function (running in the `CpuAndWallTimeWorker` background thread),
+// a `SIGPROF` signal gets sent to the current process.
+//
+// 2. The `handle_sampling_signal` signal handler function gets called to handle the `SIGPROF` signal.
+//
+//   Which thread the signal handler function gets called on by the operating system is quite important. We need to perform
+// an operation -- calling the `rb_postponed_job_register_one` API -- that can only be called from the thread that
+// is holding on to the global VM lock. So this is the thread we're "hoping" our signal lands on.
+//
+//   The signal never lands on the `CpuAndWallTimeWorker` background thread because we explicitly block it off from that
+// thread in `block_sigprof_signal_handler_from_running_in_current_thread`.
+//
+//   If the signal lands on a thread that is not holding onto the global VM lock, we can't proceed to the next step,
+// and we need to restart the sampling flow from step 1. (There's still quite a few improvements we can make here,
+// but this is the current state of the implementation).
+//
+// 3. Inside `handle_sampling_signal`, if it's getting executed by the Ruby thread that is holding the global VM lock,
+// we can call `rb_postponed_job_register_one` to ask the Ruby VM to call our `sample_from_postponed_job` function
+// "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`.
+//
+// ---
+
+// Contains state for a single CpuAndWallTimeWorker instance
+struct cpu_and_wall_time_worker_state {
+  // Important: This is not atomic nor is it guaranteed to replace memory barriers and the like. Aka this works for
+  // telling the sampling trigger loop to stop, but if we ever need to communicate more, we should move to actual
+  // atomic operations. stdatomic.h seems a nice thing to reach out for.
+  volatile bool should_run;
+
+  VALUE cpu_and_wall_time_collector_instance;
+  // When something goes wrong during sampling, we record the Ruby exception here, so that it can be "re-raised" on
+  // the CpuAndWallTimeWorker thread
+  VALUE failure_exception;
+};
+
+static VALUE _native_new(VALUE klass);
+static VALUE _native_initialize(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE cpu_and_wall_time_collector_instance);
+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 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);
+static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused);
+static VALUE handle_sampling_failure(VALUE self_instance, VALUE exception);
+static VALUE _native_current_sigprof_signal_handler(DDTRACE_UNUSED VALUE self);
+static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance);
+static VALUE _native_is_running(DDTRACE_UNUSED VALUE self, VALUE instance);
+static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
+static VALUE _native_install_testing_signal_handler(DDTRACE_UNUSED VALUE self);
+static VALUE _native_remove_testing_signal_handler(DDTRACE_UNUSED VALUE self);
+
+// Global state -- be very careful when accessing or modifying it
+
+// Note: Global state must only be mutated while holding the global VM lock (we piggy back on it to ensure correctness).
+// The active_sampler_instance needs to be global because we access it from the signal handler.
+static VALUE active_sampler_instance = Qnil;
+// ...We also store active_sampler_owner_thread to be able to tell who the active_sampler_instance belongs to (and also
+// to detect when it is outdated)
+static VALUE active_sampler_owner_thread = Qnil;
+
+void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
+  rb_global_variable(&active_sampler_instance);
+  rb_global_variable(&active_sampler_owner_thread);
+
+  VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
+  VALUE collectors_cpu_and_wall_time_worker_class = rb_define_class_under(collectors_module, "CpuAndWallTimeWorker", rb_cObject);
+  // Hosts methods used for testing the native code using RSpec
+  VALUE testing_module = rb_define_module_under(collectors_cpu_and_wall_time_worker_class, "Testing");
+
+  // Instances of the CpuAndWallTimeWorker class are "TypedData" objects.
+  // "TypedData" objects are special objects in the Ruby VM that can wrap C structs.
+  // In this case, it wraps the cpu_and_wall_time_worker_state.
+  //
+  // Because Ruby doesn't know how to initialize native-level structs, we MUST override the allocation function for objects
+  // of this class so that we can manage this part. Not overriding or disabling the allocation function is a common
+  // gotcha for "TypedData" objects that can very easily lead to VM crashes, see for instance
+  // 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, 2);
+  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(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);
+  rb_define_singleton_method(testing_module, "_native_remove_testing_signal_handler", _native_remove_testing_signal_handler, 0);
+}
+
+// This structure is used to define a Ruby object that stores a pointer to a struct cpu_and_wall_time_worker_state
+// See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
+static const rb_data_type_t cpu_and_wall_time_worker_typed_data = {
+  .wrap_struct_name = "Datadog::Profiling::Collectors::CpuAndWallTimeWorker",
+  .function = {
+    .dmark = cpu_and_wall_time_worker_typed_data_mark,
+    .dfree = RUBY_DEFAULT_FREE,
+    .dsize = NULL, // We don't track profile memory usage (although it'd be cool if we did!)
+    //.dcompact = NULL, // FIXME: Add support for compaction
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+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));
+
+  state->should_run = false;
+  state->cpu_and_wall_time_collector_instance = Qnil;
+  state->failure_exception = Qnil;
+
+  return TypedData_Wrap_Struct(klass, &cpu_and_wall_time_worker_typed_data, state);
+}
+
+static VALUE _native_initialize(DDTRACE_UNUSED VALUE _self, VALUE self_instance, VALUE cpu_and_wall_time_collector_instance) {
+  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->cpu_and_wall_time_collector_instance = enforce_cpu_and_wall_time_collector_instance(cpu_and_wall_time_collector_instance);
+
+  return Qtrue;
+}
+
+// Since our state contains references to Ruby objects, we need to tell the Ruby GC about them
+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->failure_exception);
+}
+
+// Called in a background thread created in CpuAndWallTimeWorker#start
+static VALUE _native_sampling_loop(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);
+
+  if (active_sampler_owner_thread != Qnil && is_thread_alive(active_sampler_owner_thread)) {
+    rb_raise(
+      rb_eRuntimeError,
+      "Could not start CpuAndWallTimeWorker: There's already another instance of CpuAndWallTimeWorker active in a different thread"
+    );
+  }
+
+  // This write to a global is thread-safe BECAUSE we're still holding on to the global VM lock at this point
+  active_sampler_instance = instance;
+  active_sampler_owner_thread = rb_thread_current();
+
+  state->should_run = true;
+
+  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);
+
+  // Release GVL, get to the actual work!
+  int exception_state;
+  rb_protect(release_gvl_and_run_sampling_trigger_loop, instance, &exception_state);
+
+  // The sample trigger loop finished (either cleanly or with an error); let's clean up
+
+  remove_sigprof_signal_handler();
+  active_sampler_instance = Qnil;
+  active_sampler_owner_thread = Qnil;
+
+  // Ensure that instance is not garbage collected while the native sampling loop is running; this is probably not needed, but just in case
+  RB_GC_GUARD(instance);
+
+  if (exception_state) rb_jump_tag(exception_state); // Re-raise any exception that happened
+
+  return Qnil;
+}
+
+static VALUE _native_stop(DDTRACE_UNUSED VALUE _self, VALUE self_instance) {
+  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->should_run = false;
+
+  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);
+}
+
+static void handle_sampling_signal(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
+  if (!ruby_thread_has_gvl_p()) {
+    return; // Not safe to enqueue a sample from this thread
+  }
+
+  // We implicitly assume there can be no concurrent nor nested calls to handle_sampling_signal because
+  // a) we get triggered using SIGPROF, and the docs state second SIGPROF will not interrupt an existing one
+  // b) we validate we are in the thread that has the global VM lock; if a different thread gets a signal, it will return early
+  //    because it will not have the global VM lock
+  // TODO: Validate that this does not impact Ractors
+
+  // Note: rb_postponed_job_register_one ensures that if there's a previous sample_from_postponed_job queued for execution
+  // then we will not queue a second one. It does this by doing a linear scan on the existing jobs; in the future we
+  // may want to implement that check ourselves.
+
+  // TODO: Do something with result (potentially update tracking counters?)
+  /*int result =*/ rb_postponed_job_register_one(0, sample_from_postponed_job, NULL);
+}
+
+// The actual sampling trigger loop always runs **without** the global vm lock.
+static void *run_sampling_trigger_loop(void *state_ptr) {
+  struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
+
+  struct timespec time_between_signals = {.tv_nsec = 10 * 1000 * 1000 /* 10ms */};
+
+  while (state->should_run) {
+    // TODO: This is still a placeholder for a more complex mechanism. In particular:
+    // * We want to signal a particular thread or threads, not the process in general
+    // * We want to track if a signal landed on the thread holding the global VM lock and do something about it
+    // * We want to do more than having a fixed sampling rate
+
+    kill(getpid(), SIGPROF);
+    nanosleep(&time_between_signals, NULL);
+  }
+
+  return NULL; // Unused
+}
+
+// This is called by the Ruby VM when it wants to shut down the background thread
+static void interrupt_sampling_trigger_loop(void *state_ptr) {
+  struct cpu_and_wall_time_worker_state *state = (struct cpu_and_wall_time_worker_state *) state_ptr;
+
+  state->should_run = false;
+}
+
+static void sample_from_postponed_job(DDTRACE_UNUSED void *_unused) {
+  VALUE instance = active_sampler_instance; // Read from global variable
+
+  // This can potentially happen if the CpuAndWallTimeWorker was stopped while the postponed job was waiting to be executed; nothing to do
+  if (instance == Qnil) return;
+
+  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);
+
+  // Trigger sampling using the Collectors::CpuAndWallTime; rescue against any exceptions that happen during sampling
+  VALUE (*function_to_call_safely)(VALUE) = cpu_and_wall_time_collector_sample;
+  VALUE function_to_call_safely_arg = state->cpu_and_wall_time_collector_instance;
+  VALUE (*exception_handler_function)(VALUE, VALUE) = handle_sampling_failure;
+  VALUE exception_handler_function_arg = instance;
+  rb_rescue2(
+    function_to_call_safely,
+    function_to_call_safely_arg,
+    exception_handler_function,
+    exception_handler_function_arg,
+    rb_eException, // rb_eException is the base class of all Ruby exceptions
+    0 // Required by API to be the last argument
+  );
+}
+
+static VALUE handle_sampling_failure(VALUE self_instance, VALUE exception) {
+  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->should_run = false;
+  state->failure_exception = exception;
+
+  return Qnil;
+}
+
+static VALUE _native_current_sigprof_signal_handler(DDTRACE_UNUSED VALUE self) {
+  struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
+  if (sigaction(SIGPROF, NULL, &existing_signal_handler_config) != 0) {
+    rb_sys_fail("Failed to probe existing handler");
+  }
+
+  if (existing_signal_handler_config.sa_sigaction == handle_sampling_signal) {
+    return ID2SYM(rb_intern("profiling"));
+  } else if (existing_signal_handler_config.sa_sigaction != NULL) {
+    return ID2SYM(rb_intern("other"));
+  } else {
+    return Qnil;
+  }
+}
+
+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);
+
+  rb_thread_call_without_gvl(run_sampling_trigger_loop, state, interrupt_sampling_trigger_loop, state);
+
+  // If we stopped sampling due to an exception, re-raise it (now in the worker thread)
+  if (state->failure_exception != Qnil) rb_exc_raise(state->failure_exception);
+
+  return Qnil;
+}
+
+static VALUE _native_is_running(DDTRACE_UNUSED VALUE self, VALUE instance) {
+  return \
+    (active_sampler_owner_thread != Qnil && is_thread_alive(active_sampler_owner_thread) && active_sampler_instance == instance) ?
+    Qtrue : Qfalse;
+}
+
+static void testing_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
+  /* Does nothing on purpose */
+}
+
+static VALUE _native_install_testing_signal_handler(DDTRACE_UNUSED VALUE self) {
+  install_sigprof_signal_handler(testing_signal_handler);
+  return Qtrue;
+}
+
+static VALUE _native_remove_testing_signal_handler(DDTRACE_UNUSED VALUE self) {
+  remove_sigprof_signal_handler();
+  return Qtrue;
+}

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -1,9 +1,12 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 #include "extconf.h"
-#include "libddprof_helpers.h"
+#include "helpers.h"
+#include "libdatadog_helpers.h"
+#include "ruby_helpers.h"
 #include "private_vm_api_access.h"
 #include "stack_recorder.h"
+#include "collectors_stack.h"
 
 // Gathers stack traces from running threads, storing them in a StackRecorder instance
 // This file implements the native bits of the Datadog::Profiling::Collectors::Stack class
@@ -14,37 +17,36 @@
 static VALUE missing_string = Qnil;
 
 // Used as scratch space during sampling
-typedef struct sampling_buffer {
+struct sampling_buffer {
   unsigned int max_frames;
   VALUE *stack_buffer;
   int *lines_buffer;
   bool *is_ruby_frame;
   ddprof_ffi_Location *locations;
   ddprof_ffi_Line *lines;
-} sampling_buffer;
+}; // Note: typedef'd in the header to sampling_buffer
 
 static VALUE _native_sample(VALUE self, VALUE thread, VALUE recorder_instance, VALUE metric_values_hash, VALUE labels_array, VALUE max_frames);
-void sample(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels);
-void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size);
-void record_placeholder_stack_in_native_code(VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels);
-sampling_buffer *sampling_buffer_new(unsigned int max_frames);
-void sampling_buffer_free(sampling_buffer *buffer);
+static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size);
+static void record_placeholder_stack_in_native_code(VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels);
 
 void collectors_stack_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
   VALUE collectors_stack_class = rb_define_class_under(collectors_module, "Stack", rb_cObject);
+  // Hosts methods used for testing the native code using RSpec
+  VALUE testing_module = rb_define_module_under(collectors_stack_class, "Testing");
 
-  rb_define_singleton_method(collectors_stack_class, "_native_sample", _native_sample, 5);
+  rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 5);
 
   missing_string = rb_str_new2("");
   rb_global_variable(&missing_string);
 }
 
-// This method exists only to enable testing Collectors::Stack behavior using RSpec.
+// This method exists only to enable testing Datadog::Profiling::Collectors::Stack behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
-static VALUE _native_sample(VALUE self, VALUE thread, VALUE recorder_instance, VALUE metric_values_hash, VALUE labels_array, VALUE max_frames) {
-  Check_Type(metric_values_hash, T_HASH);
-  Check_Type(labels_array, T_ARRAY);
+static VALUE _native_sample(DDTRACE_UNUSED VALUE _self, VALUE thread, VALUE recorder_instance, VALUE metric_values_hash, VALUE labels_array, VALUE max_frames) {
+  ENFORCE_TYPE(metric_values_hash, T_HASH);
+  ENFORCE_TYPE(labels_array, T_ARRAY);
 
   if (RHASH_SIZE(metric_values_hash) != ENABLED_VALUE_TYPES_COUNT) {
     rb_raise(
@@ -78,7 +80,7 @@ static VALUE _native_sample(VALUE self, VALUE thread, VALUE recorder_instance, V
 
   sampling_buffer *buffer = sampling_buffer_new(max_frames_requested);
 
-  sample(
+  sample_thread(
     thread,
     buffer,
     recorder_instance,
@@ -91,7 +93,7 @@ static VALUE _native_sample(VALUE self, VALUE thread, VALUE recorder_instance, V
   return Qtrue;
 }
 
-void sample(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels) {
+void sample_thread(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels) {
   int captured_frames = ddtrace_rb_profile_frames(
     thread,
     0 /* stack starting depth */,
@@ -139,8 +141,8 @@ void sample(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddpr
       // **IMPORTANT**: Be very careful when calling any `rb_profile_frame_...` API with a non-Ruby frame, as legacy
       // Rubies may assume that what's in a buffer will lead to a Ruby frame.
       //
-      // In particular for Ruby 2.2 and below the buffer contains a Ruby string (see the notes on our custom
-      // rb_profile_frames for Ruby 2.2 and below) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
+      // In particular for Ruby 2.2 the buffer contains a Ruby string (see the notes on our custom
+      // rb_profile_frames for Ruby 2.2) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
 
 #ifndef USE_LEGACY_RB_PROFILE_FRAMES // Modern Rubies
       name = ddtrace_rb_profile_frame_method_name(buffer->stack_buffer[i]);
@@ -186,7 +188,7 @@ void sample(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddpr
   );
 }
 
-void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size) {
+static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer, char *frames_omitted_message, int frames_omitted_message_size) {
   ptrdiff_t frames_omitted = stack_depth_for(thread) - buffer->max_frames;
 
   if (frames_omitted == 0) return; // Perfect fit!
@@ -228,7 +230,7 @@ void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer* buffer,
 //
 // To give customers visibility into these threads, rather than reporting an empty stack, we replace the empty stack
 // with one containing a placeholder frame, so that these threads are properly represented in the UX.
-void record_placeholder_stack_in_native_code(VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels) {
+static void record_placeholder_stack_in_native_code(VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels) {
   ddprof_ffi_Line placeholder_stack_in_native_code_line = {
     .function = (ddprof_ffi_Function) {
       .name = DDPROF_FFI_CHARSLICE_C(""),
@@ -268,6 +270,8 @@ sampling_buffer *sampling_buffer_new(unsigned int max_frames) {
 }
 
 void sampling_buffer_free(sampling_buffer *buffer) {
+  if (buffer == NULL) rb_raise(rb_eArgError, "sampling_buffer_free called with NULL buffer");
+
   ruby_xfree(buffer->stack_buffer);
   ruby_xfree(buffer->lines_buffer);
   ruby_xfree(buffer->is_ruby_frame);

data/ext/ddtrace_profiling_native_extension/collectors_stack.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <ddprof/ffi.h>
+
+typedef struct sampling_buffer sampling_buffer;
+
+void sample_thread(VALUE thread, sampling_buffer* buffer, VALUE recorder_instance, ddprof_ffi_Slice_i64 metric_values, ddprof_ffi_Slice_label labels);
+sampling_buffer *sampling_buffer_new(unsigned int max_frames);
+void sampling_buffer_free(sampling_buffer *buffer);

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -10,13 +10,31 @@ SKIPPED_REASON_FILE = "#{__dir__}/skipped_reason.txt".freeze
 File.delete(SKIPPED_REASON_FILE) rescue nil
 
 def skip_building_extension!(reason)
-  $stderr.puts(Datadog::Profiling::NativeExtensionHelpers::Supported.failure_banner_for(**reason))
+  fail_install_if_missing_extension =
+    Datadog::Profiling::NativeExtensionHelpers.fail_install_if_missing_extension?
+
+  $stderr.puts(
+    Datadog::Profiling::NativeExtensionHelpers::Supported.failure_banner_for(
+      **reason,
+      fail_install: fail_install_if_missing_extension,
+    )
+  )
+
   File.write(
     SKIPPED_REASON_FILE,
     Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason),
   )
 
-  File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+  if fail_install_if_missing_extension
+    require 'mkmf'
+    Logging.message(
+      ' [ddtrace] Failure cause: ' \
+      "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
+    )
+  else
+    File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+  end
+
   exit
 end
 
@@ -24,7 +42,8 @@ unless Datadog::Profiling::NativeExtensionHelpers::Supported.supported?
   skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported.unsupported_reason)
 end
 
-$stderr.puts(%(
+$stderr.puts(
+  %(
 +------------------------------------------------------------------------------+
 | ** Preparing to build the ddtrace profiling native extension... **           |
 |                                                                              |
@@ -41,7 +60,8 @@ $stderr.puts(%(
 | Thanks for using ddtrace! You rock!                                          |
 +------------------------------------------------------------------------------+
 
-))
+)
+)
 
 # NOTE: we MUST NOT require 'mkmf' before we check the #skip_building_extension? because the require triggers checks
 # that may fail on an environment not properly setup for building Ruby extensions.
@@ -73,6 +93,9 @@ add_compiler_flag '-Wno-declaration-after-statement'
 # cause a segfault later. Let's ensure that never happens.
 add_compiler_flag '-Werror-implicit-function-declaration'
 
+# Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+add_compiler_flag '-Wunused-parameter'
+
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
 # the sole exception being `Init_ddtrace_profiling_native_extension` which needs to be visible for Ruby to call it when
 # it `dlopen`s the library.
@@ -81,17 +104,24 @@ add_compiler_flag '-Werror-implicit-function-declaration'
 # For more details see https://gcc.gnu.org/wiki/Visibility
 add_compiler_flag '-fvisibility=hidden'
 
+# Enable all other compiler warnings
+add_compiler_flag '-Wall'
+add_compiler_flag '-Wextra'
+
 if RUBY_PLATFORM.include?('linux')
   # Supposedly, the correct way to do this is
   # ```
   # have_library 'pthread'
   # have_func 'pthread_getcpuclockid'
   # ```
-  # but it broke the build on Windows and on older Ruby versions (2.1 and 2.2)
+  # but it broke the build on Windows and on older Ruby versions (2.2)
   # so instead we just assume that we have the function we need on Linux, and nowhere else
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
 
+# On older Rubies, there was no struct rb_native_thread. See private_vm_api_acccess.c for details.
+$defs << '-DNO_RB_NATIVE_THREAD' if RUBY_VERSION < '3.2'
+
 # On older Rubies, we need to use a backported version of this function. See private_vm_api_access.h for details.
 $defs << '-DUSE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME' if RUBY_VERSION < '3'
 
@@ -112,14 +142,39 @@ if RUBY_VERSION < '2.3'
   $defs << '-DNO_RB_TIME_TIMESPEC_NEW'
   # ...the VM changed enough that we need an alternative legacy rb_profile_frames
   $defs << '-DUSE_LEGACY_RB_PROFILE_FRAMES'
+  # ... you couldn't name threads
+  $defs << '-DNO_THREAD_NAMES'
+  # ...the ruby_thread_has_gvl_p function was not exposed to users outside of the VM
+  $defs << '-DNO_THREAD_HAS_GVL'
 end
 
-# If we got here, libddprof is available and loaded
-ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libddprof.pkgconfig_folder}"
+# If we got here, libdatadog is available and loaded
+ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
+Logging.message(" [ddtrace] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+
 unless pkg_config('ddprof_ffi_with_rpath')
-  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDDPROF)
+  skip_building_extension!(
+    if Datadog::Profiling::NativeExtensionHelpers::Supported.pkg_config_missing?
+      Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
+    else
+      # Less specific error message
+      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG
+    end
+  )
 end
 
+# See comments on the helper method being used for why we need to additionally set this.
+# The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
+# experimentation. We need to get these special characters across a lot of tools untouched...
+$LDFLAGS += \
+  ' -Wl,-rpath,$$$\\\\{ORIGIN\\}/' \
+  "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
+Logging.message(" [ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+
+Logging.message(" [ddtrace] Using compiler:\n")
+xsystem("#{CONFIG['CC']} --version")
+Logging.message(" [ddtrace] End of compiler information\n")
+
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.
@@ -153,13 +208,6 @@ else
   # This gem ships source code copies of these VM headers for the different Ruby VM versions;
   # see https://github.com/ruby-debug/debase-ruby_core_source for details
 
-  thread_native_for_ruby_2_1 = proc { true }
-  if RUBY_VERSION < '2.2'
-    # This header became public in Ruby 2.2, but we need to pull it from the private headers folder for 2.1
-    thread_native_for_ruby_2_1 = proc { have_header('thread_native.h') }
-    $defs << '-DRUBY_2_1_WORKAROUND'
-  end
-
   create_header
 
   require 'debase/ruby_core_source'
@@ -167,7 +215,7 @@ else
 
   Debase::RubyCoreSource
     .create_makefile_with_core(
-      proc { have_header('vm_core.h') && have_header('iseq.h') && thread_native_for_ruby_2_1.call },
+      proc { have_header('vm_core.h') && have_header('iseq.h') },
       EXTENSION_NAME,
     )
 end