[pbs-devel] [PATCH proxmox 2/2] worker_task: print worker starting message and upid

[Gabriel Goller]

In addition to forcing the task result (last message) to the tasklog
file and syslog, also force a start message to file and syslog. When
printing to syslog, also add the upid (in the tasklog the upid is
already visible in th window header or the status tab).

This allows us to always see the start and end log of a task in the
syslog and tasklog regardless of the task's result (failure or success)
and the tracing filtering.

Suggested-by: Friedrich Weber <f.weber at proxmox.com>
Signed-off-by: Gabriel Goller <g.goller at proxmox.com>
---
 proxmox-rest-server/src/worker_task.rs | 30 +++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/proxmox-rest-server/src/worker_task.rs b/proxmox-rest-server/src/worker_task.rs
index 6840938bdb2a..e036c54f78dd 100644
--- a/proxmox-rest-server/src/worker_task.rs
+++ b/proxmox-rest-server/src/worker_task.rs
@@ -921,7 +921,7 @@ impl WorkerTask {
         let res = setup.update_active_workers(Some(&upid));
         if res.is_err() {
             // needed to undo the insertion into WORKER_TASK_LIST above
-            worker.log_result(&res);
+            worker.log_result(&res, &upid.to_string());
             res?
         }
 
@@ -942,11 +942,14 @@ impl WorkerTask {
     {
         let (worker, logger) = WorkerTask::new(worker_type, worker_id, auth_id, to_stdout)?;
         let upid_str = worker.upid.to_string();
+        let inner_upid_str = upid_str.clone();
+        let inner_worker_type = worker_type.to_string();
         let f = f(worker.clone());
 
         tokio::spawn(LogContext::new(logger).scope(async move {
+            worker.log_start(&inner_upid_str, &inner_worker_type);
             let result = f.await;
-            worker.log_result(&result);
+            worker.log_result(&result, &inner_upid_str);
         }));
 
         Ok(upid_str)
@@ -965,12 +968,15 @@ impl WorkerTask {
     {
         let (worker, logger) = WorkerTask::new(worker_type, worker_id, auth_id, to_stdout)?;
         let upid_str = worker.upid.to_string();
+        let inner_upid_str = upid_str.clone();
+        let inner_worker_type = worker_type.to_string();
 
         let _child = std::thread::Builder::new()
             .name(upid_str.clone())
             .spawn(move || {
                 LogContext::new(logger).sync_scope(|| {
                     let worker1 = worker.clone();
+                    worker1.log_start(&inner_upid_str, &inner_worker_type);
 
                     let result = match std::panic::catch_unwind(move || f(worker1)) {
                         Ok(r) => r,
@@ -985,7 +991,7 @@ impl WorkerTask {
                         },
                     };
 
-                    worker.log_result(&result);
+                    worker.log_result(&result, &inner_upid_str);
                 });
             });
 
@@ -1016,8 +1022,22 @@ impl WorkerTask {
         }
     }
 
+    /// Log task start message
+    pub fn log_start(&self, upid: &str, worker_type: &str) {
+        // Write the result manually to the workertask file. We don't want to filter or process
+        // this message by the logging system. This also guarantees the start message will be in
+        // the file, regardless of the logging level.
+        match LogContext::current() {
+            Some(context) => {
+                context.log_unfiltered(&format!("TASK: starting {worker_type} task"));
+                eprintln!("TASK: starting {worker_type} task - {upid}");
+            }
+            None => error!("error writing task start to the tasklog"),
+        }
+    }
+
     /// Log task result, remove task from running list
-    pub fn log_result(&self, result: &Result<(), Error>) {
+    pub fn log_result(&self, result: &Result<(), Error>, upid: &str) {
         let state = self.create_state(result);
 
         // Write the result manually to the workertask file. We don't want to filter or process
@@ -1026,7 +1046,7 @@ impl WorkerTask {
         match LogContext::current() {
             Some(context) => {
                 context.log_unfiltered(&state.result_text());
-                eprintln!("{}", &state.result_text());
+                eprintln!("{} - {upid}", &state.result_text());
             }
             None => error!("error writing task result to the tasklog"),
         }
-- 
2.47.2