datadog 2.8.0 → 2.39.0

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -21,74 +21,83 @@ void ruby_helpers_init(void) {
   to_s_id = rb_intern("to_s");
 }
 
-#define MAX_RAISE_MESSAGE_SIZE 256
+// Use `raise_syserr` the macro instead, as it provides additional argument checks.
+void private_raise_syserr(int syserr_errno, const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  VALUE detailed_message = rb_vsprintf(fmt, args);
+  va_end(args);
+
+  VALUE exception = rb_syserr_new_str(syserr_errno, detailed_message);
+  private_raise_exception(exception, fmt);
+}
 
-struct raise_arguments {
+typedef struct {
   VALUE exception_class;
-  char exception_message[MAX_RAISE_MESSAGE_SIZE];
-};
+  int syserr_errno;
+  const char *format_string;
+  va_list va_args;
+} raise_args;
 
+// Called via rb_thread_call_with_gvl from private_grab_gvl_and_raise.
+// Formats the message with rb_vsprintf (which requires the GVL) and raises.
 static void *trigger_raise(void *raise_arguments) {
-  struct raise_arguments *args = (struct raise_arguments *) raise_arguments;
-  rb_raise(args->exception_class, "%s", args->exception_message);
-}
+  raise_args *args = (raise_args *) raise_arguments;
 
-void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
-  struct raise_arguments args;
+  VALUE detailed_message = rb_vsprintf(args->format_string, args->va_args);
 
-  args.exception_class = exception_class;
-
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
-
-  if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise called by thread holding the global VM lock. exception_message: '%s'",
-      args.exception_message
-    );
+  VALUE exception;
+  if (args->syserr_errno) {
+    exception = rb_syserr_new_str(args->syserr_errno, detailed_message);
+  } else {
+    exception = rb_exc_new_str(args->exception_class, detailed_message);
   }
 
-  rb_thread_call_with_gvl(trigger_raise, &args);
+  private_raise_exception(exception, args->format_string);
 
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
+  return NULL;
 }
 
-struct syserr_raise_arguments {
-  int syserr_errno;
-  char exception_message[MAX_RAISE_MESSAGE_SIZE];
-};
-
-static void *trigger_syserr_raise(void *syserr_raise_arguments) {
-  struct syserr_raise_arguments *args = (struct syserr_raise_arguments *) syserr_raise_arguments;
-  rb_syserr_fail(args->syserr_errno, args->exception_message);
-}
+void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const char *format_string, ...) {
+  raise_args args;
 
-void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...) {
-  struct syserr_raise_arguments args;
-
-  args.syserr_errno = syserr_errno;
+  if (syserr_errno != 0) {
+    args.exception_class = Qnil;
+    args.syserr_errno = syserr_errno;
+  } else {
+    args.exception_class = exception_class;
+    args.syserr_errno = 0;
+  }
 
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+  args.format_string = format_string;
+  va_start(args.va_args, format_string);
 
   if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise_syserr called by thread holding the global VM lock. syserr_errno: %d, exception_message: '%s'",
-      syserr_errno,
-      args.exception_message
+    VALUE detailed_message = rb_vsprintf(format_string, args.va_args);
+    va_end(args.va_args);
+
+    VALUE wrapped_message = rb_sprintf(
+      "grab_gvl_and_raise called by thread holding the global VM lock: %"PRIsVALUE,
+      detailed_message
+    );
+    char telemetry_message[MAX_RAISE_MESSAGE_SIZE];
+    snprintf(
+      telemetry_message,
+      MAX_RAISE_MESSAGE_SIZE,
+      "grab_gvl_and_raise called by thread holding the global VM lock: %s",
+      format_string
     );
+    VALUE exception = rb_exc_new_str(rb_eRuntimeError, wrapped_message);
+    private_raise_exception(exception, telemetry_message);
   }
 
-  rb_thread_call_with_gvl(trigger_syserr_raise, &args);
+  rb_thread_call_with_gvl(trigger_raise, &args);
 
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+  va_end(args.va_args);
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", format_string);
 }
 
