Implement two-tier exception strategy for profiler errors

bouwkast · bouwkast · commit 3d908d725685 · 2025-11-07T15:09:24.000-05:00
diff --git a/ext/datadog_profiling_native_extension/encoded_profile.c b/ext/datadog_profiling_native_extension/encoded_profile.c
@@ -41,7 +41,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) {
-    rb_raise(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
   }
   return raw_bytes.ok;
 }
diff --git a/ext/datadog_profiling_native_extension/http_transport.c b/ext/datadog_profiling_native_extension/http_transport.c
@@ -112,7 +112,7 @@ static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configura
 }
 
 static void validate_token(ddog_CancellationToken token, const char *file, int line) {
-  if (token.inner == NULL) rb_raise(rb_eRuntimeError, "Unexpected: Validation token was empty at %s:%d", file, line);
+  if (token.inner == NULL) rb_raise(datadog_profiling_internal_error_class, "Unexpected: Validation token was empty at %s:%d", file, line);
 }
 
 static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result) {
diff --git a/ext/datadog_profiling_native_extension/libdatadog_helpers.c b/ext/datadog_profiling_native_extension/libdatadog_helpers.c
@@ -66,7 +66,7 @@ ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_
 
   ddog_prof_ManagedStringStorageInternResult intern_result = ddog_prof_ManagedStringStorage_intern(string_storage, string);
   if (intern_result.tag == DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
   }
   return intern_result.ok;
 }
@@ -79,6 +79,6 @@ void intern_all_or_raise(
 ) {
   ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_intern_all(string_storage, strings, output_ids, output_ids_size);
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 }
diff --git a/ext/datadog_profiling_native_extension/private_vm_api_access.c b/ext/datadog_profiling_native_extension/private_vm_api_access.c
@@ -738,7 +738,7 @@ void self_test_mn_enabled(void) {
     return;
   #else
     if (ddtrace_get_ractor()->threads.sched.enable_mn_threads == true) {
-      rb_raise(rb_eRuntimeError, "Ruby VM is running with RUBY_MN_THREADS=1. This is not yet supported");
+      rb_raise(datadog_profiling_error_class, "Ruby VM is running with RUBY_MN_THREADS=1. This is not yet supported");
     }
   #endif
 }
@@ -871,11 +871,11 @@ bool is_raised_flag_set(VALUE thread) { return thread_struct_from_object(thread)
       expected_current_fiber = current_fiber_for(rb_thread_current());
     }
 
-    if (expected_current_fiber != actual_current_fiber) rb_raise(rb_eRuntimeError, "current_fiber_for() self-test failed");
+    if (expected_current_fiber != actual_current_fiber) rb_raise(datadog_profiling_error_class, "current_fiber_for() self-test failed");
   }
 #else
   NORETURN(VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread));
 
-  VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread) { rb_raise(rb_eRuntimeError, "Not implemented for Ruby < 3.1"); }
+  VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread) { rb_raise(datadog_profiling_error_class, "Not implemented for Ruby < 3.1"); }
   void self_test_current_fiber_for(void) { } // Nothing to do
 #endif
diff --git a/ext/datadog_profiling_native_extension/profiling.c b/ext/datadog_profiling_native_extension/profiling.c
@@ -60,6 +60,11 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   datadog_profiling_error_class = rb_const_get(profiling_module, rb_intern("ProfilingError"));
   rb_global_variable(&datadog_profiling_error_class);
 
+  // Initialize the ProfilingInternalError exception class reference
+  // This exception class should be defined in Ruby code (lib/datadog/profiling.rb)
+  datadog_profiling_internal_error_class = rb_const_get(profiling_module, rb_intern("ProfilingInternalError"));
+  rb_global_variable(&datadog_profiling_internal_error_class);
+
   ruby_helpers_init();
   collectors_cpu_and_wall_time_worker_init(profiling_module);
   collectors_discrete_dynamic_sampler_init(profiling_module);
diff --git a/ext/datadog_profiling_native_extension/ruby_helpers.c b/ext/datadog_profiling_native_extension/ruby_helpers.c
@@ -16,6 +16,10 @@ static ID to_s_id = Qnil;
 // Initialized in profiling.c during extension initialization
 VALUE datadog_profiling_error_class = Qnil;
 
