Maybe we remove custom exception classes

Author: marcotc

ext/datadog_profiling_native_extension/clock_id_from_pthread.c

@@ -19,7 +19,7 @@ void self_test_clock_id(void) {
   rb_nativethread_id_t expected_pthread_id = pthread_self();
   rb_nativethread_id_t actual_pthread_id = pthread_id_for(rb_thread_current());
 
-  if (expected_pthread_id != actual_pthread_id) raise_error(eDatadogRuntimeError, "pthread_id_for() self-test failed");
+  if (expected_pthread_id != actual_pthread_id) raise_error(rb_eRuntimeError, "pthread_id_for() self-test failed");
 }
 
 // Safety: This function is assumed never to raise exceptions by callers

ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -289,7 +289,7 @@ void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module) {
       after_gc_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID ||
       after_gvl_running_from_postponed_job_handle == POSTPONED_JOB_HANDLE_INVALID
     ) {
-      raise_error(eDatadogRuntimeError, "Failed to register profiler postponed jobs (got POSTPONED_JOB_HANDLE_INVALID)");
+      raise_error(rb_eRuntimeError, "Failed to register profiler postponed jobs (got POSTPONED_JOB_HANDLE_INVALID)");
     }
   #else
     gc_finalize_deferred_workaround = objspace_ptr_for_gc_finalize_deferred_workaround();