-void raise_syserr(
+void private_raise_enforce_syserr(
   int syserr_errno,
   bool have_gvl,
   const char *expression,
@@ -96,23 +105,14 @@ void raise_syserr(
   int line,
   const char *function_name
 ) {
+  const char *format = "Failure returned by '%s' at %s:%d:in `%s'";
   if (have_gvl) {
-    rb_exc_raise(rb_syserr_new_str(syserr_errno, rb_sprintf("Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name)));
+    private_raise_exception(rb_syserr_new_str(syserr_errno, rb_sprintf(format, expression, file, line, function_name)), format);
   } else {
-    grab_gvl_and_raise_syserr(syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
+    private_grab_gvl_and_raise(Qnil, syserr_errno, format, expression, file, line, function_name);
   }
 }
 
-char* ruby_strndup(const char *str, size_t size) {
-  char *dup;
-
-  dup = xmalloc(size + 1);
-  memcpy(dup, str, size);
-  dup[size] = '\0';
-
-  return dup;
-}
-
 static VALUE _id2ref(VALUE obj_id) {
   // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
   return rb_funcall(module_object_space, _id2ref_id, 1, obj_id);
@@ -122,9 +122,7 @@ static VALUE _id2ref_failure(DDTRACE_UNUSED VALUE _unused1, DDTRACE_UNUSED VALUE
   return Qfalse;
 }
 
-// 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).
+// See notes on header for important details
 bool ruby_ref_from_id(VALUE obj_id, VALUE *value) {
   // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
   // so we need to call it via rb_rescue2
@@ -164,9 +162,16 @@ size_t rb_obj_memsize_of(VALUE obj);
 size_t ruby_obj_memsize_of(VALUE obj) {
   switch (rb_type(obj)) {
     case T_OBJECT:
+    // On Ruby 4.0, computing the size of a class/module/iclass seems to not be safe: `rb_obj_memsize_of` walks the
+    // per-namespace class extensions (`rb_class_classext_foreach` -> `classext_memsize` -> `rb_id_table_memsize`)
+    // and can crash the VM when called on objects tracked by heap profiling.
+    // See https://github.com/DataDog/dd-trace-rb/issues/5936. Class objects contribute negligibly to heap size,
+    // so we skip them (fall through to the `default` branch, returning 0) rather than risk a SIGSEGV.
+    #ifndef NO_SAFE_CLASS_MEMSIZE
     case T_MODULE:
     case T_CLASS:
     case T_ICLASS:
+    #endif
     case T_STRING:
     case T_ARRAY:
     case T_HASH:

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <stdarg.h>
 #include "datadog_ruby_common.h"
 
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
@@ -39,26 +40,37 @@ static inline int check_if_pending_exception(void) {
 
 #define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
 
+// Raises a SysErr exception with the formatted string as its message.
+// See `raise_error` for details about telemetry messages.
+#define raise_syserr(syserr_errno, fmt, ...) \
+  private_raise_syserr(syserr_errno, "" fmt, ##__VA_ARGS__)
+
+#define grab_gvl_and_raise(exception_class, fmt, ...) \
+  private_grab_gvl_and_raise(exception_class, 0, "" fmt, ##__VA_ARGS__)
+
 NORETURN(
-  void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...)
+  void private_raise_syserr(int syserr_errno, const char *fmt, ...)
   __attribute__ ((format (printf, 2, 3)));
 );
+
 NORETURN(
-  void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
-  __attribute__ ((format (printf, 2, 3)));
+  void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const char *format_string, ...)
+  __attribute__ ((format (printf, 3, 4)));
 );
 
+
+
 #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__); }
+  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) private_raise_enforce_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
 
 #define RUBY_NUM_OR_NIL(val, condition, conv) ((val condition) ? conv(val) : Qnil)
 #define RUBY_AVG_OR_NIL(total, count) ((count == 0) ? Qnil : DBL2NUM(((double) total) / count))
 
 // Called by ENFORCE_SUCCESS_HELPER; should not be used directly
-NORETURN(void raise_syserr(
+NORETURN(void private_raise_enforce_syserr(
   int syserr_errno,
   bool have_gvl,
   const char *expression,
@@ -67,20 +79,12 @@ NORETURN(void raise_syserr(
   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);
+//
+// Note: GVL can be released and other threads may get to run before this method returns
+bool ruby_ref_from_id(VALUE obj_id, VALUE *value);
 
 // Native wrapper to get the approximate/estimated current size of the passed
 // object.

data/ext/datadog_profiling_native_extension/setup_signal_handler.c

@@ -9,29 +9,35 @@
 
 // Used by Collectors::CpuAndWallTimeWorker to setup SIGPROF signal handlers used for cpu/wall-time profiling.
 
+static VALUE existing_signal_handler_exception_class = Qnil;
+
 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 (*signal_handler_to_replace)(int, siginfo_t *, void *),
+  bool should_raise_on_failure
 );
 
 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);
+  install_sigprof_signal_handler_internal(signal_handler_function, handler_pretty_name, NULL, true);
 }
 
-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);
+void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *), bool should_raise_on_failure) {
+  install_sigprof_signal_handler_internal(empty_signal_handler, "empty_signal_handler", expected_existing_handler, should_raise_on_failure);
 }
 
 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 (*signal_handler_to_replace)(int, siginfo_t *, void *),
+  bool should_raise_on_failure
 ) {
   struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
   struct sigaction signal_handler_config = {
+    // NOTE: Deliberately not SA_ONSTACK. `handle_sampling_signal` uses "am I running on the alternate signal stack?"
+    // to detect that if it interrupted another signal handler from the Ruby VM, see `is_running_on_alternate_signal_stack` for details.
     .sa_flags = SA_RESTART | SA_SIGINFO,
     .sa_sigaction = signal_handler_function
   };
@@ -52,8 +58,7 @@ static void install_sigprof_signal_handler_internal(
   ) { 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.
+    // An unexpected/unknown signal handler already existed.
 
     if (sigaction(SIGPROF, &existing_signal_handler_config, NULL) != 0) {
       rb_exc_raise(
@@ -71,8 +76,12 @@ static void install_sigprof_signal_handler_internal(
       );
     }
 
-    rb_raise(
-      rb_eRuntimeError,
+    // If should_raise_on_failure is false (e.g., during cleanup), just return silently.
+    // This can happen if we failed to install our handler earlier due to a pre-existing handler.
+    if (!should_raise_on_failure) return;
+
+    raise_error(
+      existing_signal_handler_exception_class,
       "Could not install profiling signal handler (%s): There's a pre-existing SIGPROF signal handler",
       handler_pretty_name
     );
@@ -95,8 +104,14 @@ static inline 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)));
+  if (error) {
+    const char *message = (action == SIG_BLOCK) ?
+      "Unexpected failure in pthread_sigmask: action SIG_BLOCK" :
+      "Unexpected failure in pthread_sigmask: action SIG_UNBLOCK";
+    private_raise_syserr(error, message, message);
+  }
 }
 
 void block_sigprof_signal_handler_from_running_in_current_thread(void) {
@@ -113,3 +128,12 @@ VALUE is_sigprof_blocked_in_current_thread(void) {
   ENFORCE_SUCCESS_GVL(pthread_sigmask(0, NULL, &current_signals));
   return sigismember(&current_signals, SIGPROF) ? Qtrue : Qfalse;
 }
+
+void setup_signal_handler_init(VALUE profiling_module) {
+  existing_signal_handler_exception_class = rb_define_class_under(
+    profiling_module,
+    "ExistingSignalHandler",
+    rb_eRuntimeError
+  );
+  rb_gc_register_mark_object(existing_signal_handler_exception_class);
+}

data/ext/datadog_profiling_native_extension/setup_signal_handler.h

@@ -4,8 +4,9 @@
 #include "datadog_ruby_common.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 replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *), bool should_raise_on_failure);
 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);