log, rest-server: worker_task: add log_unfiltered

To write result message manually, bypassing tracing.

The workertasks currently get their status from parsing the log
messages in the task-log file. The problem is that if these messages are
filtered – which is now possible using the PBS_LOG env variable – some
workertasks will end up with a "stopped: unknown" status. This is not
desirable so write the message manually to the workertask file and
bypass tracing.

This way we are guaranteed that, regardless of the max logging level the
user sets, the final message (and status) is written.

Signed-off-by: Gabriel Goller <g.goller@proxmox.com>

proxmox-log/src/lib.rs

@@ -98,6 +98,15 @@ impl LogContext {
     pub fn state(&self) -> &Arc<Mutex<FileLogState>> {
         &self.logger
     }
+
+    /// Log directly to the underlying FileLogger, without going through tracing.
+    ///
+    /// Using this function we can guarantee that a log message will be in the tasklog file,
+    /// regardless of the tracing layers/filters.
+    pub fn log_unfiltered(&self, msg: &str) {
+        let mut logger = self.logger.lock().unwrap();
+        logger.logger.log(msg);
+    }
 }
 
 fn journald_or_stderr_layer<S>() -> Box<dyn tracing_subscriber::Layer<S> + Send + Sync>
@@ -172,3 +181,4 @@ pub fn init_cli_logger(
         .tasklog_pbs()
         .init()
 }
+

proxmox-rest-server/src/worker_task.rs

@@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tokio::signal::unix::SignalKind;
 use tokio::sync::{oneshot, watch};
-use tracing::{info, warn};
+use tracing::{error, info, warn};
 
 use proxmox_daemon::command_socket::CommandSocket;
 use proxmox_lang::try_block;
@@ -1019,7 +1019,19 @@ impl WorkerTask {
     /// Log task result, remove task from running list
     pub fn log_result(&self, result: &Result<(), Error>) {
         let state = self.create_state(result);
-        self.log_message(state.result_text());
+
+        // 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 result message will be in
+        // the file, regardless of the logging level.
+        match LogContext::current() {
+            Some(context) => {
+                context.log_unfiltered(&state.result_text());
+                if result.is_err() {
+                    eprintln!("{}", &state.result_text());
+                }
+            },
+            None => error!("error writing task result to the tasklog"),
+        }
 
         WORKER_TASK_LIST.lock().unwrap().remove(&self.upid.task_id);
         // this wants to access WORKER_TASK_LIST, so we need to drop the lock above