datadog 2.2.0 → 2.4.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -182,7 +182,7 @@ uint64_t native_thread_id_for(VALUE thread) {
   #if !defined(NO_THREAD_TID) && defined(RB_THREAD_T_HAS_NATIVE_ID)
     #ifndef NO_RB_NATIVE_THREAD
       struct rb_native_thread* native_thread = thread_struct_from_object(thread)->nt;
-      if (native_thread == NULL) rb_raise(rb_eRuntimeError, "BUG: rb_native_thread* is null. Is this Ruby running with RUBY_MN_THREADS=1?");
+      if (native_thread == NULL) return 0;
       return native_thread->tid;
     #else
       return thread_struct_from_object(thread)->tid;
@@ -311,7 +311,7 @@ VALUE thread_name_for(VALUE thread) {
 // with diagnostic stuff. See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
-inline static int
+static inline int
 calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 {
     VM_ASSERT(iseq);
@@ -364,7 +364,7 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
 // Modifications: None
-inline static int
+static inline int
 calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 {
     int lineno;
@@ -376,8 +376,8 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // Modifications:
 // * Renamed rb_profile_frames => ddtrace_rb_profile_frames
-// * Add thread argument
-// * Add is_ruby_frame argument
+// * Add thread argument (this is now upstream, actually!)
+// * Add frame_flags.is_ruby_frame argument
 // * Removed `if (lines)` tests -- require/assume that like `buff`, `lines` is always specified
 // * Skip dummy frame that shows up in main thread
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
@@ -392,6 +392,9 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //   was called from.
 // * Imported fix from https://github.com/ruby/ruby/pull/7116 to avoid sampling threads that are still being created
 // * Imported fix from https://github.com/ruby/ruby/pull/8415 to avoid potential crash when using YJIT.
+// * Add frame_flags.same_frame and logic to skip redoing work if the buffer already contains the same data we're collecting
+// * Skipped use of rb_callable_method_entry_t (cme) for Ruby frames as it doesn't impact us.
+// * Imported fix from https://github.com/ruby/ruby/pull/8280 to keep us closer to upstream
 //
 // What is rb_profile_frames?
 // `rb_profile_frames` is a Ruby VM debug API added for use by profilers for sampling the stack trace of a Ruby thread.
@@ -421,8 +424,7 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //    and friends). We've found quite a few situations where the data from rb_profile_frames and the reference APIs
 //    disagree, and quite a few of them seem oversights/bugs (speculation from my part) rather than deliberate
 //    decisions.
-int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame)
-{
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer) {
     int i;
     // Modified from upstream: Instead of using `GET_EC` to collect info from the current thread,
     // support sampling any thread (including the current) passed as an argument
@@ -466,7 +468,7 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
     if (end_cfp <= cfp) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
 
-    for (i=0; i<limit && cfp != end_cfp;) {
+    for (i=0; i<limit && cfp != end_cfp; cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)) {
         if (cfp->iseq && !cfp->pc) {
           // Fix: Do nothing -- this frame should not be used
           //
@@ -479,164 +481,88 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
                 continue;
             }
 
-            /* record frame info */
-            cme = rb_vm_frame_method_entry(cfp);
+            stack_buffer[i].same_frame =
+              stack_buffer[i].is_ruby_frame &&
+              stack_buffer[i].as.ruby_frame.iseq == (VALUE) cfp->iseq &&
+              stack_buffer[i].as.ruby_frame.caching_pc == cfp->pc;
 
-            if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ &&
-              // Fix: Do not use callable method entry when iseq is for an eval.
-              // TL;DR: This fix is needed for us to match the Ruby reference API information in the
-              // "when sampling an eval/instance eval inside an object" spec.
-              //
-              // Longer note:
-              // When a frame is a ruby frame (VM_FRAME_RUBYFRAME_P above), we can get information about it
-              // by introspecting both the callable method entry, as well as the iseq directly.
-              // Often they match... but sometimes they provide different info (as in the "iseq for an eval" situation
-              // here).
-              // If my reading of vm_backtrace.c is correct, the actual Ruby stack trace API **never** uses the
-              // callable method entry for Ruby frames, but only for VM_METHOD_TYPE_CFUNC (see `backtrace_each` method
-              // on that file).
-              // So... why does `rb_profile_frames` do something different? Is it a bug? Is it because it exposes
-              // more information than the Ruby stack frame API?
-              // As a final note, the `backtracie` gem (https://github.com/ivoanjo/backtracie) can be used to introspect
-              // the full metadata provided by both the callable method entry as well as the iseq, and is really useful
-              // to debug and learn more about these differences.
-              cfp->iseq->body->type != ISEQ_TYPE_EVAL) {
-                buff[i] = (VALUE)cme;
-            }
-            else {
-                buff[i] = (VALUE)cfp->iseq;
+            if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
+              i++;
+              continue;
             }
 
+            // dd-trace-rb NOTE:
+            // Upstream Ruby has code here to retrieve the rb_callable_method_entry_t (cme) and in some cases to use it
+            // instead of the iseq.
+            // In practice, they are usually the same; the difference is that when you have e.g. block, one gets you a
+            // reference to the block, and the other to the method containing the block.
+            // This would be important if we used `rb_profile_frame_label` and wanted the "block in foo" label instead
+            // of just "foo". But we're currently using `rb_profile_frame_base_label` which I believe is always the same
+            // between the rb_callable_method_entry_t and the iseq. Thus, to simplify a bit our logic and reduce a bit
+            // the overhead, we always use the iseq here.
+            //
+            // @ivoanjo: I've left the upstream Ruby code commented out below for reference, so it's more obvious that
+            // we're diverging, and we can easily compare and experiment with the upstream version in the future.
+            //
+            // cme = rb_vm_frame_method_entry(cfp);
+
+            // if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ &&
+            //   // Fix: Do not use callable method entry when iseq is for an eval.
+            //   // TL;DR: This fix is needed for us to match the Ruby reference API information in the
+            //   // "when sampling an eval/instance eval inside an object" spec.
+            //   cfp->iseq->body->type != ISEQ_TYPE_EVAL) {
+            //     buff[i] = (VALUE)cme;
+            // }
+            // else {
+            stack_buffer[i].as.ruby_frame.iseq = (VALUE)cfp->iseq;
+            stack_buffer[i].as.ruby_frame.caching_pc = (void *) cfp->pc;
+            // }
+
             // The topmost frame may not have an updated PC because the JIT
             // may not have set one.  The JIT compiler will update the PC
             // before entering a new function (so that `caller` will work),
             // so only the topmost frame could possibly have an out of date PC
             #ifndef NO_JIT_RETURN
               if (cfp == top && cfp->jit_return) {
-                lines[i] = 0;
+                stack_buffer[i].as.ruby_frame.line = 0;
               } else {
-                lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+                stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
               }
             #else // Ruby < 3.1
-              lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+              stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
             #endif
 
-            is_ruby_frame[i] = true;
+            stack_buffer[i].is_ruby_frame = true;
             i++;
         }
         else {
             cme = rb_vm_frame_method_entry(cfp);
             if (cme && cme->def->type == VM_METHOD_TYPE_CFUNC) {
-                buff[i] = (VALUE)cme;
-                lines[i] = 0;
-                is_ruby_frame[i] = false;
+                if (start > 0) {
+                    start--;
+                    continue;
+                }
+
+                stack_buffer[i].same_frame =
+                  !stack_buffer[i].is_ruby_frame &&
+                  stack_buffer[i].as.native_frame.caching_cme == (VALUE) cme;
+
+                if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
+                  i++;
+                  continue;
+                }
+
+                stack_buffer[i].as.native_frame.caching_cme = (VALUE)cme;
+                stack_buffer[i].as.native_frame.method_id = cme->def->original_id;
+                stack_buffer[i].is_ruby_frame = false;
                 i++;
             }
         }
-        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
 
     return i;
 }
 
-#ifdef USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static VALUE
-id2str(ID id)
-{
-    VALUE str = rb_id2str(id);
-    if (!str) return Qnil;
-    return str;
-}
-#define rb_id2str(id) id2str(id)
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static const rb_iseq_t *
-frame2iseq(VALUE frame)
-{
-    if (NIL_P(frame)) return NULL;
-
-    if (RB_TYPE_P(frame, T_IMEMO)) {
-    switch (imemo_type(frame)) {
-      case imemo_iseq:
-        return (const rb_iseq_t *)frame;
-      case imemo_ment:
-        {
-        const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
-        switch (cme->def->type) {
-          case VM_METHOD_TYPE_ISEQ:
-            return cme->def->body.iseq.iseqptr;
-          default:
-            return NULL;
-        }
-        }
-      default:
-        break;
-    }
-    }
-    rb_bug("frame2iseq: unreachable");
-}
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static const rb_callable_method_entry_t *
-cframe(VALUE frame)
-{
-    if (NIL_P(frame)) return NULL;
-
-    if (RB_TYPE_P(frame, T_IMEMO)) {
-    switch (imemo_type(frame)) {
-      case imemo_ment:
-            {
-        const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
-        switch (cme->def->type) {
-          case VM_METHOD_TYPE_CFUNC:
-            return cme;
-          default:
-            return NULL;
-        }
-            }
-          default:
-            return NULL;
-        }
-    }
-
-    return NULL;
-}
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-//
-// Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)
-// in stack traces gathered via `rb_profile_frames` (https://github.com/ruby/ruby/pull/3299).
-// To access this information on older Rubies, beyond using our custom `ddtrace_rb_profile_frames` above, we also need
-// to backport the Ruby 3.0+ version of `rb_profile_frame_method_name`.
-//
-// Modifications:
-// * Renamed rb_profile_frame_method_name => ddtrace_rb_profile_frame_method_name
-VALUE
-ddtrace_rb_profile_frame_method_name(VALUE frame)
-{
-    const rb_callable_method_entry_t *cme = cframe(frame);
-    if (cme) {
-        ID mid = cme->def->original_id;
-        return id2str(mid);
-    }
-    const rb_iseq_t *iseq = frame2iseq(frame);
-    return iseq ? rb_iseq_method_name(iseq) : Qnil;
-}
-
-#endif // USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-
 // Support code for older Rubies that cannot use the MJIT header
 #ifndef RUBY_MJIT_HEADER
 
@@ -829,3 +755,54 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
     return GET_VM()->objspace;
   }
 #endif