+// Global reference to Datadog::Profiling::ProfilingInternalError exception class
+// Initialized in profiling.c during extension initialization
+VALUE datadog_profiling_internal_error_class = Qnil;
+
 void ruby_helpers_init(void) {
   rb_global_variable(&module_object_space);
 
diff --git a/ext/datadog_profiling_native_extension/ruby_helpers.h b/ext/datadog_profiling_native_extension/ruby_helpers.h
@@ -7,6 +7,10 @@
 // This is initialized in profiling.c during extension initialization
 extern VALUE datadog_profiling_error_class;
 
+// Global reference to Datadog::Profiling::ProfilingInternalError exception class
+// This is initialized in profiling.c during extension initialization
+extern VALUE datadog_profiling_internal_error_class;
+
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
 // usage of ruby helpers.
 void ruby_helpers_init(void);
diff --git a/ext/datadog_profiling_native_extension/stack_recorder.c b/ext/datadog_profiling_native_extension/stack_recorder.c
@@ -349,7 +349,7 @@ static VALUE _native_new(VALUE klass) {
   ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();
 
   if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
   }
 
   state->string_storage = string_storage.ok;
@@ -383,7 +383,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
     ddog_prof_Profile_with_string_storage(sample_types, NULL /* period is optional */, state->string_storage);
 
   if (slot_one_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));
   }
 
   state->profile_slot_one = (profile_slot) { .profile = slot_one_profile_result.ok, .start_timestamp = start_timestamp };
@@ -393,7 +393,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
 
   if (slot_two_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
     // Note: No need to take any special care of slot one, it'll get cleaned up by stack_recorder_typed_data_free
-    rb_raise(rb_eRuntimeError, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));
   }
 
   state->profile_slot_two = (profile_slot) { .profile = slot_two_profile_result.ok, .start_timestamp = start_timestamp };
@@ -591,7 +591,7 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
 
   ddog_prof_MaybeError result = args.advance_gen_result;
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 
   VALUE start = ruby_time_from(args.slot->start_timestamp);
@@ -824,7 +824,7 @@ static locked_profile_slot sampler_lock_active_profile(stack_recorder_state *sta
   }
 
   // We already tried both multiple times, and we did not succeed. This is not expected to happen. Let's stop sampling.
-  rb_raise(rb_eRuntimeError, "Failed to grab either mutex in sampler_lock_active_profile");
+  rb_raise(datadog_profiling_error_class, "Failed to grab either mutex in sampler_lock_active_profile");
 }
 
 static void sampler_unlock_active_profile(locked_profile_slot active_slot) {
@@ -889,7 +889,7 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
     return Qtrue;
   } else {
     ENFORCE_SUCCESS_GVL(error);
-    rb_raise(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");
+    rb_raise(datadog_profiling_error_class, "Failed to raise exception in test_slot_mutex_state; this should never happen");
   }
 }
 
@@ -941,7 +941,7 @@ static VALUE _native_track_object(DDTRACE_UNUSED VALUE _self, VALUE recorder_ins
 static void reset_profile_slot(profile_slot *slot, ddog_Timespec start_timestamp) {
   ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&slot->profile);
   if (reset_result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));
   }
   slot->start_timestamp = start_timestamp;
   slot->stats = (stats_slot) {};
@@ -1056,14 +1056,14 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();
 
   if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
   }
 
   ddog_prof_Slice_ValueType sample_types = {.ptr = all_value_types, .len = ALL_VALUE_TYPES_COUNT};
   ddog_prof_Profile_NewResult profile = ddog_prof_Profile_with_string_storage(sample_types, NULL, string_storage.ok);
 
   if (profile.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));
   }
 
   ddog_prof_ManagedStringId hello = intern_or_raise(string_storage.ok, DDOG_CHARSLICE_C("hello"));
@@ -1105,13 +1105,13 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   ddog_prof_Profile_SerializeResult serialize_result = ddog_prof_Profile_serialize(&profile.ok, &start_timestamp, &finish_timestamp);
 
   if (serialize_result.tag == DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
   }
 
   ddog_prof_MaybeError advance_gen_result = ddog_prof_ManagedStringStorage_advance_gen(string_storage.ok);
 
   if (advance_gen_result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));
+    rb_raise(datadog_profiling_internal_error_class, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));
   }
 
   VALUE encoded_pprof_1 = from_ddog_prof_EncodedProfile(serialize_result.ok);
