use crate::config::{Compression, Rotation, RotationConfig, Timezone};
use crate::rolling_writer::RollingWriter;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::sync::{
Arc,
atomic::{AtomicU8, Ordering},
};
pub struct LogWriterBuilder {
path: PathBuf,
config: RotationConfig,
level: log::LevelFilter,
}
impl LogWriterBuilder {
pub fn new<P: AsRef<Path>>(path: P) -> Self {
Self {
path: path.as_ref().to_path_buf(),
config: RotationConfig::default(),
level: log::LevelFilter::Info,
}
}
pub fn rotation(mut self, rotation: Rotation) -> Self {
self.config.rotation = rotation;
self
}
pub fn max_file_size(mut self, size: u64) -> Self {
self.config.max_file_size = Some(size);
self
}
pub fn max_files(mut self, max: usize) -> Self {
self.config.max_files = Some(max);
self
}
pub fn compression(mut self, compression: Compression) -> Self {
self.config.compression = compression;
self
}
pub fn timezone(mut self, timezone: Timezone) -> Self {
self.config.timezone = timezone;
self
}
pub fn level(mut self, level: log::LevelFilter) -> Self {
self.level = level;
self
}
pub fn init(self) -> io::Result<LogHandle> {
self::init(self.build()?)
}
pub fn build(self) -> io::Result<LogWriter> {
let mut builder = RollingWriter::builder(&self.path)
.rotation(self.config.rotation)
.compression(self.config.compression)
.timezone(self.config.timezone);
if let Some(size) = self.config.max_file_size {
builder = builder.max_file_size(size);
}
if let Some(max) = self.config.max_files {
builder = builder.max_files(max);
}
let rolling = builder.build()?;
let level = Arc::new(AtomicU8::new(level_to_u8(self.level)));
Ok(LogWriter {
writer: rolling,
level,
timezone: self.config.timezone,
})
}
}
fn level_to_u8(level: log::LevelFilter) -> u8 {
match level {
log::LevelFilter::Trace => 0,
log::LevelFilter::Debug => 1,
log::LevelFilter::Info => 2,
log::LevelFilter::Warn => 3,
log::LevelFilter::Error => 4,
log::LevelFilter::Off => 5,
}
}
fn u8_to_level(val: u8) -> log::LevelFilter {
match val {
0 => log::LevelFilter::Trace,
1 => log::LevelFilter::Debug,
2 => log::LevelFilter::Info,
3 => log::LevelFilter::Warn,
4 => log::LevelFilter::Error,
_ => log::LevelFilter::Off,
}
}
pub struct LogWriter {
writer: RollingWriter,
level: Arc<AtomicU8>,
timezone: Timezone,
}
impl LogWriter {
pub fn builder<P: AsRef<Path>>(path: P) -> LogWriterBuilder {
LogWriterBuilder::new(path)
}
pub fn handle(&self) -> LogHandle {
LogHandle {
level: self.level.clone(),
}
}
pub fn max_level(&self) -> log::LevelFilter {
u8_to_level(self.level.load(Ordering::Relaxed))
}
}
impl log::Log for LogWriter {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
metadata.level() <= u8_to_level(self.level.load(Ordering::Relaxed))
}
fn log(&self, record: &log::Record<'_>) {
if !self.enabled(record.metadata()) {
return;
}
let level = match record.level() {
log::Level::Error => "ERROR",
log::Level::Warn => " WARN",
log::Level::Info => " INFO",
log::Level::Debug => "DEBUG",
log::Level::Trace => "TRACE",
};
let timestamp = self.timezone.now().format("%Y-%m-%dT%H:%M:%S%.6f");
let line = format!(
"{} {} {} {}\n",
timestamp,
level,
record.target(),
record.args(),
);
let _ = (&self.writer).write_all(line.as_bytes());
}
fn flush(&self) {
let _ = (&self.writer).flush();
}
}
#[derive(Clone)]
pub struct LogHandle {
level: Arc<AtomicU8>,
}
impl LogHandle {
pub fn set_level(&self, level: log::LevelFilter) {
self.level.store(level_to_u8(level), Ordering::Relaxed);
}
pub fn get_level(&self) -> log::LevelFilter {
u8_to_level(self.level.load(Ordering::Relaxed))
}
}
pub(crate) fn init(writer: LogWriter) -> io::Result<LogHandle> {
let initial_level = writer.max_level();
let level = writer.level.clone();
let boxed = Box::new(writer);
log::set_max_level(initial_level);
log::set_boxed_logger(boxed).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
level.store(level_to_u8(initial_level), Ordering::Relaxed);
Ok(LogHandle { level })
}
#[cfg(test)]
mod tests {
use super::*;
use log::Log;
use tempfile::tempdir;
#[test]
fn test_log_writer_builder() -> Result<(), Box<dyn std::error::Error>> {
let dir = tempdir().unwrap();
let path = dir.path().join("test.log");
let writer = LogWriterBuilder::new(&path)
.rotation(Rotation::Never)
.max_file_size(1024)
.max_files(3)
.level(log::LevelFilter::Debug)
.build()?;
assert_eq!(writer.max_level(), log::LevelFilter::Debug);
let handle = writer.handle();
handle.set_level(log::LevelFilter::Trace);
assert_eq!(handle.get_level(), log::LevelFilter::Trace);
Ok(())
}
#[test]
fn test_log_writer_log_trait() -> Result<(), Box<dyn std::error::Error>> {
let dir = tempdir().unwrap();
let path = dir.path().join("test.log");
let writer = LogWriterBuilder::new(&path)
.rotation(Rotation::Never)
.level(log::LevelFilter::Info)
.build()?;
assert!(
writer.enabled(
&log::Record::builder()
.level(log::Level::Info)
.target("test")
.build()
.metadata()
)
);
assert!(
!writer.enabled(
&log::Record::builder()
.level(log::Level::Debug)
.target("test")
.build()
.metadata()
)
);
let handle = writer.handle();
handle.set_level(log::LevelFilter::Debug);
assert!(
writer.enabled(
&log::Record::builder()
.level(log::Level::Debug)
.target("test")
.build()
.metadata()
)
);
Ok(())
}
#[test]
fn test_log_handle_is_clone_send_sync() -> Result<(), Box<dyn std::error::Error>> {
let dir = tempdir().unwrap();
let path = dir.path().join("test.log");
let writer = LogWriterBuilder::new(&path)
.rotation(Rotation::Never)
.level(log::LevelFilter::Info)
.build()?;
let handle = writer.handle();
let handle2 = handle.clone();
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
assert_send::<LogHandle>();
assert_sync::<LogHandle>();
handle2.set_level(log::LevelFilter::Debug);
assert_eq!(handle.get_level(), log::LevelFilter::Debug);
Ok(())
}
}