Remove need to register specific callback type, rather have specific callback registration functions

Author: gyuheon0h

LICENSE-3rdparty.yml

@@ -1,4 +1,4 @@
-root_name: builder, build_common, tools, datadog-alloc, datadog-crashtracker, ddcommon, ddtelemetry, datadog-ddsketch, datadog-crashtracker-ffi, ddcommon-ffi, datadog-ffe, datadog-ipc, datadog-ipc-macros, tarpc, tarpc-plugins, tinybytes, spawn_worker, datadog-library-config, datadog-library-config-ffi, datadog-live-debugger, datadog-live-debugger-ffi, datadog-profiling, datadog-profiling-protobuf, datadog-profiling-ffi, data-pipeline-ffi, data-pipeline, datadog-trace-protobuf, datadog-trace-stats, datadog-trace-utils, datadog-trace-normalization, dogstatsd-client, datadog-log, datadog-log-ffi, ddsketch-ffi, ddtelemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, datadog-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib
+root_name: builder, build_common, tools, datadog-alloc, datadog-crashtracker, ddcommon, ddcommon-ffi, ddtelemetry, datadog-ddsketch, cc_utils, datadog-crashtracker-ffi, datadog-ffe, datadog-ipc, datadog-ipc-macros, tarpc, tarpc-plugins, tinybytes, spawn_worker, datadog-library-config, datadog-library-config-ffi, datadog-live-debugger, datadog-live-debugger-ffi, datadog-profiling, datadog-profiling-protobuf, datadog-profiling-ffi, data-pipeline-ffi, data-pipeline, datadog-trace-protobuf, datadog-trace-stats, datadog-trace-utils, datadog-trace-normalization, dogstatsd-client, datadog-log, datadog-log-ffi, ddsketch-ffi, ddtelemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, datadog-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib, bin_tests
 third_party_libraries:
 - package_name: addr2line
   package_version: 0.24.2

bin_tests/src/modes/unix/test_010_runtime_callback_frame.rs

@@ -5,15 +5,14 @@
 // It registers a test callback that provides mock runtime stack frames,
 // then crashes and verifies that the runtime frames appear in the crash report.
 //
-// This test uses CallbackType::Frame to emit structured runtime stack data.
+// This test uses frame-by-frame callback to emit structured runtime stack data.
 
 use crate::modes::behavior::Behavior;
 use datadog_crashtracker::{
-    clear_runtime_callback, register_runtime_stack_callback, CallbackType,
-    CrashtrackerConfiguration, RuntimeStackFrame,
+    clear_runtime_callback, register_runtime_frame_callback, CrashtrackerConfiguration,
+    RuntimeStackFrame,
 };
 use ddcommon_ffi::CharSlice;
-use std::ffi::c_char;
 use std::path::Path;
 
 pub struct Test;
@@ -32,7 +31,7 @@ impl Behavior for Test {
         unsafe {
             clear_runtime_callback();
         }
-        register_runtime_stack_callback(test_runtime_callback_frame, CallbackType::Frame)
+        register_runtime_frame_callback(test_runtime_callback_frame)
             .map_err(|e| anyhow::anyhow!("Failed to register runtime callback: {:?}", e))?;
         Ok(())
     }
