lean_log/

lib.rs

#![forbid(unsafe_code)]

use core::sync::atomic::{AtomicU8, Ordering};
use std::env;
use std::fs::{File, OpenOptions};
use std::io::{self, BufWriter, Write};
use std::path::Path;
use std::sync::{Mutex, OnceLock};

#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub enum Level {
    Off = 0,
    Error = 1,
    Warn = 2,
    Notice = 3,
    Info = 4,
    Debug = 5,
    Trace = 6,
}

impl Level {
    #[inline]
    pub fn as_str(self) -> &'static str {
        match self {
            Level::Off => "OFF",
            Level::Error => "ERROR",
            Level::Warn => "WARN",
            Level::Notice => "NOTICE",
            Level::Info => "INFO",
            Level::Debug => "DEBUG",
            Level::Trace => "TRACE",
        }
    }

    #[inline]
    pub fn parse(s: &str) -> Option<Self> {
        match s.trim().to_ascii_lowercase().as_str() {
            "off" => Some(Level::Off),
            "error" => Some(Level::Error),
            "warn" | "warning" => Some(Level::Warn),
            "notice" => Some(Level::Notice),
            "info" => Some(Level::Info),
            "debug" => Some(Level::Debug),
            "trace" => Some(Level::Trace),
            _ => None,
        }
    }
}

static RUNTIME_LEVEL: AtomicU8 = AtomicU8::new(Level::Info as u8);

#[inline]
pub fn set_level(level: Level) {
    RUNTIME_LEVEL.store(level as u8, Ordering::Relaxed);
}

#[inline]
#[must_use]
pub fn level() -> Level {
    match RUNTIME_LEVEL.load(Ordering::Relaxed) {
        0 => Level::Off,
        1 => Level::Error,
        2 => Level::Warn,
        3 => Level::Notice,
        4 => Level::Info,
        5 => Level::Debug,
        _ => Level::Trace,
    }
}

/// Initialize log level from an environment variable.
///
/// Checks the specified environment variable and parses it as a log level.
/// If the variable is not set or cannot be parsed, uses the provided default.
///
/// # Examples
///
/// ```no_run
/// use lean_log::Level;
/// // Check RUST_LOG, default to Info
/// lean_log::init_from_env("RUST_LOG", Level::Info);
/// ```
pub fn init_from_env(var_name: &str, default: Level) {
    let level = env::var(var_name)
        .ok()
        .and_then(|s| Level::parse(&s))
        .unwrap_or(default);
    set_level(level);
}

/// Initialize log level from RUST_LOG environment variable.
///
/// This is a convenience wrapper around `init_from_env("RUST_LOG", default)`.
/// Follows the common Rust convention of using RUST_LOG for log level configuration.
///
/// # Examples
///
/// ```no_run
/// use lean_log::Level;
/// // Check RUST_LOG env var, default to Info if not set
/// lean_log::init();
/// // Or with custom default:
/// lean_log::init_with_default(Level::Warn);
/// ```
pub fn init() {
    init_from_env("RUST_LOG", Level::Info);
}

/// Initialize log level from RUST_LOG with a custom default.
pub fn init_with_default(default: Level) {
    init_from_env("RUST_LOG", default);
}

pub const COMPILED_MAX_LEVEL: Level = compiled_max_level();

const fn compiled_max_level() -> Level {
    #[cfg(feature = "max_trace")]
    {
        return Level::Trace;
    }
    #[cfg(all(not(feature = "max_trace"), feature = "max_debug"))]
    {
        return Level::Debug;
    }
    #[cfg(all(
        not(feature = "max_trace"),
        not(feature = "max_debug"),
        feature = "max_info"
    ))]
    {
        return Level::Info;
    }

    #[cfg(all(
        not(feature = "max_trace"),
        not(feature = "max_debug"),
        not(feature = "max_info"),
        feature = "max_notice"
    ))]
    {
        return Level::Notice;
    }

    #[cfg(all(
        not(feature = "max_trace"),
        not(feature = "max_debug"),
        not(feature = "max_info"),
        not(feature = "max_notice"),
        feature = "max_warn"
    ))]
    {
        return Level::Warn;
    }
    #[cfg(all(
        not(feature = "max_trace"),
        not(feature = "max_debug"),
        not(feature = "max_info"),
        not(feature = "max_notice"),
        not(feature = "max_warn"),
        feature = "max_error"
    ))]
    {
        return Level::Error;
    }

    #[allow(unreachable_code)]
    Level::Off
}