+
+#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
+  #include "gvl_profiling_helper.h"
+
+  gvl_profiling_thread thread_from_thread_object(VALUE thread) {
+    return (gvl_profiling_thread) {.thread = thread_struct_from_object(thread)};
+  }
+
+  // Hack: In Ruby 3.3+ we attach gvl profiling state to Ruby threads using the
+  // rb_internal_thread_specific_* APIs. These APIs did not exist on Ruby 3.2. On Ruby 3.2 we instead store the
+  // needed data inside the `rb_thread_t` structure, specifically in `stat_insn_usage` as a Ruby FIXNUM.
+  //
+  // Why `stat_insn_usage`? We needed some per-thread storage, and while looking at the Ruby VM sources I noticed
+  // that `stat_insn_usage` has been in `rb_thread_t` for a long time, but is not used anywhere in the VM
+  // code. There's a comment attached to it "/* statistics data for profiler */" but other than marking this
+  // field for GC, I could not find any place in the VM commit history or on GitHub where this has ever been used.
+  //
+  // Thus, since this hack is only for 3.2, which presumably will never see this field either removed or used
+  // during its remaining maintenance release period we... kinda take it for our own usage. It's ugly, I know...
+  intptr_t gvl_profiling_state_get(gvl_profiling_thread thread) {
+    if (thread.thread == NULL) return 0;
+
+    VALUE current_value = ((rb_thread_t *)thread.thread)->stat_insn_usage;
+    intptr_t result = current_value == Qnil ? 0 : FIX2LONG(current_value);
+    return result;
+  }
+
+  void gvl_profiling_state_set(gvl_profiling_thread thread, intptr_t value) {
+    if (thread.thread == NULL) return;
+    ((rb_thread_t *)thread.thread)->stat_insn_usage = LONG2FIX(value);
+  }
+
+  // Because Ruby 3.2 does not give us the current thread when calling the RUBY_INTERNAL_THREAD_EVENT_READY and
+  // RUBY_INTERNAL_THREAD_EVENT_RESUMED APIs, we need to figure out this info ourselves.
+  //
+  // Specifically, this method was created to be called from a RUBY_INTERNAL_THREAD_EVENT_RESUMED callback --
+  // when it's triggered, we know the thread the code gets executed on is holding the GVL, so we use this
+  // opportunity to initialize our thread-local value.
+  gvl_profiling_thread gvl_profiling_state_maybe_initialize(void) {
+    gvl_profiling_thread current_thread = gvl_waiting_tls;
+
+    if (current_thread.thread == NULL) {
+      // threads.sched.running is the thread currently holding the GVL, which when this gets executed is the
+      // current thread!
+      current_thread = (gvl_profiling_thread) {.thread = (void *) rb_current_ractor()->threads.sched.running};
+      gvl_waiting_tls = current_thread;
+    }
+
+    return current_thread;
+  }
+#endif

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -18,6 +18,22 @@ typedef struct {
   rb_nativethread_id_t owner;
 } current_gvl_owner;
 