@@ -45,7 +44,6 @@ impl Behavior for Test {
 // Signal-safe test callback that emits mock runtime stack frames
 unsafe extern "C" fn test_runtime_callback_frame(
     emit_frame: unsafe extern "C" fn(*const RuntimeStackFrame),
-    _emit_stacktrace_string: unsafe extern "C" fn(*const c_char),
 ) {
     static FUNCTION_NAME_1: &str = "test_module.TestClass.runtime_function_1";
     static FUNCTION_NAME_2: &str = "my_package.submodule.MyModule.runtime_function_2";
@@ -93,8 +91,7 @@ mod tests {
 
         assert!(!is_runtime_callback_registered());
 
-        let result =
-            register_runtime_stack_callback(test_runtime_callback_frame, CallbackType::Frame);
+        let result = register_runtime_frame_callback(test_runtime_callback_frame);
         assert!(result.is_ok(), "Frame callback registration should succeed");
         assert!(
             is_runtime_callback_registered(),

bin_tests/src/modes/unix/test_011_runtime_callback_string.rs

@@ -5,12 +5,11 @@
 // It registers a test callback that provides mock runtime stacktrace string,
 // then crashes and verifies that the runtime stacktrace string appear in the crash report.
 //
-// This test uses CallbackType::StacktraceString to emit structured runtime stack data.
+// This test uses stacktrace string callback to emit structured runtime stack data.
 
 use crate::modes::behavior::Behavior;
 use datadog_crashtracker::{
-    clear_runtime_callback, register_runtime_stack_callback, CallbackType,
-    CrashtrackerConfiguration, RuntimeStackFrame,
+    clear_runtime_callback, register_runtime_stacktrace_string_callback, CrashtrackerConfiguration,
 };
 use std::ffi::c_char;
 use std::path::Path;
@@ -31,11 +30,8 @@ impl Behavior for Test {
         unsafe {
             clear_runtime_callback();
         }
-        register_runtime_stack_callback(
-            test_runtime_callback_string,
-            CallbackType::StacktraceString,
-        )
-        .map_err(|e| anyhow::anyhow!("Failed to register runtime callback: {:?}", e))?;
+        register_runtime_stacktrace_string_callback(test_runtime_callback_string)
+            .map_err(|e| anyhow::anyhow!("Failed to register runtime callback: {:?}", e))?;
         Ok(())
     }
 
@@ -46,7 +42,6 @@ impl Behavior for Test {
 
 // Signal-safe test callback that emits mock runtime stacktrace string
 unsafe extern "C" fn test_runtime_callback_string(
-    _emit_frame: unsafe extern "C" fn(*const RuntimeStackFrame),
     emit_stacktrace_string: unsafe extern "C" fn(*const c_char),
 ) {
     static STACKTRACE_STRING: &[u8] = b"test_stacktrace_string\0";
@@ -66,10 +61,7 @@ mod tests {
 
         assert!(!is_runtime_callback_registered());
 
-        let result = register_runtime_stack_callback(
-            test_runtime_callback_string,
-            CallbackType::StacktraceString,
-        );
+        let result = register_runtime_stacktrace_string_callback(test_runtime_callback_string);
         assert!(
             result.is_ok(),
             "String callback registration should succeed"

datadog-crashtracker-ffi/src/runtime_callback.rs

@@ -5,14 +5,13 @@
 //!
 //! This module provides C-compatible FFI bindings for registering runtime-specific
 //! crash callbacks that can provide stack traces for dynamic languages.
+#[cfg(unix)]
 use datadog_crashtracker::{
     get_registered_callback_type_ptr, is_runtime_callback_registered,
-    register_runtime_stack_callback, CallbackError, CallbackType, RuntimeStackCallback,
+    register_runtime_frame_callback, register_runtime_stacktrace_string_callback, CallbackError,
+    RuntimeFrameCallback, RuntimeStacktraceStringCallback,
 };
 
-// Re-export the enums for C/C++ consumers
-pub use datadog_crashtracker::CallbackType as ddog_CallbackType;
-
 pub use datadog_crashtracker::RuntimeStackFrame as ddog_RuntimeStackFrame;
 
 /// Result type for runtime callback registration
@@ -65,19 +64,43 @@ impl From<CallbackError> for CallbackResult {
 /// }
 ///
 ///
-/// ddog_CallbackResult result = ddog_crasht_register_runtime_stack_callback(
-///     my_runtime_callback,
-///     CallbackType::Frame,
+/// ddog_CallbackResult result = ddog_crasht_register_runtime_frame_callback(
+///     my_runtime_callback
 /// );
 /// ```
-/// Register a runtime stack collection callback using type-safe enums
+/// Register a runtime frame collection callback
+///
+/// This function allows language runtimes to register a callback that will be invoked
+/// during crash handling to collect runtime-specific stack frames.
+///
+/// # Arguments
+/// - `callback`: The callback function to invoke during crashes
+///
+/// # Returns
+/// - `CallbackResult::Ok` if registration succeeds (replaces any existing callback)
+/// - `CallbackResult::Error` if registration fails
+///
+/// # Safety
+/// - The callback must be signal-safe
+/// - Only one callback can be registered at a time (this replaces any existing one)
+#[cfg(unix)]
+#[no_mangle]
+pub unsafe extern "C" fn ddog_crasht_register_runtime_frame_callback(
+    callback: RuntimeFrameCallback,
+) -> CallbackResult {
+    match register_runtime_frame_callback(callback) {
+        Ok(()) => CallbackResult::Ok,
+        Err(e) => e.into(),
+    }
+}
+
+/// Register a runtime stacktrace string collection callback
 ///
-/// This function provides compile-time safety by using enums instead of strings
-/// for runtime and callback types.
+/// This function allows language runtimes to register a callback that will be invoked
+/// during crash handling to collect runtime-specific stacktrace strings.
 ///
 /// # Arguments
 /// - `callback`: The callback function to invoke during crashes
-/// - `callback_type`: Callback type enum (Frame, StacktraceString)
 ///
 /// # Returns
 /// - `CallbackResult::Ok` if registration succeeds (replaces any existing callback)
@@ -86,12 +109,12 @@ impl From<CallbackError> for CallbackResult {
 /// # Safety
 /// - The callback must be signal-safe
 /// - Only one callback can be registered at a time (this replaces any existing one)
+#[cfg(unix)]
 #[no_mangle]
-pub unsafe extern "C" fn ddog_crasht_register_runtime_stack_callback(
-    callback: RuntimeStackCallback,
-    callback_type: CallbackType,
+pub unsafe extern "C" fn ddog_crasht_register_runtime_stacktrace_string_callback(
+    callback: RuntimeStacktraceStringCallback,
 ) -> CallbackResult {
-    match register_runtime_stack_callback(callback, callback_type) {
+    match register_runtime_stacktrace_string_callback(callback) {
         Ok(()) => CallbackResult::Ok,
         Err(e) => e.into(),
     }
@@ -103,6 +126,7 @@ pub unsafe extern "C" fn ddog_crasht_register_runtime_stack_callback(
 ///
 /// # Safety
 /// This function is safe to call at any time
+#[cfg(unix)]
 #[no_mangle]
 pub extern "C" fn ddog_crasht_is_runtime_callback_registered() -> bool {
     is_runtime_callback_registered()
@@ -117,6 +141,7 @@ pub extern "C" fn ddog_crasht_is_runtime_callback_registered() -> bool {
 /// - The returned pointer is valid only while the callback remains registered
 /// - The caller should not free the returned pointer
 /// - The returned string should be copied if it needs to persist beyond callback lifetime
+#[cfg(unix)]
 #[no_mangle]
 pub unsafe extern "C" fn ddog_crasht_get_registered_callback_type() -> *const std::ffi::c_char {
     get_registered_callback_type_ptr()
@@ -134,9 +159,8 @@ mod tests {
     // with the global static variable
     static TEST_MUTEX: Mutex<()> = Mutex::new(());
 
-    unsafe extern "C" fn test_runtime_callback(
+    unsafe extern "C" fn test_frame_callback(
         emit_frame: unsafe extern "C" fn(*const RuntimeStackFrame),
-        _emit_stacktrace_string: unsafe extern "C" fn(*const c_char),
     ) {
         let function_name = "TestModule.TestClass.test_function";
         let file_name = "test.rb";
@@ -151,6 +175,13 @@ mod tests {
         emit_frame(&frame);
     }
 
+    unsafe extern "C" fn test_stacktrace_string_callback(
+        emit_stacktrace_string: unsafe extern "C" fn(*const c_char),
+    ) {
+        let stacktrace_string = "test_stacktrace_string\0";
+        emit_stacktrace_string(stacktrace_string.as_ptr() as *const c_char);
+    }
+
     #[test]
     fn test_callback_registration() {
         let _guard = TEST_MUTEX.lock().unwrap();
@@ -159,9 +190,8 @@ mod tests {
 
             assert!(!ddog_crasht_is_runtime_callback_registered());
 
-            let result = ddog_crasht_register_runtime_stack_callback(
-                test_runtime_callback,
-                CallbackType::StacktraceString,
+            let result = ddog_crasht_register_runtime_stacktrace_string_callback(
+                test_stacktrace_string_callback,
             );
 
             assert_eq!(result, CallbackResult::Ok);
@@ -174,10 +204,7 @@ mod tests {
                 .unwrap();
             assert_eq!(callback_type_str, "stacktrace_string");
 
-            let result = ddog_crasht_register_runtime_stack_callback(
-                test_runtime_callback,
-                CallbackType::Frame,
-            );
+            let result = ddog_crasht_register_runtime_frame_callback(test_frame_callback);
 
             assert_eq!(result, CallbackResult::Ok);
 

datadog-crashtracker/src/collector/emitters.rs

@@ -5,8 +5,8 @@ use crate::collector::additional_tags::consume_and_emit_additional_tags;
 use crate::collector::counters::emit_counters;
 use crate::collector::spans::{emit_spans, emit_traces};
 use crate::runtime_callback::{
-    get_registered_callback_type_enum, invoke_runtime_callback_with_writer,
-    is_runtime_callback_registered, CallbackType,
+    get_registered_callback_type_internal, invoke_runtime_callback_with_writer,
+    is_runtime_callback_registered,
 };
 use crate::shared::constants::*;
 use crate::{translate_si_code, CrashtrackerConfiguration, SignalNames, StacktraceCollection};
@@ -236,16 +236,17 @@ fn emit_ucontext(w: &mut impl Write, ucontext: *const ucontext_t) -> Result<(),
 ///     callbacks and writing to the provided stream. The runtime callback itself
 ///     must be signal safe.
 fn emit_runtime_stack(w: &mut impl Write) -> Result<(), EmitterError> {
-    let callback_type = unsafe { get_registered_callback_type_enum() };
+    let callback_type = unsafe { get_registered_callback_type_internal() };
 
     let callback_type = match callback_type {
         Some(ct) => ct,
         None => return Ok(()), // No callback registered
     };
 
     match callback_type {
-        CallbackType::Frame => emit_runtime_stack_by_frames(w),
-        CallbackType::StacktraceString => emit_runtime_stack_by_stacktrace_string(w),
+        "frame" => emit_runtime_stack_by_frames(w),
+        "stacktrace_string" => emit_runtime_stack_by_stacktrace_string(w),
+        _ => Ok(()), // Unknown callback type
     }
 }