Test suite for directory logging functionality (#536)

Author: hoytak

.vscode/settings.json

@@ -1,5 +1,6 @@
 {
   "[rust]": {
     "editor.defaultFormatter": "rust-lang.rust-analyzer"
-  }
-}
+  },
+  "rust-analyzer.rustc.source": null
+}

Cargo.lock

@@ -26,3 +26,12 @@ console-subscriber = { version = "0.4.1", optional = true }
 [features]
 default = []
 tokio-console = ["dep:console-subscriber"]
+
+[[bin]]
+name = "log_test_executable"
+path = "tests/bin/log_test_executable.rs"
+
+[dev-dependencies]
+tempfile = "3.0"
+tokio = { version = "1.0", features = ["rt", "time"] }
+rand = { workspace = true }

xet_logging/Cargo.toml

@@ -3,4 +3,4 @@ mod constants;
 mod logging;
 
 pub use config::{LogDirConfig, LoggingConfig, LoggingMode};
-pub use logging::init;
+pub use logging::{init, wait_for_log_directory_cleanup};

xet_logging/src/lib.rs

@@ -1,7 +1,8 @@
 use std::ffi::OsStr;
 use std::io;
 use std::path::{Path, PathBuf};
-use std::sync::OnceLock;
+use std::sync::{Mutex, OnceLock};
+use std::thread::JoinHandle;
 use std::time::Duration;
 
 use chrono::{DateTime, FixedOffset, Local, Utc};
@@ -17,6 +18,19 @@ use utils::ByteSize;
 use crate::config::*;
 use crate::constants::{DEFAULT_LOG_LEVEL_CONSOLE, DEFAULT_LOG_LEVEL_FILE};
 
+/// Global variable to hold the JoinHandle for the log cleanup thread
+static LOG_CLEANUP_HANDLE: Mutex<Option<JoinHandle<()>>> = Mutex::new(None);
+
+/// Wait for the log directory cleanup to complete.
+/// This function blocks until the background cleanup thread finishes.
+pub fn wait_for_log_directory_cleanup() {
+    if let Ok(mut handle_opt) = LOG_CLEANUP_HANDLE.lock()
+        && let Some(handle) = handle_opt.take()
+    {
+        let _ = handle.join();
+    }
+}
+
 /// The main entry point to set up logging.  Should only be called once.
 pub fn init(cfg: LoggingConfig) {
     let mut dir_cleanup_task = None;
@@ -112,6 +126,7 @@ fn init_logging_to_file(path: &Path, use_json: bool) -> Result<(), std::io::Erro
     let _ = FILE_GUARD.set(guard); // ignore error if already initialised
 
     let registry = tracing_subscriber::registry();
+
     #[cfg(feature = "tokio-console")]
     let registry = {
         // Console subscriber layer for tokio-console, custom filter for tokio trace level events
@@ -189,11 +204,17 @@ struct CandidateLogFile {
 fn run_log_directory_cleanup_background(cfg: LogDirConfig, log_dir: &Path) {
     // Spawn run_log_directory_cleanup as background thread, logging any errors as a warn!
     let log_dir = log_dir.to_path_buf();
-    std::thread::spawn(move || {
+    let handle = std::thread::spawn(move || {
         if let Err(e) = run_log_directory_cleanup(cfg, &log_dir) {
             warn!("Error during log directory cleanup in {:?}: {}", log_dir, e);
         }
     });
+
+    // Store the JoinHandle in the global variable
+    if let Ok(mut handle_opt) = LOG_CLEANUP_HANDLE.lock() {
+        debug_assert!(handle_opt.is_none(), "Log directory cleanup called multiple times.");
+        *handle_opt = Some(handle);
+    }
 }
 
 fn run_log_directory_cleanup(cfg: LogDirConfig, log_dir: &Path) -> io::Result<()> {

xet_logging/src/logging.rs

@@ -0,0 +1,38 @@
+use std::env;
+use std::time::Duration;
+
+use tracing::info;
+use xet_logging::{LoggingConfig, LoggingMode};
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 3 {
+        eprintln!("Usage: {} <log_directory> <num_lines>", args[0]);
+        std::process::exit(1);
+    }
+
+    let log_directory = &args[1];
+    let num_lines: usize = args[2].parse().expect("num_lines must be a number");
+
+    // Initialize logging to the specified directory
+    let config = LoggingConfig {
+        logging_mode: LoggingMode::Directory(log_directory.into()),
+        use_json: true,
+        enable_log_dir_cleanup: true,
+        version: "test".to_string(),
+        log_dir_config: xet_logging::LogDirConfig::default(),
+    };
+
+    xet_logging::init(config);
+
+    // Generate log messages with 5ms delay between each
+    for i in 0..num_lines {
+        info!("Test log message number {} - this is a dummy log message for testing purposes", i + 1);
+
+        // Wait for 50 microseconds between each log message just to spread it out a little...
+        std::thread::sleep(Duration::from_micros(50));
+    }
+
+    // Wait for background cleanup to complete before exiting
+    xet_logging::wait_for_log_directory_cleanup();
+}