debug

Author: gyuheon0h

datadog-crashtracker/src/crash_info/mod.rs

@@ -151,8 +151,6 @@ impl CrashInfo {
                 .host()
                 .map_or(false, |host| host.contains("event-platform-intake"))
             {
-                panic!("Secondary endpoint is not an Error Tracking intake endpoint");
-
                 self.upload_to_error_tracking(&Some(secondary.clone()))
                     .await
             } else {

datadog-crashtracker/src/receiver/entry_points.rs

@@ -4,7 +4,6 @@
 use super::receive_report::receive_report_from_stream;
 use crate::{crash_info::CrashInfo, CrashtrackerConfiguration, StacktraceCollection};
 use anyhow::Context;
-use ddcommon::Endpoint;
 use std::time::Duration;
 use tokio::{
     io::{AsyncBufReadExt, BufReader},
@@ -113,12 +112,7 @@ pub(crate) async fn receiver_entry_point(
             }
         }
         crash_info
-            .async_upload_to_endpoints(
-                config.endpoint(),
-                &Some(Endpoint::from_slice(
-                    "https://event-platform-intake.datad0g.com/api/v2/errorsintake",
-                )),
-            )
+            .async_upload_to_endpoints(config.endpoint(), config.secondary_endpoint())
             .await?;
     }
     Ok(())

datadog-crashtracker/src/shared/configuration.rs

@@ -24,7 +24,7 @@ pub enum StacktraceCollection {
     EnabledWithSymbolsInReceiver,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
 pub struct CrashtrackerConfiguration {
     // Paths to any additional files to track, if any
     additional_files: Vec<String>,
@@ -223,6 +223,50 @@ impl CrashtrackerConfiguration {
     }
 }
 
+impl<'de> serde::Deserialize<'de> for CrashtrackerConfiguration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct CrashtrackerConfigurationHelper {
+            additional_files: Vec<String>,
+            create_alt_stack: bool,
+            demangle_names: bool,
+            endpoint: Option<Endpoint>,
+            resolve_frames: StacktraceCollection,
+            secondary_endpoint: Option<Endpoint>,
+            signals: Vec<i32>,
+            timeout: Duration,
+            unix_socket_path: Option<String>,
+            use_alt_stack: bool,
+        }
+
+        let helper = CrashtrackerConfigurationHelper::deserialize(deserializer)?;
+
+        // Apply secondary endpoint derivation logic during deserialization
+        let secondary_endpoint = helper.secondary_endpoint.or_else(|| {
+            helper
+                .endpoint
+                .as_ref()
+                .and_then(derive_default_secondary_endpoint)
+        });
+
+        Ok(CrashtrackerConfiguration {
+            additional_files: helper.additional_files,
+            create_alt_stack: helper.create_alt_stack,
+            demangle_names: helper.demangle_names,
+            endpoint: helper.endpoint,
+            resolve_frames: helper.resolve_frames,
+            secondary_endpoint,
+            signals: helper.signals,
+            timeout: helper.timeout,
+            unix_socket_path: helper.unix_socket_path,
+            use_alt_stack: helper.use_alt_stack,
+        })
+    }
+}
+
 /// Derives a default secondary endpoint based on the primary endpoint.
 /// This mirrors the primary endpoint logic but uses Error Tracking endpoints.
 fn derive_default_secondary_endpoint(primary: &Endpoint) -> Option<Endpoint> {
@@ -511,4 +555,40 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_deserialize_with_secondary_endpoint_derivation() -> anyhow::Result<()> {
+        use ddcommon::Endpoint;
+        use std::time::Duration;
+
+        // Create a config with primary endpoint, serialize it without secondary
+        let mut original_config = super::CrashtrackerConfiguration::new(
+            vec![],
+            false,
+            false,
+            Some(Endpoint::from_slice("https://intake.profile.datadoghq.com")),
+            super::StacktraceCollection::Disabled,
+            vec![],
+            Some(Duration::from_secs(1)),
+            None,
+            false,
+        )?;
+
+        // Clear the secondary endpoint to simulate receiving from collector
+        original_config.secondary_endpoint = None;
+
+        // Serialize and then deserialize
+        let serialized = serde_json::to_string(&original_config)?;
+        let deserialized: super::CrashtrackerConfiguration = serde_json::from_str(&serialized)?;
+
+        // Verify that deserialization applied secondary endpoint derivation
+        assert!(deserialized.secondary_endpoint().is_some());
+        let secondary = deserialized.secondary_endpoint().as_ref().unwrap();
+        assert_eq!(
+            secondary.url.to_string(),
+            "https://event-platform-intake.datad0g.com/api/v2/errorsintake"
+        );
+
+        Ok(())
+    }
 }