feat(lambda-rs-logging): Update log files to be kept open on flush

crates/lambda-rs-logging/src/handler.rs

@@ -1,7 +1,10 @@
 //! Log handling implementations for the logger.
 
 use std::{
-  fs::OpenOptions,
+  fs::{
+    File,
+    OpenOptions,
+  },
   io::{
     self,
     IsTerminal,
@@ -25,15 +28,21 @@ pub trait Handler: Send + Sync {
 /// A handler that logs to a file.
 #[derive(Debug)]
 pub struct FileHandler {
-  file: String,
   log_buffer: Mutex<Vec<String>>,
+  writer: Mutex<io::BufWriter<File>>,
 }
 
 impl FileHandler {
-  pub fn new(file: String) -> Self {
+  pub fn new(path: String) -> Self {
+    let log_file = OpenOptions::new()
+      .append(true)
+      .create(true)
+      .open(&path)
+      .expect("open log file");
+
     Self {
-      file,
       log_buffer: Mutex::new(Vec::new()),
+      writer: Mutex::new(io::BufWriter::new(log_file)),
     }
   }
 }
@@ -59,27 +68,30 @@ impl Handler for FileHandler {
       LogLevel::FATAL => format!("\x1B[31;1m{}\x1B[0m", log_message),
     };
 
-    let mut buf = self.log_buffer.lock().unwrap();
-    buf.push(colored_message);
+    let mut buffer = match self.log_buffer.lock() {
+      Ok(guard) => guard,
+      Err(poisoned) => poisoned.into_inner(),
+    };
+    buffer.push(colored_message);
 
     // Flush buffer every ten messages.
-    if buf.len() < 10 {
+    if buffer.len() < 10 {
       return;
     }
 
-    let log_message = buf.join("\n");
+    let messages = std::mem::take(&mut *buffer);
+    drop(buffer);
 
-    let mut file = OpenOptions::new()
-      .append(true)
-      .create(true)
-      .open(self.file.clone())
-      .unwrap();
+    let log_message = messages.join("\n");
 
-    file
+    let mut writer = match self.writer.lock() {
+      Ok(guard) => guard,
+      Err(poisoned) => poisoned.into_inner(),
+    };
+    writer
       .write_all(log_message.as_bytes())
       .expect("Unable to write data");
-
-    buf.clear();
+    let _ = writer.flush();
   }
 }
 

crates/lambda-rs-logging/src/lib.rs

@@ -502,6 +502,51 @@ mod tests {
     assert!(!content.is_empty());
   }
 
+  #[test]
+  #[cfg(unix)]
+  fn file_handler_does_not_reopen_between_flushes() {
+    use std::{
+      fs,
+      time::UNIX_EPOCH,
+    };
+
+    let tmp = std::env::temp_dir();
+    let base = format!(
+      "lambda_logging_persist_{}_{}",
+      std::process::id(),
+      SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos()
+    );
+    let original = tmp.join(format!("{}.log", base));
+    let moved = tmp.join(format!("{}_moved.log", base));
+
+    let logger = Logger::new(LogLevel::TRACE, "file_reopen");
+    logger.add_handler(Box::new(crate::handler::FileHandler::new(
+      original.to_string_lossy().to_string(),
+    )));
+
+    for i in 0..10 {
+      logger.info(format!("batch1_line{}", i));
+    }
+
+    fs::rename(&original, &moved).expect("rename log file while handler lives");
+
+    for i in 0..10 {
+      logger.info(format!("batch2_line{}", i));
+    }
+
+    assert!(
+      !original.exists(),
+      "handler should not reopen and recreate the original path"
+    );
+
+    let content = fs::read_to_string(&moved).expect("moved file must exist");
+    assert!(content.contains("batch1_line0"));
+    assert!(content.contains("batch2_line0"));
+  }
+
   #[test]
   fn macro_early_guard_avoids_formatting() {
     // Ensure TRACE is disabled by setting level to INFO.