feat(crashtracking): include Kind in crash ping and clarify requirements (#1595)

# What does this PR do?

This PR updates what a `CrashPing` consists of. This is in preparation of allowing the crashtracker to not only handle UNIX signal based crashes, but other types of program terminations, such as unhandled exceptions. 


These are the biggest changes
1. We add a `CRASHTRACK_*_KIND` block in the communication protocol of the receiver. Previously, we always defaulted to `UnixSignal` in the receiver, which is not true in the world of supporting unhandled exceptions
    - This involves adding a public `with_kind` API to the crash info builder, which is why this PR is marked as `feat`
2. We also set `Kind` as an explicit `ErrorKind` for the `CrashPing`. Previously, under the assumption that we were only supporting unix signal based crashes, we would set it to `Crash ping`. This was bad design and this PR fixes that.

This PR does not contain any changes for actually handling unhandled exceptions. It is still in the world of unix signals only, it can now be extended, however, in the PR above this one

# Additional Notes

PR on top of this on the stack: [feat(crashtracking): report unhandled exceptions](#1596)

# How to test the change?

Unit tests have been updated to include Kind. If not, then any time Kind is not included, crash ping build will fail


Co-authored-by: gyuheon.oh <gyuheon.oh@datadoghq.com>

Author: gyuheon0h

bin_tests/tests/crashtracker_bin_test.rs

@@ -1365,11 +1365,16 @@ fn test_receiver_emits_debug_logs_on_receiver_issue() -> anyhow::Result<()> {
         .context("spawning receiver process")?;
 
     {
+        use libdd_crashtracker::ErrorKind;
+
         let mut stdin = BufWriter::new(child.stdin.take().context("child stdin missing")?);
         for line in [
             "DD_CRASHTRACK_BEGIN_CONFIG".to_string(),
             serde_json::to_string(&config)?,
             "DD_CRASHTRACK_END_CONFIG".to_string(),
+            "DD_CRASHTRACK_BEGIN_KIND".to_string(),
+            serde_json::to_string(&ErrorKind::UnixSignal)?,
+            "DD_CRASHTRACK_END_KIND".to_string(),
             "DD_CRASHTRACK_BEGIN_METADATA".to_string(),
             serde_json::to_string(&metadata)?,
             "DD_CRASHTRACK_END_METADATA".to_string(),
@@ -1567,7 +1572,7 @@ fn assert_crash_ping_message(body: &str) {
 
     assert_eq!(message_json["version"].as_str(), Some("1.0"));
 
-    assert_eq!(message_json["kind"].as_str(), Some("Crash ping"));
+    assert_eq!(message_json["kind"].as_str(), Some("UnixSignal"));
 }
 
 // Old TestFixtures struct kept for UDS socket tests that weren't migrated

libdd-crashtracker-ffi/src/crash_info/builder.rs

@@ -428,7 +428,12 @@ pub unsafe extern "C" fn ddog_crasht_CrashInfoBuilder_with_thread_name(
 /// The `builder` can be null, but if non-null it must point to a Builder made by this module,
 /// which has not previously been dropped.
 /// All arguments must be valid.
-/// This method requires that the builder has a UUID and metadata set
+/// This method requires that the builder has `metadata` and `kind` set
+/// Applications can add `message` or `sig_info` to the builder to provide additional context.
+/// If set, the data will be used to derive the crash ping message in the order of
+/// - an explicit message set with `with_message`
+/// - sig_info set with `with_sig_info`
+/// - kind set with `with_kind`
 #[no_mangle]
 #[must_use]
 #[named]

libdd-crashtracker/src/collector/emitters.rs

@@ -9,7 +9,9 @@ use crate::runtime_callback::{
     CallbackData,
 };
 use crate::shared::constants::*;
-use crate::{translate_si_code, CrashtrackerConfiguration, SignalNames, StacktraceCollection};
+use crate::{
+    translate_si_code, CrashtrackerConfiguration, ErrorKind, SignalNames, StacktraceCollection,
+};
 use backtrace::Frame;
 use libc::{siginfo_t, ucontext_t};
 use std::{
@@ -145,13 +147,15 @@ pub(crate) fn emit_crashreport(
     crashing_tid: libc::pid_t,
 ) -> Result<(), EmitterError> {
     // The following order is important in order to emit the crash ping:
-    // - receiver expects the config
+    // - receiver expects the config because the endpoint to emit to is there
     // - then message if any
-    // - then siginfo (if the message is not set, we use the siginfo to generate the message)
+    // - then siginfo if any
+    // - then the kind if any
     // - then metadata
     emit_config(pipe, config_str)?;
     emit_message(pipe, message_ptr)?;
     emit_siginfo(pipe, sig_info)?;
+    emit_kind(pipe, &ErrorKind::UnixSignal)?;
     emit_metadata(pipe, metadata_string)?;
     // after the metadata the ping should have been sent
     emit_ucontext(pipe, ucontext)?;
@@ -193,6 +197,15 @@ fn emit_config(w: &mut impl Write, config_str: &str) -> Result<(), EmitterError>
     Ok(())
 }
 
+fn emit_kind<W: std::io::Write>(w: &mut W, kind: &ErrorKind) -> Result<(), EmitterError> {
+    writeln!(w, "{DD_CRASHTRACK_BEGIN_KIND}")?;
+    let _ = serde_json::to_writer(&mut *w, kind);
+    writeln!(w)?;
+    writeln!(w, "{DD_CRASHTRACK_END_KIND}")?;
+    w.flush()?;
+    Ok(())
+}
+
 fn emit_metadata(w: &mut impl Write, metadata_str: &str) -> Result<(), EmitterError> {
     writeln!(w, "{DD_CRASHTRACK_BEGIN_METADATA}")?;
     writeln!(w, "{metadata_str}")?;

libdd-crashtracker/src/crash_info/builder.rs

@@ -401,14 +401,16 @@ impl CrashInfoBuilder {
         Ok(())
     }
 
-    /// This method requires that the builder has a UUID and metadata set.
-    /// Siginfo is optional for platforms that don't support it (like Windows)
+    /// This method requires that the builder has Metadata and Kind set
     pub fn build_crash_ping(&self) -> anyhow::Result<CrashPing> {
+        let metadata = self.metadata.clone().context("metadata is required")?;
+        let kind = self.error.kind.clone().context("kind is required")?;
         let message = self.error.message.clone();
         let sig_info = self.sig_info.clone();
-        let metadata = self.metadata.clone().context("metadata is required")?;
 
-        let mut builder = CrashPingBuilder::new(self.uuid).with_metadata(metadata);
+        let mut builder = CrashPingBuilder::new(self.uuid)
+            .with_metadata(metadata)
+            .with_kind(kind);
         if let Some(sig_info) = sig_info {
             builder = builder.with_sig_info(sig_info);
         }
@@ -419,16 +421,7 @@ impl CrashInfoBuilder {
     }
 
     pub fn is_ping_ready(&self) -> bool {
-        // On Unix platforms, wait for both metadata and siginfo
-        // On Windows, siginfo is not available, so only wait for metadata
-        #[cfg(unix)]
-        {
-            self.metadata.is_some() && self.sig_info.is_some()
-        }
-        #[cfg(windows)]
-        {
-            self.metadata.is_some()
-        }
+        self.metadata.is_some() && self.error.kind.is_some()
     }
 
     pub fn has_message(&self) -> bool {
@@ -463,6 +456,8 @@ mod tests {
     #[test]
     fn test_with_message() {
         let mut builder = CrashInfoBuilder::new();
+
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let test_message = "Test error message".to_string();
 
         let result = builder.with_message(test_message.clone());
@@ -473,6 +468,7 @@ mod tests {
         let sig_info = SigInfo::test_instance(42);
         builder.with_sig_info(sig_info).unwrap();
         builder.with_metadata(Metadata::test_instance(1)).unwrap();
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
 
         let crash_ping = builder.build_crash_ping().unwrap();
         assert!(crash_ping.message().contains(&test_message));
@@ -506,6 +502,7 @@ mod tests {
         let sig_info = SigInfo::test_instance(42);
         builder.with_sig_info(sig_info).unwrap();
         builder.with_metadata(Metadata::test_instance(1)).unwrap();
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
 
         let crash_ping = builder.build_crash_ping().unwrap();
         assert!(crash_ping.message().contains("second message"));
@@ -524,6 +521,7 @@ mod tests {
         builder.with_message(special_message.to_string()).unwrap();
         builder.with_sig_info(SigInfo::test_instance(42)).unwrap();
         builder.with_metadata(Metadata::test_instance(1)).unwrap();
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
 
         let crash_ping = builder.build_crash_ping().unwrap();
         assert!(crash_ping.message().contains(special_message));
@@ -543,6 +541,7 @@ mod tests {
 
         builder.with_sig_info(SigInfo::test_instance(42)).unwrap();
         builder.with_metadata(Metadata::test_instance(1)).unwrap();
+        builder.with_kind(ErrorKind::UnixSignal).unwrap();
 
         let crash_ping = builder.build_crash_ping().unwrap();
         assert!(crash_ping.message().len() >= 10000);

libdd-crashtracker/src/crash_info/telemetry.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 use std::{fmt::Write, time::SystemTime};
 
-use crate::SigInfo;
+use crate::{ErrorKind, SigInfo};
 
 use super::{CrashInfo, Metadata};
 use anyhow::Context;
@@ -26,6 +26,7 @@ struct TelemetryMetadata {
 pub struct CrashPingBuilder {
     crash_uuid: Uuid,
     custom_message: Option<String>,
+    kind: Option<ErrorKind>,
     metadata: Option<Metadata>,
     sig_info: Option<SigInfo>,
 }
@@ -38,6 +39,7 @@ impl CrashPingBuilder {
         Self {
             crash_uuid,
             custom_message: None,
+            kind: None,
             metadata: None,
             sig_info: None,
         }
@@ -53,6 +55,11 @@ impl CrashPingBuilder {
         self
     }
 
+    pub fn with_kind(mut self, kind: ErrorKind) -> Self {
+        self.kind = Some(kind);
+        self
+    }
+
     pub fn with_metadata(mut self, metadata: Metadata) -> Self {
         self.metadata = Some(metadata);
         self
@@ -62,6 +69,7 @@ impl CrashPingBuilder {
         let crash_uuid = self.crash_uuid;
         let sig_info = self.sig_info;
         let metadata = self.metadata.context("metadata is required")?;
+        let kind = self.kind.context("kind is required")?;
 
         let message = if let Some(custom_message) = self.custom_message {
             format!("Crashtracker crash ping: crash processing started - {custom_message}")
@@ -71,13 +79,13 @@ impl CrashPingBuilder {
                 sig_info.si_code_human_readable, sig_info.si_signo_human_readable
             )
         } else {
-            "Crashtracker crash ping: crash processing started - Process terminated".to_string()
+            format!("Crashtracker crash ping: crash processing started - Process terminated due to {:?}", kind)
         };
 
         Ok(CrashPing {
             crash_uuid: crash_uuid.to_string(),
-            kind: "Crash ping".to_string(),
             message,
+            kind,
             metadata,
             siginfo: sig_info,
             version: CrashPing::current_schema_version(),
@@ -88,11 +96,11 @@ impl CrashPingBuilder {
 #[derive(Debug, Serialize)]
 pub struct CrashPing {
     crash_uuid: String,
+    kind: ErrorKind,
+    message: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     siginfo: Option<SigInfo>,
-    message: String,
     version: String,
-    kind: String,
     metadata: Metadata,
 }
 
@@ -446,7 +454,10 @@ fn extract_crash_info_tags(crash_info: &CrashInfo) -> anyhow::Result<String> {
 #[cfg(test)]
 mod tests {
     use super::TelemetryCrashUploader;
-    use crate::crash_info::{test_utils::TestInstance, CrashInfo, CrashInfoBuilder, Metadata};
+    use crate::{
+        crash_info::{test_utils::TestInstance, CrashInfo, CrashInfoBuilder, Metadata},
+        ErrorKind,
+    };
     use libdd_common::Endpoint;
     use libdd_telemetry::data::LogLevel;
     use std::{collections::HashSet, fs};
@@ -580,6 +591,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
         t.upload_crash_ping(&crash_ping).await.unwrap();
 
@@ -607,7 +619,7 @@ mod tests {
         assert!(Uuid::parse_str(message_json["crash_uuid"].as_str().unwrap()).is_ok());
 
         assert_eq!(message_json["version"], "1.0");
-        assert_eq!(message_json["kind"], "Crash ping");
+        assert_eq!(message_json["kind"], "UnixSignal");
 
         let metadata_in_message = &message_json["metadata"];
         assert!(
@@ -655,6 +667,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
         t.upload_crash_ping(&crash_ping).await.unwrap();
 
@@ -707,7 +720,7 @@ mod tests {
         );
 
         assert_eq!(message_json["version"], "1.0");
-        assert_eq!(message_json["kind"], "Crash ping");
+        assert_eq!(message_json["kind"], "UnixSignal");
 
         let tags = log_entry["tags"].as_str().unwrap();
         let uuid_str = message_json["crash_uuid"].as_str().unwrap();
@@ -738,6 +751,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping()?;
 
         let endpoint = Some(Endpoint::from_slice(&format!(
@@ -781,7 +795,7 @@ mod tests {
         assert!(message_json["crash_uuid"].is_string());
         assert!(Uuid::parse_str(message_json["crash_uuid"].as_str().unwrap()).is_ok());
         assert_eq!(message_json["version"], "1.0");
-        assert_eq!(message_json["kind"], "Crash ping");
+        assert_eq!(message_json["kind"], "UnixSignal");
 
         Ok(())
     }
@@ -794,6 +808,7 @@ mod tests {
         crash_info_builder
             .with_metadata(Metadata::test_instance(1))
             .unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let result = crash_info_builder.build_crash_ping();
         assert!(result.is_ok());
         let crash_ping = result.unwrap();
@@ -807,6 +822,7 @@ mod tests {
         crash_info_builder
             .with_sig_info(crate::SigInfo::test_instance(1))
             .unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let result = crash_info_builder.build_crash_ping();
         assert!(result.is_err());
         assert!(result
@@ -822,6 +838,7 @@ mod tests {
         crash_info_builder
             .with_metadata(Metadata::test_instance(1))
             .unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let result = crash_info_builder.build_crash_ping();
         assert!(result.is_ok());
         let crash_ping = result.unwrap();
@@ -838,6 +855,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
 
         assert!(!crash_ping.crash_uuid().is_empty());
@@ -857,6 +875,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
 
         assert!(!crash_ping.crash_uuid().is_empty());
@@ -882,6 +901,7 @@ mod tests {
         crash_info_builder
             .with_message("my process panicked".to_string())
             .unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
 
         assert!(!crash_ping.crash_uuid().is_empty());
@@ -918,6 +938,7 @@ mod tests {
         let mut crash_info_builder = CrashInfoBuilder::new();
         crash_info_builder.with_sig_info(sig_info.clone()).unwrap();
         crash_info_builder.with_metadata(metadata.clone()).unwrap();
+        crash_info_builder.with_kind(ErrorKind::UnixSignal).unwrap();
         let crash_ping = crash_info_builder.build_crash_ping().unwrap();
 
         uploader.upload_crash_ping(&crash_ping).await?;
@@ -941,7 +962,7 @@ mod tests {
         assert!(message_json["crash_uuid"].is_string());
         assert!(Uuid::parse_str(message_json["crash_uuid"].as_str().unwrap()).is_ok());
         assert_eq!(message_json["version"], "1.0");
-        assert_eq!(message_json["kind"], "Crash ping");
+        assert_eq!(message_json["kind"], "UnixSignal");
 
         let uploaded_siginfo = &message_json["siginfo"];
         assert_eq!(uploaded_siginfo["si_signo"], sig_info.si_signo);

libdd-crashtracker/src/receiver/mod.rs

@@ -18,7 +18,7 @@ mod tests {
     use crate::collector::default_signals;
     use crate::crash_info::{SiCodes, SigInfo, SignalNames};
     use crate::shared::constants::*;
-    use crate::{CrashtrackerConfiguration, StacktraceCollection};
+    use crate::{CrashtrackerConfiguration, ErrorKind, StacktraceCollection};
     use std::time::Duration;
     use tokio::io::{AsyncWriteExt, BufReader};
     use tokio::net::UnixStream;
@@ -49,6 +49,10 @@ mod tests {
         .await?;
         to_socket(sender, DD_CRASHTRACK_END_SIGINFO).await?;
 
+        to_socket(sender, DD_CRASHTRACK_BEGIN_KIND).await?;
+        to_socket(sender, serde_json::to_string(&ErrorKind::UnixSignal)?).await?;
+        to_socket(sender, DD_CRASHTRACK_END_KIND).await?;
+
         to_socket(sender, DD_CRASHTRACK_BEGIN_CONFIG).await?;
         to_socket(
             sender,