Make sure we can handle different type of panic payload

Author: gleocadie

bin_tests/src/modes/behavior.rs

@@ -135,6 +135,8 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {
             Box::new(test_012_runtime_callback_frame_invalid_utf8::Test)
         }
         "panic_hook_after_fork" => Box::new(test_013_panic_hook_after_fork::Test),
+        "panic_hook_string" => Box::new(test_014_panic_hook_string::Test),
+        "panic_hook_unknown_type" => Box::new(test_015_panic_hook_unknown_type::Test),
         _ => panic!("Unknown mode: {mode_str}"),
     }
 }

bin_tests/src/modes/unix/mod.rs

@@ -14,3 +14,5 @@ pub mod test_010_runtime_callback_frame;
 pub mod test_011_runtime_callback_string;
 pub mod test_012_runtime_callback_frame_invalid_utf8;
 pub mod test_013_panic_hook_after_fork;
+pub mod test_014_panic_hook_string;
+pub mod test_015_panic_hook_unknown_type;

bin_tests/src/modes/unix/test_014_panic_hook_string.rs

@@ -0,0 +1,31 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+//
+// Test that panic hooks work correctly with String payloads (not just &str).
+// This validates that:
+// 1. String panic payloads are correctly captured
+// 2. The panic message format is "Process panicked with message: <msg>"
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::CrashtrackerConfiguration;
+use std::path::Path;
+
+pub struct Test;
+
+impl Behavior for Test {
+    fn setup(
+        &self,
+        _output_dir: &Path,
+        _config: &mut CrashtrackerConfiguration,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        let dynamic_value = 42;
+        panic!("Panic with value: {}", dynamic_value);
+    }
+}

bin_tests/src/modes/unix/test_015_panic_hook_unknown_type.rs

@@ -0,0 +1,30 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+//
+// Test that panic hooks work correctly with unknown types via panic_any.
+// This validates that:
+// 1. panic_any() with non-string types is handled gracefully
+// 2. The message format is: "Process panicked with unknown type (<location>)"
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::CrashtrackerConfiguration;
+use std::path::Path;
+
+pub struct Test;
+
+impl Behavior for Test {
+    fn setup(
+        &self,
+        _output_dir: &Path,
+        _config: &mut CrashtrackerConfiguration,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        std::panic::panic_any(42i32);
+    }
+}

bin_tests/tests/crashtracker_bin_test.rs

