fix(sidecar): retry connect on Windows to fix startup race in named-pipe IPC

On Windows, a named-pipe client's CreateFileA fails immediately if the
server has not yet called ConnectNamedPipe — there is no kernel-level
connection backlog as Unix domain sockets provide.  After daemonize()
returns the child process exists but its Tokio runtime may not have
entered the accept loop yet, causing test_ddog_sidecar_register_app to
fail intermittently.

Add connect_to_sidecar_with_retry() that retries the connection with
exponential back-off (1 ms → 100 ms cap, up to 20 attempts ≈ 1.9 s
total) when just_spawned is true.  On non-Windows platforms is_pipe_not_ready()
always returns false so the helper is a single-attempt no-op there.

Remove the APMSP-2356 ignore annotation from test_ddog_sidecar_register_app
so the fix is validated in CI.

Author: Leiyks

datadog-sidecar-ffi/tests/sidecar.rs

@@ -68,10 +68,6 @@ fn test_ddog_sidecar_connection() {
 }
 
 #[test]
-#[cfg_attr(
-    target_os = "windows",
-    ignore = "APMSP-2356 Investigate flakiness on Windows"
-)]
 #[cfg_attr(miri, ignore)]
 fn test_ddog_sidecar_register_app() {
     set_sidecar_per_process();

datadog-sidecar/src/entry.rs

@@ -274,6 +274,50 @@ pub fn daemonize(listener: IpcServer, mut cfg: Config) -> anyhow::Result<()> {
     Ok(())
 }
 
+/// Returns `true` for transient Windows named-pipe errors that indicate the server is not
+/// yet ready to accept connections (pipe instance doesn't exist yet, or all instances are
+/// busy).  Always returns `false` on non-Windows so the retry loop is a no-op there.
+#[cfg(windows)]
+fn is_pipe_not_ready(e: &io::Error) -> bool {
+    matches!(
+        e.kind(),
+        io::ErrorKind::NotFound
+            | io::ErrorKind::ConnectionRefused
+            | io::ErrorKind::WouldBlock
+    )
+}
+
+#[cfg(not(windows))]
+fn is_pipe_not_ready(_e: &io::Error) -> bool {
+    false
+}
+
+/// Connect to the sidecar, optionally retrying with exponential back-off.
+///
+/// On Windows, a named-pipe client's `CreateFileA` fails immediately if the server has not
+/// yet called `ConnectNamedPipe` — there is no kernel-level connection backlog like Unix
+/// domain sockets provide.  When `just_spawned` is `true` (we just called `daemonize()`),
+/// we retry up to 20 times with doubling delays (1 ms → 100 ms cap, ≈ 1.9 s total budget)
+/// to give the child time to start its Tokio runtime and enter the accept loop.
+fn connect_to_sidecar_with_retry(
+    liaison: &impl setup::Liaison,
+    just_spawned: bool,
+) -> io::Result<SidecarTransport> {
+    let max_attempts: u32 = if just_spawned { 20 } else { 1 };
+    let mut delay = std::time::Duration::from_millis(1);
+    for attempt in 0..max_attempts {
+        match liaison.connect_to_server() {
+            Ok(conn) => return Ok(SidecarTransport::from(conn)),
+            Err(e) if attempt + 1 < max_attempts && is_pipe_not_ready(&e) => {
+                std::thread::sleep(delay);
+                delay = (delay * 2).min(std::time::Duration::from_millis(100));
+            }
+            Err(e) => return Err(e),
+        }
+    }
+    liaison.connect_to_server().map(SidecarTransport::from)
+}
+
 pub fn start_or_connect_to_sidecar(cfg: Config) -> anyhow::Result<SidecarTransport> {
     // On Windows, named-pipe buffer sizes are fixed at creation time.  Set the global before
     // attempt_listen so that the initial server pipe (created by this process and handed to the
@@ -289,18 +333,18 @@ pub fn start_or_connect_to_sidecar(cfg: Config) -> anyhow::Result<SidecarTranspo
         config::IpcMode::InstancePerProcess => setup::DefaultLiason::ipc_per_process(),
     };
 
+    let mut just_spawned = false;
     let err = match liaison.attempt_listen() {
         Ok(Some(listener)) => {
             daemonize(listener, cfg)?;
+            just_spawned = true;
             None
         }
         Ok(None) => None,
         err => err.context("Error starting sidecar").err(),
     };
 
-    Ok(SidecarTransport::from(
-        liaison
-            .connect_to_server()
-            .map_err(|e| err.unwrap_or(e.into()))?,
-    ))
+    connect_to_sidecar_with_retry(&liaison, just_spawned)
+        .map_err(|e| err.unwrap_or(e.into()))
+        .map_err(Into::into)
 }