#[inline(always)]
pub fn enabled(_level: Level) -> bool {
    #[cfg(feature = "disabled")]
    {
        return false;
    }

    #[cfg(not(feature = "disabled"))]
    {
        if (_level as u8) > (COMPILED_MAX_LEVEL as u8) {
            return false;
        }
        RUNTIME_LEVEL.load(Ordering::Relaxed) >= _level as u8
    }
}

pub fn init_from_args<I, S>(args: I)
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut it = args.into_iter();
    while let Some(arg) = it.next() {
        let a = arg.as_ref();

        // --log=info or --log-level=info
        if let Some(v) = a
            .strip_prefix("--log=")
            .or_else(|| a.strip_prefix("--log-level="))
        {
            if let Some(lvl) = Level::parse(v) {
                set_level(lvl);
            }
            continue;
        }

        // --log info  OR  --log-level info
        if a == "--log" || a == "--log-level" {
            if let Some(next) = it.next() {
                if let Some(lvl) = Level::parse(next.as_ref()) {
                    set_level(lvl);
                }
            }
            continue;
        }
    }
}

enum Sink {
    Stderr,
    File(FileSink),
}

struct FileSink {
    writer: Mutex<BufWriter<File>>,
}

impl FileSink {
    fn new(file: File) -> Self {
        Self {
            writer: Mutex::new(BufWriter::new(file)),
        }
    }

    fn write(
        &self,
        timestamp: &str,
        level: &str,
        module: &str,
        line: u32,
        msg: core::fmt::Arguments<'_>,
    ) {
        let mut writer = match self.writer.lock() {
            Ok(guard) => guard,
            Err(poisoned) => poisoned.into_inner(),
        };

        let _ = writer.write_fmt(format_args!("{} {} {}:{} ", timestamp, level, module, line));
        let _ = writer.write_fmt(msg);
        let _ = writer.write_all(b"\n");
    }

    fn write_with_fields(
        &self,
        timestamp: &str,
        level: &str,
        module: &str,
        line: u32,
        msg: core::fmt::Arguments<'_>,
        fields: core::fmt::Arguments<'_>,
    ) {
        let mut writer = match self.writer.lock() {
            Ok(guard) => guard,
            Err(poisoned) => poisoned.into_inner(),
        };

        let _ = writer.write_fmt(format_args!("{} {} {}:{} ", timestamp, level, module, line));
        let _ = writer.write_fmt(msg);
        let _ = writer.write_all(b" ");
        let _ = writer.write_fmt(fields);
        let _ = writer.write_all(b"\n");
    }
}

static ACTIVE_SINK: OnceLock<Sink> = OnceLock::new();

fn active_sink() -> &'static Sink {
    ACTIVE_SINK.get_or_init(|| Sink::Stderr)
}

pub fn set_file_logging(path: impl AsRef<Path>) -> io::Result<()> {
    configure_file_sink(path.as_ref(), false)
}

pub fn append_file_logging(path: impl AsRef<Path>) -> io::Result<()> {
    configure_file_sink(path.as_ref(), true)
}

fn configure_file_sink(path: &Path, append: bool) -> io::Result<()> {
    let file = OpenOptions::new()
        .create(true)
        .write(true)
        .append(append)
        .truncate(!append)
        .open(path)?;

    let sink = Sink::File(FileSink::new(file));
    ACTIVE_SINK
        .set(sink)
        .map_err(|_| io::Error::new(io::ErrorKind::AlreadyExists, "log sink already initialized"))
}