@@ -327,11 +327,11 @@ fn test_crash_tracking_app(crash_type: &str) {
 
         match crash_type_owned.as_str() {
             "panic" => {
-                let expected_message = "program panicked";
-                assert_eq!(
-                    error["message"].as_str().unwrap(),
-                    expected_message,
-                    "Expected panic message for panic crash type"
+                let message = error["message"].as_str().unwrap();
+                assert!(
+                    message.contains("Process panicked with message") && message.contains("program panicked"),
+                    "Expected panic message to contain 'Process panicked with message' and 'program panicked', got: {}",
+                    message
                 );
             }
             "segfault" => {
@@ -360,6 +360,31 @@ fn test_crash_tracking_app(crash_type: &str) {
 #[cfg_attr(miri, ignore)]
 #[cfg(not(target_os = "macos"))] // Same restriction as other panic tests
 fn test_crash_tracking_bin_panic_hook_after_fork() {
+    test_panic_hook_mode("panic_hook_after_fork", "child panicked after fork");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+#[cfg(not(target_os = "macos"))] // Same restriction as other panic tests
+fn test_crash_tracking_bin_panic_hook_string() {
+    test_panic_hook_mode(
+        "panic_hook_string",
+        "Process panicked with message: Panic with value: 42",
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+#[cfg(not(target_os = "macos"))] // Same restriction as other panic tests
+fn test_crash_tracking_bin_panic_hook_unknown_type() {
+    test_panic_hook_mode(
+        "panic_hook_unknown_type",
+        "Process panicked with unknown type",
+    );
+}
+
+/// Helper function to run panic hook tests with different payload types
+fn test_panic_hook_mode(mode: &str, expected_message_substring: &str) {
     use bin_tests::test_runner::run_custom_crash_test;
 
     // Set up custom artifacts: receiver + crashtracker_bin_test
@@ -368,24 +393,18 @@ fn test_crash_tracking_bin_panic_hook_after_fork() {
 
     let artifacts_map = build_artifacts(&[&crashtracker_receiver, &crashtracker_bin_test]).unwrap();
 
-    let validator: ValidatorFn = Box::new(|payload, _fixtures| {
+    let expected_msg = expected_message_substring.to_owned();
+    let validator: ValidatorFn = Box::new(move |payload, _fixtures| {
         // Verify the panic message is captured
         let error = &payload["error"];
         let message = error["message"].as_str().unwrap();
         assert!(
-            message.contains("child panicked after fork"),
-            "Expected panic message to contain 'child panicked after fork', got: {}",
+            message.contains(&expected_msg),
+            "Expected panic message to contain '{}', got: {}",
+            expected_msg,
             message
         );
 
-        // TODO change the kind into Panic instead
-        let kind = error["kind"].as_str().unwrap();
-        assert_eq!(
-            kind, "UnixSignal",
-            "Expected error kind to be UnixSignal, got: {}",
-            kind
-        );
-
         Ok(())
     });
 
@@ -395,8 +414,8 @@ fn test_crash_tracking_bin_panic_hook_after_fork() {
             cmd.arg(format!("file://{}", fixtures.crash_profile_path.display()))
                 .arg(&artifacts_map[&crashtracker_receiver])
                 .arg(&fixtures.output_dir)
-                .arg("panic_hook_after_fork") // mode
-                .arg("donothing"); // crash method (not used in this mode)
+                .arg(mode)
+                .arg("donothing"); // crash method (not used in panic hook tests)
         },
         validator,
     )

libdd-crashtracker/src/collector/crash_handler.rs

@@ -78,6 +78,30 @@ pub fn update_metadata(metadata: Metadata) -> anyhow::Result<()> {
     Ok(())
 }
 
+/// Format a panic message with optional location information.
+fn format_panic_message(
+    category: &str,
+    description: &str,
+    location: Option<&panic::Location>,
+) -> String {
+    let base = match location {
+        Some(loc) => format!(
+            "Process panicked with {} ({}:{}:{})",
+            category,
+            loc.file(),
+            loc.line(),
+            loc.column()
+        ),
+        None => format!("Process panicked with {}", category),
+    };
+
+    if description.is_empty() {
+        base
+    } else {
+        format!("{}: {}", base, description)
+    }
+}
+
 /// Register the panic hook.
 ///
 /// This function is used to register the panic hook and store the previous hook.
@@ -98,15 +122,25 @@ pub fn register_panic_hook() -> anyhow::Result<()> {
     let old_hook_ptr = Box::into_raw(Box::new(old_hook));
     PREVIOUS_PANIC_HOOK.swap(old_hook_ptr, SeqCst);
     panic::set_hook(Box::new(|panic_info| {
-        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
-            let message_ptr = PANIC_MESSAGE.swap(Box::into_raw(Box::new(s.to_string())), SeqCst);
-            // message_ptr should be null, but just in case.
-            if !message_ptr.is_null() {
-                unsafe {
-                    std::mem::drop(Box::from_raw(message_ptr));
-                }
+        // Extract panic message from payload (supports &str and String)
+        let message = if let Some(&s) = panic_info.payload().downcast_ref::<&str>() {
+            format_panic_message("message", s, panic_info.location())
+        } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
+            format_panic_message("message", s.as_str(), panic_info.location())
+        } else {
+            // For non-string types, use a generic message
+            format_panic_message("unknown type", "", panic_info.location())
+        };
+
+        // Store the message, cleaning up any old message
+        let message_ptr = PANIC_MESSAGE.swap(Box::into_raw(Box::new(message)), SeqCst);
+        // message_ptr should be null, but just in case.
+        if !message_ptr.is_null() {
+            unsafe {
+                std::mem::drop(Box::from_raw(message_ptr));
             }
         }
+
         call_previous_panic_hook(panic_info);
     }));
     Ok(())