Add kind to crash ping and clarify requirements

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,7 @@ 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
 #[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 {

libdd-crashtracker/src/crash_info/error_data.rs

@@ -189,6 +189,16 @@ pub enum ErrorKind {
     UnixSignal,
 }
 
+impl ErrorKind {
+    pub fn to_json_string(&self) -> &str {
+        match self {
+            ErrorKind::Panic => "\"Panic\"",
+            ErrorKind::UnhandledException => "\"UnhandledException\"",
+            ErrorKind::UnixSignal => "\"UnixSignal\"",
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct ThreadData {
     pub crashed: bool,

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,
 }
 

libdd-crashtracker/src/receiver/receive_report.rs

@@ -108,6 +108,7 @@ pub(crate) enum StdinState {
     Counters,
     Done,
     File(String, Vec<String>),
+    Kind,
     Metadata,
     ProcInfo,
     SigInfo,
@@ -186,6 +187,13 @@ fn process_line(
             StdinState::File(name, contents)
         }
 
+        StdinState::Kind if line.starts_with(DD_CRASHTRACK_END_KIND) => StdinState::Waiting,
+        StdinState::Kind => {
+            let kind: ErrorKind = serde_json::from_str(line)?;
+            builder.with_kind(kind)?;
+            StdinState::Kind
+        }
+
         StdinState::Metadata if line.starts_with(DD_CRASHTRACK_END_METADATA) => StdinState::Waiting,
         StdinState::Metadata => {
             let metadata = serde_json::from_str(line)?;
@@ -311,6 +319,7 @@ fn process_line(
             let (_, filename) = line.split_once(' ').unwrap_or(("", "MISSING_FILENAME"));
             StdinState::File(filename.to_string(), vec![])
         }
+        StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_KIND) => StdinState::Kind,
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_METADATA) => {
             StdinState::Metadata
         }
@@ -392,7 +401,7 @@ pub(crate) async fn receive_report_from_stream(
             }
         }
 
-        // We need to wait until at least we receive config, metadata, and siginfo (on non-Windows
+        // We need to wait until at least we receive config, metadata, and kind (on non-Windows
         // platforms) before sending the crash ping
         if !crash_ping_sent && builder.is_ping_ready() {
             if let Some(ref config_ref) = config {
@@ -485,8 +494,6 @@ pub(crate) async fn receive_report_from_stream(
         return Ok(None);
     }
 
-    // For now, we only support Signal based crash detection in the receiver.
-    builder.with_kind(ErrorKind::UnixSignal)?;
     enrich_thread_name(&mut builder)?;
     builder.with_os_info_this_machine()?;
 

libdd-crashtracker/src/shared/constants.rs

@@ -7,6 +7,7 @@ pub const DD_CRASHTRACK_BEGIN_ADDITIONAL_TAGS: &str = "DD_CRASHTRACK_BEGIN_ADDIT
 pub const DD_CRASHTRACK_BEGIN_CONFIG: &str = "DD_CRASHTRACK_BEGIN_CONFIG";
 pub const DD_CRASHTRACK_BEGIN_COUNTERS: &str = "DD_CRASHTRACK_BEGIN_COUNTERS";
 pub const DD_CRASHTRACK_BEGIN_FILE: &str = "DD_CRASHTRACK_BEGIN_FILE";
+pub const DD_CRASHTRACK_BEGIN_KIND: &str = "DD_CRASHTRACK_BEGIN_KIND";
 pub const DD_CRASHTRACK_BEGIN_METADATA: &str = "DD_CRASHTRACK_BEGIN_METADATA";
 pub const DD_CRASHTRACK_BEGIN_PROCINFO: &str = "DD_CRASHTRACK_BEGIN_PROCESSINFO";
 pub const DD_CRASHTRACK_BEGIN_THREAD_NAME: &str = "DD_CRASHTRACK_BEGIN_THREAD_NAME";
@@ -24,6 +25,7 @@ pub const DD_CRASHTRACK_END_ADDITIONAL_TAGS: &str = "DD_CRASHTRACK_END_ADDITIONA
 pub const DD_CRASHTRACK_END_CONFIG: &str = "DD_CRASHTRACK_END_CONFIG";
 pub const DD_CRASHTRACK_END_COUNTERS: &str = "DD_CRASHTRACK_END_COUNTERS";
 pub const DD_CRASHTRACK_END_FILE: &str = "DD_CRASHTRACK_END_FILE";
+pub const DD_CRASHTRACK_END_KIND: &str = "DD_CRASHTRACK_END_KIND";
 pub const DD_CRASHTRACK_END_METADATA: &str = "DD_CRASHTRACK_END_METADATA";
 pub const DD_CRASHTRACK_END_PROCINFO: &str = "DD_CRASHTRACK_END_PROCESSINFO";
 pub const DD_CRASHTRACK_END_THREAD_NAME: &str = "DD_CRASHTRACK_END_THREAD_NAME";