@@ -472,7 +472,7 @@ static VALUE _native_sampling_loop(DDTRACE_UNUSED VALUE _self, VALUE instance) {
   cpu_and_wall_time_worker_state *old_state = active_sampler_instance_state;
   if (old_state != NULL) {
     if (is_thread_alive(old_state->owner_thread)) {
-      raise_error(eDatadogRuntimeError, "Could not start CpuAndWallTimeWorker: There's already another instance of CpuAndWallTimeWorker active in a different thread");
+      raise_error(rb_eRuntimeError, "Could not start CpuAndWallTimeWorker: There's already another instance of CpuAndWallTimeWorker active in a different thread");
     } else {
       // The previously active thread seems to have died without cleaning up after itself.
       // In this case, we can still go ahead and start the profiler BUT we make sure to disable any existing tracepoint
@@ -818,7 +818,7 @@ static VALUE release_gvl_and_run_sampling_trigger_loop(VALUE instance) {
         NULL
       );
     #else
-      raise_error(eDatadogArgumentError, "GVL profiling is not supported in this Ruby version");
+      raise_error(rb_eArgError, "GVL profiling is not supported in this Ruby version");
     #endif
   }
 
@@ -1090,7 +1090,7 @@ static void reset_stats_not_thread_safe(cpu_and_wall_time_worker_state *state) {
 static void sleep_for(uint64_t time_ns) {
   // As a simplification, we currently only support setting .tv_nsec
   if (time_ns >= SECONDS_AS_NS(1)) {
-    grab_gvl_and_raise(eDatadogArgumentError, "sleep_for can only sleep for less than 1 second, time_ns: %"PRIu64, time_ns);
+    grab_gvl_and_raise(rb_eArgError, "sleep_for can only sleep for less than 1 second, time_ns: %"PRIu64, time_ns);
   }
 
   struct timespec time_to_sleep = {.tv_nsec = time_ns};
@@ -1281,7 +1281,7 @@ static VALUE rescued_sample_allocation(DDTRACE_UNUSED VALUE unused) {
 
 static void delayed_error(cpu_and_wall_time_worker_state *state, const char *error) {
   // If we can't raise an immediate exception at the calling site, use the asynchronous flow through the main worker loop.
-  stop_state(state, rb_exc_new_cstr(eDatadogRuntimeError, error));
+  stop_state(state, rb_exc_new_cstr(rb_eRuntimeError, error));
 }
 
 static VALUE _native_delayed_error(DDTRACE_UNUSED VALUE self, VALUE instance, VALUE error_msg) {

ext/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.c

@@ -51,7 +51,7 @@ void discrete_dynamic_sampler_reset(discrete_dynamic_sampler *sampler, long now_
 
 void discrete_dynamic_sampler_set_overhead_target_percentage(discrete_dynamic_sampler *sampler, double target_overhead, long now_ns) {
   if (target_overhead <= 0 || target_overhead > 100) {
-    raise_error(eDatadogArgumentError, "Target overhead must be a double between ]0,100] was %f", target_overhead);
+    raise_error(rb_eArgError, "Target overhead must be a double between ]0,100] was %f", target_overhead);
   }
   sampler->target_overhead = target_overhead;
   return discrete_dynamic_sampler_reset(sampler, now_ns);
@@ -369,7 +369,7 @@ static VALUE _native_new(VALUE klass) {
 
   long now_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
   if (now_ns == 0) {
-    raise_error(eDatadogRuntimeError, "failed to get clock time");
+    raise_error(rb_eRuntimeError, "failed to get clock time");
   }
   discrete_dynamic_sampler_init(&state->sampler, "test sampler", now_ns);
 

ext/datadog_profiling_native_extension/collectors_gc_profiling_helper.c

@@ -72,7 +72,7 @@ uint8_t gc_profiling_set_metadata(ddog_prof_Label *labels, int labels_length) {
     1;  // gc type
 
   if (max_label_count > labels_length) {
-    raise_error(eDatadogArgumentError, "BUG: gc_profiling_set_metadata invalid labels_length (%d) < max_label_count (%d)", labels_length, max_label_count);
+    raise_error(rb_eArgError, "BUG: gc_profiling_set_metadata invalid labels_length (%d) < max_label_count (%d)", labels_length, max_label_count);
   }
 
   uint8_t label_pos = 0;
@@ -120,7 +120,7 @@ uint8_t gc_profiling_set_metadata(ddog_prof_Label *labels, int labels_length) {
   };
 
   if (label_pos > max_label_count) {
-    raise_error(eDatadogRuntimeError, "BUG: gc_profiling_set_metadata unexpected label_pos (%d) > max_label_count (%d)", label_pos, max_label_count);
+    raise_error(rb_eRuntimeError, "BUG: gc_profiling_set_metadata unexpected label_pos (%d) > max_label_count (%d)", label_pos, max_label_count);
   }
 
   return label_pos;

ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -153,7 +153,7 @@ static void *run_idle_sampling_loop(void *state_ptr) {
     // Process pending action
     if (next_action == ACTION_RUN) {
       if (run_action_function == NULL) {
-        grab_gvl_and_raise(eDatadogRuntimeError, "Unexpected NULL run_action_function in run_idle_sampling_loop");
+        grab_gvl_and_raise(rb_eRuntimeError, "Unexpected NULL run_action_function in run_idle_sampling_loop");
       }
 
       run_action_function();
@@ -206,7 +206,7 @@ static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
 void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_function)(void)) {
   idle_sampling_loop_state *state;
   if (!rb_typeddata_is_kind_of(self_instance, &idle_sampling_helper_typed_data)) {
-    grab_gvl_and_raise(eDatadogTypeError, "Wrong argument for idle_sampling_helper_request_action");
+    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);

ext/datadog_profiling_native_extension/collectors_stack.c

@@ -285,11 +285,11 @@ void sample_thread(
   // here, but >= 0 makes this easier to understand/debug.
   bool only_wall_time = cpu_or_wall_sample && values.cpu_time_ns == 0 && values.wall_time_ns >= 0;
 
-  if (cpu_or_wall_sample && state_label == NULL) raise_error(eDatadogRuntimeError, "BUG: Unexpected missing state_label");
+  if (cpu_or_wall_sample && state_label == NULL) raise_error(rb_eRuntimeError, "BUG: Unexpected missing state_label");
 
   if (has_cpu_time) {
     state_label->str = DDOG_CHARSLICE_C("had cpu");
-    if (labels.is_gvl_waiting_state) raise_error(eDatadogRuntimeError, "BUG: Unexpected combination of cpu-time with is_gvl_waiting");
+    if (labels.is_gvl_waiting_state) raise_error(rb_eRuntimeError, "BUG: Unexpected combination of cpu-time with is_gvl_waiting");
   }
 
   int top_of_stack_position = captured_frames - 1;
@@ -601,8 +601,8 @@ bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
 }
 
 uint16_t sampling_buffer_check_max_frames(int max_frames) {
-  if (max_frames < 5) raise_error(eDatadogArgumentError, "Invalid max_frames: value must be >= 5");
-  if (max_frames > MAX_FRAMES_LIMIT) raise_error(eDatadogArgumentError, "Invalid max_frames: value must be <= " MAX_FRAMES_LIMIT_AS_STRING);
+  if (max_frames < 5) raise_error(rb_eArgError, "Invalid max_frames: value must be >= 5");
+  if (max_frames > MAX_FRAMES_LIMIT) raise_error(rb_eArgError, "Invalid max_frames: value must be <= " MAX_FRAMES_LIMIT_AS_STRING);
   return max_frames;
 }
 
@@ -619,7 +619,7 @@ void sampling_buffer_initialize(sampling_buffer *buffer, uint16_t max_frames, dd
 
 void sampling_buffer_free(sampling_buffer *buffer) {
   if (buffer->max_frames == 0 || buffer->locations == NULL || buffer->stack_buffer == NULL) {
-    raise_error(eDatadogArgumentError, "sampling_buffer_free called with invalid buffer");
+    raise_error(rb_eArgError, "sampling_buffer_free called with invalid buffer");
   }
 
   ruby_xfree(buffer->stack_buffer);

ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -519,7 +519,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   } else if (otel_context_enabled == ID2SYM(rb_intern("both"))) {
     state->otel_context_enabled = OTEL_CONTEXT_ENABLED_BOTH;
   } else {
-    raise_error(eDatadogArgumentError, "Unexpected value for otel_context_enabled: %+" PRIsVALUE, otel_context_enabled);
+    raise_error(rb_eArgError, "Unexpected value for otel_context_enabled: %+" PRIsVALUE, otel_context_enabled);
   }
 
   global_waiting_for_gvl_threshold_ns = NUM2UINT(waiting_for_gvl_threshold_ns);
@@ -540,7 +540,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
 static VALUE _native_sample(DDTRACE_UNUSED VALUE _self, VALUE collector_instance, VALUE profiler_overhead_stack_thread, VALUE allow_exception) {
   ENFORCE_BOOLEAN(allow_exception);
 
-  if (!is_thread_alive(profiler_overhead_stack_thread)) raise_error(eDatadogArgumentError, "Unexpected: profiler_overhead_stack_thread is not alive");
+  if (!is_thread_alive(profiler_overhead_stack_thread)) raise_error(rb_eArgError, "Unexpected: profiler_overhead_stack_thread is not alive");
 
   if (allow_exception == Qfalse) debug_enter_unsafe_context();
 
@@ -832,7 +832,7 @@ VALUE thread_context_collector_sample_after_gc(VALUE self_instance) {
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   if (state->gc_tracking.wall_time_at_previous_gc_ns == INVALID_TIME) {
-    raise_error(eDatadogRuntimeError, "BUG: Unexpected call to sample_after_gc without valid GC information available");
+    raise_error(rb_eRuntimeError, "BUG: Unexpected call to sample_after_gc without valid GC information available");
   }
 
   int max_labels_needed_for_gc = 7; // Magic number gets validated inside gc_profiling_set_metadata
@@ -999,7 +999,7 @@ static void trigger_sample_for_thread(
   // @ivoanjo: I wonder if C compilers are smart enough to statically prove this check never triggers unless someone
   // changes the code erroneously and remove it entirely?
   if (label_pos > max_label_count) {
-    raise_error(eDatadogRuntimeError, "BUG: Unexpected label_pos (%d) > max_label_count (%d)", label_pos, max_label_count);
+    raise_error(rb_eRuntimeError, "BUG: Unexpected label_pos (%d) > max_label_count (%d)", label_pos, max_label_count);
   }
 
   ddog_prof_Slice_Label slice_labels = {.ptr = labels, .len = label_pos};
@@ -1296,7 +1296,7 @@ static long update_time_since_previous_sample(long *time_at_previous_sample_ns,
       elapsed_time_ns = 0;
     } else {
       // We don't expect non-wall time to go backwards, so let's flag this as a bug
-      raise_error(eDatadogRuntimeError, "BUG: Unexpected negative elapsed_time_ns between samples");
+      raise_error(rb_eRuntimeError, "BUG: Unexpected negative elapsed_time_ns between samples");
     }
   }
 
@@ -1962,7 +1962,7 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id) {
     thread_context_collector_state *state;
     TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
-    if (!state->timeline_enabled) raise_error(eDatadogRuntimeError, "GVL profiling requires timeline to be enabled");
+    if (!state->timeline_enabled) raise_error(rb_eRuntimeError, "GVL profiling requires timeline to be enabled");
 
     intptr_t gvl_waiting_at = gvl_profiling_state_thread_object_get(current_thread);
 
@@ -2158,7 +2158,7 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id) {
     TypedData_Get_Struct(collector_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
     per_thread_context *thread_context = get_context_for(thread, state);
-    if (thread_context == NULL) raise_error(eDatadogArgumentError, "Unexpected: This method cannot be used unless the per-thread context for the thread already exists");
+    if (thread_context == NULL) raise_error(rb_eArgError, "Unexpected: This method cannot be used unless the per-thread context for the thread already exists");
 
     thread_context->cpu_time_at_previous_sample_ns += NUM2LONG(delta_ns);
 

ext/datadog_profiling_native_extension/datadog_ruby_common.c

@@ -3,10 +3,7 @@
 
 // IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
 
-// Exception classes defined in Ruby, in the `Datadog::Core` namespace.
-VALUE eDatadogRuntimeError = Qnil;
-VALUE eDatadogArgumentError = Qnil;
-VALUE eDatadogTypeError = Qnil;
+// Native extensions now use Ruby's built-in exception classes directly.
 
 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(
@@ -94,21 +91,15 @@ ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
 }
 
 void datadog_ruby_common_init(VALUE datadog_module) {
-  VALUE core_module = rb_const_get(datadog_module, rb_intern("Core"));
+  ENFORCE_TYPE(datadog_module, T_MODULE);
+
+  ID core_id = rb_intern("Core");
+  VALUE core_module =
+    rb_const_defined(datadog_module, core_id) ? rb_const_get(datadog_module, core_id) : rb_define_module_under(datadog_module, "Core");
   ENFORCE_TYPE(core_module, T_MODULE);
 
-  VALUE native_module = rb_const_get(core_module, rb_intern("Native"));
+  ID native_id = rb_intern("Native");
+  VALUE native_module =
+    rb_const_defined(core_module, native_id) ? rb_const_get(core_module, native_id) : rb_define_module_under(core_module, "Native");
   ENFORCE_TYPE(native_module, T_MODULE);
-
-  rb_global_variable(&eDatadogRuntimeError);
-  eDatadogRuntimeError = rb_const_get(native_module, rb_intern("RuntimeError"));
-  ENFORCE_TYPE(eDatadogRuntimeError, T_CLASS);
-
-  rb_global_variable(&eDatadogArgumentError);
-  eDatadogArgumentError = rb_const_get(native_module, rb_intern("ArgumentError"));
-  ENFORCE_TYPE(eDatadogArgumentError, T_CLASS);
-
-  rb_global_variable(&eDatadogTypeError);
-  eDatadogTypeError = rb_const_get(native_module, rb_intern("TypeError"));
-  ENFORCE_TYPE(eDatadogTypeError, T_CLASS);
 }

ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -38,10 +38,7 @@ NORETURN(void raise_unexpected_type(VALUE value, const char *value_name, const c
 // Helper to raise errors with formatted messages
 NORETURN(void raise_error(VALUE error_class, const char *fmt, ...)) __attribute__ ((format (gnu_printf, 2, 3)));
 
-// Exception classes defined in Ruby, in the `Datadog::Core` namespace.
-extern VALUE eDatadogRuntimeError;
-extern VALUE eDatadogArgumentError;
-extern VALUE eDatadogTypeError;
+
 
 // Helper to retrieve Datadog::VERSION::STRING
 VALUE datadog_gem_version(void);

ext/datadog_profiling_native_extension/encoded_profile.c

@@ -42,7 +42,7 @@ VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile) {
 static ddog_ByteSlice get_bytes(ddog_prof_EncodedProfile *state) {
   ddog_prof_Result_ByteSlice raw_bytes = ddog_prof_EncodedProfile_bytes(state);
   if (raw_bytes.tag == DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE) {
-    raise_error(eDatadogRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
+    raise_error(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
   }
   return raw_bytes.ok;
 }