try patching URL building logic

Author: gyuheon0h

datadog-crashtracker/src/crash_info/errors_intake.rs

@@ -204,6 +204,10 @@ impl ErrorsIntakeUploader {
         telemetry_endpoint: &Option<Endpoint>,
     ) -> anyhow::Result<Self> {
         let endpoint = Self::build_errors_intake_endpoint(telemetry_endpoint)?;
+        eprintln!(
+            "DEBUG: Created errors intake uploader with URL: {}",
+            endpoint.url
+        );
         Ok(Self { endpoint })
     }
 
@@ -214,12 +218,13 @@ impl ErrorsIntakeUploader {
             Some(endpoint) => {
                 let mut errors_endpoint = endpoint.clone();
 
-                // Modify the path based on whether we're using agent proxy or direct intake
-                let _new_path = if endpoint.api_key.is_some() {
+                // Modify the endpoint based on whether we're using agent proxy or direct intake
+                if endpoint.api_key.is_some() {
                     // Direct intake - change hostname to event-platform-intake
                     let mut parts = endpoint.url.clone().into_parts();
 
                     // Update the authority to use event-platform-intake subdomain
+                    // Only modify authority for production domains, not localhost
                     if let Some(authority) = parts.authority.as_ref() {
                         let authority_str = authority.as_str();
                         let new_authority = if authority_str.contains("datad0g.com") {
@@ -228,6 +233,11 @@ impl ErrorsIntakeUploader {
                         } else if authority_str.contains("datadoghq.com") {
                             authority_str
                                 .replace("instrumentation-telemetry-intake", ERROR_INTAKE_SUBDOMAIN)
+                        } else if authority_str.starts_with("localhost")
+                            || authority_str.starts_with("127.0.0.1")
+                        {
+                            // For localhost, keep the same authority for direct intake testing
+                            authority_str.to_string()
                         } else {
                             // For other domains, prepend event-platform-intake
                             format!("{}.{}", ERROR_INTAKE_SUBDOMAIN, authority_str)
@@ -240,24 +250,23 @@ impl ErrorsIntakeUploader {
                         );
                     }
 
+                    // Set direct intake path
                     parts.path_and_query = Some(
                         ERROR_INTAKE_DIRECT_PATH
                             .parse()
                             .context("Failed to parse direct errors intake path")?,
                     );
 
                     errors_endpoint.url = Uri::from_parts(parts)?;
-                    ERROR_INTAKE_DIRECT_PATH
                 } else {
-                    // Agent proxy - use evp_proxy path
+                    // Agent proxy - keep same authority, just change path to evp_proxy
                     let mut parts = endpoint.url.clone().into_parts();
                     parts.path_and_query = Some(
                         ERROR_INTAKE_AGENT_PATH
                             .parse()
                             .context("Failed to parse agent errors intake path")?,
                     );
                     errors_endpoint.url = Uri::from_parts(parts)?;
-                    ERROR_INTAKE_AGENT_PATH
                 };
 
                 Ok(errors_endpoint)
@@ -283,11 +292,19 @@ impl ErrorsIntakeUploader {
         sig_info: &SigInfo,
         metadata: &Metadata,
     ) -> anyhow::Result<()> {
+        eprintln!(
+            "DEBUG: Sending crash ping to errors intake URL: {}",
+            self.endpoint.url
+        );
         let payload = ErrorsIntakePayload::from_crash_ping(crash_uuid, sig_info, metadata)?;
         self.send_payload(&payload).await
     }
 
     pub async fn upload_to_errors_intake(&self, crash_info: &CrashInfo) -> anyhow::Result<()> {
+        eprintln!(
+            "DEBUG: Sending crash report to errors intake URL: {}",
+            self.endpoint.url
+        );
         let payload = ErrorsIntakePayload::from_crash_info(crash_info)?;
         self.send_payload(&payload).await
     }

datadog-crashtracker/src/crash_info/telemetry.rs

@@ -5,7 +5,7 @@ use std::{fmt::Write, time::SystemTime};
 use crate::SigInfo;
 
 use super::{build_crash_ping_message, CrashInfo, ErrorsIntakeUploader, Metadata};
-use anyhow::{Context, Ok};
+use anyhow::Context;
 use chrono::{DateTime, Utc};
 use ddcommon::Endpoint;
 use ddtelemetry::{
@@ -148,9 +148,13 @@ impl TelemetryCrashUploader {
 
         let host = build_host();
 
-        // Try to create errors intake uploader - it's optional and non-blocking
         let errors_intake_uploader =
-            ErrorsIntakeUploader::new(crashtracker_metadata, endpoint).ok(); // Ignore errors for now, errors intake is optional
+            match ErrorsIntakeUploader::new(crashtracker_metadata, endpoint) {
+                Ok(uploader) => Some(uploader),
+                Err(e) => {
+                    panic!("Failed to create errors intake uploader: {e}");
+                }
+            };
 
         let s = Self {
             metadata: TelemetryMetadata {