use chrono::Local;
use log::{LevelFilter, Metadata, Record};
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
type LogFileSink = Arc<Mutex<File>>;
pub struct MoonLogger {
global_sink: Option<LogFileSink>,
core_sink: Option<LogFileSink>,
api_sink: Option<LogFileSink>,
default_level: LevelFilter,
}
impl MoonLogger {
fn open_log_file(path: &Path) -> std::io::Result<File> {
if let Some(parent) = path.parent() {
if !parent.exists() {
std::fs::create_dir_all(parent)?;
}
}
OpenOptions::new()
.create(true)
.write(true)
.append(true)
.open(path)
}
fn write_to_sink(sink: &LogFileSink, message: &str) {
let mut file = sink.lock().unwrap_or_else(|e| e.into_inner());
let _ = writeln!(file, "{}", message);
let _ = file.flush();
}
}
impl log::Log for MoonLogger {
fn enabled(&self, metadata: &Metadata) -> bool {
metadata.level() <= self.default_level
}
fn log(&self, record: &Record) {
if !self.enabled(record.metadata()) {
return;
}
let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
let level = record.level();
let target = record.target();
let args = record.args();
let log_line = format!("[{}] [{:<5}] [{}] {}", timestamp, level, target, args);
println!("{}", log_line);
if let Some(global) = &self.global_sink {
Self::write_to_sink(global, &log_line);
}
if self.core_sink.is_some() || self.api_sink.is_some() {
if target.starts_with("moonclient") {
if let Some(core) = &self.core_sink {
Self::write_to_sink(core, &log_line);
}
} else {
if let Some(api) = &self.api_sink {
Self::write_to_sink(api, &log_line);
}
}
}
}
fn flush(&self) {
if let Some(global) = &self.global_sink {
let mut file = global.lock().unwrap_or_else(|e| e.into_inner());
let _ = file.flush();
}
if let Some(core) = &self.core_sink {
let mut file = core.lock().unwrap_or_else(|e| e.into_inner());
let _ = file.flush();
}
if let Some(api) = &self.api_sink {
let mut file = api.lock().unwrap_or_else(|e| e.into_inner());
let _ = file.flush();
}
}
}
pub struct MoonLoggerBuilder {
global_path: Option<PathBuf>,
core_path: Option<PathBuf>,
api_path: Option<PathBuf>,
default_level: LevelFilter,
}
impl MoonLoggerBuilder {
pub fn new() -> Self {
Self {
global_path: None,
core_path: None,
api_path: None,
default_level: LevelFilter::Info,
}
}
pub fn with_level(mut self, level: LevelFilter) -> Self {
self.default_level = level;
self
}
pub fn with_global_file(mut self, path: impl Into<PathBuf>) -> Self {
self.global_path = Some(path.into());
self
}
pub fn with_split_files(
mut self,
core_path: impl Into<PathBuf>,
api_path: impl Into<PathBuf>,
) -> Self {
self.core_path = Some(core_path.into());
self.api_path = Some(api_path.into());
self
}
pub fn setup(self) -> Result<(), Box<dyn std::error::Error>> {
let global_sink = match self.global_path {
Some(path) => {
let file = MoonLogger::open_log_file(&path)?;
Some(Arc::new(Mutex::new(file)))
}
None => None,
};
let core_sink = match self.core_path {
Some(path) => {
let file = MoonLogger::open_log_file(&path)?;
Some(Arc::new(Mutex::new(file)))
}
None => None,
};
let api_sink = match self.api_path {
Some(path) => {
let file = MoonLogger::open_log_file(&path)?;
Some(Arc::new(Mutex::new(file)))
}
None => None,
};
let logger = MoonLogger {
global_sink,
core_sink,
api_sink,
default_level: self.default_level,
};
log::set_boxed_logger(Box::new(logger))?;
log::set_max_level(self.default_level);
Ok(())
}
}
pub fn init() -> MoonLoggerBuilder {
MoonLoggerBuilder::new()
}