ddtrace 1.6.1 → 1.8.0

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.c

@@ -0,0 +1,115 @@
+#include <ruby.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdbool.h>
+
+#include "helpers.h"
+#include "setup_signal_handler.h"
+#include "ruby_helpers.h"
+
+// Used by Collectors::CpuAndWallTimeWorker to setup SIGPROF signal handlers used for cpu/wall-time profiling.
+
+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");
+}
+
+static void toggle_sigprof_signal_handler_for_current_thread(int action) {
+  sigset_t signals_to_toggle;
+  sigemptyset(&signals_to_toggle);
+  sigaddset(&signals_to_toggle, SIGPROF);
+  int error = pthread_sigmask(action, &signals_to_toggle, NULL);
+  if (error) rb_exc_raise(rb_syserr_new_str(error, rb_sprintf("Unexpected failure in pthread_sigmask, action=%d", action)));
+}
+
+void block_sigprof_signal_handler_from_running_in_current_thread(void) {
+  toggle_sigprof_signal_handler_for_current_thread(SIG_BLOCK);
+}
+
+void unblock_sigprof_signal_handler_from_running_in_current_thread(void) {
+  toggle_sigprof_signal_handler_for_current_thread(SIG_UNBLOCK);
+}
+
+VALUE is_sigprof_blocked_in_current_thread(void) {
+  sigset_t current_signals;
+  sigemptyset(&current_signals);
+  ENFORCE_SUCCESS_GVL(pthread_sigmask(0, NULL, &current_signals));
+  return sigismember(&current_signals, SIGPROF) ? Qtrue : Qfalse;
+}

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <signal.h>
+
+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);
+void unblock_sigprof_signal_handler_from_running_in_current_thread(void);
+VALUE is_sigprof_blocked_in_current_thread(void);

data/ext/ddtrace_profiling_native_extension/stack_recorder.c

@@ -152,6 +152,7 @@ struct active_slot_pair {
 struct call_serialize_without_gvl_arguments {
   // Set by caller
   struct stack_recorder_state *state;
+  ddog_Timespec finish_timestamp;
 
   // Set by callee
   ddog_Profile *profile;
@@ -162,18 +163,22 @@ struct call_serialize_without_gvl_arguments {
 };
 
 static VALUE _native_new(VALUE klass);
+static void initialize_slot_concurrency_control(struct stack_recorder_state *state);
 static void stack_recorder_typed_data_free(void *data);
 static VALUE _native_serialize(VALUE self, VALUE recorder_instance);
 static VALUE ruby_time_from(ddog_Timespec ddprof_time);
 static void *call_serialize_without_gvl(void *call_args);
 static struct active_slot_pair sampler_lock_active_profile();
 static void sampler_unlock_active_profile(struct active_slot_pair active_slot);
-static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state, ddog_Timespec start_timestamp_for_next_profile);
+static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state);
 static VALUE _native_active_slot(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE _native_is_slot_one_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE _native_is_slot_two_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot);
