Conditions for upload

Author: gyuheon0h

datadog-crashtracker/src/crash_info/errors_intake.rs

@@ -203,23 +203,32 @@ impl ErrorsIntakeUploader {
         _crashtracker_metadata: &Metadata,
         telemetry_endpoint: &Option<Endpoint>,
     ) -> anyhow::Result<Self> {
-        let endpoint = Self::build_errors_intake_endpoint(telemetry_endpoint)?;
+        // Check direct submission setting from environment (same as telemetry)
+        let cfg = ddtelemetry::config::Config::from_env();
+        let direct_submission_enabled = cfg.direct_submission_enabled;
+
+        let endpoint =
+            Self::build_errors_intake_endpoint(telemetry_endpoint, direct_submission_enabled)?;
         eprintln!(
             "DEBUG: Created errors intake uploader with URL: {}",
             endpoint.url
         );
+        eprintln!(
+            "DEBUG: Direct submission enabled: {}",
+            direct_submission_enabled
+        );
         Ok(Self { endpoint })
     }
 
     fn build_errors_intake_endpoint(
         telemetry_endpoint: &Option<Endpoint>,
+        direct_submission_enabled: bool,
     ) -> anyhow::Result<Endpoint> {
         match telemetry_endpoint {
             Some(endpoint) => {
                 let mut errors_endpoint = endpoint.clone();
 
-                // Modify the endpoint based on whether we're using agent proxy or direct intake
-                if endpoint.api_key.is_some() {
+                if endpoint.api_key.is_some() && direct_submission_enabled {
                     // Direct intake - change hostname to event-platform-intake
                     let mut parts = endpoint.url.clone().into_parts();
 
@@ -333,26 +342,38 @@ impl ErrorsIntakeUploader {
             return Ok(());
         }
 
-        // Build the HTTP request
-        let mut req_builder = self
-            .endpoint
-            .to_request_builder(concat!("crashtracker/", env!("CARGO_PKG_VERSION")))?;
+        eprintln!(
+            "DEBUG: Building HTTP request for URL: {}",
+            self.endpoint.url
+        );
+
+        // Build the HTTP request manually to match telemetry approach
+        let mut req_builder = http::Request::builder()
+            .method(http::Method::POST)
+            .uri(self.endpoint.url.clone())
+            .header(
+                http::header::CONTENT_TYPE,
+                ddcommon::header::APPLICATION_JSON,
+            )
+            .header(
+                http::header::USER_AGENT,
+                concat!("crashtracker/", env!("CARGO_PKG_VERSION")),
+            );
 
         // Add errors intake specific headers
         if self.endpoint.api_key.is_some() {
-            // Direct intake - DD-API-KEY is added by to_request_builder
+            // Direct intake - add API key header
+            if let Some(api_key) = &self.endpoint.api_key {
+                req_builder = req_builder.header("DD-API-KEY", api_key.as_ref());
+            }
         } else {
             // Agent proxy - add EvP subdomain header
             req_builder = req_builder.header("X-Datadog-EVP-Subdomain", ERROR_INTAKE_SUBDOMAIN);
         }
 
-        let req = req_builder
-            .method(http::Method::POST)
-            .header(
-                http::header::CONTENT_TYPE,
-                ddcommon::header::APPLICATION_JSON,
-            )
-            .body(serde_json::to_string(payload)?.into())?;
+        let req = req_builder.body(serde_json::to_string(payload)?.into())?;
+
+        eprintln!("DEBUG: Built request with headers: {:?}", req.headers());
 
         // Create HTTP client and send request
         let client = ddcommon::hyper_migration::new_client_periodic();
@@ -415,10 +436,12 @@ mod tests {
         });
 
         let errors_endpoint =
-            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint).unwrap();
+            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint, false).unwrap();
         assert_eq!(errors_endpoint.url.path(), ERROR_INTAKE_AGENT_PATH);
         assert!(errors_endpoint.api_key.is_none());
 
+        // Verify the URL is correct for port 8126
+
         // Test direct intake endpoint
         let telemetry_endpoint = Some(Endpoint {
             url: "https://instrumentation-telemetry-intake.datadoghq.com/api/v2/apmtelemetry"
@@ -428,14 +451,43 @@ mod tests {
             ..Default::default()
         });
 
+        // Test with direct submission enabled
         let errors_endpoint =
-            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint).unwrap();
+            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint, true).unwrap();
         assert_eq!(errors_endpoint.url.path(), ERROR_INTAKE_DIRECT_PATH);
         assert!(errors_endpoint
             .url
             .host()
             .unwrap()
             .contains(ERROR_INTAKE_SUBDOMAIN));
         assert!(errors_endpoint.api_key.is_some());
+
+        // Test with direct submission disabled (should use agent proxy even with API key)
+        let errors_endpoint_agent =
+            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint, false).unwrap();
+        assert_eq!(errors_endpoint_agent.url.path(), ERROR_INTAKE_AGENT_PATH);
+        assert!(errors_endpoint_agent.api_key.is_some()); // API key is preserved but agent proxy is used
+
+        // Test with port 9126 (test environment)
+        let telemetry_endpoint_9126 = Some(Endpoint {
+            url: "http://localhost:9126/telemetry/proxy/api/v2/apmtelemetry"
+                .parse()
+                .unwrap(),
+            api_key: None,
+            ..Default::default()
+        });
+
+        let errors_endpoint_9126 =
+            ErrorsIntakeUploader::build_errors_intake_endpoint(&telemetry_endpoint_9126, false)
+                .unwrap();
+
+        // Verify the URL preserves the correct port
+        assert_eq!(errors_endpoint_9126.url.host(), Some("localhost"));
+        assert_eq!(errors_endpoint_9126.url.port_u16(), Some(9126));
+        assert_eq!(errors_endpoint_9126.url.path(), ERROR_INTAKE_AGENT_PATH);
+
+        // This should be the URL that gets built for the test environment
+        let expected_url = "http://localhost:9126/evp_proxy/v4/api/v2/errorsintake";
+        assert_eq!(errors_endpoint_9126.url.to_string(), expected_url);
     }
 }

datadog-crashtracker/src/crash_info/telemetry.rs

@@ -240,13 +240,16 @@ impl TelemetryCrashUploader {
 
         // Also send crash ping to errors intake if available
         if let Some(errors_uploader) = &self.errors_intake_uploader {
+            eprintln!("DEBUG: Attempting to send crash ping to errors intake");
             let crash_metadata = self.telemetry_metadata_to_crashtracker_metadata();
             if let Err(e) = errors_uploader
                 .send_crash_ping(crash_uuid, sig_info, &crash_metadata)
                 .await
             {
                 eprintln!("Failed to send crash ping to errors intake: {e}");
             }
+        } else {
+            eprintln!("DEBUG: No errors intake uploader available for crash ping");
         }
 
         telemetry_result
@@ -294,9 +297,12 @@ impl TelemetryCrashUploader {
 
         // Also send crash report to errors intake if available
         if let Some(errors_uploader) = &self.errors_intake_uploader {
+            eprintln!("DEBUG: Attempting to send crash report to errors intake");
             if let Err(e) = errors_uploader.upload_to_errors_intake(crash_info).await {
                 eprintln!("Failed to send crash report to errors intake: {e}");
             }
+        } else {
+            eprintln!("DEBUG: No errors intake uploader available for crash report");
         }
 
         telemetry_result