ddtrace 1.1.0 → 1.4.0

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -13,7 +13,13 @@
   #include RUBY_MJIT_HEADER
 #else
   // On older Rubies, use a copy of the VM internal headers shipped in the debase-ruby_core_source gem
-  #include <vm_core.h>
+
+  // We can't do anything about warnings in VM headers, so we just use this technique to surpress them.
+  // See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-parameter"
+    #include <vm_core.h>
+  #pragma GCC diagnostic pop
   #include <iseq.h>
 #endif
 
@@ -35,7 +41,12 @@ static inline rb_thread_t *thread_struct_from_object(VALUE thread) {
 }
 
 rb_nativethread_id_t pthread_id_for(VALUE thread) {
-  return thread_struct_from_object(thread)->thread_id;
+  // struct rb_native_thread was introduced in Ruby 3.2 (preview2): https://github.com/ruby/ruby/pull/5836
+  #ifndef NO_RB_NATIVE_THREAD
+    return thread_struct_from_object(thread)->nt->thread_id;
+  #else
+    return thread_struct_from_object(thread)->thread_id;
+  #endif
 }
 
 // Returns the stack depth by using the same approach as rb_profile_frames and backtrace_each: get the positions
@@ -58,6 +69,64 @@ ptrdiff_t stack_depth_for(VALUE thread) {
   return end_cfp <= cfp ? 0 : end_cfp - cfp - 1;
 }
 
+// This was renamed in Ruby 3.2
+#if !defined(ccan_list_for_each) && defined(list_for_each)
+  #define ccan_list_for_each list_for_each
+#endif
+
+// Tries to match rb_thread_list() but that method isn't accessible to extensions
+VALUE ddtrace_thread_list(void) {
+  VALUE result = rb_ary_new();
+  rb_thread_t *thread = NULL;
+
+  // Ruby 3 Safety: Our implementation is inspired by `rb_ractor_thread_list` BUT that method wraps the operations below
+  // with `RACTOR_LOCK` and `RACTOR_UNLOCK`.
+  //
+  // This initially made me believe that one MUST grab the ractor lock (which is different from the ractor-scoped Global
+  // VM Lock) in able to iterate the `threads.set`. This turned out not to be the case: upon further study of the VM
+  // codebase in 3.2-master, 3.1 and 3.0, there's quite a few places where `threads.set` is accessed without grabbing
+  // the ractor lock: `ractor_mark` (ractor.c), `thgroup_list` (thread.c), `rb_check_deadlock` (thread.c), etc.
+  //
+  // I suspect the design in `rb_ractor_thread_list` may be done that way to perhaps in the future expose it to be
+  // called from a different Ractor, but I'm not sure...
+  #ifdef HAVE_RUBY_RACTOR_H
+    rb_ractor_t *current_ractor = GET_RACTOR();
+    ccan_list_for_each(&current_ractor->threads.set, thread, lt_node) {
+  #else
+    rb_vm_t *vm = thread_struct_from_object(rb_thread_current())->vm;
+    list_for_each(&vm->living_threads, thread, vmlt_node) {
+  #endif
+      switch (thread->status) {
+        case THREAD_RUNNABLE:
+        case THREAD_STOPPED:
+        case THREAD_STOPPED_FOREVER:
+          rb_ary_push(result, thread->self);
+        default:
+          break;
+      }
+    }
+
+  return result;
+}
+
+bool is_thread_alive(VALUE thread) {
+  return thread_struct_from_object(thread)->status != THREAD_KILLED;
+}
+
+// `thread` gets used on all Rubies except 2.2
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// 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"
+VALUE thread_name_for(VALUE thread) {
+  #ifdef NO_THREAD_NAMES
+    return Qnil;
+  #else
+    return thread_struct_from_object(thread)->name;
+  #endif
+}
+#pragma GCC diagnostic pop
+
 // -----------------------------------------------------------------------------
 // The sources below are modified versions of code extracted from the Ruby project.
 // Each function is annotated with its origin, why we imported it, and the changes made.
@@ -99,6 +168,12 @@ ptrdiff_t stack_depth_for(VALUE thread) {
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
 // Modifications: None
+//
+// `node_id` gets used depending on Ruby VM compilation settings (USE_ISEQ_NODE_ID being defined).
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// 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
 calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 {
@@ -142,6 +217,7 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
         return 1;
     }
 }
+#pragma GCC diagnostic pop
 
 // Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
@@ -545,11 +621,11 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Check thread status and do not sample if thread has been killed.
 //
 // The `rb_profile_frames` function changed quite a bit between Ruby 2.2 and 2.3. Since the change was quite complex
-// I opted not to try to extend support to Ruby 2.2 and below using the same custom function, and instead I started
+// I opted not to try to extend support to Ruby 2.2 using the same custom function, and instead I started
 // anew from the Ruby 2.2 version of the function, applying some of the same fixes that we have for the modern version.
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame)
 {
-    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2 AND BELOW;
+    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2;
     // SEE ABOVE FOR THE FUNCTION THAT GETS USED FOR MODERN RUBIES**
 
     int i;
@@ -605,3 +681,12 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
 }
 
 #endif // USE_LEGACY_RB_PROFILE_FRAMES
