use crate::handle;
use std::io::{self, Write};
use std::sync::Arc;
#[cfg(feature = "console")]
use colored::Colorize;
pub use handle::LogHandle;
pub struct ConsoleWriterBuilder {
level: log::LevelFilter,
timezone: crate::config::Timezone,
}
impl ConsoleWriterBuilder {
pub fn new() -> Self {
Self {
level: log::LevelFilter::Info,
timezone: crate::config::Timezone::Utc,
}
}
pub fn level(mut self, level: log::LevelFilter) -> Self {
self.level = level;
self
}
pub fn timezone(mut self, timezone: crate::config::Timezone) -> Self {
self.timezone = timezone;
self
}
pub fn build(self) -> io::Result<ConsoleWriter> {
let level = Arc::new(std::sync::atomic::AtomicU8::new(
handle::level_to_u8(self.level),
));
Ok(ConsoleWriter {
level,
timezone: self.timezone,
})
}
}
impl Default for ConsoleWriterBuilder {
fn default() -> Self {
Self::new()
}
}
pub struct ConsoleWriter {
level: Arc<std::sync::atomic::AtomicU8>,
timezone: crate::config::Timezone,
}
impl ConsoleWriter {
pub fn builder() -> ConsoleWriterBuilder {
ConsoleWriterBuilder::new()
}
pub fn handle(&self) -> LogHandle {
LogHandle {
level: self.level.clone(),
}
}
pub fn max_level(&self) -> log::LevelFilter {
handle::u8_to_level(self.level.load(std::sync::atomic::Ordering::Relaxed))
}
}
impl log::Log for ConsoleWriter {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
metadata.level()
<= handle::u8_to_level(self.level.load(std::sync::atomic::Ordering::Relaxed))
}
fn log(&self, record: &log::Record<'_>) {
if !self.enabled(record.metadata()) {
return;
}
#[cfg(feature = "console")]
let line = {
let timestamp = self
.timezone
.now()
.to_rfc3339_opts(chrono::SecondsFormat::Micros, true);
let level_str = match record.level() {
log::Level::Error => "ERROR".bold().red().to_string(),
log::Level::Warn => " WARN".yellow().to_string(),
log::Level::Info => " INFO".green().to_string(),
log::Level::Debug => "DEBUG".cyan().to_string(),
log::Level::Trace => "TRACE".bright_black().to_string(),
};
format!(
"{} {} {} {}\n",
timestamp.dimmed(),
level_str,
record.target().italic(),
record.args(),
)
};
#[cfg(not(feature = "console"))]
let line = {
let timestamp = self
.timezone
.now()
.to_rfc3339_opts(chrono::SecondsFormat::Micros, true);
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",
};
format!(
"{} {} {} {}\n",
timestamp,
level,
record.target(),
record.args(),
)
};
let result = match record.level() {
log::Level::Error | log::Level::Warn => {
let stderr = io::stderr();
let mut handle = stderr.lock();
handle.write_all(line.as_bytes()).and_then(|_| handle.flush())
}
_ => {
let stdout = io::stdout();
let mut handle = stdout.lock();
handle.write_all(line.as_bytes()).and_then(|_| handle.flush())
}
};
let _ = result;
}
fn flush(&self) {
let _ = io::stdout().flush();
let _ = io::stderr().flush();
}
}
pub fn init(writer: ConsoleWriter) -> 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(
handle::level_to_u8(initial_level),
std::sync::atomic::Ordering::Relaxed,
);
Ok(LogHandle { level })
}
impl ConsoleWriterBuilder {
pub fn init(self) -> io::Result<LogHandle> {
init(self.build()?)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_builder_defaults() {
let builder = ConsoleWriterBuilder::new();
let writer = builder.build().unwrap();
assert_eq!(writer.max_level(), log::LevelFilter::Info);
}
#[test]
fn test_custom_level() {
let builder = ConsoleWriterBuilder::new().level(log::LevelFilter::Debug);
let writer = builder.build().unwrap();
assert_eq!(writer.max_level(), log::LevelFilter::Debug);
}
#[test]
fn test_handle_clone_send_sync() {
let builder = ConsoleWriterBuilder::new().level(log::LevelFilter::Info);
let writer = builder.build().unwrap();
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);
}
}