From 8ca5e296bddc3e5d887a1c1a98787a157304fab6 Mon Sep 17 00:00:00 2001 From: EFanZh Date: Sat, 2 Dec 2023 14:07:19 +0800 Subject: [PATCH] Specialize target and level arguments that can be statically determined --- src/__private_api.rs | 259 ++++++++++++++++++++++++++++--------------- src/macros.rs | 134 ++++++++++++++++------ 2 files changed, 269 insertions(+), 124 deletions(-) diff --git a/src/__private_api.rs b/src/__private_api.rs index 359deebbc..934a25d42 100644 --- a/src/__private_api.rs +++ b/src/__private_api.rs @@ -1,89 +1,170 @@ -//! WARNING: this is not part of the crate's public API and is subject to change at any time - -use self::sealed::KVs; -use crate::{Level, Metadata, Record}; -use std::fmt::Arguments; -pub use std::{file, format_args, line, module_path, stringify}; - -#[cfg(feature = "kv_unstable")] -pub type Value<'a> = dyn crate::kv::value::ToValue + 'a; - -#[cfg(not(feature = "kv_unstable"))] -pub type Value<'a> = str; - -mod sealed { - /// Types for the `kv` argument. - pub trait KVs<'a> { - fn into_kvs(self) -> Option<&'a [(&'a str, &'a super::Value<'a>)]>; - } -} - -// Types for the `kv` argument. - -impl<'a> KVs<'a> for &'a [(&'a str, &'a Value<'a>)] { - #[inline] - fn into_kvs(self) -> Option<&'a [(&'a str, &'a Value<'a>)]> { - Some(self) - } -} - -impl<'a> KVs<'a> for () { - #[inline] - fn into_kvs(self) -> Option<&'a [(&'a str, &'a Value<'a>)]> { - None - } -} - -// Log implementation. - -fn log_impl( - args: Arguments, - level: Level, - &(target, module_path, file): &(&str, &'static str, &'static str), - line: u32, - kvs: Option<&[(&str, &Value)]>, -) { - #[cfg(not(feature = "kv_unstable"))] - if kvs.is_some() { - panic!( - "key-value support is experimental and must be enabled using the `kv_unstable` feature" - ) - } - - let mut builder = Record::builder(); - - builder - .args(args) - .level(level) - .target(target) - .module_path_static(Some(module_path)) - .file_static(Some(file)) - .line(Some(line)); - - #[cfg(feature = "kv_unstable")] - builder.key_values(&kvs); - - crate::logger().log(&builder.build()); -} - -pub fn log<'a, K>( - args: Arguments, - level: Level, - target_module_path_and_file: &(&str, &'static str, &'static str), - line: u32, - kvs: K, -) where - K: KVs<'a>, -{ - log_impl( - args, - level, - target_module_path_and_file, - line, - kvs.into_kvs(), - ) -} - -pub fn enabled(level: Level, target: &str) -> bool { - crate::logger().enabled(&Metadata::builder().level(level).target(target).build()) -} +//! WARNING: this is not part of the crate's public API and is subject to change at any time + +use self::sealed::{KVs, Level as LevelTrait, Target}; +use crate::{Level, LevelFilter, Metadata, Record}; +use std::cmp::Ordering; +use std::fmt::Arguments; +pub use std::{file, format_args, line, module_path, stringify}; + +#[cfg(feature = "kv_unstable")] +pub type Value<'a> = dyn crate::kv::value::ToValue + 'a; + +#[cfg(not(feature = "kv_unstable"))] +pub type Value<'a> = &'a str; + +mod sealed { + /// Types for the `target` argument. + pub trait Target<'a>: Copy { + fn target(self, module_path: &'a &'a str) -> &'a &'a str; + } + + /// Types for the `level` argument. + pub trait Level: Copy { + fn level(self) -> crate::Level; + } + + /// Types for the `kv` argument. + pub trait KVs<'a> { + fn kvs(self) -> Option<&'a &'a [(&'a str, &'a super::Value<'a>)]>; + } +} + +// Types for the `target` argument. + +/// Caller specified target explicitly. +impl<'a> Target<'a> for &'a &'a str { + #[inline] + fn target(self, _module_path: &'a &'a str) -> &'a &'a str { + self + } +} + +/// Caller did not specified target. +impl<'a> Target<'a> for () { + #[inline] + fn target(self, module_path: &'a &'a str) -> &'a &'a str { + module_path + } +} + +// Types for the `kvs` argument. + +/// Caller specified key-value data explicitly. +impl<'a> KVs<'a> for &'a &'a [(&'a str, &'a Value<'a>)] { + #[inline] + fn kvs(self) -> Option<&'a &'a [(&'a str, &'a Value<'a>)]> { + Some(self) + } +} + +/// Caller did not specify key-value data. +impl<'a> KVs<'a> for () { + #[inline] + fn kvs(self) -> Option<&'a &'a [(&'a str, &'a Value<'a>)]> { + None + } +} + +// Types for the `level` argument. + +/// The log level is dynamically determined. +impl LevelTrait for Level { + #[inline] + fn level(self) -> Level { + self + } +} + +macro_rules! define_static_levels { + ($(($name:ident, $level:ident),)*) => {$( + #[derive(Clone, Copy, Debug)] + pub struct $name; + + /// The log level is statically determined. + impl LevelTrait for $name { + #[inline] + fn level(self) -> Level { + Level::$level + } + } + + impl PartialEq for $name { + #[inline] + fn eq(&self, other: &LevelFilter) -> bool { + self.level().eq(other) + } + } + + impl PartialOrd for $name { + #[inline] + fn partial_cmp(&self, other: &LevelFilter) -> Option { + self.level().partial_cmp(other) + } + } + )*}; +} + +define_static_levels![ + (LevelError, Error), + (LevelWarn, Warn), + (LevelInfo, Info), + (LevelDebug, Debug), + (LevelTrace, Trace), +]; + +// Log implementation. + +#[derive(Debug)] +pub struct RequiredArgs<'a> { + pub module_path_and_file: &'static (&'static str, &'static str), + pub line: u32, + pub args: Arguments<'a>, +} + +fn log_impl( + required_args: &RequiredArgs, + target: &&str, + level: Level, + kvs: Option<&&[(&str, &Value)]>, +) { + #[cfg(not(feature = "kv_unstable"))] + if kvs.is_some() { + panic!( + "key-value support is experimental and must be enabled using the `kv_unstable` feature" + ) + } + + let mut builder = Record::builder(); + + builder + .args(required_args.args) + .level(level) + .target(target) + .module_path_static(Some(required_args.module_path_and_file.0)) + .file_static(Some(required_args.module_path_and_file.1)) + .line(Some(required_args.line)); + + #[cfg(feature = "kv_unstable")] + builder.key_values(&kvs); + + crate::logger().log(&builder.build()); +} + +#[inline(never)] +pub fn log<'a, T, L, K>(required_args: &RequiredArgs, target: T, level: L, kvs: K) +where + T: Target<'a>, + L: LevelTrait, + K: KVs<'a>, +{ + log_impl( + required_args, + target.target(&required_args.module_path_and_file.0), + level.level(), + kvs.kvs(), + ) +} + +pub fn enabled(level: Level, target: &str) -> bool { + crate::logger().enabled(&Metadata::builder().level(level).target(target).build()) +} diff --git a/src/macros.rs b/src/macros.rs index 44945f0d9..93c072de0 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -8,6 +8,78 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#[doc(hidden)] +#[macro_export] +macro_rules! __private_api_log_impl { + ( + @impl + $target:expr => $target_ty:ty, + $lvl:expr => $lvl_ty:ty, + $kvs:expr => $kvs_ty:ty, + $($arg:tt)+ + ) => {{ + let lvl = $lvl; + if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() { + $crate::__private_api::log::<$target_ty, $lvl_ty, $kvs_ty>( + &$crate::__private_api::RequiredArgs { + module_path_and_file: &( + $crate::__private_api::module_path!(), + $crate::__private_api::file!(), + ), + line: $crate::__private_api::line!(), + args: $crate::__private_api::format_args!($($arg)+), + }, + $target, + $lvl, + $kvs, + ); + } + }}; + + // Parse key value data. + + (@parse_kvs $target:expr => $target_ty:ty, $lvl:expr => $lvl_ty:ty, $($key:tt = $value:expr),+; $($arg:tt)+) => ( + $crate::__private_api_log_impl!( + @impl + $target => $target_ty, + $lvl => $lvl_ty, + &(&[$(($crate::__log_key!($key), (&$value as &$crate::__private_api::Value))),+] as &[_]) => &_, + $($arg)+ + ) + ); + + (@parse_kvs $target:expr => $target_ty:ty, $lvl:expr => $lvl_ty:ty, $($arg:tt)+) => ( + $crate::__private_api_log_impl!( + @impl + $target => $target_ty, + $lvl => $lvl_ty, + () => (), + $($arg)+ + ) + ); + + // Parse level. + + (@parse_level $target:expr => $target_ty:ty, $lvl:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(@parse_kvs $target => $target_ty, $lvl => $crate::Level, $($arg)+) + ); + + (@parse_level $target:expr => $target_ty:ty, @static $lvl:ident, $($arg:tt)+) => ( + $crate::__private_api_log_impl!( + @parse_kvs + $target => $target_ty, + $crate::__private_api::$lvl => $crate::__private_api::$lvl, + $($arg)+ + ) + ); + + // Parse target. + + (target: $target:expr, $($arg:tt)+) => ($crate::__private_api_log_impl!(@parse_level &$target => &_, $($arg)+)); + + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@parse_level () => (), $($arg)+)); +} + /// The standard logging macro. /// /// This macro will generically log with the specified `Level` and `format!` @@ -30,35 +102,17 @@ #[macro_export] macro_rules! log { // log!(target: "my_target", Level::Info, key1 = 42, key2 = true; "a {} event", "log"); - (target: $target:expr, $lvl:expr, $($key:tt = $value:expr),+; $($arg:tt)+) => ({ - let lvl = $lvl; - if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() { - $crate::__private_api::log::<&_>( - $crate::__private_api::format_args!($($arg)+), - lvl, - &($target, $crate::__private_api::module_path!(), $crate::__private_api::file!()), - $crate::__private_api::line!(), - &[$(($crate::__log_key!($key), &$value)),+] - ); - } - }); + (target: $target:expr, $lvl:expr, $($key:tt = $value:expr),+; $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, $lvl, $($key = $value),+; $($arg)+) + ); // log!(target: "my_target", Level::Info, "a {} event", "log"); - (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({ - let lvl = $lvl; - if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() { - $crate::__private_api::log( - $crate::__private_api::format_args!($($arg)+), - lvl, - &($target, $crate::__private_api::module_path!(), $crate::__private_api::file!()), - $crate::__private_api::line!(), - (), - ); - } - }); + (target: $target:expr, $lvl:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, $lvl, $($arg)+) + ); // log!(Level::Info, "a log event") - ($lvl:expr, $($arg:tt)+) => ($crate::log!(target: $crate::__private_api::module_path!(), $lvl, $($arg)+)); + ($lvl:expr, $($arg:tt)+) => ($crate::__private_api_log_impl!($lvl, $($arg)+)); } /// Logs a message at the error level. @@ -79,10 +133,12 @@ macro_rules! log { macro_rules! error { // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // error!(target: "my_target", "a {} event", "log") - (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Error, $($arg)+)); + (target: $target:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, @static LevelError, $($arg)+) + ); // error!("a {} event", "log") - ($($arg:tt)+) => ($crate::log!($crate::Level::Error, $($arg)+)) + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@static LevelError, $($arg)+)); } /// Logs a message at the warn level. @@ -103,10 +159,12 @@ macro_rules! error { macro_rules! warn { // warn!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // warn!(target: "my_target", "a {} event", "log") - (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Warn, $($arg)+)); + (target: $target:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, @static LevelWarn, $($arg)+) + ); // warn!("a {} event", "log") - ($($arg:tt)+) => ($crate::log!($crate::Level::Warn, $($arg)+)) + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@static LevelWarn, $($arg)+)); } /// Logs a message at the info level. @@ -129,10 +187,12 @@ macro_rules! warn { macro_rules! info { // info!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // info!(target: "my_target", "a {} event", "log") - (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Info, $($arg)+)); + (target: $target:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, @static LevelInfo, $($arg)+) + ); // info!("a {} event", "log") - ($($arg:tt)+) => ($crate::log!($crate::Level::Info, $($arg)+)) + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@static LevelInfo, $($arg)+)); } /// Logs a message at the debug level. @@ -154,10 +214,12 @@ macro_rules! info { macro_rules! debug { // debug!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // debug!(target: "my_target", "a {} event", "log") - (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Debug, $($arg)+)); + (target: $target:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, @static LevelDebug, $($arg)+) + ); // debug!("a {} event", "log") - ($($arg:tt)+) => ($crate::log!($crate::Level::Debug, $($arg)+)) + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@static LevelDebug, $($arg)+)); } /// Logs a message at the trace level. @@ -181,10 +243,12 @@ macro_rules! debug { macro_rules! trace { // trace!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // trace!(target: "my_target", "a {} event", "log") - (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Trace, $($arg)+)); + (target: $target:expr, $($arg:tt)+) => ( + $crate::__private_api_log_impl!(target: $target, @static LevelTrace, $($arg)+) + ); // trace!("a {} event", "log") - ($($arg:tt)+) => ($crate::log!($crate::Level::Trace, $($arg)+)) + ($($arg:tt)+) => ($crate::__private_api_log_impl!(@static LevelTrace, $($arg)+)); } /// Determines if a message logged at the specified level in that module will