From 7aacc8fea367dd6518f02db792af8b6215ed33d6 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Sun, 23 Mar 2025 14:22:24 +1000 Subject: [PATCH 1/6] pass global logger by value, supplied logger by ref --- src/__private_api.rs | 2 +- src/macros.rs | 126 +++++++++++++++++++++++++++++++------------ 2 files changed, 92 insertions(+), 36 deletions(-) diff --git a/src/__private_api.rs b/src/__private_api.rs index e2744bef6..609374757 100644 --- a/src/__private_api.rs +++ b/src/__private_api.rs @@ -85,7 +85,7 @@ fn log_impl( } pub fn log<'a, K, L>( - logger: &L, + logger: L, args: Arguments, level: Level, target_module_path_and_loc: &(&str, &'static str, &'static Location), diff --git a/src/macros.rs b/src/macros.rs index a20e8172b..ff2dd8c5a 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -66,12 +66,56 @@ #[macro_export] #[clippy::format_args] macro_rules! log { + // log!(logger: my_logger, target: "my_target", Level::Info, "a {} event", "log"); + (logger: $logger:expr, target: $target:expr, $lvl:expr, $($arg:tt)+) => ({ + $crate::__log!( + logger: $crate::__log_logger!($logger), + target: $target, + $lvl, + $($arg)+ + ) + }); + + // log!(logger: my_logger, Level::Info, "a log event") + (logger: $logger:expr, $lvl:expr, $($arg:tt)+) => ({ + $crate::__log!( + logger: $crate::__log_logger!($logger), + target: $crate::__private_api::module_path!(), + $lvl, + $($arg)+ + ) + }); + + // log!(target: "my_target", Level::Info, "a log event") + (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({ + $crate::__log!( + logger: $crate::__log_logger!(__log_global_logger), + target: $target, + $lvl, + $($arg)+ + ) + }); + + // log!(Level::Info, "a log event") + ($lvl:expr, $($arg:tt)+) => ({ + $crate::__log!( + logger: $crate::__log_logger!(__log_global_logger), + target: $crate::__private_api::module_path!(), + $lvl, + $($arg)+ + ) + }); +} + +#[doc(hidden)] +#[macro_export] +macro_rules! __log { // log!(logger: my_logger, target: "my_target", Level::Info, key1:? = 42, key2 = true; "a {} event", "log"); (logger: $logger:expr, target: $target:expr, $lvl:expr, $($key:tt $(:$capture:tt)? $(= $value:expr)?),+; $($arg:tt)+) => ({ let lvl = $lvl; if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() { - $crate::__private_api::log::<&_, _>( - &($logger), + $crate::__private_api::log( + $logger, $crate::__private_api::format_args!($($arg)+), lvl, &($target, $crate::__private_api::module_path!(), $crate::__private_api::loc()), @@ -85,7 +129,7 @@ macro_rules! log { let lvl = $lvl; if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() { $crate::__private_api::log( - &($logger), + $logger, $crate::__private_api::format_args!($($arg)+), lvl, &($target, $crate::__private_api::module_path!(), $crate::__private_api::loc()), @@ -93,21 +137,6 @@ macro_rules! log { ); } }); - - // log!(logger: my_logger, Level::Info, "a log event") - (logger: $logger:expr, $lvl:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $crate::__private_api::module_path!(), $lvl, $($arg)+) - }); - - // log!(target: "my_target", Level::Info, "a log event") - (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $crate::__private_api::GlobalLogger, target: $target, $lvl, $($arg)+) - }); - - // log!(Level::Info, "a log event") - ($lvl:expr, $($arg:tt)+) => ({ - $crate::log!(target: $crate::__private_api::module_path!(), $lvl, $($arg)+) - }); } /// Logs a message at the error level. @@ -130,13 +159,13 @@ macro_rules! error { // error!(logger: my_logger, target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // error!(logger: my_logger, target: "my_target", "a {} event", "log") (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $target, $crate::Level::Error, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), target: $target, $crate::Level::Error, $($arg)+) }); // error!(logger: my_logger, key1 = 42, key2 = true; "a {} event", "log") // error!(logger: my_logger, "a {} event", "log") (logger: $logger:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, $crate::Level::Error, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), $crate::Level::Error, $($arg)+) }); // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") @@ -169,13 +198,13 @@ macro_rules! warn { // warn!(logger: my_logger, target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // warn!(logger: my_logger, target: "my_target", "a {} event", "log") (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $target, $crate::Level::Warn, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), target: $target, $crate::Level::Warn, $($arg)+) }); // warn!(logger: my_logger, key1 = 42, key2 = true; "a {} event", "log") // warn!(logger: my_logger, "a {} event", "log") (logger: $logger:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, $crate::Level::Warn, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), $crate::Level::Warn, $($arg)+) }); // warn!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") @@ -217,13 +246,13 @@ macro_rules! info { // info!(logger: my_logger, target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // info!(logger: my_logger, target: "my_target", "a {} event", "log") (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $target, $crate::Level::Info, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), target: $target, $crate::Level::Info, $($arg)+) }); // info!(logger: my_logger, key1 = 42, key2 = true; "a {} event", "log") // info!(logger: my_logger, "a {} event", "log") (logger: $logger:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, $crate::Level::Info, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), $crate::Level::Info, $($arg)+) }); // info!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") @@ -257,13 +286,13 @@ macro_rules! debug { // debug!(logger: my_logger, target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // debug!(logger: my_logger, target: "my_target", "a {} event", "log") (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $target, $crate::Level::Debug, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), target: $target, $crate::Level::Debug, $($arg)+) }); // debug!(logger: my_logger, key1 = 42, key2 = true; "a {} event", "log") // debug!(logger: my_logger, "a {} event", "log") (logger: $logger:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, $crate::Level::Debug, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), $crate::Level::Debug, $($arg)+) }); // debug!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") @@ -301,13 +330,13 @@ macro_rules! trace { // trace!(logger: my_logger, target: "my_target", key1 = 42, key2 = true; "a {} event", "log") // trace!(logger: my_logger, target: "my_target", "a {} event", "log") (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, target: $target, $crate::Level::Trace, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), target: $target, $crate::Level::Trace, $($arg)+) }); // trace!(logger: my_logger, key1 = 42, key2 = true; "a {} event", "log") // trace!(logger: my_logger, "a {} event", "log") (logger: $logger:expr, $($arg:tt)+) => ({ - $crate::log!(logger: $logger, $crate::Level::Trace, $($arg)+) + $crate::log!(logger: $crate::__log_logger!($logger), $crate::Level::Trace, $($arg)+) }); // trace!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log") @@ -351,23 +380,50 @@ macro_rules! trace { /// ``` #[macro_export] macro_rules! log_enabled { + // log_enabled!(logger: my_logger, target: "my_target", Level::Info) (logger: $logger:expr, target: $target:expr, $lvl:expr) => ({ - let lvl = $lvl; - lvl <= $crate::STATIC_MAX_LEVEL - && lvl <= $crate::max_level() - && $crate::__private_api::enabled($logger, lvl, $target) + $crate::__log_enabled!(logger: $crate::__log_logger!($logger), target: $target, $lvl) }); + // log_enabled!(logger: my_logger, Level::Info) (logger: $logger:expr, $lvl:expr) => ({ - $crate::log_enabled!(logger: $logger, target: $crate::__private_api::module_path!(), $lvl) + $crate::__log_enabled!(logger: $crate::__log_logger!($logger), target: $crate::__private_api::module_path!(), $lvl) }); + // log_enabled!(target: "my_target", Level::Info) (target: $target:expr, $lvl:expr) => ({ - $crate::log_enabled!(logger: $crate::__private_api::GlobalLogger, target: $target, $lvl) + $crate::__log_enabled!(logger: $crate::__log_logger!(__log_global_logger), target: $target, $lvl) }); + // log_enabled!(Level::Info) ($lvl:expr) => ({ - $crate::log_enabled!(target: $crate::__private_api::module_path!(), $lvl) + $crate::__log_enabled!(logger: $crate::__log_logger!(__log_global_logger), target: $crate::__private_api::module_path!(), $lvl) + }); +} + +#[doc(hidden)] +#[macro_export] +macro_rules! __log_enabled { + // log_enabled!(logger: my_logger, target: "my_target", Level::Info) + (logger: $logger:expr, target: $target:expr, $lvl:expr) => ({ + let lvl = $lvl; + lvl <= $crate::STATIC_MAX_LEVEL + && lvl <= $crate::max_level() + && $crate::__private_api::enabled($logger, lvl, $target) + }); +} + +// Determine the logger to use, and whether to take it by-value or by reference + +#[doc(hidden)] +#[macro_export] +macro_rules! __log_logger { + (__log_global_logger) => ({ + $crate::__private_api::GlobalLogger + }); + + ($logger:expr) => ({ + &($logger) }); } From 39d4c3ab88b5d4096ce9c8d795e9a1187e83c9d6 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Sun, 23 Mar 2025 14:24:43 +1000 Subject: [PATCH 2/6] run fmt --- src/macros.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/macros.rs b/src/macros.rs index ff2dd8c5a..5f0e49f18 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -405,12 +405,12 @@ macro_rules! log_enabled { #[macro_export] macro_rules! __log_enabled { // log_enabled!(logger: my_logger, target: "my_target", Level::Info) - (logger: $logger:expr, target: $target:expr, $lvl:expr) => ({ + (logger: $logger:expr, target: $target:expr, $lvl:expr) => {{ let lvl = $lvl; lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() && $crate::__private_api::enabled($logger, lvl, $target) - }); + }}; } // Determine the logger to use, and whether to take it by-value or by reference @@ -418,13 +418,13 @@ macro_rules! __log_enabled { #[doc(hidden)] #[macro_export] macro_rules! __log_logger { - (__log_global_logger) => ({ + (__log_global_logger) => {{ $crate::__private_api::GlobalLogger - }); + }}; - ($logger:expr) => ({ + ($logger:expr) => {{ &($logger) - }); + }}; } // These macros use a pattern of #[cfg]s to produce nicer error From dfa067e65c49db82b2ace612982007efef09b8b4 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Sun, 23 Mar 2025 14:25:45 +1000 Subject: [PATCH 3/6] fix up kv passing --- src/macros.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/macros.rs b/src/macros.rs index 5f0e49f18..dc51f6c83 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -119,7 +119,7 @@ macro_rules! __log { $crate::__private_api::format_args!($($arg)+), lvl, &($target, $crate::__private_api::module_path!(), $crate::__private_api::loc()), - &[$(($crate::__log_key!($key), $crate::__log_value!($key $(:$capture)* = $($value)*))),+] + &[$(($crate::__log_key!($key), $crate::__log_value!($key $(:$capture)* = $($value)*))),+] as &[_], ); } }); From 71e034ffa62b79aa67acda4b1569493bc5f9e107 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Mon, 24 Mar 2025 05:45:35 +1000 Subject: [PATCH 4/6] expand logger tests --- tests/macros.rs | 110 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 101 insertions(+), 9 deletions(-) diff --git a/tests/macros.rs b/tests/macros.rs index 35b8c8981..dded475c1 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -10,6 +10,7 @@ macro_rules! all_log_macros { }); } +// Not `Copy` struct Logger; impl Log for Logger { @@ -22,6 +23,8 @@ impl Log for Logger { #[test] fn no_args() { + let logger = Logger; + for lvl in log::Level::iter() { log!(lvl, "hello"); log!(lvl, "hello",); @@ -29,8 +32,11 @@ fn no_args() { log!(target: "my_target", lvl, "hello"); log!(target: "my_target", lvl, "hello",); - log!(lvl, "hello"); - log!(lvl, "hello",); + log!(logger: logger, lvl, "hello"); + log!(logger: logger, lvl, "hello",); + + log!(logger: logger, target: "my_target", lvl, "hello"); + log!(logger: logger, target: "my_target", lvl, "hello",); } all_log_macros!("hello"); @@ -39,10 +45,11 @@ fn no_args() { all_log_macros!(target: "my_target", "hello"); all_log_macros!(target: "my_target", "hello",); - all_log_macros!(logger: Logger, "hello"); - all_log_macros!(logger: Logger, "hello",); - all_log_macros!(logger: Logger, target: "my_target", "hello"); - all_log_macros!(logger: Logger, target: "my_target", "hello",); + all_log_macros!(logger: logger, "hello"); + all_log_macros!(logger: logger, "hello",); + + all_log_macros!(logger: logger, target: "my_target", "hello"); + all_log_macros!(logger: logger, target: "my_target", "hello",); } #[test] @@ -63,6 +70,14 @@ fn anonymous_args() { all_log_macros!(target: "my_target", "hello {}", "world"); all_log_macros!(target: "my_target", "hello {}", "world",); + + let logger = Logger; + + all_log_macros!(logger: logger, "hello {}", "world"); + all_log_macros!(logger: logger, "hello {}", "world",); + + all_log_macros!(logger: logger, target: "my_target", "hello {}", "world"); + all_log_macros!(logger: logger, target: "my_target", "hello {}", "world",); } #[test] @@ -83,6 +98,14 @@ fn named_args() { all_log_macros!(target: "my_target", "hello {world}", world = "world"); all_log_macros!(target: "my_target", "hello {world}", world = "world",); + + let logger = Logger; + + all_log_macros!(logger: logger, "hello {world}", world = "world"); + all_log_macros!(logger: logger, "hello {world}", world = "world",); + + all_log_macros!(logger: logger, target: "my_target", "hello {world}", world = "world"); + all_log_macros!(logger: logger, target: "my_target", "hello {world}", world = "world",); } #[test] @@ -105,81 +128,136 @@ fn inlined_args() { all_log_macros!(target: "my_target", "hello {world}"); all_log_macros!(target: "my_target", "hello {world}",); + + let logger = Logger; + + all_log_macros!(logger: logger, "hello {world}"); + all_log_macros!(logger: logger, "hello {world}",); + + all_log_macros!(logger: logger, target: "my_target", "hello {world}"); + all_log_macros!(logger: logger, target: "my_target", "hello {world}",); } #[test] fn enabled() { + let logger = Logger; + for lvl in log::Level::iter() { + let _enabled = log_enabled!(lvl); let _enabled = log_enabled!(target: "my_target", lvl); + let _enabled = log_enabled!(logger: logger, target: "my_target", lvl); + let _enabled = log_enabled!(logger: logger, lvl); } } #[test] fn expr() { + let logger = Logger; + for lvl in log::Level::iter() { log!(lvl, "hello"); + + log!(logger: logger, lvl, "hello"); } } #[test] #[cfg(feature = "kv")] fn kv_no_args() { + let logger = Logger; + for lvl in log::Level::iter() { log!(target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); - log!(lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); + + log!(logger: logger, target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); + log!(logger: logger, lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); } - all_log_macros!(logger: Logger, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); - all_log_macros!(logger: Logger, target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); all_log_macros!(target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); all_log_macros!(target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); all_log_macros!(cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); + + all_log_macros!(logger: logger, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); + all_log_macros!(logger: logger, target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello"); } #[test] #[cfg(feature = "kv")] fn kv_expr_args() { + let logger = Logger; + for lvl in log::Level::iter() { log!(target: "my_target", lvl, cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); log!(lvl, target = "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); log!(lvl, cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + + log!(logger: logger, target: "my_target", lvl, cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + + log!(logger: logger, lvl, target = "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + log!(logger: logger, lvl, cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); } all_log_macros!(target: "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); all_log_macros!(target = "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); all_log_macros!(cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + + all_log_macros!(logger: logger, target: "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + all_log_macros!(logger: logger, target = "my_target", cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); + all_log_macros!(logger: logger, cat_math = { let mut x = 0; x += 1; x + 1 }; "hello"); } #[test] #[cfg(feature = "kv")] fn kv_anonymous_args() { + let logger = Logger; + for lvl in log::Level::iter() { log!(target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); log!(lvl, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); log!(lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + + log!(logger: logger, target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + log!(logger: logger, lvl, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + + log!(logger: logger, lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); } all_log_macros!(target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); all_log_macros!(target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); all_log_macros!(cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + + all_log_macros!(logger: logger, target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + all_log_macros!(logger: logger, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); + all_log_macros!(logger: logger, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {}", "world"); } #[test] #[cfg(feature = "kv")] fn kv_named_args() { + let logger = Logger; + for lvl in log::Level::iter() { log!(target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); log!(lvl, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); log!(lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + + log!(logger: logger, target: "my_target", lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + log!(logger: logger, lvl, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + + log!(logger: logger, lvl, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); } all_log_macros!(target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); all_log_macros!(target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); all_log_macros!(cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + + all_log_macros!(logger: logger, target: "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + all_log_macros!(logger: logger, target = "my_target", cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); + all_log_macros!(logger: logger, cat_1 = "chashu", cat_2 = "nori", cat_count = 2; "hello {world}", world = "world"); } #[test] @@ -323,6 +401,20 @@ fn kv_serde() { ); } +#[test] +fn logger_short_lived() { + all_log_macros!(logger: Logger, "hello"); + all_log_macros!(logger: &Logger, "hello"); +} + +#[test] +fn logger_expr() { + all_log_macros!(logger: { + let logger = Logger; + logger + }, "hello"); +} + /// Some and None (from Option) are used in the macros. #[derive(Debug)] enum Type { From 02486e458cfc8e5e6a0a5bc0586db095a3e33b87 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Mon, 24 Mar 2025 05:56:21 +1000 Subject: [PATCH 5/6] fill in more tests for logger argument --- src/__private_api.rs | 7 ++----- src/macros.rs | 10 +++++++++- tests/integration.rs | 8 -------- 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/src/__private_api.rs b/src/__private_api.rs index 609374757..58d4c0fab 100644 --- a/src/__private_api.rs +++ b/src/__private_api.rs @@ -35,11 +35,7 @@ impl<'a> KVs<'a> for () { // Log implementation. /// The global logger proxy. -/// -/// This zero-sized type implements the [`Log`] trait by forwarding calls -/// to the logger registered with the `set_boxed_logger` or `set_logger` -/// methods if there is one, or a nop logger as default. -#[derive(Copy, Clone, Default, Debug)] +#[derive(Debug)] pub struct GlobalLogger; impl Log for GlobalLogger { @@ -56,6 +52,7 @@ impl Log for GlobalLogger { } } +// Split from `log` to reduce generics and code size fn log_impl( logger: L, args: Arguments, diff --git a/src/macros.rs b/src/macros.rs index dc51f6c83..b03ae5c67 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -58,11 +58,17 @@ /// /// let my_logger = MyLogger {}; /// log!( -/// logger: &my_logger, +/// logger: my_logger, /// Level::Error, /// "Received errors: {}, {}", /// data.0, data.1 /// ); +/// +/// The `logger` argument accepts a value that implements the `Log` trait. The value +/// will be borrowed within the macro. +/// +/// Note that the global level set via Cargo features, or through `set_max_level` will +/// still apply, even when a custom logger is supplied with the `logger` argument. #[macro_export] #[clippy::format_args] macro_rules! log { @@ -378,6 +384,8 @@ macro_rules! trace { /// debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y); /// } /// ``` +/// +/// This macro accepts the same `target` and `logger` arguments as [`macro@log`]. #[macro_export] macro_rules! log_enabled { // log_enabled!(logger: my_logger, target: "my_target", Level::Info) diff --git a/tests/integration.rs b/tests/integration.rs index 14f7a427d..0b8522d71 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -3,14 +3,6 @@ use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record}; use std::sync::{Arc, Mutex}; -#[cfg(feature = "std")] -use log::set_boxed_logger; - -#[cfg(not(feature = "std"))] -fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { - log::set_logger(Box::leak(logger)) -} - struct State { last_log_level: Mutex>, last_log_location: Mutex>, From d229c7355bb2d985454a99846f57b51fd4ad58d4 Mon Sep 17 00:00:00 2001 From: KodrAus Date: Mon, 24 Mar 2025 06:09:40 +1000 Subject: [PATCH 6/6] fix unclosed code block --- src/macros.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/macros.rs b/src/macros.rs index b03ae5c67..14e4ac64b 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -63,6 +63,7 @@ /// "Received errors: {}, {}", /// data.0, data.1 /// ); +/// ``` /// /// The `logger` argument accepts a value that implements the `Log` trait. The value /// will be borrowed within the macro.