ddtrace 1.4.2 → 1.23.3

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -1,391 +0,0 @@
-#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,282 +0,0 @@
-#include <ruby.h>
-#include <ruby/debug.h>
-#include "extconf.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
-
-#define MAX_FRAMES_LIMIT            10000
-#define MAX_FRAMES_LIMIT_AS_STRING "10000"
-
-static VALUE missing_string = Qnil;
-
-// Used as scratch space during sampling
-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;
-}; // 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);
-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(testing_module, "_native_sample", _native_sample, 5);
-
-  missing_string = rb_str_new2("");
-  rb_global_variable(&missing_string);
-}
-
-// 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(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(
-      rb_eArgError,
-      "Mismatched values for metrics; expected %lu values and got %lu instead",
-      ENABLED_VALUE_TYPES_COUNT,
-      RHASH_SIZE(metric_values_hash)
-    );
-  }
-
-  int64_t metric_values[ENABLED_VALUE_TYPES_COUNT];
-  for (unsigned int i = 0; i < ENABLED_VALUE_TYPES_COUNT; i++) {
-    VALUE metric_value = rb_hash_fetch(metric_values_hash, rb_str_new_cstr(enabled_value_types[i].type_.ptr));
-    metric_values[i] = NUM2LONG(metric_value);
-  }
-
-  long labels_count = RARRAY_LEN(labels_array);
-  ddprof_ffi_Label labels[labels_count];
-
-  for (int i = 0; i < labels_count; i++) {
-    VALUE key_str_pair = rb_ary_entry(labels_array, i);
-
-    labels[i] = (ddprof_ffi_Label) {
-      .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))
-    };
-  }
-
-  int max_frames_requested = NUM2INT(max_frames);
-  if (max_frames_requested < 0) rb_raise(rb_eArgError, "Invalid max_frames: value must not be negative");
-
-  sampling_buffer *buffer = sampling_buffer_new(max_frames_requested);
-
-  sample_thread(
-    thread,
-    buffer,
-    recorder_instance,
-    (ddprof_ffi_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
-    (ddprof_ffi_Slice_label) {.ptr = labels, .len = labels_count}
-  );
-
-  sampling_buffer_free(buffer);
-
-  return Qtrue;
-}
-
-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 */,
-    buffer->max_frames,
-    buffer->stack_buffer,
-    buffer->lines_buffer,
-    buffer->is_ruby_frame
-  );
-
-  // 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.
-  //
-  // Other things to take into consideration if we go in that direction:
-  // * Is it safe to call `rb_profile_frame_...` methods on things from the `stack_buffer` without the GVL acquired?
-  // * We need to make `VALUE` references in the `stack_buffer` visible to the Ruby GC
-  // * Should we move this into a different thread entirely?
-  // * If we don't move it into a different thread, does releasing the GVL on a Ruby thread mean that we're introducing
-  //   a new thread switch point where there previously was none?
-
-  // Ruby does not give us path and line number for methods implemented using native code.
-  // The convention in Kernel#caller_locations is to instead use the path and line number of the first Ruby frame
-  // on the stack that is below (e.g. directly or indirectly has called) the native method.
-  // Thus, we keep that frame here to able to replicate that behavior.
-  // (This is why we also iterate the sampling buffers backwards below -- so that it's easier to keep the last_ruby_frame)
-  VALUE last_ruby_frame = Qnil;
-  int last_ruby_line = 0;
-
-  if (captured_frames == PLACEHOLDER_STACK_IN_NATIVE_CODE) {
-    record_placeholder_stack_in_native_code(recorder_instance, metric_values, labels);
-    return;
-  }
-
-  for (int i = captured_frames - 1; i >= 0; i--) {
-    VALUE name, filename;
-    int line;
-
-    if (buffer->is_ruby_frame[i]) {
-      last_ruby_frame = buffer->stack_buffer[i];
-      last_ruby_line = buffer->lines_buffer[i];
-
-      name = rb_profile_frame_base_label(buffer->stack_buffer[i]);
-      filename = rb_profile_frame_path(buffer->stack_buffer[i]);
-      line = buffer->lines_buffer[i];
-    } else {
-      // **IMPORTANT**: Be very careful when calling any `rb_profile_frame_...` API with a non-Ruby frame, as legacy
-      // Rubies may assume that what's in a buffer will lead to a Ruby frame.
-      //
-      // In particular for Ruby 2.2 the buffer contains a Ruby string (see the notes on our custom
-      // rb_profile_frames for Ruby 2.2) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
-
-#ifndef USE_LEGACY_RB_PROFILE_FRAMES // Modern Rubies
-      name = ddtrace_rb_profile_frame_method_name(buffer->stack_buffer[i]);
-#else // Ruby < 2.3
-      name = buffer->stack_buffer[i];
-#endif
-
-      filename = NIL_P(last_ruby_frame) ? Qnil : rb_profile_frame_path(last_ruby_frame);
-      line = last_ruby_line;
-    }
-
-    name = NIL_P(name) ? missing_string : name;
-    filename = NIL_P(filename) ? missing_string : filename;
-
-    buffer->lines[i] = (ddprof_ffi_Line) {
-      .function = (ddprof_ffi_Function) {
-        .name = char_slice_from_ruby_string(name),
-        .filename = char_slice_from_ruby_string(filename)
-      },
-      .line = line,
-    };
-
-    buffer->locations[i] = (ddprof_ffi_Location) {.lines = (ddprof_ffi_Slice_line) {.ptr = &buffer->lines[i], .len = 1}};
-  }
-
-  // Used below; since we want to stack-allocate this, we must do it here rather than in maybe_add_placeholder_frames_omitted
-  const int frames_omitted_message_size = sizeof(MAX_FRAMES_LIMIT_AS_STRING " frames omitted");
-  char frames_omitted_message[frames_omitted_message_size];
-
-  // If we filled up the buffer, some frames may have been omitted. In that case, we'll add a placeholder frame
-  // with that info.
-  if (captured_frames == (long) buffer->max_frames) {
-    maybe_add_placeholder_frames_omitted(thread, buffer, frames_omitted_message, frames_omitted_message_size);
-  }
-
-  record_sample(
-    recorder_instance,
-    (ddprof_ffi_Sample) {
-      .locations = (ddprof_ffi_Slice_location) {.ptr = buffer->locations, .len = captured_frames},
-      .values = metric_values,
-      .labels = labels,
-    }
-  );
-}
-
-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!
-
-  // The placeholder frame takes over a space, so if 10 frames were left out and we consume one other space for the
-  // placeholder, then 11 frames are omitted in total
-  frames_omitted++;
-
-  snprintf(frames_omitted_message, frames_omitted_message_size, "%td frames omitted", frames_omitted);
-
-  // 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!)
-  buffer->lines[buffer->max_frames - 1] = (ddprof_ffi_Line) {
-    .function = (ddprof_ffi_Function) {
-      .name = DDPROF_FFI_CHARSLICE_C(""),
-      .filename = ((ddprof_ffi_CharSlice) {.ptr = frames_omitted_message, .len = strlen(frames_omitted_message)})
-    },
-    .line = 0,
-  };
-}
-
-// Our custom rb_profile_frames returning PLACEHOLDER_STACK_IN_NATIVE_CODE is equivalent to when the
-// Ruby `Thread#backtrace` API returns an empty array: we know that a thread is alive but we don't know what it's doing:
-//
-// 1. It can be starting up
-//    ```
-//    > Thread.new { sleep }.backtrace
-//    => [] # <-- note the thread hasn't actually started running sleep yet, we got there first
-//    ```
-// 2. It can be running native code
-//    ```
-//    > t = Process.detach(fork { sleep })
-//    => #<Process::Waiter:0x00007ffe7285f7a0 run>
-//    > t.backtrace
-//    => [] # <-- this can happen even minutes later, e.g. it's not a race as in 1.
-//    ```
-//    This effect has been observed in threads created by the Iodine web server and the ffi gem,
-//    see for instance https://github.com/ffi/ffi/pull/883 and https://github.com/DataDog/dd-trace-rb/pull/1719 .
-//
-// 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.
-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(""),
-      .filename = DDPROF_FFI_CHARSLICE_C("In native code")
-    },
-    .line = 0
-  };
-  ddprof_ffi_Location placeholder_stack_in_native_code_location =
-    {.lines = (ddprof_ffi_Slice_line) {.ptr = &placeholder_stack_in_native_code_line, .len = 1}};
-
-  record_sample(
-    recorder_instance,
-    (ddprof_ffi_Sample) {
-      .locations = (ddprof_ffi_Slice_location) {.ptr = &placeholder_stack_in_native_code_location, .len = 1},
-      .values = metric_values,
-      .labels = labels,
-    }
-  );
-}
-
-sampling_buffer *sampling_buffer_new(unsigned int max_frames) {
-  if (max_frames < 5) rb_raise(rb_eArgError, "Invalid max_frames: value must be >= 5");
-  if (max_frames > MAX_FRAMES_LIMIT) rb_raise(rb_eArgError, "Invalid max_frames: value must be <= " MAX_FRAMES_LIMIT_AS_STRING);
-
-  // Note: never returns NULL; if out of memory, it calls the Ruby out-of-memory handlers
-  sampling_buffer* buffer = ruby_xcalloc(1, sizeof(sampling_buffer));
-
-  buffer->max_frames = max_frames;
-
-  buffer->stack_buffer  = ruby_xcalloc(max_frames, sizeof(VALUE));
-  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(ddprof_ffi_Location));
-  buffer->lines         = ruby_xcalloc(max_frames, sizeof(ddprof_ffi_Line));
-
-  return buffer;
-}
-
-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);
-  ruby_xfree(buffer->locations);
-  ruby_xfree(buffer->lines);
-
-  ruby_xfree(buffer);
-}

data/ext/ddtrace_profiling_native_extension/collectors_stack.h

@@ -1,9 +0,0 @@
-#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);