384 lines
10 KiB
Rust
384 lines
10 KiB
Rust
use std::fmt;
|
||
use std::io::{IsTerminal, Write};
|
||
use std::sync::atomic::{AtomicU8, Ordering};
|
||
use std::sync::OnceLock;
|
||
|
||
// 极简日志：等级用原子变量，关掉的等级只花一次原子读。
|
||
|
||
// 颜色
|
||
/// 转义序列收尾
|
||
const RESET: &str = "\u{1b}[0m";
|
||
/// 加粗红（ERROR）
|
||
const BOLD_RED: &str = "\u{1b}[1m\u{1b}[31m";
|
||
/// 加粗橙（WARN）
|
||
const BOLD_ORANGE: &str = "\u{1b}[1m\u{1b}[38;5;208m";
|
||
/// 只加粗（DEBUG）
|
||
const BOLD: &str = "\u{1b}[1m";
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||
// 等级与来源
|
||
/// 日志等级
|
||
pub enum Level {
|
||
Off,
|
||
Error,
|
||
Warn,
|
||
Info,
|
||
Debug,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
/// 来源：服务自身或管道请求
|
||
pub enum Channel {
|
||
Core,
|
||
Pipe,
|
||
}
|
||
|
||
impl Channel {
|
||
/// 来源标签
|
||
fn tag(self) -> &'static str {
|
||
match self {
|
||
Channel::Core => "core",
|
||
Channel::Pipe => "pipe",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Level {
|
||
/// 解析等级名
|
||
pub fn parse(s: &str) -> Option<Level> {
|
||
match s.trim().to_ascii_lowercase().as_str() {
|
||
"off" => Some(Level::Off),
|
||
"error" => Some(Level::Error),
|
||
"warn" | "warning" => Some(Level::Warn),
|
||
"info" => Some(Level::Info),
|
||
"debug" => Some(Level::Debug),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// 等级名
|
||
pub fn name(self) -> &'static str {
|
||
match self {
|
||
Level::Off => "off",
|
||
Level::Error => "error",
|
||
Level::Warn => "warn",
|
||
Level::Info => "info",
|
||
Level::Debug => "debug",
|
||
}
|
||
}
|
||
|
||
/// 行里的等级标签
|
||
fn tag(self) -> &'static str {
|
||
match self {
|
||
Level::Error => "ERROR",
|
||
Level::Warn => "WARN ",
|
||
Level::Info => "INFO ",
|
||
_ => "DEBUG",
|
||
}
|
||
}
|
||
|
||
/// 等级的颜色
|
||
fn color(self) -> &'static str {
|
||
match self {
|
||
Level::Error => BOLD_RED,
|
||
Level::Warn => BOLD_ORANGE,
|
||
Level::Debug => BOLD,
|
||
_ => "",
|
||
}
|
||
}
|
||
}
|
||
|
||
static LEVEL: AtomicU8 = AtomicU8::new(Level::Info as u8);
|
||
|
||
static COLOR: OnceLock<bool> = OnceLock::new();
|
||
|
||
// 写入
|
||
/// 设置全局等级
|
||
pub fn set_level(level: Level) {
|
||
LEVEL.store(level as u8, Ordering::Relaxed);
|
||
}
|
||
|
||
#[inline]
|
||
/// 这个等级要不要输出
|
||
pub fn enabled(level: Level) -> bool {
|
||
level as u8 <= LEVEL.load(Ordering::Relaxed)
|
||
}
|
||
|
||
/// 启动时调一次
|
||
pub fn init() {
|
||
enable_vt();
|
||
}
|
||
|
||
/// 写出一行
|
||
pub fn write(channel: Channel, level: Level, args: fmt::Arguments) {
|
||
let msg = args.to_string();
|
||
let line = render(level, channel, color_enabled(), &now(), &msg);
|
||
let stderr = std::io::stderr();
|
||
let mut out = stderr.lock();
|
||
let _ = writeln!(out, "{}", line);
|
||
}
|
||
|
||
/// 是否着色（终端或强制）
|
||
fn color_enabled() -> bool {
|
||
*COLOR.get_or_init(|| match std::env::var("CHUSQL_LOG_COLOR").as_deref().map(str::trim) {
|
||
Ok("always") | Ok("yes") | Ok("1") => true,
|
||
Ok("never") | Ok("no") | Ok("0") => false,
|
||
_ => std::io::stderr().is_terminal(),
|
||
})
|
||
}
|
||
|
||
/// 拼一行（纯函数，可测）
|
||
fn render(level: Level, channel: Channel, color: bool, stamp: &Stamp, msg: &str) -> String {
|
||
let tag = level.tag();
|
||
let paint = level.color();
|
||
let level_text = if color && !paint.is_empty() {
|
||
format!("{}{}{}", paint, tag, RESET)
|
||
} else {
|
||
tag.to_string()
|
||
};
|
||
format!("[{} {}] [{}] {}", level_text, stamp, channel.tag(), msg)
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
// 时间
|
||
/// 本地日期时间
|
||
pub struct Stamp {
|
||
pub year: u16,
|
||
pub month: u16,
|
||
pub day: u16,
|
||
pub hour: u16,
|
||
pub minute: u16,
|
||
pub second: u16,
|
||
pub milli: u16,
|
||
}
|
||
|
||
/// 格式：年-月-日 时:分:秒.毫秒
|
||
impl fmt::Display for Stamp {
|
||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||
write!(
|
||
f,
|
||
"{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
|
||
self.year, self.month, self.day, self.hour, self.minute, self.second, self.milli
|
||
)
|
||
}
|
||
}
|
||
|
||
/// 当前本地时间（Windows）
|
||
#[cfg(windows)]
|
||
fn now() -> Stamp {
|
||
#[repr(C)]
|
||
struct SystemTime {
|
||
year: u16,
|
||
month: u16,
|
||
day_of_week: u16,
|
||
day: u16,
|
||
hour: u16,
|
||
minute: u16,
|
||
second: u16,
|
||
milliseconds: u16,
|
||
}
|
||
|
||
#[link(name = "kernel32")]
|
||
unsafe extern "system" {
|
||
fn GetLocalTime(out: *mut SystemTime);
|
||
}
|
||
|
||
let mut t = SystemTime {
|
||
year: 0,
|
||
month: 0,
|
||
day_of_week: 0,
|
||
day: 0,
|
||
hour: 0,
|
||
minute: 0,
|
||
second: 0,
|
||
milliseconds: 0,
|
||
};
|
||
unsafe { GetLocalTime(&mut t) };
|
||
Stamp {
|
||
year: t.year,
|
||
month: t.month,
|
||
day: t.day,
|
||
hour: t.hour,
|
||
minute: t.minute,
|
||
second: t.second,
|
||
milli: t.milliseconds,
|
||
}
|
||
}
|
||
|
||
/// 当前时间（其他平台用 UTC）
|
||
#[cfg(not(windows))]
|
||
fn now() -> Stamp {
|
||
let d = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap_or_default();
|
||
let secs = d.as_secs();
|
||
let (year, month, day) = civil_from_days((secs / 86_400) as i64);
|
||
Stamp {
|
||
year: year as u16,
|
||
month: month as u16,
|
||
day: day as u16,
|
||
hour: ((secs % 86_400) / 3600) as u16,
|
||
minute: ((secs % 3_600) / 60) as u16,
|
||
second: (secs % 60) as u16,
|
||
milli: d.subsec_millis() as u16,
|
||
}
|
||
}
|
||
|
||
/// 天数换算成日期
|
||
pub fn civil_from_days(days: i64) -> (i64, u16, u16) {
|
||
let z = days + 719_468;
|
||
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
|
||
let doe = z - era * 146_097;
|
||
let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
|
||
let y = yoe + era * 400;
|
||
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
||
let mp = (5 * doy + 2) / 153;
|
||
let day = (doy - (153 * mp + 2) / 5 + 1) as u16;
|
||
let month = if mp < 10 { mp + 3 } else { mp - 9 } as u16;
|
||
(y + i64::from(month <= 2), month, day)
|
||
}
|
||
|
||
// 终端
|
||
/// 打开 Windows 的 VT 处理
|
||
#[cfg(windows)]
|
||
fn enable_vt() {
|
||
#[link(name = "kernel32")]
|
||
unsafe extern "system" {
|
||
fn GetStdHandle(which: u32) -> *mut core::ffi::c_void;
|
||
fn GetConsoleMode(handle: *mut core::ffi::c_void, mode: *mut u32) -> i32;
|
||
fn SetConsoleMode(handle: *mut core::ffi::c_void, mode: u32) -> i32;
|
||
}
|
||
|
||
const STD_ERROR_HANDLE: u32 = 0xFFFF_FFF4;
|
||
const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
|
||
|
||
unsafe {
|
||
let handle = GetStdHandle(STD_ERROR_HANDLE);
|
||
let mut mode = 0u32;
|
||
if GetConsoleMode(handle, &mut mode) != 0 {
|
||
let _ = SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 其他平台什么都不用做
|
||
#[cfg(not(windows))]
|
||
fn enable_vt() {}
|
||
|
||
// 宏
|
||
/// debug 日志
|
||
#[macro_export]
|
||
macro_rules! log_debug {
|
||
(core, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Core, $crate::log::Level::Debug, $($arg)*)
|
||
};
|
||
(pipe, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Pipe, $crate::log::Level::Debug, $($arg)*)
|
||
};
|
||
}
|
||
|
||
/// info 日志
|
||
#[macro_export]
|
||
macro_rules! log_info {
|
||
(core, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Core, $crate::log::Level::Info, $($arg)*)
|
||
};
|
||
(pipe, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Pipe, $crate::log::Level::Info, $($arg)*)
|
||
};
|
||
}
|
||
|
||
/// warn 日志
|
||
#[macro_export]
|
||
macro_rules! log_warn {
|
||
(core, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Core, $crate::log::Level::Warn, $($arg)*)
|
||
};
|
||
(pipe, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Pipe, $crate::log::Level::Warn, $($arg)*)
|
||
};
|
||
}
|
||
|
||
/// error 日志
|
||
#[macro_export]
|
||
macro_rules! log_error {
|
||
(core, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Core, $crate::log::Level::Error, $($arg)*)
|
||
};
|
||
(pipe, $($arg:tt)*) => {
|
||
$crate::log_line!($crate::log::Channel::Pipe, $crate::log::Level::Error, $($arg)*)
|
||
};
|
||
}
|
||
|
||
/// 四个宏的公共部分
|
||
#[doc(hidden)]
|
||
#[macro_export]
|
||
macro_rules! log_line {
|
||
($chan:expr, $lvl:expr, $($arg:tt)*) => {
|
||
if $crate::log::enabled($lvl) {
|
||
$crate::log::write($chan, $lvl, format_args!($($arg)*))
|
||
}
|
||
};
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn civil_from_days_known_dates() {
|
||
assert_eq!(civil_from_days(0), (1970, 1, 1));
|
||
assert_eq!(civil_from_days(10_957), (2000, 1, 1));
|
||
assert_eq!(civil_from_days(11_016), (2000, 2, 29));
|
||
assert_eq!(civil_from_days(19_723), (2024, 1, 1));
|
||
assert_eq!(civil_from_days(19_782), (2024, 2, 29));
|
||
}
|
||
|
||
#[test]
|
||
fn render_has_time_channel_and_colors() {
|
||
let stamp = Stamp {
|
||
year: 2026,
|
||
month: 9,
|
||
day: 24,
|
||
hour: 13,
|
||
minute: 45,
|
||
second: 12,
|
||
milli: 130,
|
||
};
|
||
|
||
assert_eq!(
|
||
render(Level::Error, Channel::Pipe, true, &stamp, "boom"),
|
||
"[\u{1b}[1m\u{1b}[31mERROR\u{1b}[0m 2026-09-24 13:45:12.130] [pipe] boom"
|
||
);
|
||
assert_eq!(
|
||
render(Level::Warn, Channel::Core, true, &stamp, "careful"),
|
||
"[\u{1b}[1m\u{1b}[38;5;208mWARN \u{1b}[0m 2026-09-24 13:45:12.130] [core] careful"
|
||
);
|
||
assert_eq!(
|
||
render(Level::Debug, Channel::Pipe, true, &stamp, "detail"),
|
||
"[\u{1b}[1mDEBUG\u{1b}[0m 2026-09-24 13:45:12.130] [pipe] detail"
|
||
);
|
||
assert_eq!(
|
||
render(Level::Info, Channel::Core, true, &stamp, "hello"),
|
||
"[INFO 2026-09-24 13:45:12.130] [core] hello"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn render_without_color_is_plain() {
|
||
let stamp = Stamp {
|
||
year: 2026,
|
||
month: 9,
|
||
day: 24,
|
||
hour: 1,
|
||
minute: 2,
|
||
second: 3,
|
||
milli: 4,
|
||
};
|
||
assert_eq!(
|
||
render(Level::Error, Channel::Core, false, &stamp, "boom"),
|
||
"[ERROR 2026-09-24 01:02:03.004] [core] boom"
|
||
);
|
||
}
|
||
}
|