struct LevelStyle {
    ansi: &'static str,
    display: &'static str,
    plain: &'static str,
}

const ERROR_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[91m",
    display: "ERROR",
    plain: "ERROR",
};

const NOTICE_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[95m",
    display: "NOTICE",
    plain: "NOTICE",
};

const WARN_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[93m",
    display: " WARN",
    plain: "WARN",
};

const INFO_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[92m",
    display: " INFO",
    plain: "INFO",
};

const DEBUG_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[96m",
    display: "DEBUG",
    plain: "DEBUG",
};

const TRACE_STYLE: LevelStyle = LevelStyle {
    ansi: "\x1b[94m",
    display: "TRACE",
    plain: "TRACE",
};

#[inline]
fn emit_with_style(style: &LevelStyle, msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style_and_fields(style, msg, None, _line, _module)
}

#[inline]
fn emit_with_style_and_fields(
    style: &LevelStyle,
    msg: core::fmt::Arguments<'_>,
    fields: Option<core::fmt::Arguments<'_>>,
    _line: u32,
    _module: &str,
) {
    #[cfg(not(feature = "disabled"))]
    {
        let timestamp = format_timestamp();
        match active_sink() {
            Sink::Stderr => {
                if let Some(fields) = fields {
                    eprintln!(
                        "\x1b[90m{}\x1b[0m {}{}\x1b[0m \x1b[1;37m{}:{}\x1b[0m {} \x1b[36m{}\x1b[0m",
                        timestamp, style.ansi, style.display, _module, _line, msg, fields
                    );
                } else {
                    eprintln!(
                        "\x1b[90m{}\x1b[0m {}{}\x1b[0m \x1b[1;37m{}:{}\x1b[0m {}",
                        timestamp, style.ansi, style.display, _module, _line, msg
                    );
                }
            }
            Sink::File(file_sink) => {
                if let Some(fields) = fields {
                    file_sink.write_with_fields(
                        &timestamp,
                        style.plain,
                        _module,
                        _line,
                        msg,
                        fields,
                    );
                } else {
                    file_sink.write(&timestamp, style.plain, _module, _line, msg);
                }
            }
        }
    }
}

