Windows e2e named pipe test

Author: gyuheon0h

Cargo.lock

@@ -24,6 +24,9 @@ hex = "0.4"
 
 [target.'cfg(windows)'.dependencies]
 tokio = { version = "1.0", features = ["net"] }
+windows = { version = "0.58", features = [
+    "Win32_System_Diagnostics_Debug",
+] }
 
 [lib]
 bench = false
@@ -42,4 +45,4 @@ bench = false
 
 [[bin]]
 name = "crashing_test_app"
-bench = false
+bench = false

bin_tests/Cargo.toml

@@ -1,14 +1,22 @@
 // Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(not(unix))]
-fn main() {}
-
 #[cfg(unix)]
 fn main() -> anyhow::Result<()> {
     unix::main()
 }
 
+#[cfg(windows)]
+fn main() -> anyhow::Result<()> {
+    windows::main()
+}
+
+#[cfg(not(any(unix, windows)))]
+fn main() -> anyhow::Result<()> {
+    eprintln!("Crashing test app is only supported on Unix and Windows");
+    std::process::exit(1);
+}
+
 #[cfg(unix)]
 mod unix {
     use anyhow::ensure;
@@ -104,3 +112,137 @@ mod unix {
         Ok(())
     }
 }
+
+#[cfg(windows)]
+mod windows {
+    use anyhow::Context;
+    use std::env;
+
+    use datadog_crashtracker::{init_crashtracking_windows, Metadata};
+    use ddcommon::{tag, Endpoint};
+
+    #[inline(never)]
+    unsafe fn fn3() {
+        // Force a true access violation that WER will catch
+        // Use inline assembly to avoid Rust's null pointer checks
+        #[cfg(target_arch = "x86_64")]
+        {
+            std::arch::asm!(
+                "mov rax, 0",
+                "mov dword ptr [rax], 42",
+                out("rax") _,
+            );
+        }
+
+        #[cfg(target_arch = "x86")]
+        {
+            std::arch::asm!(
+                "mov eax, 0",
+                "mov dword ptr [eax], 42",
+                out("eax") _,
+            );
+        }
+
+        #[cfg(not(any(target_arch = "x86_64", target_arch = "x86")))]
+        {
+            // Fallback for other architectures - this will be a panic, not WER
+            let null_ptr = std::ptr::null_mut::<i32>();
+            *null_ptr = 42;
+        }
+    }
+
+    #[inline(never)]
+    fn fn2() {
+        unsafe { fn3() }
+    }
+
+    #[inline(never)]
+    fn fn1() {
+        fn2()
+    }
+
+    #[inline(never)]
+    pub fn main() -> anyhow::Result<()> {
+        println!("Windows crashing test app starting...");
+
+        // Parse arguments: output_url
+        let mut args = env::args().skip(1);
+        let output_url = args.next().context("Expected output_url argument")?;
+
+        // Check environment variables for named pipe configuration
+        if let Ok(pipe_name) = env::var("DD_TRACE_PIPE_NAME") {
+            println!("Using named pipe: {}", pipe_name);
+        }
+
+        if let Ok(errors_intake) = env::var("_DD_ERRORS_INTAKE_ENABLED") {
+            println!("Errors intake enabled: {}", errors_intake);
+        }
+
+        if let Ok(api_key) = env::var("DD_API_KEY") {
+            println!("API key configured (length: {})", api_key.len());
+        }
+
+        if let Ok(direct_submission) = env::var("_DD_DIRECT_SUBMISSION_ENABLED") {
+            println!("Direct submission enabled: {}", direct_submission);
+        }
+
+        // Create endpoint for crash output
+        let endpoint = if output_url.is_empty() {
+            None
+        } else {
+            Some(Endpoint::from_slice(&output_url))
+        };
+
+        println!("Output endpoint: {:?}", endpoint.as_ref().map(|e| &e.url));
+
+        // Initialize Windows crashtracker
+        let metadata = Metadata {
+            library_name: "libdatadog".to_owned(),
+            library_version: "1.0.0".to_owned(),
+            family: "native".to_owned(),
+            tags: vec![
+                tag!("service", "foo"),
+                tag!("service_version", "bar"),
+                tag!("runtime-id", "xyz"),
+                tag!("language", "native"),
+            ]
+            .into_iter()
+            .map(|x| x.to_string())
+            .collect(),
+        };
+
+        // Get current module path (this executable)
+        let module_path = env::current_exe()?;
+        let module_name = module_path.to_string_lossy().to_string();
+
+        println!("Initializing Windows crashtracker...");
+        println!("Module: {}", module_name);
+        println!("Endpoint: {:?}", endpoint);
+
+        // Initialize crashtracker
+        init_crashtracking_windows(module_name, endpoint.as_ref(), metadata)?;
+
+        println!("Crashtracker initialized successfully!");
+
+        // Enable Windows Error Reporting like the FFI test app does
+        println!("Enabling Windows Error Reporting...");
+        unsafe {
+            use windows::Win32::System::Diagnostics::Debug::{SetErrorMode, THREAD_ERROR_MODE};
+            SetErrorMode(THREAD_ERROR_MODE(0x0001));
+        }
+
+        // Add a longer delay to ensure WER registration is complete
+        println!("Waiting for WER registration to complete...");
+        std::thread::sleep(std::time::Duration::from_millis(500));
+
+        println!("About to trigger crash in call stack: main -> fn1 -> fn2 -> fn3");
+        println!("This should generate an access violation that WER will catch...");
+
+        // Create the call stack for better crash traces
+        fn1();
+
+        // This should never be reached
+        println!("ERROR: Failed to crash!");
+        Ok(())
+    }
+}