Report error when process fails to start

unflxw · unflxw · commit bfd4bb53ec64 · 2024-11-18T14:48:23.000+01:00
When starting the child process fails and error reporting is enabled, report the failure to start the process as an error to AppSignal. Fixes #22.
diff --git a/.changesets/report-exit-failures-as-errors-to-appsignal.md b/.changesets/report-exit-failures-as-errors-to-appsignal.md
@@ -0,0 +1,12 @@
+---
+bump: patch
+type: add
+---
+
+Report exit failures as errors to AppSignal. Use the `--error` command-line option to report an error to AppSignal when the command exits with a non-zero status code, or when the command fails to start:
+
+```
+appsignal-wrap --error backup -- ./backup.sh
+```
+
+The name given as the value to the `--error` command-line option will be used to group the errors in AppSignal.
diff --git a/src/error.rs b/src/error.rs
@@ -19,21 +19,41 @@ pub struct ErrorConfig {
 }
 
 impl ErrorConfig {
-    pub fn request(
-        &self,
-        timestamp: &mut impl Timestamp,
-        exit: &ExitStatus,
-        lines: impl IntoIterator<Item = String>,
-    ) -> Result<reqwest::Request, reqwest::Error> {
+    pub fn request(&self, body: impl Into<Body>) -> Result<reqwest::Request, reqwest::Error> {
         let url = format!("{}/errors", self.endpoint);
 
         client()
             .post(url)
             .query(&[("api_key", &self.api_key)])
             .header("Content-Type", "application/json")
-            .body(ErrorBody::from_config(self, timestamp, exit, lines))
+            .body(body)
             .build()
     }
+
+    pub fn request_from_spawn(
+        &self,
+        timestamp: &mut impl Timestamp,
+        error: &std::io::Error,
+    ) -> Result<reqwest::Request, reqwest::Error> {
+        self.request(ErrorBody::from_spawn(self, timestamp, error))
+    }
+
+    pub fn request_from_exit(
+        &self,
+        timestamp: &mut impl Timestamp,
+        exit: &ExitStatus,
+        lines: impl IntoIterator<Item = String>,
+    ) -> Result<reqwest::Request, reqwest::Error> {
+        self.request(ErrorBody::from_exit(self, timestamp, exit, lines))
+    }
+
+    fn tags(&self) -> BTreeMap<String, String> {
+        [
+            ("hostname".to_string(), self.hostname.clone()),
+            (format!("{}-digest", NAME), self.digest.clone()),
+        ]
+        .into()
+    }
 }
 
 #[derive(Serialize)]
@@ -46,26 +66,42 @@ pub struct ErrorBody {
 }
 
 impl ErrorBody {
-    pub fn from_config(
+    pub fn new(
         config: &ErrorConfig,
         timestamp: &mut impl Timestamp,
-        exit: &ExitStatus,
-        lines: impl IntoIterator<Item = String>,
+        error: ErrorBodyError,
+        tags: impl IntoIterator<Item = (String, String)>,
     ) -> Self {
         ErrorBody {
             timestamp: timestamp.as_secs(),
             action: config.action.clone(),
             namespace: "process".to_string(),
-            error: ErrorBodyError::new(exit, lines),
-            tags: exit_tags(exit)
-                .into_iter()
-                .chain([
-                    ("hostname".to_string(), config.hostname.clone()),
-                    (format!("{}-digest", NAME), config.digest.clone()),
-                ])
-                .collect(),
+            error,
+            tags: tags.into_iter().chain(config.tags()).collect(),
         }
     }
+
+    pub fn from_spawn(
+        config: &ErrorConfig,
+        timestamp: &mut impl Timestamp,
+        error: &std::io::Error,
+    ) -> Self {
+        Self::new(config, timestamp, ErrorBodyError::from_spawn(error), vec![])
+    }
+
+    pub fn from_exit(
+        config: &ErrorConfig,
+        timestamp: &mut impl Timestamp,
+        exit: &ExitStatus,
+        lines: impl IntoIterator<Item = String>,
+    ) -> Self {
+        Self::new(
+            config,
+            timestamp,
+            ErrorBodyError::from_exit(exit, lines),
+            exit_tags(exit),
+        )
+    }
 }
 
 impl From<ErrorBody> for Body {
@@ -81,7 +117,14 @@ pub struct ErrorBodyError {
 }
 
 impl ErrorBodyError {
-    pub fn new(exit: &ExitStatus, lines: impl IntoIterator<Item = String>) -> Self {
+    pub fn from_spawn(error: &std::io::Error) -> Self {
+        ErrorBodyError {
+            name: "StartError".to_string(),
+            message: format!("[Error starting process: {}]", error),
+        }
+    }
+
+    pub fn from_exit(exit: &ExitStatus, lines: impl IntoIterator<Item = String>) -> Self {
         let (name, exit_context) = if let Some(code) = exit.code() {
             ("NonZeroExit".to_string(), format!("code {}", code))
         } else if let Some(signal) = exit.signal() {
@@ -136,15 +179,59 @@ mod tests {
     }
 
     #[test]
-    fn error_config_request() {
+    fn error_config_request_from_spawn() {
+        let config = error_config();
+        let error = std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "No such file or directory (os error 2)",
+        );
+
+        let request = config.request_from_spawn(&mut timestamp(), &error).unwrap();
+
+        assert_eq!(request.method().as_str(), "POST");
+        assert_eq!(
+            request.url().as_str(),
+            "https://some-endpoint.com/errors?api_key=some_api_key"
+        );
+        assert_eq!(
+            request.headers().get("Content-Type").unwrap(),
+            "application/json"
+        );
+        assert_eq!(
+            String::from_utf8_lossy(request.body().unwrap().as_bytes().unwrap()),
+            format!(
+                concat!(
+                    "{{",
+                    r#""timestamp":{},"#,
+                    r#""action":"some-action","#,
+                    r#""namespace":"process","#,
+                    r#""error":{{"#,
+                    r#""name":"StartError","#,
+                    r#""message":"[Error starting process: No such file or directory (os error 2)]""#,
+                    r#"}},"#,
+                    r#""tags":{{"#,
+                    r#""{}-digest":"some-digest","#,
+                    r#""hostname":"some-hostname""#,
+                    r#"}}"#,
+                    "}}"
+                ),
+                EXPECTED_SECS, NAME
+            )
+        );
+    }
+
+    #[test]
+    fn error_config_request_from_exit() {
         let config = error_config();
         // `ExitStatus::from_raw` expects a wait status, not an exit status.
         // The wait status for exit code `n` is represented by `n << 8`.
         // See `__WEXITSTATUS` in `glibc/bits/waitstatus.h` for reference.
         let exit = ExitStatus::from_raw(42 << 8);
         let lines = vec!["line 1".to_string(), "line 2".to_string()];
 
-        let request = config.request(&mut timestamp(), &exit, lines).unwrap();
+        let request = config
+            .request_from_exit(&mut timestamp(), &exit, lines)
+            .unwrap();
 
         assert_eq!(request.method().as_str(), "POST");
         assert_eq!(
diff --git a/src/main.rs b/src/main.rs
@@ -56,7 +56,10 @@ fn main() {
 
     match start(cli) {
         Ok(code) => exit(code),
-        Err(err) => error!("{}", err),
+        Err(err) => {
+            error!("{}", err);
+            exit(1);
+        }
     }
 }
 
@@ -68,7 +71,20 @@ async fn start(cli: Cli) -> Result<i32, Box<dyn std::error::Error>> {
 
     let tasks = TaskTracker::new();
 
-    let (child, stdout, stderr) = spawn_child(&cli, &tasks)?;
+    let (child, stdout, stderr) = match spawn_child(&cli, &tasks) {
+        Ok(spawned_child) => spawned_child,
+        Err(err) => {
+            if let Some(config) = error {
+                tasks.spawn(send_request(
+                    config.request_from_spawn(&mut SystemTimestamp, &err),
+                ));
+                tasks.close();
+                tasks.wait().await;
+            }
+
+            return Err(format!("could not spawn child process: {err}").into());
+        }
+    };
 
     let (log_stdout, error_stdout) = maybe_spawn_tee(stdout);
     let (log_stderr, error_stderr) = maybe_spawn_tee(stderr);
@@ -106,7 +122,7 @@ async fn start(cli: Cli) -> Result<i32, Box<dyn std::error::Error>> {
             ));
         }
     } else if let Some(error) = error {
-        tasks.spawn(send_error_request(
+        tasks.spawn(send_error_exit_request(
             error,
             exit_status,
             error_message.unwrap(),
@@ -412,7 +428,7 @@ async fn forward_signals_and_wait(mut child: Child) -> io::Result<ExitStatus> {
     }
 }
 
-async fn send_error_request(
+async fn send_error_exit_request(
     error: ErrorConfig,
     exit_status: ExitStatus,
     receiver: oneshot::Receiver<VecDeque<String>>,
@@ -425,7 +441,7 @@ async fn send_error_request(
         }
     };
 
-    send_request(error.request(&mut SystemTimestamp, &exit_status, lines)).await;
+    send_request(error.request_from_exit(&mut SystemTimestamp, &exit_status, lines)).await;
 }
 
 fn command(argv: &[String], should_stdout: bool, should_stderr: bool) -> Command {