#[inline]
fn format_timestamp() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};

    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");

    let secs = duration.as_secs();
    let micros = duration.subsec_micros();

    let days_since_epoch = secs / 86400;
    let secs_today = secs % 86400;

    let hours = secs_today / 3600;
    let minutes = (secs_today % 3600) / 60;
    let seconds = secs_today % 60;

    let mut year = 1970;
    let mut days = days_since_epoch;

    loop {
        let days_in_year = if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) {
            366
        } else {
            365
        };
        if days < days_in_year {
            break;
        }
        days -= days_in_year;
        year += 1;
    }

    let is_leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
    let days_in_months = if is_leap {
        [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    } else {
        [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    };

    let mut month = 1;
    for &days_in_month in &days_in_months {
        if days < days_in_month {
            break;
        }
        days -= days_in_month;
        month += 1;
    }
    let day = days + 1;

    format!(
        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:06}Z",
        year, month, day, hours, minutes, seconds, micros
    )
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_error(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&ERROR_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_error_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&ERROR_STYLE, _msg, Some(_fields), _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_warn(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&WARN_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_warn_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&WARN_STYLE, _msg, Some(_fields), _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_notice(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&NOTICE_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_notice_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&NOTICE_STYLE, _msg, Some(_fields), _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_info(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&INFO_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_info_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&INFO_STYLE, _msg, Some(_fields), _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_debug(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&DEBUG_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_debug_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&DEBUG_STYLE, _msg, Some(_fields), _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_trace(_msg: core::fmt::Arguments<'_>, _line: u32, _module: &str) {
    emit_with_style(&TRACE_STYLE, _msg, _line, _module);
}

#[cold]
#[inline(never)]
#[doc(hidden)]
pub fn emit_trace_with_fields(
    _msg: core::fmt::Arguments<'_>,
    _fields: core::fmt::Arguments<'_>,
    _line: u32,
    _module: &str,
) {
    emit_with_style_and_fields(&TRACE_STYLE, _msg, Some(_fields), _line, _module);
}

// -------- Macros (compile-time elimination + runtime check) --------

#[macro_export]
#[doc(hidden)]
macro_rules! __format_fields {
    () => { "" };

    (? $name:ident) => {
        format_args!("{}={:?}", stringify!($name), $name)
    };

    (% $name:ident) => {
        format_args!("{}={}", stringify!($name), $name)
    };

    ($key:ident = ? $value:expr) => {
        format_args!("{}={:?}", stringify!($key), $value)
    };

    ($key:ident = $value:expr) => {
        format_args!("{}={}", stringify!($key), $value)
    };

    (? $name:ident, $($rest:tt)*) => {
        format_args!("{}={:?} {}", stringify!($name), $name, $crate::__format_fields!($($rest)*))
    };

    (% $name:ident, $($rest:tt)*) => {
        format_args!("{}={} {}", stringify!($name), $name, $crate::__format_fields!($($rest)*))
    };

    ($key:ident = ? $value:expr, $($rest:tt)*) => {
        format_args!("{}={:?} {}", stringify!($key), $value, $crate::__format_fields!($($rest)*))
    };

    ($key:ident = $value:expr, $($rest:tt)*) => {
        format_args!("{}={} {}", stringify!($key), $value, $crate::__format_fields!($($rest)*))
    };
}

#[macro_export]
macro_rules! error {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Error) {
            $crate::emit_error_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Error) {
            $crate::emit_error_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Error) {
            $crate::emit_error_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Error) {
            $crate::emit_error_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Error) {
            $crate::emit_error(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}

#[macro_export]
macro_rules! warn {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Warn) {
            $crate::emit_warn_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Warn) {
            $crate::emit_warn_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Warn) {
            $crate::emit_warn_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Warn) {
            $crate::emit_warn_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Warn) {
            $crate::emit_warn(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}

#[macro_export]
macro_rules! notice {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Notice) {
            $crate::emit_notice_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Notice) {
            $crate::emit_notice_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Notice) {
            $crate::emit_notice_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Notice) {
            $crate::emit_notice_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Notice) {
            $crate::emit_notice(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}

#[macro_export]
macro_rules! info {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Info) {
            $crate::emit_info_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Info) {
            $crate::emit_info_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Info) {
            $crate::emit_info_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Info) {
            $crate::emit_info_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Info) {
            $crate::emit_info(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}

#[macro_export]
macro_rules! debug {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Debug) {
            $crate::emit_debug_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Debug) {
            $crate::emit_debug_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Debug) {
            $crate::emit_debug_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Debug) {
            $crate::emit_debug_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Debug) {
            $crate::emit_debug(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}

#[macro_export]
macro_rules! trace {
    ($msg:literal; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Trace) {
            $crate::emit_trace_with_fields(
                format_args!($msg),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, $($arg:expr),+; $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Trace) {
            $crate::emit_trace_with_fields(
                format_args!($msg, $($arg),+),
                $crate::__format_fields!($($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, ? $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Trace) {
            $crate::emit_trace_with_fields(
                format_args!($msg),
                $crate::__format_fields!(? $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($msg:literal, % $($field:tt)+) => {{
        if $crate::enabled($crate::Level::Trace) {
            $crate::emit_trace_with_fields(
                format_args!($msg),
                $crate::__format_fields!(% $($field)+),
                line!(),
                module_path!()
            );
        }
    }};

    ($($arg:tt)+) => {{
        if $crate::enabled($crate::Level::Trace) {
            $crate::emit_trace(format_args!($($arg)+), line!(), module_path!());
        }
    }};
}