captains_log/
macros.rs

1#[doc(hidden)]
2#[macro_export]
3macro_rules! do_log_filter {
4    (target: $target:expr, $log_filter:expr, $lvl:expr, $($arg:tt)+) => ({
5        let lvl = $lvl;
6        if lvl <= log::STATIC_MAX_LEVEL && lvl as usize <= $log_filter.get_level() && lvl <= log::max_level() {
7            $log_filter._private_api_log(
8                std::format_args!($($arg)+),
9                lvl,
10                &($target, std::module_path!(), std::file!(), std::line!()),
11            );
12        }
13    });
14    ($log_filter:expr, $lvl:expr, $($arg:tt)+) => (do_log_filter!(target: std::module_path!(), $log_filter, $lvl, $($arg)+))
15}
16#[allow(unused_imports)]
17pub(super) use do_log_filter;
18
19/// Similar to [error!()](log::error!()), but the first argument is [LogFilter](crate::LogFilter) or
20/// [LogFilterKV](crate::LogFilterKV).
21#[macro_export]
22macro_rules! logger_error {
23    ($log_filter:expr, $($arg:tt)+) => (
24        do_log_filter!($log_filter, log::Level::Error, $($arg)+);
25    )
26}
27#[allow(unused_imports)]
28pub(super) use logger_error;
29
30/// Similar to [warn!()](log::warn!()), but the first argument is [LogFilter](crate::LogFilter) or
31/// [LogFilterKV](crate::LogFilterKV).
32#[macro_export]
33macro_rules! logger_warn {
34    ($log_filter:expr, $($arg:tt)+) => (
35        do_log_filter!($log_filter, log::Level::Warn, $($arg)+);
36    )
37}
38#[allow(unused_imports)]
39pub(super) use logger_warn;
40
41/// Similar to [info!()](log::info!()), but the first argument is [LogFilter](crate::LogFilter) or
42/// [LogFilterKV](crate::LogFilterKV).
43#[macro_export]
44macro_rules! logger_info {
45    ($log_filter:expr, $($arg:tt)+) => (
46        do_log_filter!($log_filter, log::Level::Info, $($arg)+);
47    )
48}
49#[allow(unused_imports)]
50pub(super) use logger_info;
51
52/// Similar to [debug!()](log::debug!()), but the first argument is [LogFilter](crate::LogFilter) or
53/// [LogFilterKV](crate::LogFilterKV)
54#[macro_export]
55macro_rules! logger_debug {
56    ($log_filter:expr, $($arg:tt)+) => (
57        do_log_filter!($log_filter, log::Level::Debug, $($arg)+);
58    )
59}
60#[allow(unused_imports)]
61pub(super) use logger_debug;
62
63/// Similar to [trace!()](log::trace!()), but the first argument is [LogFilter](crate::LogFilter) or
64/// [LogFilterKV](crate::LogFilterKV)
65#[macro_export]
66macro_rules! logger_trace {
67    ($log_filter:expr, $($arg:tt)+) => (
68        do_log_filter!($log_filter, log::Level::Trace, $($arg)+);
69    )
70}
71#[allow(unused_imports)]
72pub(super) use logger_trace;
73
74/// On debug build, will log with log_filter and panic when condition not met. Skip the check on
75/// release build.
76///
77/// The first argument is [LogFilter](crate::LogFilter) or [LogFilterKV](crate::LogFilterKV), the rest arguments are like [core::debug_assert!()].
78///
79/// # Examples:
80///
81/// ``` rust
82/// use captains_log::*;
83/// let logger = LogFilterKV::new("req_id", format!("{:016x}", 123).to_string());
84/// let started = true;
85/// logger_debug_assert!(logger, started);
86/// logger_debug_assert!(logger, started, "job must have been started");
87/// ```
88#[macro_export]
89macro_rules! logger_debug_assert {
90    ($log_filter:expr, $($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::logger_assert!($log_filter, $($arg)*); });
91}
92#[allow(unused_imports)]
93pub(super) use logger_debug_assert;
94
95/// On debug build, will log with log_filter and panic when condition not met. Skip the check on
96/// release build.
97///
98/// The first argument is [LogFilter](crate::LogFilter) or [LogFilterKV](crate::LogFilterKV), the rest arguments are like [core::debug_assert_eq!()].
99///
100/// # Examples:
101///
102/// ``` rust
103/// use captains_log::*;
104/// let logger = LogFilterKV::new("req_id", format!("{:016x}", 123).to_string());
105/// logger_debug_assert_eq!(logger, 1, 1);
106/// logger_debug_assert_eq!(logger, 1, 1, "impossible things happened: {}", "haha");
107/// ```
108#[macro_export]
109macro_rules! logger_debug_assert_eq {
110    ($log_filter:expr, $($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::logger_assert_eq!($log_filter, $($arg)*); })
111}
112#[allow(unused_imports)]
113pub(super) use logger_debug_assert_eq;
114
115/// Will log with log_filter and panic when condition not met.
116///
117/// The first argument is [LogFilter](crate::LogFilter) or [LogFilterKV](crate::LogFilterKV), the rest arguments are like [core::assert!()].
118///
119/// # Examples:
120///
121/// ``` rust
122/// use captains_log::*;
123/// let logger = LogFilterKV::new("req_id", format!("{:016x}", 123).to_string());
124/// let user_id = Some(111);
125/// logger_assert!(logger, user_id.is_some());
126/// logger_assert!(logger, user_id.is_some(), "user must login");
127/// ```
128#[macro_export]
129macro_rules! logger_assert {
130    ($log_filter:expr, $cond:expr) => ({
131        if !$cond {
132            do_log_filter!(
133                $log_filter,
134                log::Level::Error,
135                "assertion failed: {:?}",
136                $cond
137            );
138            std::panic!(r#"assertion failed: {:?}"#, $cond);
139        }
140    });
141    ($log_filter:expr, $cond:expr,) => ({
142        $crate::logger_assert!($log_filter, $cond);
143    });
144    ($log_filter:expr, $cond:expr, $($arg:tt)+) => ({
145        if !$cond {
146            do_log_filter!(
147                $log_filter,
148                log::Level::Error,
149                "assertion failed: {}",
150                std::format_args!($($arg)+)
151            );
152            std::panic!(r#"{}"#, std::format_args!($($arg)+));
153        }
154    });
155}
156#[allow(unused_imports)]
157pub(super) use logger_assert;
158
159/// Will log with log_filter and panic when condition not met.
160///
161/// The first argument is [LogFilter](crate::LogFilter) or [LogFilterKV](crate::LogFilterKV), the rest arguments are like [core::assert_eq!()].
162///
163/// # Examples:
164///
165/// ``` rust
166/// use captains_log::*;
167/// let logger = LogFilterKV::new("req_id", format!("{:016x}", 123).to_string());
168/// logger_assert_eq!(logger, 1, 1);
169/// logger_assert_eq!(logger, 1, 1, "impossible things happened");
170/// ```
171#[macro_export]
172macro_rules! logger_assert_eq {
173    ($log_filter:expr, $left:expr, $right:expr) => ({
174        match (&$left, &$right) {
175            (left_val, right_val) => {
176                if !(*left_val == *right_val) {
177                    do_log_filter!($log_filter, log::Level::Error, "assertion failed! \
178                    expected: (`left == right`) actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
179                    std::panic!(r#"assertion failed: `(left == right)`
180  left: `{:?}`,
181 right: `{:?}`"#, &*left_val, &*right_val);
182                }
183            }
184        }
185    });
186    ($log_filter:expr, $left:expr, $right:expr,) => ({
187        $crate::logger_assert_eq!($log_filter, $left, $right);
188    });
189    ($log_filter:expr, $left:expr, $right:expr, $($arg:tt)+) => ({
190        match (&($left), &($right)) {
191            (left_val, right_val) => {
192                if !(*left_val == *right_val) {
193                    do_log_filter!($log_filter, log::Level::Error, "assertion failed! \
194                    expected: `(left == right)` actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
195                    std::panic!(r#"assertion failed: `(left == right)`
196  left: `{:?}`,
197 right: `{:?}`: {}"#, &*left_val, &*right_val,
198                           std::format_args!($($arg)+));
199                }
200            }
201        }
202    });
203}
204#[allow(unused_imports)]
205pub(super) use logger_assert_eq;
206
207/// On Debug build, will log and panic when condition not met. Skip the check on
208/// release build.
209///
210/// The arguments are like [core::debug_assert!()].
211///
212/// # Examples:
213///
214/// ``` rust
215/// use captains_log::*;
216/// let user_id = Some(111);
217/// log_debug_assert!(user_id.is_some());
218/// log_debug_assert!(user_id.is_some(), "user must login");
219/// ```
220#[macro_export]
221macro_rules! log_debug_assert {
222    ($($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::log_assert!($($arg)*); });
223}
224#[allow(unused_imports)]
225pub(super) use log_debug_assert;
226
227/// On Debug build, will log and panic when condition not met. Skip the check on
228/// release build.
229///
230/// The arguments are like [core::debug_assert_eq!()].
231///
232/// # Examples:
233///
234/// ``` rust
235/// use captains_log::*;
236/// log_debug_assert_eq!(1, 1);
237/// log_debug_assert_eq!(1, 1, "impossible things happened");
238/// ```
239#[macro_export]
240macro_rules! log_debug_assert_eq {
241    ($($arg:tt)*) => (if std::cfg!(debug_assertions) { $crate::log_assert_eq!($($arg)*); })
242}
243#[allow(unused_imports)]
244pub(super) use log_debug_assert_eq;
245
246/// Will log and panic when condition not met.
247///
248/// The arguments are like [core::assert!()].
249///
250/// # Examples:
251///
252/// ``` rust
253/// use captains_log::*;
254/// let user_id = Some(111);
255/// log_assert!(user_id.is_some());
256/// log_assert!(user_id.is_some(), "user must login");
257/// ```
258#[macro_export]
259macro_rules! log_assert {
260    ($cond:expr) => ({
261        if !$cond {
262            log::error!(
263                "assertion failed: {:?}",
264                $cond
265            );
266            std::panic!(r#"assertion failed: {:?}"#, $cond);
267        }
268    });
269    ($cond:expr,) => ({
270        $crate::log_assert!($log_filter, $cond);
271    });
272    ($cond:expr, $($arg:tt)+) => ({
273        if !$cond {
274            log::error!(
275                "assertion failed: {}",
276                std::format_args!($($arg)+)
277            );
278            std::panic!(r#"{}"#, std::format_args!($($arg)+));
279        }
280    });
281}
282#[allow(unused_imports)]
283pub(super) use log_assert;
284
285/// Will log and panic when condition not met.
286///
287/// The arguments are like [core::assert_eq!()].
288///
289/// # Examples:
290///
291/// ``` rust
292/// use captains_log::*;
293/// log_assert_eq!(1, 1);
294/// log_assert_eq!(1, 1, "impossible things happened");
295/// ```
296#[macro_export]
297macro_rules! log_assert_eq {
298    ($left:expr, $right:expr) => ({
299        match (&$left, &$right) {
300            (left_val, right_val) => {
301                if !(*left_val == *right_val) {
302                    log::error!("assertion failed! \
303                    expected: (`left == right`) actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
304                    std::panic!(r#"assertion failed: `(left == right)`
305  left: `{:?}`,
306 right: `{:?}`"#, &*left_val, &*right_val);
307                }
308            }
309        }
310    });
311    ($left:expr, $right:expr,) => ({
312        $crate::log_assert_eq!($left, $right);
313    });
314    ($left:expr, $right:expr, $($arg:tt)+) => ({
315        match (&($left), &($right)) {
316            (left_val, right_val) => {
317                if !(*left_val == *right_val) {
318                    log::error!( "assertion failed! \
319                    expected: `(left == right)` actual: (`{:?}` != `{:?}`)", &*left_val, &*right_val);
320                    std::panic!(r#"assertion failed: `(left == right)`
321  left: `{:?}`,
322 right: `{:?}`: {}"#, &*left_val, &*right_val,
323                           std::format_args!($($arg)+));
324                }
325            }
326        }
327    });
328}
329
330#[allow(unused_imports)]
331pub(super) use log_assert_eq;
332
333/// log and println to stdout.
334///
335/// The usage is similar to [std::println!()]
336#[macro_export]
337macro_rules! log_println {
338    ($($arg:tt)+) => {
339        std::println!($($arg)+);
340        log::info!($($arg)+);
341    }
342}
343#[allow(unused_imports)]
344pub(super) use log_println;
345
346/// log and println to stderr.
347///
348/// The usage is similar to [std::eprintln!()]
349#[macro_export]
350macro_rules! log_eprintln {
351    ($($arg:tt)+) => {
352        std::eprintln!($($arg)+);
353        log::info!($($arg)+);
354    }
355}
356#[allow(unused_imports)]
357pub(super) use log_eprintln;
captains_log/macros.rs

captains_log/
macros.rs
