use std::{ collections::VecDeque, fmt, path::PathBuf, str::FromStr as _, sync::{ OnceLock, atomic::{AtomicU64, AtomicUsize, Ordering}, }, time::Duration, }; use anyhow::{Result, bail}; use flexi_logger::{ Cleanup, Criterion, DeferredNow, FileSpec, Naming, writers::{FileLogWriter, FileLogWriterBuilder, LogWriter as _}, }; use log::{Level, LevelFilter, Record}; use parking_lot::RwLock; use tracing_estuary::Pipeline; #[derive(Debug, PartialEq, Eq)] pub enum Type { Cmd, Core, Config, Setup, System, SystemSignal, Service, Hotkey, Window, Tray, Timer, Frontend, Backup, File, Lightweight, Network, ProxyMode, Validate, ClashVergeRev, } impl fmt::Display for Type { #[inline] fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Cmd => write!(f, "[Cmd]"), Self::Core => write!(f, "[Core]"), Self::Config => write!(f, "[Config]"), Self::Setup => write!(f, "[Setup]"), Self::System => write!(f, "[System]"), Self::SystemSignal => write!(f, "[SysSignal]"), Self::Service => write!(f, "[Service]"), Self::Hotkey => write!(f, "[Hotkey]"), Self::Window => write!(f, "[Window]"), Self::Tray => write!(f, "[Tray]"), Self::Timer => write!(f, "[Timer]"), Self::Frontend => write!(f, "[Frontend]"), Self::Backup => write!(f, "[Backup]"), Self::File => write!(f, "[File]"), Self::Lightweight => write!(f, "[Lightweight]"), Self::Network => write!(f, "[Network]"), Self::ProxyMode => write!(f, "[ProxMode]"), Self::Validate => write!(f, "[Validate]"), Self::ClashVergeRev => write!(f, "[ClashVergeRev]"), } } } #[macro_export] macro_rules! logging { ($level:ident, $type:expr, $($arg:tt)*) => { log::$level!(target: "app", "{} {}", $type, format_args!($($arg)*)) }; } #[macro_export] macro_rules! logging_error { ($type:expr, $expr:expr) => { if let Err(err) = $expr { log::error!(target: "app", "[{}] {}", $type, err); } }; ($type:expr, $fmt:literal $(, $arg:expr)*) => { log::error!(target: "app", "[{}] {}", $type, format_args!($fmt $(, $arg)*)); }; } const LOGS_QUEUE_LEN: usize = 100; /// In-memory ring buffer of recent mihomo core log lines. pub struct LogRing { inner: RwLock>, } impl LogRing { #[must_use] pub fn new() -> Self { Self { inner: RwLock::new(VecDeque::with_capacity(LOGS_QUEUE_LEN)), } } pub fn append_log(&self, log: String) { let mut guard = self.inner.write(); if guard.len() >= LOGS_QUEUE_LEN { guard.pop_front(); } guard.push_back(log); } pub fn get_logs(&self) -> Vec { let guard = self.inner.read(); guard.iter().cloned().collect() } pub fn clear_logs(&self) { let mut guard = self.inner.write(); guard.clear(); } } impl Default for LogRing { fn default() -> Self { Self::new() } } // Buffered writes avoid flexi's one-syscall-per-line default; the flusher // bounds the hard-kill loss window. const WRITE_BUFFER_CAPACITY: usize = 64 * 1024; const WRITE_FLUSH_INTERVAL: Duration = Duration::from_millis(500); const ROTATE_NAMING: Naming = Naming::TimestampsCustomFormat { current_infix: Some("latest"), format: "%Y-%m-%d_%H-%M-%S", }; /// Directories and limits supplied by the embedder; the crate owns no path logic. pub struct LoggerConfig { pub level: LevelFilter, pub max_size_kb: u64, pub max_count: usize, pub log_dir: PathBuf, pub sidecar_log_dir: PathBuf, } pub struct Logger { pipeline: OnceLock, sidecar_file_writer: RwLock>, log_dir: OnceLock, sidecar_log_dir: OnceLock, log_max_size: AtomicU64, log_max_count: AtomicUsize, } static LOGGER: OnceLock = OnceLock::new(); impl Logger { fn new() -> Self { Self { pipeline: OnceLock::new(), sidecar_file_writer: RwLock::new(None), log_dir: OnceLock::new(), sidecar_log_dir: OnceLock::new(), log_max_size: AtomicU64::new(128), log_max_count: AtomicUsize::new(8), } } pub fn global() -> &'static Self { LOGGER.get_or_init(Self::new) } /// Installs the global tracing pipeline. `RUST_LOG` (parsed as a bare /// level) overrides the configured level. pub fn init(&self, cfg: &LoggerConfig) -> Result<()> { let log_level = std::env::var("RUST_LOG") .ok() .and_then(|v| LevelFilter::from_str(v.trim()).ok()) .unwrap_or(cfg.level); self.store_config(cfg); let pipeline = tracing_estuary::PipelineBuilder::new() .default_level(log_level) .file_writer(self.generate_file_log_writer()?) .init()?; self.pipeline.set(pipeline).ok(); Ok(()) } /// Installs the sidecar file writer and the panic hook. Safe to call when /// the pipeline is owned elsewhere (e.g. a devtools-provided subscriber). pub fn init_sidecar(&self, cfg: &LoggerConfig) -> Result<()> { self.store_config(cfg); self.ensure_sidecar_writer(self.generate_sidecar_builder())?; std::panic::set_hook(Box::new(move |info| { // Capture both common panic payload types instead of logging String payloads as unknown. // This global hook covers panics after logger init; early setup panics are handled separately. let payload = info .payload() .downcast_ref::<&str>() .map(|s| (*s).to_string()) .or_else(|| info.payload().downcast_ref::().cloned()) .unwrap_or_else(|| "Unknown panic payload".to_string()); let location = info .location() .map(|loc| format!("{}:{}", loc.file(), loc.line())) .unwrap_or_else(|| "Unknown location".to_string()); logging!(error, Type::System, "Panic occurred at {}: {}", location, payload); Self::global().flush_logs(); std::thread::sleep(Duration::from_millis(100)); })); Ok(()) } fn store_config(&self, cfg: &LoggerConfig) { self.log_dir.set(cfg.log_dir.clone()).ok(); self.sidecar_log_dir.set(cfg.sidecar_log_dir.clone()).ok(); self.log_max_size.store(cfg.max_size_kb, Ordering::SeqCst); self.log_max_count.store(cfg.max_count, Ordering::SeqCst); } fn generate_file_log_writer(&self) -> Result { let log_dir = self.log_dir.get().cloned().unwrap_or_default(); let log_max_size = self.log_max_size.load(Ordering::SeqCst); let log_max_count = self.log_max_count.load(Ordering::SeqCst); let flwb = FileLogWriter::builder(FileSpec::default().directory(log_dir).basename("")) .format(tracing_estuary::file_format_with_level) .write_mode(flexi_logger::WriteMode::BufferAndFlushWith( WRITE_BUFFER_CAPACITY, WRITE_FLUSH_INTERVAL, )) .rotate( Criterion::Size(log_max_size * 1024), ROTATE_NAMING, Cleanup::KeepLogFiles(log_max_count), ); Ok(flwb) } /// Ensures the sidecar writer exists and points at `builder`'s config: /// built once, then reset in place — flexi's flusher thread cannot be /// stopped, so every dropped writer would leak a thread and an fd. fn ensure_sidecar_writer(&self, builder: FileLogWriterBuilder) -> Result<()> { let sidecar = self.sidecar_file_writer.write(); match sidecar.as_ref() { Some(writer) => { let _ = writer.flush(); writer.reset(&builder)?; } None => { // Build outside the guard: a spawn panic inside it would // deadlock the panic hook, which takes this lock to flush. drop(sidecar); let writer = builder.try_build()?; *self.sidecar_file_writer.write() = Some(writer); } } Ok(()) } fn generate_sidecar_builder(&self) -> FileLogWriterBuilder { let sidecar_log_dir = self.sidecar_log_dir.get().cloned().unwrap_or_default(); let log_max_size = self.log_max_size.load(Ordering::SeqCst); let log_max_count = self.log_max_count.load(Ordering::SeqCst); FileLogWriter::builder( FileSpec::default() .directory(sidecar_log_dir) .basename("sidecar") .suppress_timestamp(), ) .format(tracing_estuary::file_format_without_level) .write_mode(flexi_logger::WriteMode::BufferAndFlushWith( WRITE_BUFFER_CAPACITY, WRITE_FLUSH_INTERVAL, )) .rotate( Criterion::Size(log_max_size * 1024), ROTATE_NAMING, Cleanup::KeepLogFiles(log_max_count), ) } /// Drains the pipeline and the sidecar writer, whose flusher only runs every 500ms. pub fn flush_logs(&self) { if let Some(pipeline) = self.pipeline.get() { pipeline.flush_all(); } if let Some(writer) = self.sidecar_file_writer.read().as_ref() { let _ = writer.flush(); } } /// only update app log level pub fn update_log_level(&self, level: LevelFilter) -> Result<()> { if let Some(pipeline) = self.pipeline.get() { pipeline.filter.set_default_level(level)?; } else { bail!("failed to get tracing pipeline, make sure it init"); }; Ok(()) } /// Rebuilds both file writers with the new limits. pub fn update_log_config(&self, log_max_size: u64, log_max_count: usize) -> Result<()> { self.log_max_size.store(log_max_size, Ordering::SeqCst); self.log_max_count.store(log_max_count, Ordering::SeqCst); if let Some(pipeline) = self.pipeline.get() { let log_file_writer = self.generate_file_log_writer()?; if let Some(sink) = pipeline.sink.as_ref() { sink.reset(log_file_writer) .map_err(|error| anyhow::anyhow!("failed to reset log writer: {error}"))?; } } else { bail!("failed to get tracing pipeline, make sure it init"); }; self.ensure_sidecar_writer(self.generate_sidecar_builder())?; Ok(()) } pub fn writer_sidecar_log(&self, level: Level, message: &str) { if let Some(writer) = self.sidecar_file_writer.read().as_ref() { let mut now = DeferredNow::default(); let args = format_args!("{}", message); let record = Record::builder().args(args).level(level).target("sidecar").build(); let _ = writer.write(&mut now, &record); } } }