+typedef struct frame_info {
+  union {
+    struct {
+      VALUE iseq;
+      void *caching_pc; // For caching only
+      int line;
+    } ruby_frame;
+    struct {
+      VALUE caching_cme; // For caching only
+      ID method_id;
+    } native_frame;
+  } as;
+  bool is_ruby_frame : 1;
+  bool same_frame : 1;
+} frame_info;
+
 rb_nativethread_id_t pthread_id_for(VALUE thread);
 bool is_current_thread_holding_the_gvl(void);
 current_gvl_owner gvl_owner(void);
@@ -27,20 +43,10 @@ void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);
 
-int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame);
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 
-// Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)
-// in stack traces gathered via `rb_profile_frames` (https://github.com/ruby/ruby/pull/3299).
-// To access this information on older Rubies, beyond using our custom `ddtrace_rb_profile_frames` above, we also need
-// to backport the Ruby 3.0+ version of `rb_profile_frame_method_name`.
-#ifdef USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-  VALUE ddtrace_rb_profile_frame_method_name(VALUE frame);
-#else // Ruby > 3.0, just use the stock functionality
-  #define ddtrace_rb_profile_frame_method_name rb_profile_frame_method_name
-#endif
-
 // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
 #define PLACEHOLDER_STACK_IN_NATIVE_CODE -1
 
