async_rawlogger/

lib.rs

use async_channel::{Receiver, Sender, bounded, unbounded};
pub use log::{
    Level, LevelFilter, Record, debug, error, info, log, log_enabled, logger, trace, warn,
};
use log::{Log, Metadata, SetLoggerError, set_boxed_logger, set_max_level};
use logmsg::LogMsg;
use std::{
    borrow::Cow,
    // fmt::Display,
    io::Error as IoError,
    sync::atomic::{AtomicBool, Ordering},
};
mod logmsg;

enum LoggerInput {
    LogMsg(LogMsg),
    Flush,
}

enum LoggerOutput {
    Flushed,
}

/// A guard that flushes logs associated to a Logger on a drop
///
/// With this guard, you can ensure all logs are written to destination
/// when the application exits.
pub struct LoggerGuard {
    queue: Sender<LoggerInput>,
    notification: Receiver<LoggerOutput>,
}

impl Drop for LoggerGuard {
    fn drop(&mut self) {
        let _ = self.queue.send_blocking(LoggerInput::Flush);
        let _ = self.notification.recv_blocking();
    }
}

/// Global logger
pub struct Logger {
    level: LevelFilter,
    queue: Sender<LoggerInput>,
    notification: Receiver<LoggerOutput>,
    stopped: AtomicBool,
}

impl Logger {
    pub fn init(self) -> Result<LoggerGuard, SetLoggerError> {
        let guard = LoggerGuard {
            queue: self.queue.clone(),
            notification: self.notification.clone(),
        };

        set_max_level(self.level);
        let boxed = Box::new(self);
        set_boxed_logger(boxed).map(|_| guard)
    }
}

impl Log for Logger {
    #[inline]
    fn enabled(
        &self,
        metadata: &Metadata,
    ) -> bool {
        self.level >= metadata.level()
    }

    fn log(
        &self,
        record: &Record,
    ) {
        let msg = LogMsg {
            time: std::time::SystemTime::now(),
            level: record.level(),
            file: record
                .file_static()
                .map(Cow::Borrowed)
                .or_else(|| record.file().map(|s| Cow::Owned(s.to_owned())))
                .unwrap_or(Cow::Borrowed("")),
            line: record.line(),
            args: record
                .args()
                .as_str()
                .map(Cow::Borrowed)
                .unwrap_or_else(|| Cow::Owned(record.args().to_string())),
        };

        match self.queue.try_send(LoggerInput::LogMsg(msg)) {
            Err(async_channel::TrySendError::Full(_)) => {}
            Err(async_channel::TrySendError::Closed(_)) => {
                let stop = self.stopped.load(Ordering::SeqCst);
                if !stop {
                    eprintln!("logger queue closed when logging, this is a bug");
                    self.stopped.store(true, Ordering::SeqCst);
                }
            }
            Ok(_) => {}
        }
    }

    fn flush(&self) {
        let _ = self
            .queue
            .send_blocking(LoggerInput::Flush)
            .map_err(|e| eprintln!("logger queue closed when flushing, this is a bug: {e}"));
    }
}

struct BoundedChannelOption {
    size: usize,
}

pub struct Builder {
    level: Option<LevelFilter>,
    root_level: Option<LevelFilter>,
    bounded_channel_option: Option<BoundedChannelOption>,
}

/// Handy function to get ftlog builder
#[inline]
pub fn builder() -> Builder {
    Builder::new()
}

impl Builder {
    #[inline]
    /// Create a ftlog builder with default settings:
    /// - global log level: INFO
    /// - root log level: INFO
    /// - bounded channel between worker thread and log thread, with a size limit of 100_000
    /// - discard excessive log messages
    pub fn new() -> Builder {
        Builder {
            level: None,
            root_level: None,
            bounded_channel_option: Some(BoundedChannelOption { size: 100_000 }),
        }
    }

    /// Set channel size to unbound
    ///
    /// **ATTENTION**: too much log message will lead to huge memory consumption,
    /// as log messages are queued to be handled by log thread.
    /// When log message exceed the current channel size, it will double the size by default,
    /// Since channel expansion asks for memory allocation, log calls can be slow down.
    #[inline]
    pub fn unbounded(mut self) -> Builder {
        self.bounded_channel_option = None;
        self
    }

    #[inline]
    /// Set max log level
    ///
    /// Logs with level more verbose than this will not be sent to log thread.
    pub fn max_log_level(
        mut self,
        level: LevelFilter,
    ) -> Builder {
        self.level = Some(level);
        self
    }

    #[inline]
    /// Set max log level
    ///
    /// Logs with level more verbose than this will not be sent to log thread.
    pub fn root_log_level(
        mut self,
        level: LevelFilter,
    ) -> Builder {
        self.root_level = Some(level);
        self
    }

    /// Finish building ftlog logger
    ///
    /// The call spawns a log thread to formatting log message into string,
    /// and write to output target.
    pub fn build(self) -> Result<Logger, IoError> {
        let global_level = self.level.unwrap_or(LevelFilter::Info);
        let root_level = self.root_level.unwrap_or(global_level);
        if global_level < root_level {
            warn!("Logs with level more verbose than {global_level} will be ignored");
        }

        let (queue, rx) = match self.bounded_channel_option {
            Some(BoundedChannelOption { size }) => bounded(size),
            None => unbounded(),
        };

        let (notification_tx, notification) = bounded(1);

        std::thread::spawn(move || {
            let mut batch = Vec::with_capacity(100);
            let mut last_flush = std::time::Instant::now();
            let batch_timeout = std::time::Duration::from_millis(100);

            while let Ok(msg) = rx.recv_blocking() {
                match msg {
                    LoggerInput::LogMsg(msg) => {
                        batch.push(msg);
                        if batch.len() >= 100 || last_flush.elapsed() > batch_timeout {
                            for msg in batch.drain(..) {
                                msg.write();
                            }
                            last_flush = std::time::Instant::now();
                        }
                    }
                    LoggerInput::Flush => {
                        for msg in batch.drain(..) {
                            msg.write();
                        }
                        let _ = notification_tx.send_blocking(LoggerOutput::Flushed);
                    }
                }
            }
        });

        Ok(Logger {
            level: global_level,
            queue,
            notification,
            stopped: AtomicBool::new(false),
        })
    }

    /// Try building and setting as global logger
    pub fn try_init(self) -> Result<LoggerGuard, Box<dyn std::error::Error>> {
        let logger = self.build()?;
        Ok(logger.init()?)
    }
}

impl Default for Builder {
    #[inline]
    fn default() -> Self {
        Builder::new()
    }
}