diff --git a/ext/datadog_profiling_native_extension/unsafe_api_calls_check.c b/ext/datadog_profiling_native_extension/unsafe_api_calls_check.c
@@ -21,7 +21,7 @@ void unsafe_api_calls_check_init(void) {
     check_for_unsafe_api_calls_handle = rb_postponed_job_preregister(unused_flags, check_for_unsafe_api_calls, NULL);
 
    if (check_for_unsafe_api_calls_handle == POSTPONED_JOB_HANDLE_INVALID) {
-     rb_raise(rb_eRuntimeError, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");
+     rb_raise(datadog_profiling_error_class, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");
    }
   #endif
 }
diff --git a/lib/datadog/profiling.rb b/lib/datadog/profiling.rb
@@ -7,12 +7,17 @@
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
-    # Custom exception class for profiler errors.
-    # This exception class is used by the profiler's C code to signal errors.
-    # Telemetry will only include exception messages for instances of this class,
-    # ensuring that only known-safe messages (created by Datadog code) are reported.
+    # Custom exception class for profiler errors with constant messages.
+    # This exception class is used by the profiler's C code to signal errors with constant,
+    # known-safe messages. Telemetry will include exception messages for instances of this class.
     class ProfilingError < StandardError; end
 
+    # Custom exception class for profiler internal errors with dynamic content.
+    # This exception class is used for errors that include dynamic information from libdatadog
+    # or system state. Telemetry will NOT include exception messages from this class to avoid
+    # fingerprinting issues, but the full details are preserved for local debugging.
+    class ProfilingInternalError < StandardError; end
+
     def self.supported?
       unsupported_reason.nil?
     end
diff --git a/sig/datadog/profiling.rbs b/sig/datadog/profiling.rbs
@@ -3,6 +3,9 @@ module Datadog
     class ProfilingError < StandardError
     end
 
+    class ProfilingInternalError < StandardError
+    end
+
     def self.supported?: () -> bool
     def self.unsupported_reason: () -> ::String?
     def self.start_if_enabled: () -> bool
diff --git a/spec/datadog/core/telemetry/logging_spec.rb b/spec/datadog/core/telemetry/logging_spec.rb
@@ -120,6 +120,48 @@ def log!(_event)
         end
       end
     end
+
+    context 'with ProfilingInternalError' do
+      before do
+        skip unless defined?(Datadog::Profiling::ProfilingInternalError)
+      end
+
+      it 'excludes the exception message from telemetry' do
+        expect(component).to receive(:log!).with(instance_of(Datadog::Core::Telemetry::Event::Log)) do |event|
+          expect(event.payload).to include(
+            logs: [{message: 'Datadog::Profiling::ProfilingInternalError', level: 'ERROR', count: 1,
+                    stack_trace: a_string_including('REDACTED')}]
+          )
+          # Verify the dynamic content is NOT in the message
+          expect(event.payload[:logs].map { |log| log[:message] }).not_to include(/Failed to initialize.*0x[0-9a-f]+/)
+        end
+
+        begin
+          raise Datadog::Profiling::ProfilingInternalError, 'Failed to initialize string storage: Error at address 0xdeadbeef'
+        rescue => e
+          component.report(e, level: :error)
+        end
+      end
+
+      context 'with description' do
+        it 'includes description but excludes exception message' do
+          expect(component).to receive(:log!).with(instance_of(Datadog::Core::Telemetry::Event::Log)) do |event|
+            expect(event.payload).to include(
+              logs: [{message: 'Datadog::Profiling::ProfilingInternalError: libdatadog internal error', level: 'ERROR', count: 1,
+                      stack_trace: a_string_including('REDACTED')}]
+            )
+            # Verify the dynamic content is NOT in the message
+            expect(event.payload[:logs].map { |log| log[:message] }).not_to include(/memory address/)
+          end
+
+          begin
+            raise Datadog::Profiling::ProfilingInternalError, 'Failed to serialize profile: Invalid memory address 0x12345678'
+          rescue => e
+            component.report(e, level: :error, description: 'libdatadog internal error')
+          end
+        end
+      end
+    end
   end
 
   describe '.error' do

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile) {`
`41`	`41`	`static ddog_ByteSlice get_bytes(ddog_prof_EncodedProfile *state) {`
`42`	`42`	`ddog_prof_Result_ByteSlice raw_bytes = ddog_prof_EncodedProfile_bytes(state);`
`43`	`43`	`if (raw_bytes.tag == DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE) {`
`44`		`- rb_raise(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));`
	`44`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));`
`45`	`45`	`}`
`46`	`46`	`return raw_bytes.ok;`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configura`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`static void validate_token(ddog_CancellationToken token, const char *file, int line) {`
`115`		`- if (token.inner == NULL) rb_raise(rb_eRuntimeError, "Unexpected: Validation token was empty at %s:%d", file, line);`
	`115`	`+ if (token.inner == NULL) rb_raise(datadog_profiling_internal_error_class, "Unexpected: Validation token was empty at %s:%d", file, line);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result) {`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_`
`66`	`66`
`67`	`67`	`ddog_prof_ManagedStringStorageInternResult intern_result = ddog_prof_ManagedStringStorage_intern(string_storage, string);`
`68`	`68`	`if (intern_result.tag == DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR) {`
`69`		`- rb_raise(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));`
	`69`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));`
`70`	`70`	`}`
`71`	`71`	`return intern_result.ok;`
`72`	`72`	`}`
`@@ -79,6 +79,6 @@ void intern_all_or_raise(`
`79`	`79`	`) {`
`80`	`80`	`ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_intern_all(string_storage, strings, output_ids, output_ids_size);`
`81`	`81`	`if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {`
`82`		`- rb_raise(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));`
	`82`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -738,7 +738,7 @@ void self_test_mn_enabled(void) {`
`738`	`738`	`return;`
`739`	`739`	`#else`
`740`	`740`	`if (ddtrace_get_ractor()->threads.sched.enable_mn_threads == true) {`
`741`		`- rb_raise(rb_eRuntimeError, "Ruby VM is running with RUBY_MN_THREADS=1. This is not yet supported");`
	`741`	`+ rb_raise(datadog_profiling_error_class, "Ruby VM is running with RUBY_MN_THREADS=1. This is not yet supported");`
`742`	`742`	`}`
`743`	`743`	`#endif`
`744`	`744`	`}`
`@@ -871,11 +871,11 @@ bool is_raised_flag_set(VALUE thread) { return thread_struct_from_object(thread)`
`871`	`871`	`expected_current_fiber = current_fiber_for(rb_thread_current());`
`872`	`872`	`}`
`873`	`873`
`874`		`- if (expected_current_fiber != actual_current_fiber) rb_raise(rb_eRuntimeError, "current_fiber_for() self-test failed");`
	`874`	`+ if (expected_current_fiber != actual_current_fiber) rb_raise(datadog_profiling_error_class, "current_fiber_for() self-test failed");`
`875`	`875`	`}`
`876`	`876`	`#else`
`877`	`877`	`NORETURN(VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread));`
`878`	`878`
`879`		`- VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread) { rb_raise(rb_eRuntimeError, "Not implemented for Ruby < 3.1"); }`
	`879`	`+ VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread) { rb_raise(datadog_profiling_error_class, "Not implemented for Ruby < 3.1"); }`
`880`	`880`	`void self_test_current_fiber_for(void) { } // Nothing to do`
`881`	`881`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -349,7 +349,7 @@ static VALUE _native_new(VALUE klass) {`
`349`	`349`	`ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();`
`350`	`350`
`351`	`351`	`if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {`
`352`		`- rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));`
	`352`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));`
`353`	`353`	`}`
`354`	`354`
`355`	`355`	`state->string_storage = string_storage.ok;`
`@@ -383,7 +383,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val`
`383`	`383`	`ddog_prof_Profile_with_string_storage(sample_types, NULL /* period is optional */, state->string_storage);`
`384`	`384`
`385`	`385`	`if (slot_one_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {`
`386`		`- rb_raise(rb_eRuntimeError, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));`
	`386`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));`
`387`	`387`	`}`
`388`	`388`
`389`	`389`	`state->profile_slot_one = (profile_slot) { .profile = slot_one_profile_result.ok, .start_timestamp = start_timestamp };`
`@@ -393,7 +393,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val`
`393`	`393`
`394`	`394`	`if (slot_two_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {`
`395`	`395`	`// Note: No need to take any special care of slot one, it'll get cleaned up by stack_recorder_typed_data_free`
`396`		`- rb_raise(rb_eRuntimeError, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));`
	`396`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`state->profile_slot_two = (profile_slot) { .profile = slot_two_profile_result.ok, .start_timestamp = start_timestamp };`
`@@ -591,7 +591,7 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan`
`591`	`591`
`592`	`592`	`ddog_prof_MaybeError result = args.advance_gen_result;`
`593`	`593`	`if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {`
`594`		`- rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));`
	`594`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));`
`595`	`595`	`}`
`596`	`596`
`597`	`597`	`VALUE start = ruby_time_from(args.slot->start_timestamp);`
`@@ -824,7 +824,7 @@ static locked_profile_slot sampler_lock_active_profile(stack_recorder_state *sta`
`824`	`824`	`}`
`825`	`825`
`826`	`826`	`// We already tried both multiple times, and we did not succeed. This is not expected to happen. Let's stop sampling.`
`827`		`- rb_raise(rb_eRuntimeError, "Failed to grab either mutex in sampler_lock_active_profile");`
	`827`	`+ rb_raise(datadog_profiling_error_class, "Failed to grab either mutex in sampler_lock_active_profile");`
