datadog 2.30.0 → 2.45.0

data/ext/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.c

@@ -6,7 +6,7 @@
 #include "ruby_helpers.h"
 
 #define BASE_OVERHEAD_PCT 1.0
-#define BASE_SAMPLING_INTERVAL 50
+#define BASE_SAMPLING_INTERVAL 1
 
 #define ADJUSTMENT_WINDOW_NS SECONDS_AS_NS(1)
 #define ADJUSTMENT_WINDOW_SAMPLES 100
@@ -367,11 +367,7 @@ static const rb_data_type_t sampler_typed_data = {
 static VALUE _native_new(VALUE klass) {
   sampler_state *state = ruby_xcalloc(1, sizeof(sampler_state));
 
-  long now_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
-  if (now_ns == 0) {
-    raise_error(rb_eRuntimeError, "failed to get clock time");
-  }
-  discrete_dynamic_sampler_init(&state->sampler, "test sampler", now_ns);
+  discrete_dynamic_sampler_init(&state->sampler, "test sampler", monotonic_wall_time_now_ns());
 
   // 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

data/ext/datadog_profiling_native_extension/collectors_gc_profiling_helper.c

@@ -53,8 +53,6 @@ void gc_profiling_init(void) {
   shady_sym     = ID2SYM(rb_intern_const("shady"));
   force_sym     = ID2SYM(rb_intern_const("force"));
   oldmalloc_sym = ID2SYM(rb_intern_const("oldmalloc"));
-  state_sym     = ID2SYM(rb_intern_const("state"));
-  none_sym      = ID2SYM(rb_intern_const("none"));
 }
 
 bool gc_profiling_has_major_gc_finished(void) {

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -6,6 +6,7 @@
 #include "helpers.h"
 #include "ruby_helpers.h"
 #include "collectors_idle_sampling_helper.h"
+#include "collectors_thread_context.h"
 
 // Used by the Collectors::CpuAndWallTimeWorker to gather samples when the Ruby process is idle.
 //
@@ -21,22 +22,24 @@
 typedef enum { ACTION_WAIT, ACTION_RUN, ACTION_STOP } action;
 
 // Contains state for a single CpuAndWallTimeWorker instance
-typedef struct {
+struct idle_sampling_loop_state {
   pthread_mutex_t wakeup_mutex;
   pthread_cond_t wakeup;
   action requested_action;
   void (*run_action_function)(void);
-} idle_sampling_loop_state;
+};
 
 static VALUE _native_new(VALUE klass);
 static void reset_state(idle_sampling_loop_state *state);
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance);
+static VALUE idle_sampling_loop_body(VALUE self_instance);
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static void *run_idle_sampling_loop(void *state_ptr);
 static void interrupt_idle_sampling_loop(void *state_ptr);
 static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static VALUE _native_idle_sampling_helper_request_action(DDTRACE_UNUSED VALUE self, VALUE self_instance);
-static void *request_testing_action(void *self_instance_ptr);
+static void *request_testing_action(void *state_ptr);
 static void grab_gvl_and_run_testing_action(void);
 static void *run_testing_action(DDTRACE_UNUSED void *unused);
 
@@ -56,7 +59,7 @@ void collectors_idle_sampling_helper_init(VALUE profiling_module) {
   // https://bugs.ruby-lang.org/issues/18007 for a discussion around this.
   rb_define_alloc_func(collectors_idle_sampling_helper_class, _native_new);
 
-  rb_define_singleton_method(collectors_idle_sampling_helper_class, "_native_idle_sampling_loop", _native_idle_sampling_loop, 1);
+  rb_define_singleton_method(collectors_idle_sampling_helper_class, "_native_idle_sampling_loop", _native_idle_sampling_loop, 2);
   rb_define_singleton_method(collectors_idle_sampling_helper_class, "_native_stop", _native_stop, 1);
   rb_define_singleton_method(collectors_idle_sampling_helper_class, "_native_reset", _native_reset, 1);
   rb_define_singleton_method(testing_module, "_native_idle_sampling_helper_request_action", _native_idle_sampling_helper_request_action, 1);
@@ -109,16 +112,26 @@ static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance) {
+  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, cpu_and_wall_time_worker_instance);
+}
+
+static VALUE idle_sampling_loop_body(VALUE self_instance) {
   idle_sampling_loop_state *state;
   TypedData_Get_Struct(self_instance, idle_sampling_loop_state, &idle_sampling_helper_typed_data, state);
 
+  thread_context_collector_profiler_internal_thread_started();
+
   // Release GVL and run the loop waiting for requests
   rb_thread_call_without_gvl(run_idle_sampling_loop, state, interrupt_idle_sampling_loop, state);
 
   return Qtrue;
 }
 
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance) {
+  return rb_funcall(cpu_and_wall_time_worker_instance, rb_intern("_native_profiler_internal_thread_done"), 0);
+}
+
 static void *run_idle_sampling_loop(void *state_ptr) {
   idle_sampling_loop_state *state = (idle_sampling_loop_state *) state_ptr;
   int error = 0;
@@ -202,15 +215,14 @@ static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-// Assumption: Function gets called without the global VM lock
-void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_function)(void)) {
+idle_sampling_loop_state *idle_sampling_helper_get_state(VALUE self_instance) {
   idle_sampling_loop_state *state;
-  if (!rb_typeddata_is_kind_of(self_instance, &idle_sampling_helper_typed_data)) {
-    grab_gvl_and_raise(rb_eTypeError, "Wrong argument for idle_sampling_helper_request_action");
-  }
-  // This should never fail the the above check passes
   TypedData_Get_Struct(self_instance, idle_sampling_loop_state, &idle_sampling_helper_typed_data, state);
+  return state;
+}
 
+// Called without the GVL, so we access native state directly: touching the Ruby self_instance is unsafe during GC compaction.
+void idle_sampling_helper_request_action(idle_sampling_loop_state *state, void (*run_action_function)(void)) {
   ENFORCE_SUCCESS_NO_GVL(pthread_mutex_lock(&state->wakeup_mutex));
   if (state->requested_action == ACTION_WAIT) {
     state->requested_action = ACTION_RUN;
@@ -225,13 +237,14 @@ void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_
 // Because the idle_sampling_helper_request_action is built to be called without the global VM lock, here we release it
 // to be able to call that API.
 static VALUE _native_idle_sampling_helper_request_action(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
-  rb_thread_call_without_gvl(request_testing_action, (void *) self_instance, NULL, NULL);
+  idle_sampling_loop_state *state = idle_sampling_helper_get_state(self_instance);
+  rb_thread_call_without_gvl(request_testing_action, state, NULL, NULL);
+  RB_GC_GUARD(self_instance);
   return Qtrue;
 }
 
-static void *request_testing_action(void *self_instance_ptr) {
-  VALUE self_instance = (VALUE) self_instance_ptr;
-  idle_sampling_helper_request_action(self_instance, grab_gvl_and_run_testing_action);
+static void *request_testing_action(void *state_ptr) {
+  idle_sampling_helper_request_action(state_ptr, grab_gvl_and_run_testing_action);
   return NULL;
 }
 

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.h

@@ -1,3 +1,7 @@
 #pragma once
 
-void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_function)(void));
+typedef struct idle_sampling_loop_state idle_sampling_loop_state;
+
+// Must be called with the GVL held; keep self_instance alive while using the returned pointer.
+idle_sampling_loop_state *idle_sampling_helper_get_state(VALUE self_instance);
+void idle_sampling_helper_request_action(idle_sampling_loop_state *state, void (*run_action_function)(void));