fix: improve status exit dedicated workers

backend/windmill-common/src/ee.rs

@@ -1,5 +1,5 @@
 use crate::ee::LicensePlan::Community;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
@@ -20,9 +20,8 @@ pub async fn get_license_plan() -> LicensePlan {
     return Community;
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
+#[serde(untagged)]
 pub enum CriticalErrorChannel {}
 
-pub async fn trigger_critical_error_channels(_msg: String) {
-    // Implementation is not open source
-}
+pub async fn trigger_critical_error_channels(_error_message: String) {}

backend/windmill-worker/src/common.rs

@@ -39,6 +39,7 @@ use windmill_queue::{append_logs, CanceledBy};
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use std::os::unix::process::ExitStatusExt;
 
+use std::process::ExitStatus;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 use std::{
@@ -1145,26 +1146,7 @@ pub async fn handle_child(
         _ if *too_many_logs.borrow() => Err(Error::ExecutionErr(format!(
             "logs or result reached limit. (current max size: {MAX_RESULT_SIZE} characters)"
         ))),
-        Ok(Ok(status)) => {
-            if status.success() {
-                Ok(())
-            } else if let Some(code) = status.code() {
-                Err(error::Error::ExitStatus(code))
-            } else {
-                #[cfg(any(target_os = "linux", target_os = "macos"))]
-                return Err(error::Error::ExecutionErr(format!(
-                    "process terminated by signal: {:#?}, stopped_signal: {:#?}, core_dumped: {}",
-                    status.signal(),
-                    status.stopped_signal(),
-                    status.core_dumped()
-                )));
-
-                #[cfg(not(any(target_os = "linux", target_os = "macos")))]
-                return Err(error::Error::ExecutionErr(String::from(
-                    "process terminated by signal",
-                )));
-            }
-        }
+        Ok(Ok(status)) => process_status(status),
         Ok(Err(kill_reason)) => Err(Error::ExecutionErr(format!(
             "job process killed because {kill_reason:#?}"
         ))),
@@ -1172,6 +1154,26 @@ pub async fn handle_child(
     }
 }
 
+pub fn process_status(status: ExitStatus) -> error::Result<()> {
+    if status.success() {
+        Ok(())
+    } else if let Some(code) = status.code() {
+        Err(error::Error::ExitStatus(code))
+    } else {
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        return Err(error::Error::ExecutionErr(format!(
+            "process terminated by signal: {:#?}, stopped_signal: {:#?}, core_dumped: {}",
+            status.signal(),
+            status.stopped_signal(),
+            status.core_dumped()
+        )));
+
+        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+        return Err(error::Error::ExecutionErr(String::from(
+            "process terminated by signal",
+        )));
+    }
+}
 pub async fn start_child_process(mut cmd: Command, executable: &str) -> Result<Child, Error> {
     return cmd
         .spawn()

backend/windmill-worker/src/dedicated_worker.rs

@@ -16,7 +16,8 @@ use std::{collections::VecDeque, process::Stdio, sync::Arc};
 use anyhow::Context;
 
 use crate::{
-    common::start_child_process, JobCompleted, JobCompletedSender, MAX_BUFFERED_DEDICATED_JOBS,
+    common::{process_status, start_child_process},
+    JobCompleted, JobCompletedSender, MAX_BUFFERED_DEDICATED_JOBS,
 };
 
 use futures::{future, Future};
@@ -108,7 +109,11 @@ pub async fn handle_dedicated_process(
             .wait()
             .await
             .expect("child process encountered an error");
-        tracing::info!("child status was: {}", status);
+        if let Err(e) = process_status(status) {
+            tracing::error!("child exit status was not success: {e}");
+        } else {
+            tracing::info!("child exist status was success");
+        }
     });
 
     let mut jobs = VecDeque::with_capacity(MAX_BUFFERED_DEDICATED_JOBS);