`828`	`828`	`}`
`829`	`829`
`830`	`830`	`static void sampler_unlock_active_profile(locked_profile_slot active_slot) {`
`@@ -889,7 +889,7 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {`
`889`	`889`	`return Qtrue;`
`890`	`890`	`} else {`
`891`	`891`	`ENFORCE_SUCCESS_GVL(error);`
`892`		`- rb_raise(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");`
	`892`	`+ rb_raise(datadog_profiling_error_class, "Failed to raise exception in test_slot_mutex_state; this should never happen");`
`893`	`893`	`}`
`894`	`894`	`}`
`895`	`895`
`@@ -941,7 +941,7 @@ static VALUE _native_track_object(DDTRACE_UNUSED VALUE _self, VALUE recorder_ins`
`941`	`941`	`static void reset_profile_slot(profile_slot *slot, ddog_Timespec start_timestamp) {`
`942`	`942`	`ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&slot->profile);`
`943`	`943`	`if (reset_result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {`
`944`		`- rb_raise(rb_eRuntimeError, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));`
	`944`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));`
`945`	`945`	`}`
`946`	`946`	`slot->start_timestamp = start_timestamp;`
`947`	`947`	`slot->stats = (stats_slot) {};`
`@@ -1056,14 +1056,14 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE`
`1056`	`1056`	`ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();`
`1057`	`1057`
`1058`	`1058`	`if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {`
`1059`		`- rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));`
	`1059`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));`
