Terminate process on timeout in windows for the coverage task

src/agent/coverage/Cargo.toml

@@ -20,6 +20,7 @@ symbolic = { version = "12.3", features = [
     "symcache",
 ] }
 thiserror = "1.0"
+process_control = "4.0"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 debugger = { path = "../debugger" }

src/agent/coverage/src/record.rs

@@ -121,31 +121,34 @@
     #[cfg(target_os = "windows")]
     pub fn record(self) -> Result<Recorded> {
         use debugger::Debugger;
+        use process_control::{ChildExt, Control};
         use windows::WindowsRecorder;
 
         let loader = self.loader.clone();
+        let mut recorder =
+            WindowsRecorder::new(&loader, self.module_allowlist, self.cache.as_ref());
+        let (mut dbg, child) = Debugger::init(self.cmd, &mut recorder)?;
+        dbg.run(&mut recorder)?;
+
+        // If the debugger callbacks fail, this may return with a spurious clean exit.
+        let output = child
+                    .controlled_with_output()
+                    .time_limit(self.timeout)
+                    .terminate_for_timeout()
+                    .wait()?
+                    .ok_or_else(|| crate::timer::TimerError::Timeout(self.timeout))?.into();
+
+        // Check if debugging was stopped due to a callback error.
+        //
+        // If so, the debugger terminated the target, and the recorded coverage and
+        // output are both invalid.
+        if let Some(err) = recorder.stop_error {
+            return Err(err);
+        }
 
-        crate::timer::timed(self.timeout, move || {
-            let mut recorder =
-                WindowsRecorder::new(&loader, self.module_allowlist, self.cache.as_ref());
-            let (mut dbg, child) = Debugger::init(self.cmd, &mut recorder)?;
-            dbg.run(&mut recorder)?;
-
-            // If the debugger callbacks fail, this may return with a spurious clean exit.
-            let output = child.wait_with_output()?.into();
-
-            // Check if debugging was stopped due to a callback error.
-            //
-            // If so, the debugger terminated the target, and the recorded coverage and
-            // output are both invalid.
-            if let Some(err) = recorder.stop_error {
-                return Err(err);
-            }
-
-            let coverage = recorder.coverage;
+        let coverage = recorder.coverage;
 
-            Ok(Recorded { coverage, output })
-        })?
+        Ok(Recorded { coverage, output })
     }
 }
 
@@ -157,19 +160,32 @@
 
 #[derive(Clone, Debug, Default)]
 pub struct Output {
-    pub status: Option<ExitStatus>,
+    pub status: Option<process_control::ExitStatus>,
     pub stderr: String,
     pub stdout: String,
 }
 
+impl From<process_control::Output> for Output {
+    fn from(output: process_control::Output) -> Self {
+        let status = Some(output.status);
+        let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
+        let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
+        Self {
+            status,
+            stdout,
+            stderr,
+        }
+    }
+}
+
 impl From<std::process::Output> for Output {
     fn from(output: std::process::Output) -> Self {
         let status = Some(output.status);
         let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
         let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
 
         Self {
-            status,
+            status: status.map(Into::into),
             stdout,
             stderr,
         }