@@ -59,3 +65,6 @@ const char *imemo_kind(VALUE imemo);
 #ifdef NO_POSTPONED_TRIGGER
   void *objspace_ptr_for_gc_finalize_deferred_workaround(void);
 #endif
+
+#define ENFORCE_THREAD(value) \
+  { if (RB_UNLIKELY(!rb_typeddata_is_kind_of(value, RTYPEDDATA_TYPE(rb_thread_current())))) raise_unexpected_type(value, ADD_QUOTES(value), "Thread", __FILE__, __LINE__, __func__); }

data/ext/datadog_profiling_native_extension/profiling.c

@@ -19,7 +19,6 @@ void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
 void collectors_thread_context_init(VALUE profiling_module);
-void crashtracker_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
@@ -54,7 +53,6 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
   collectors_thread_context_init(profiling_module);
-  crashtracker_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 
@@ -255,7 +253,7 @@ static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_er
 
 static void *trigger_enforce_success(void *trigger_args) {
   intptr_t syserr_errno = (intptr_t) trigger_args;
-  ENFORCE_SUCCESS_NO_GVL(syserr_errno);
+  ENFORCE_SUCCESS_NO_GVL((int) syserr_errno);
   return NULL;
 }
 

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -20,29 +20,6 @@ void ruby_helpers_init(void) {
   to_s_id = rb_intern("to_s");
 }
 
