290 lines · 9.0 KB · Rust
RawDownload
use std::{    fs,    io::{self, Write},    path::PathBuf,    sync::{        Mutex, OnceLock,        atomic::{AtomicU64, Ordering},    },}; use crate::{SCOPE_STRING_SEP_CHAR, Scope}; // ANSI color escape codes for log levelsconst ANSI_RESET: &str = "\x1b[0m";const ANSI_BOLD: &str = "\x1b[1m";const ANSI_RED: &str = "\x1b[31m";const ANSI_YELLOW: &str = "\x1b[33m";const ANSI_GREEN: &str = "\x1b[32m";const ANSI_BLUE: &str = "\x1b[34m";const ANSI_MAGENTA: &str = "\x1b[35m"; /// Whether stdout output is enabled.static mut ENABLED_SINKS_STDOUT: bool = false; /// Is Some(file) if file output is enabled.static ENABLED_SINKS_FILE: Mutex<Option<std::fs::File>> = Mutex::new(None);static SINK_FILE_PATH: OnceLock<&'static PathBuf> = OnceLock::new();static SINK_FILE_PATH_ROTATE: OnceLock<&'static PathBuf> = OnceLock::new();/// Atomic counter for the size of the log file in bytes.// TODO: make non-atomic if writing single threadedstatic SINK_FILE_SIZE_BYTES: AtomicU64 = AtomicU64::new(0);/// Maximum size of the log file before it will be rotated, in bytes.const SINK_FILE_SIZE_BYTES_MAX: u64 = 1024 * 1024; // 1 MB pub struct Record<'a> {    pub scope: Scope,    pub level: log::Level,    pub message: &'a std::fmt::Arguments<'a>,    pub module_path: Option<&'a str>,} pub fn init_output_stdout() {    unsafe {        ENABLED_SINKS_STDOUT = true;    }} pub fn init_output_file(    path: &'static PathBuf,    path_rotate: Option<&'static PathBuf>,) -> io::Result<()> {    let mut file = std::fs::OpenOptions::new()        .create(true)        .append(true)        .open(path)?;     SINK_FILE_PATH        .set(path)        .expect("Init file output should only be called once");    if let Some(path_rotate) = path_rotate {        SINK_FILE_PATH_ROTATE            .set(path_rotate)            .expect("Init file output should only be called once");    }     let mut enabled_sinks_file = ENABLED_SINKS_FILE        .try_lock()        .expect("Log file lock is available during init");     let size_bytes = file.metadata().map_or(0, |metadata| metadata.len());    if size_bytes >= SINK_FILE_SIZE_BYTES_MAX {        rotate_log_file(&mut file, Some(path), path_rotate, &SINK_FILE_SIZE_BYTES);    } else {        SINK_FILE_SIZE_BYTES.store(size_bytes, Ordering::Relaxed);    }     *enabled_sinks_file = Some(file);     Ok(())} const LEVEL_OUTPUT_STRINGS: [&str; 6] = [    "     ", // nop: ERROR = 1    "ERROR", //    "WARN ", //    "INFO ", //    "DEBUG", //    "TRACE", //]; // Colors for different log levelsstatic LEVEL_ANSI_COLORS: [&str; 6] = [    "",           // nop    ANSI_RED,     // Error: Red    ANSI_YELLOW,  // Warn: Yellow    ANSI_GREEN,   // Info: Green    ANSI_BLUE,    // Debug: Blue    ANSI_MAGENTA, // Trace: Magenta]; // PERF: batchingpub fn submit(record: Record) {    if unsafe { ENABLED_SINKS_STDOUT } {        let mut stdout = std::io::stdout().lock();        _ = writeln!(            &mut stdout,            "{} {ANSI_BOLD}{}{}{ANSI_RESET} {} {}",            chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%:z"),            LEVEL_ANSI_COLORS[record.level as usize],            LEVEL_OUTPUT_STRINGS[record.level as usize],            SourceFmt {                scope: record.scope,                module_path: record.module_path,                ansi: true,            },            record.message        );    }    let mut file = ENABLED_SINKS_FILE.lock().unwrap_or_else(|handle| {        ENABLED_SINKS_FILE.clear_poison();        handle.into_inner()    });    if let Some(file) = file.as_mut() {        struct SizedWriter<'a> {            file: &'a mut std::fs::File,            written: u64,        }        impl io::Write for SizedWriter<'_> {            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {                self.file.write(buf)?;                self.written += buf.len() as u64;                Ok(buf.len())            }             fn flush(&mut self) -> io::Result<()> {                self.file.flush()            }        }        let file_size_bytes = {            let mut writer = SizedWriter { file, written: 0 };            _ = writeln!(                &mut writer,                "{} {} {} {}",                chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%:z"),                LEVEL_OUTPUT_STRINGS[record.level as usize],                SourceFmt {                    scope: record.scope,                    module_path: record.module_path,                    ansi: false,                },                record.message            );            SINK_FILE_SIZE_BYTES.fetch_add(writer.written, Ordering::Relaxed) + writer.written        };        if file_size_bytes > SINK_FILE_SIZE_BYTES_MAX {            rotate_log_file(                file,                SINK_FILE_PATH.get(),                SINK_FILE_PATH_ROTATE.get(),                &SINK_FILE_SIZE_BYTES,            );        }    }} pub fn flush() {    if unsafe { ENABLED_SINKS_STDOUT } {        _ = std::io::stdout().lock().flush();    }    let mut file = ENABLED_SINKS_FILE.lock().unwrap_or_else(|handle| {        ENABLED_SINKS_FILE.clear_poison();        handle.into_inner()    });    if let Some(file) = file.as_mut() {        if let Err(err) = file.flush() {            eprintln!("Failed to flush log file: {}", err);        }    }} struct SourceFmt<'a> {    scope: Scope,    module_path: Option<&'a str>,    ansi: bool,} impl std::fmt::Display for SourceFmt<'_> {    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {        use std::fmt::Write;        f.write_char('[')?;        if self.ansi {            f.write_str(ANSI_BOLD)?;        }        // NOTE: if no longer prefixing scopes with their crate name, check if scope[0] is empty        if (self.scope[1].is_empty() && self.module_path.is_some()) || self.scope[0].is_empty() {            f.write_str(self.module_path.unwrap_or("?"))?;        } else {            f.write_str(self.scope[0])?;            for subscope in &self.scope[1..] {                if subscope.is_empty() {                    break;                }                f.write_char(SCOPE_STRING_SEP_CHAR)?;                f.write_str(subscope)?;            }        }        if self.ansi {            f.write_str(ANSI_RESET)?;        }        f.write_char(']')?;        Ok(())    }} fn rotate_log_file<PathRef>(    file: &mut fs::File,    path: Option<PathRef>,    path_rotate: Option<PathRef>,    atomic_size: &AtomicU64,) where    PathRef: AsRef<std::path::Path>,{    if let Err(err) = file.flush() {        eprintln!(            "Failed to flush log file before rotating, some logs may be lost: {}",            err        );    }    let rotation_error = match (path, path_rotate) {        (Some(_), None) => Some(anyhow::anyhow!("No rotation log file path configured")),        (None, _) => Some(anyhow::anyhow!("No log file path configured")),        (Some(path), Some(path_rotate)) => fs::copy(path, path_rotate)            .err()            .map(|err| anyhow::anyhow!(err)),    };    if let Some(err) = rotation_error {        eprintln!("Log file rotation failed. Truncating log file anyways: {err}",);    }    _ = file.set_len(0);     // SAFETY: It is safe to set size to 0 even if set_len fails as    // according to the documentation, it only fails if:    // - the file is not writeable: should never happen,    // - the size would cause an overflow (implementation specific): 0 should never cause an overflow    atomic_size.store(0, Ordering::Relaxed);} #[cfg(test)]mod tests {    use super::*;     #[test]    fn test_rotate_log_file() {        let temp_dir = tempfile::tempdir().unwrap();        let log_file_path = temp_dir.path().join("log.txt");        let rotation_log_file_path = temp_dir.path().join("log_rotated.txt");         let mut file = fs::File::create(&log_file_path).unwrap();        let contents = String::from("Hello, world!");        file.write_all(contents.as_bytes()).unwrap();         let size = AtomicU64::new(contents.len() as u64);         rotate_log_file(            &mut file,            Some(&log_file_path),            Some(&rotation_log_file_path),            &size,        );         assert!(log_file_path.exists());        assert_eq!(log_file_path.metadata().unwrap().len(), 0);        assert!(rotation_log_file_path.exists());        assert_eq!(            std::fs::read_to_string(&rotation_log_file_path).unwrap(),            contents,        );        assert_eq!(size.load(Ordering::Relaxed), 0);    }     /// Regression test, ensuring that if log level values change we are made aware    #[test]    fn test_log_level_names() {        assert_eq!(LEVEL_OUTPUT_STRINGS[log::Level::Error as usize], "ERROR");        assert_eq!(LEVEL_OUTPUT_STRINGS[log::Level::Warn as usize], "WARN ");        assert_eq!(LEVEL_OUTPUT_STRINGS[log::Level::Info as usize], "INFO ");        assert_eq!(LEVEL_OUTPUT_STRINGS[log::Level::Debug as usize], "DEBUG");        assert_eq!(LEVEL_OUTPUT_STRINGS[log::Level::Trace as usize], "TRACE");    }}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t