+
+#ifdef NO_THREAD_HAS_GVL
+int ruby_thread_has_gvl_p(void) {
+  // TODO: The CpuAndWallTimeWorker needs this function, but Ruby 2.2 doesn't expose it... For now this placeholder
+  // will enable the profiling native extension to continue to compile on Ruby 2.2, but the CpuAndWallTimeWorker will
+  // not work properly on 2.2. Will be addressed later.
+  return 0;
+}
+#endif // NO_THREAD_HAS_GVL

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -6,17 +6,17 @@
 // so we use PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES to be able to include private_vm_api_access.h on that file
 // without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
-  #ifdef RUBY_2_1_WORKAROUND
-    #include <thread_native.h>
-  #else
-    #include <ruby/thread_native.h>
-  #endif
+  #include <ruby/thread_native.h>
 #endif
 
 #include "extconf.h"
 
 rb_nativethread_id_t pthread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
+VALUE ddtrace_thread_list(void);
+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);
 
 // Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,15 +1,17 @@
 #include <ruby.h>
 
 #include "clock_id.h"
+#include "helpers.h"
 
 // Each class/module here is implemented in their separate file
+void collectors_cpu_and_wall_time_init(VALUE profiling_module);
+void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
+void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
 
-#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
-
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
@@ -20,11 +22,14 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
 
   rb_define_singleton_method(native_extension_module, "clock_id_for", clock_id_for, 1); // from clock_id.h
 
+  collectors_cpu_and_wall_time_init(profiling_module);
+  collectors_cpu_and_wall_time_worker_init(profiling_module);
   collectors_stack_init(profiling_module);
+  http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 }
 
-static VALUE native_working_p(VALUE self) {
+static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   self_test_clock_id();
 
   return Qtrue;

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -0,0 +1,25 @@
+#include "ruby_helpers.h"
+
+void raise_unexpected_type(
+  VALUE value,
+  DDTRACE_UNUSED enum ruby_value_type _type,
+  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
+      )
+    )
+  );
+}

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <ruby.h>
+
+#include "helpers.h"
+
+// 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.2 and 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, type, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
+// Called by ENFORCE_TYPE; should not be used directly
+NORETURN(void raise_unexpected_type(
+  VALUE value,
+  enum ruby_value_type type,
+  const char *value_name,
+  const char *type_name,
+  const char *file,
+  int line,
+  const char* function_name
+));
+
+// This API is exported as a public symbol by the VM BUT the function header is not defined in any public header, so we
+// repeat it here to be able to use in our code.
+//
+// Queries if the current thread is the owner of the global VM lock.
+int ruby_thread_has_gvl_p(void);