`1060`	`1060`	`}`
`1061`	`1061`
`1062`	`1062`	`ddog_prof_Slice_ValueType sample_types = {.ptr = all_value_types, .len = ALL_VALUE_TYPES_COUNT};`
`1063`	`1063`	`ddog_prof_Profile_NewResult profile = ddog_prof_Profile_with_string_storage(sample_types, NULL, string_storage.ok);`
`1064`	`1064`
`1065`	`1065`	`if (profile.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {`
`1066`		`- rb_raise(rb_eRuntimeError, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));`
	`1066`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));`
`1067`	`1067`	`}`
`1068`	`1068`
`1069`	`1069`	`ddog_prof_ManagedStringId hello = intern_or_raise(string_storage.ok, DDOG_CHARSLICE_C("hello"));`
`@@ -1105,13 +1105,13 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE`
`1105`	`1105`	`ddog_prof_Profile_SerializeResult serialize_result = ddog_prof_Profile_serialize(&profile.ok, &start_timestamp, &finish_timestamp);`
`1106`	`1106`
`1107`	`1107`	`if (serialize_result.tag == DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR) {`
`1108`		`- rb_raise(rb_eRuntimeError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));`
	`1108`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));`
`1109`	`1109`	`}`
`1110`	`1110`
`1111`	`1111`	`ddog_prof_MaybeError advance_gen_result = ddog_prof_ManagedStringStorage_advance_gen(string_storage.ok);`
`1112`	`1112`
`1113`	`1113`	`if (advance_gen_result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {`
`1114`		`- rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));`
	`1114`	`+ rb_raise(datadog_profiling_internal_error_class, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));`
`1115`	`1115`	`}`
`1116`	`1116`
`1117`	`1117`	`VALUE encoded_pprof_1 = from_ddog_prof_EncodedProfile(serialize_result.ok);`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ void unsafe_api_calls_check_init(void) {`
`21`	`21`	`check_for_unsafe_api_calls_handle = rb_postponed_job_preregister(unused_flags, check_for_unsafe_api_calls, NULL);`
`22`	`22`
`23`	`23`	`if (check_for_unsafe_api_calls_handle == POSTPONED_JOB_HANDLE_INVALID) {`
`24`		`- rb_raise(rb_eRuntimeError, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");`
	`24`	`+ rb_raise(datadog_profiling_error_class, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");`
`25`	`25`	`}`
`26`	`26`	`#endif`
`27`	`27`	`}`