-static ddog_Timespec time_now();
+static ddog_Timespec time_now(void);
+static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE recorder_instance);
+static void serializer_set_start_timestamp_for_next_profile(struct stack_recorder_state *state, ddog_Timespec timestamp);
+static VALUE _native_record_endpoint(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance, VALUE local_root_span_id, VALUE endpoint);
 
 void stack_recorder_init(VALUE profiling_module) {
   stack_recorder_class = rb_define_class_under(profiling_module, "StackRecorder", rb_cObject);
@@ -191,9 +196,11 @@ void stack_recorder_init(VALUE profiling_module) {
   rb_define_alloc_func(stack_recorder_class, _native_new);
 
   rb_define_singleton_method(stack_recorder_class, "_native_serialize",  _native_serialize, 1);
+  rb_define_singleton_method(stack_recorder_class, "_native_reset_after_fork", _native_reset_after_fork, 1);
   rb_define_singleton_method(testing_module, "_native_active_slot", _native_active_slot, 1);
   rb_define_singleton_method(testing_module, "_native_slot_one_mutex_locked?", _native_is_slot_one_mutex_locked, 1);
   rb_define_singleton_method(testing_module, "_native_slot_two_mutex_locked?", _native_is_slot_two_mutex_locked, 1);
+  rb_define_singleton_method(testing_module, "_native_record_endpoint", _native_record_endpoint, 3);
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
@@ -217,14 +224,7 @@ static VALUE _native_new(VALUE klass) {
 
   ddog_Slice_value_type sample_types = {.ptr = enabled_value_types, .len = ENABLED_VALUE_TYPES_COUNT};
 
-  state->slot_one_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
-  state->slot_two_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
-
-  // A newly-created StackRecorder starts with slot one being active for samples, so let's lock slot two
-  int error = pthread_mutex_lock(&state->slot_two_mutex);
-  if (error) rb_syserr_fail(error, "Unexpected failure during pthread_mutex_lock");
-
-  state->active_slot = 1;
+  initialize_slot_concurrency_control(state);
 
   // Note: Don't raise exceptions after this point, since it'll lead to libdatadog memory leaking!
 
@@ -234,6 +234,16 @@ static VALUE _native_new(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &stack_recorder_typed_data, state);
 }
 
+static void initialize_slot_concurrency_control(struct stack_recorder_state *state) {
+  state->slot_one_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
+  state->slot_two_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
+
+  // A newly-created StackRecorder starts with slot one being active for samples, so let's lock slot two
+  ENFORCE_SUCCESS_GVL(pthread_mutex_lock(&state->slot_two_mutex));
+
+  state->active_slot = 1;
+}
+
 static void stack_recorder_typed_data_free(void *state_ptr) {
   struct stack_recorder_state *state = (struct stack_recorder_state *) state_ptr;
 
@@ -250,9 +260,13 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
   struct stack_recorder_state *state;
   TypedData_Get_Struct(recorder_instance, struct stack_recorder_state, &stack_recorder_typed_data, state);
 
+  ddog_Timespec finish_timestamp = time_now();
+  // Need to do this while still holding on to the Global VM Lock; see comments on method for why
+  serializer_set_start_timestamp_for_next_profile(state, finish_timestamp);
+
   // We'll release the Global VM Lock while we're calling serialize, so that the Ruby VM can continue to work while this
   // is pending
-  struct call_serialize_without_gvl_arguments args = {.state = state, .serialize_ran = false};
+  struct call_serialize_without_gvl_arguments args = {.state = state, .finish_timestamp = finish_timestamp, .serialize_ran = false};
 
   while (!args.serialize_ran) {
     // Give the Ruby VM an opportunity to process any pending interruptions (including raising exceptions).
@@ -315,13 +329,22 @@ void record_sample(VALUE recorder_instance, ddog_Sample sample) {
   sampler_unlock_active_profile(active_slot);
 }
 
+void record_endpoint(VALUE recorder_instance, ddog_CharSlice local_root_span_id, ddog_CharSlice endpoint) {
+  struct stack_recorder_state *state;
+  TypedData_Get_Struct(recorder_instance, struct stack_recorder_state, &stack_recorder_typed_data, state);
+
+  struct active_slot_pair active_slot = sampler_lock_active_profile(state);
+
+  ddog_Profile_set_endpoint(active_slot.profile, local_root_span_id, endpoint);
+
+  sampler_unlock_active_profile(active_slot);
+}
+
 static void *call_serialize_without_gvl(void *call_args) {
   struct call_serialize_without_gvl_arguments *args = (struct call_serialize_without_gvl_arguments *) call_args;
 
-  ddog_Timespec finish_timestamp = time_now();
-
-  args->profile = serializer_flip_active_and_inactive_slots(args->state, finish_timestamp);
-  args->result = ddog_Profile_serialize(args->profile, &finish_timestamp, NULL /* duration_nanos is optional */);
+  args->profile = serializer_flip_active_and_inactive_slots(args->state);
+  args->result = ddog_Profile_serialize(args->profile, &args->finish_timestamp, NULL /* duration_nanos is optional */);
   args->serialize_ran = true;
 
   return NULL; // Unused
@@ -337,7 +360,7 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
 
   for (int attempts = 0; attempts < 2; attempts++) {
     error = pthread_mutex_trylock(&state->slot_one_mutex);
-    if (error && error != EBUSY) rb_syserr_fail(error, "Unexpected failure during sampler_lock_active_profile for slot_one_mutex");
+    if (error && error != EBUSY) ENFORCE_SUCCESS_GVL(error);
 
     // Slot one is active
     if (!error) return (struct active_slot_pair) {.mutex = &state->slot_one_mutex, .profile = state->slot_one_profile};
@@ -345,7 +368,7 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
     // If we got here, slot one was not active, let's try slot two
 
     error = pthread_mutex_trylock(&state->slot_two_mutex);
-    if (error && error != EBUSY) rb_syserr_fail(error, "Unexpected failure during sampler_lock_active_profile for slot_two_mutex");
+    if (error && error != EBUSY) ENFORCE_SUCCESS_GVL(error);
 
     // Slot two is active
     if (!error) return (struct active_slot_pair) {.mutex = &state->slot_two_mutex, .profile = state->slot_two_profile};
@@ -356,32 +379,24 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
 }
 
 static void sampler_unlock_active_profile(struct active_slot_pair active_slot) {
-  int error = pthread_mutex_unlock(active_slot.mutex);
-  if (error != 0) rb_syserr_fail(error, "Unexpected failure in sampler_unlock_active_profile");
+  ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(active_slot.mutex));
 }
 
-static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state, ddog_Timespec start_timestamp_for_next_profile) {
-  int error;
+static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state) {
   int previously_active_slot = state->active_slot;
 
   if (previously_active_slot != 1 && previously_active_slot != 2) {
-    rb_raise(rb_eRuntimeError, "Unexpected active_slot state %d in serializer_flip_active_and_inactive_slots", previously_active_slot);
+    grab_gvl_and_raise(rb_eRuntimeError, "Unexpected active_slot state %d in serializer_flip_active_and_inactive_slots", previously_active_slot);
   }
 
   pthread_mutex_t *previously_active = (previously_active_slot == 1) ? &state->slot_one_mutex : &state->slot_two_mutex;
   pthread_mutex_t *previously_inactive = (previously_active_slot == 1) ? &state->slot_two_mutex : &state->slot_one_mutex;
 
-  // Before making this profile active, we reset it so that it uses the correct timestamp for its start
-  ddog_Profile *previously_inactive_profile = (previously_active_slot == 1) ? state->slot_two_profile : state->slot_one_profile;
-  if (!ddog_Profile_reset(previously_inactive_profile, &start_timestamp_for_next_profile)) rb_raise(rb_eRuntimeError, "Failed to reset profile");
-
   // Release the lock, thus making this slot active
-  error = pthread_mutex_unlock(previously_inactive);
-  if (error) rb_syserr_fail(error, "Unexpected failure during serializer_flip_active_and_inactive_slots for previously_inactive");
+  ENFORCE_SUCCESS_NO_GVL(pthread_mutex_unlock(previously_inactive));
 
   // Grab the lock, thus making this slot inactive
-  error = pthread_mutex_lock(previously_active);
-  if (error) rb_syserr_fail(error, "Unexpected failure during serializer_flip_active_and_inactive_slots for previously_active");
+  ENFORCE_SUCCESS_NO_GVL(pthread_mutex_lock(previously_active));
 
   // Update active_slot
   state->active_slot = (previously_active_slot == 1) ? 2 : 1;
@@ -418,21 +433,55 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
 
   if (error == 0) {
     // Mutex was unlocked
-    pthread_mutex_unlock(slot_mutex);
+    ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(slot_mutex));
     return Qfalse;
   } else if (error == EBUSY) {
     // Mutex was locked
     return Qtrue;
   } else {
-    rb_syserr_fail(error, "Unexpected failure when checking mutex state");
+    ENFORCE_SUCCESS_GVL(error);
+    rb_raise(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");
   }
 }
 
-// Note that this is using CLOCK_REALTIME (e.g. actual time since unix epoch) and not the CLOCK_MONOTONIC as we use in other parts of the codebase
-static ddog_Timespec time_now() {
+// Note that this is using CLOCK_REALTIME (e.g. actual time since unix epoch) and not the CLOCK_MONOTONIC as we use in
+// monotonic_wall_time_now_ns (used in other parts of the codebase)
+static ddog_Timespec time_now(void) {
   struct timespec current_time;
 
-  if (clock_gettime(CLOCK_REALTIME, &current_time) != 0) rb_sys_fail("Failed to read CLOCK_REALTIME");
+  if (clock_gettime(CLOCK_REALTIME, &current_time) != 0) ENFORCE_SUCCESS_GVL(errno);
 
   return (ddog_Timespec) {.seconds = current_time.tv_sec, .nanoseconds = (uint32_t) current_time.tv_nsec};
 }
+
+// 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 recorder_instance) {
+  struct stack_recorder_state *state;
+  TypedData_Get_Struct(recorder_instance, struct stack_recorder_state, &stack_recorder_typed_data, state);
+
+  // In case the fork happened halfway through `serializer_flip_active_and_inactive_slots` execution and the
+  // resulting state is inconsistent, we make sure to reset it back to the initial state.
+  initialize_slot_concurrency_control(state);
+
+  ddog_Profile_reset(state->slot_one_profile, /* start_time: */ NULL);
+  ddog_Profile_reset(state->slot_two_profile, /* start_time: */ NULL);
+
+  return Qtrue;
+}
+
+// Assumption 1: This method is called with the GVL being held, because `ddog_Profile_reset` mutates the profile and should
+// not be interrupted part-way through by a VM fork.
+static void serializer_set_start_timestamp_for_next_profile(struct stack_recorder_state *state, ddog_Timespec timestamp) {
+  // Before making this profile active, we reset it so that it uses the correct timestamp for its start
+  ddog_Profile *next_profile = (state->active_slot == 1) ? state->slot_two_profile : state->slot_one_profile;
+
+  if (!ddog_Profile_reset(next_profile, &timestamp)) rb_raise(rb_eRuntimeError, "Failed to reset profile");
+}
+
+static VALUE _native_record_endpoint(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance, VALUE local_root_span_id, VALUE endpoint) {
+  record_endpoint(recorder_instance, char_slice_from_ruby_string(local_root_span_id), char_slice_from_ruby_string(endpoint));
+  return Qtrue;
+}

data/ext/ddtrace_profiling_native_extension/stack_recorder.h

@@ -35,4 +35,5 @@ static const ddog_ValueType enabled_value_types[] = {
 #define ENABLED_VALUE_TYPES_COUNT (sizeof(enabled_value_types) / sizeof(ddog_ValueType))
 
 void record_sample(VALUE recorder_instance, ddog_Sample sample);
+void record_endpoint(VALUE recorder_instance, ddog_CharSlice local_root_span_id, ddog_CharSlice endpoint);
 VALUE enforce_recorder_instance(VALUE object);

data/ext/ddtrace_profiling_native_extension/time_helpers.c

@@ -0,0 +1,17 @@
+#include <errno.h>
+#include <time.h>
+
+#include "ruby_helpers.h"
+#include "time_helpers.h"
+
+// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
+long monotonic_wall_time_now_ns(bool raise_on_failure) {
+  struct timespec current_monotonic;
+
+  if (clock_gettime(CLOCK_MONOTONIC, &current_monotonic) != 0) {
+    if (raise_on_failure) ENFORCE_SUCCESS_GVL(errno);
+    return 0;
+  }
+
+  return current_monotonic.tv_nsec + SECONDS_AS_NS(current_monotonic.tv_sec);
+}

data/ext/ddtrace_profiling_native_extension/time_helpers.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
+#define MILLIS_AS_NS(value) (value * 1000 * 1000L)
+
+#define RAISE_ON_FAILURE true
+#define DO_NOT_RAISE_ON_FAILURE false
+
+// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
+long monotonic_wall_time_now_ns(bool raise_on_failure);