-void raise_unexpected_type(
-  VALUE value,
-  const char *value_name,
-  const char *type_name,
-  const char *file,
-  int line,
-  const char* function_name
-) {
-  rb_exc_raise(
-    rb_exc_new_str(
-      rb_eTypeError,
-      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
-        rb_inspect(value),
-        value_name,
-        type_name,
-        file,
-        line,
-        function_name
-      )
-    )
-  );
-}
-
 #define MAX_RAISE_MESSAGE_SIZE 256
 
 struct raise_arguments {
@@ -255,13 +232,3 @@ VALUE ruby_safe_inspect(VALUE obj) {
     return rb_str_new_cstr("(Not inspectable)");
   }
 }
-
-VALUE ddtrace_version(void) {
-  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
-  ENFORCE_TYPE(ddtrace_module, T_MODULE);
-  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
-  ENFORCE_TYPE(version_module, T_MODULE);
-  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
-  ENFORCE_TYPE(version_string, T_STRING);
-  return version_string;
-}

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <ruby.h>
 #include <stdbool.h>
-
-#include "helpers.h"
+#include "datadog_ruby_common.h"
 
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
 // usage of ruby helpers.
@@ -39,27 +37,6 @@ static inline int check_if_pending_exception(void) {
   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(
@@ -113,5 +90,3 @@ size_t ruby_obj_memsize_of(VALUE obj);
 // 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.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <signal.h>
+#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);

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -342,6 +342,10 @@ static VALUE _native_new(VALUE klass) {
   // Note: At this point, slot_one_profile and slot_two_profile contain null pointers. Libdatadog validates pointers
   // before using them so it's ok for us to go ahead and create the StackRecorder object.
 
+  // Note: As of this writing, no new Ruby objects get created and stored in the state. If that ever changes, remember
+  // to keep them on the stack and mark them with RB_GC_GUARD -- otherwise it's possible for a GC to run and
+  // since the instance representing the state does not yet exist, such objects will not get marked.
+
   VALUE stack_recorder = TypedData_Wrap_Struct(klass, &stack_recorder_typed_data, state);
 
   // NOTE: We initialize this because we want a new recorder to be operational even without initialization and our
@@ -612,12 +616,20 @@ void record_sample(VALUE recorder_instance, ddog_prof_Slice_Location locations,
   metric_values[position_for[ALLOC_SAMPLES_UNSCALED_VALUE_ID]] = values.alloc_samples_unscaled;
   metric_values[position_for[TIMELINE_VALUE_ID]]      = values.timeline_wall_time_ns;
 
-  if (values.alloc_samples != 0) {
+  if (values.heap_sample) {
     // If we got an allocation sample end the heap allocation recording to commit the heap sample.
     // FIXME: Heap sampling currently has to be done in 2 parts because the construction of locations is happening
     //        very late in the allocation-sampling path (which is shared with the cpu sampling path). This can
     //        be fixed with some refactoring but for now this leads to a less impactful change.
-    end_heap_allocation_recording(state->heap_recorder, locations);
+    //
+    // NOTE: The heap recorder is allowed to raise exceptions if something's wrong. But we also need to handle it
+    // on this side to make sure we properly unlock the active slot mutex on our way out. Otherwise, this would
+    // later lead to deadlocks (since the active slot mutex is not expected to be locked forever).
+    int exception_state = end_heap_allocation_recording_with_rb_protect(state->heap_recorder, locations);
+    if (exception_state) {
+      sampler_unlock_active_profile(active_slot);
+      rb_jump_tag(exception_state);
+    }
   }
 
   ddog_prof_Profile_Result result = ddog_prof_Profile_add(

data/ext/datadog_profiling_native_extension/stack_recorder.h

@@ -9,6 +9,7 @@ typedef struct {
   uint32_t cpu_or_wall_samples;
   uint32_t alloc_samples;
   uint32_t alloc_samples_unscaled;
+  bool heap_sample;
   int64_t timeline_wall_time_ns;
 } sample_values;
 
@@ -18,6 +19,7 @@ typedef struct sample_labels {
   // This is used to allow the `Collectors::Stack` to modify the existing label, if any. This MUST be NULL or point
   // somewhere inside the labels slice above.
   ddog_prof_Label *state_label;
+  bool is_gvl_waiting_state;
 
   int64_t end_timestamp_ns;
 } sample_labels;

data/ext/datadog_profiling_native_extension/time_helpers.c

@@ -4,21 +4,6 @@
 #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 retrieve_clock_as_ns(clockid_t clock_id, bool raise_on_failure) {
-  struct timespec clock_value;
-
-  if (clock_gettime(clock_id, &clock_value) != 0) {
-    if (raise_on_failure) ENFORCE_SUCCESS_GVL(errno);
-    return 0;
-  }
-
-  return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
-}
-
-long monotonic_wall_time_now_ns(bool raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC, raise_on_failure); }
-long system_epoch_time_now_ns(bool raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
-
 // Design: The monotonic_to_system_epoch_state struct is kept somewhere by the caller, and MUST be initialized to
 // MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER.
 //

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -1,12 +1,16 @@
 #pragma once
 
 #include <stdbool.h>
+#include <errno.h>
+#include <time.h>
+
+#include "extconf.h" // Needed for HAVE_CLOCK_MONOTONIC_COARSE
+#include "ruby_helpers.h"
 
 #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
+typedef enum { RAISE_ON_FAILURE, DO_NOT_RAISE_ON_FAILURE } raise_on_failure_setting;
 
 #define INVALID_TIME -1
 
@@ -17,10 +21,36 @@ typedef struct {
 
 #define MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER {.system_epoch_ns_reference = INVALID_TIME, .delta_to_epoch_ns = INVALID_TIME}
 
-// 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);
+static inline long retrieve_clock_as_ns(clockid_t clock_id, raise_on_failure_setting raise_on_failure) {
+  struct timespec clock_value;
+
+  if (clock_gettime(clock_id, &clock_value) != 0) {
+    if (raise_on_failure == RAISE_ON_FAILURE) ENFORCE_SUCCESS_GVL(errno);
+    return 0;
+  }
+
+  return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
+}
+
+static inline long monotonic_wall_time_now_ns(raise_on_failure_setting raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC, raise_on_failure); }
+static inline long system_epoch_time_now_ns(raise_on_failure_setting raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
+
+// Coarse instants use CLOCK_MONOTONIC_COARSE on Linux which is expected to provide resolution in the millisecond range:
+// https://docs.redhat.com/en/documentation/red_hat_enterprise_linux_for_real_time/7/html/reference_guide/sect-posix_clocks#Using_clock_getres_to_compare_clock_resolution
+// We introduce here a separate type for it, so as to make it harder to misuse/more explicit when these timestamps are used
+
+typedef struct coarse_instant {
+  long timestamp_ns;
+} coarse_instant;
+
+static inline coarse_instant to_coarse_instant(long timestamp_ns) { return (coarse_instant) {.timestamp_ns = timestamp_ns}; }
 
-// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
-long system_epoch_time_now_ns(bool raise_on_failure);
+static inline coarse_instant monotonic_coarse_wall_time_now_ns(void) {
+ #ifdef HAVE_CLOCK_MONOTONIC_COARSE // Linux
+    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE, DO_NOT_RAISE_ON_FAILURE));
+  #else // macOS
+    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC, DO_NOT_RAISE_ON_FAILURE));
+  #endif
+}
 
 long monotonic_to_system_epoch_ns(monotonic_to_system_epoch_state *state, long monotonic_wall_time_ns);