datadog 2.0.0.beta1

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#include "helpers.h"
+
+// Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
+// usage of ruby helpers.
+void ruby_helpers_init(void);
+
+// Processes any pending interruptions, including exceptions to be raised.
+// If there's an exception to be raised, it raises it. In that case, this function does not return.
+static inline VALUE process_pending_interruptions(DDTRACE_UNUSED VALUE _) {
+  rb_thread_check_ints();
+  return Qnil;
+}
+
+// RB_UNLIKELY is not supported on Ruby 2.3
+#ifndef RB_UNLIKELY
+  #define RB_UNLIKELY(x) x
+#endif
+
+// Calls process_pending_interruptions BUT "rescues" any exceptions to be raised, returning them instead as
+// a non-zero `pending_exception`.
+//
+// Thus, if there's a non-zero `pending_exception`, the caller MUST call `rb_jump_tag(pending_exception)` after any
+// needed clean-ups.
+//
+// Usage example:
+//
+// ```c
+// foo = ruby_xcalloc(...);
+// pending_exception = check_if_pending_exception();
+// if (pending_exception) {
+//   ruby_xfree(foo);
+//   rb_jump_tag(pending_exception); // Re-raises exception
+// }
+// ```
+__attribute__((warn_unused_result))
+static inline int check_if_pending_exception(void) {
+  int pending_exception;
+  rb_protect(process_pending_interruptions, Qnil, &pending_exception);
+  return pending_exception;
+}
+
+#define ADD_QUOTES_HELPER(x) #x
+#define ADD_QUOTES(x) ADD_QUOTES_HELPER(x)
+
+// Ruby has a Check_Type(value, type) that is roughly equivalent to this BUT Ruby's version is rather cryptic when it fails
+// e.g. "wrong argument type nil (expected String)". This is a replacement that prints more information to help debugging.
+#define ENFORCE_TYPE(value, type) \
+  { if (RB_UNLIKELY(!RB_TYPE_P(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
+#define ENFORCE_BOOLEAN(value) \
+  { if (RB_UNLIKELY(value != Qtrue && value != Qfalse)) raise_unexpected_type(value, ADD_QUOTES(value), "true or false", __FILE__, __LINE__, __func__); }
+
+// Called by ENFORCE_TYPE; should not be used directly
+NORETURN(void raise_unexpected_type(
+  VALUE value,
+  const char *value_name,
+  const char *type_name,
+  const char *file,
+  int line,
+  const char *function_name
+));
+
+#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+
+NORETURN(
+  void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+NORETURN(
+  void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+
+#define ENFORCE_SUCCESS_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, true)
+#define ENFORCE_SUCCESS_NO_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, false)
+
+#define ENFORCE_SUCCESS_HELPER(expression, have_gvl) \
+  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) raise_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
+
+// Called by ENFORCE_SUCCESS_HELPER; should not be used directly
+NORETURN(void raise_syserr(
+  int syserr_errno,
+  bool have_gvl,
+  const char *expression,
+  const char *file,
+  int line,
+  const char *function_name
+));
+
+// Alternative to ruby_strdup that takes a size argument.
+// Similar to C's strndup but slightly less smart as size is expected to
+// be smaller or equal to the real size of str (minus null termination if it
+// exists).
+// A new string will be returned with size+1 bytes and last byte set to '\0'.
+// The returned string must be freed explicitly.
+//
+// WARN: Cannot be used during GC or outside the GVL.
+char* ruby_strndup(const char *str, size_t size);
+
+// Native wrapper to get an object ref from an id. Returns true on success and
+// writes the ref to the value pointer parameter if !NULL. False if id doesn't
+// reference a valid object (in which case value is not changed).
+bool ruby_ref_from_id(size_t id, VALUE *value);
+
+// Native wrapper to get the approximate/estimated current size of the passed
+// object.
+size_t ruby_obj_memsize_of(VALUE obj);
+
+// Safely inspect any ruby object. If the object responds to 'inspect',
+// return a string with the result of that call. Elsif the object responds to
+// 'to_s', return a string with the result of that call. Otherwise, return Qnil.
+VALUE ruby_safe_inspect(VALUE obj);
+
+VALUE ddtrace_version(void);

data/ext/datadog_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/datadog_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);