objectstore_log/
macros.rs

1/// Logs a message at a given static level.
2///
3/// The first argument must be a [`tracing::Level`] constant. An optional `!!<error>` second
4/// argument casts the expression to `&dyn std::error::Error` and records it as the `error` field.
5/// All remaining arguments are forwarded verbatim to [`tracing::event!`].
6///
7/// The level-specific macros (`error!`, `warn!`, `info!`, `debug!`, `trace!`) are thin wrappers
8/// around this macro and are the preferred call form.
9///
10/// # Examples
11///
12/// ```rust
13/// # use objectstore_log::Level;
14/// # fn example() -> anyhow::Result<()> {
15/// let err = anyhow::anyhow!("something broke");
16/// objectstore_log::event!(Level::ERROR, !!err.as_ref(), "fatal error");
17/// objectstore_log::event!(Level::WARN, field = "value", "plain event");
18/// # Ok(())
19/// # }
20/// ```
21#[macro_export]
22macro_rules! event {
23    ($level:expr, !!$error:expr $(,)?) => {
24        $crate::tracing::event!($level, error = $error as &dyn ::std::error::Error)
25    };
26    ($level:expr, !!$error:expr, $($args:tt)+) => {
27        $crate::tracing::event!($level, error = $error as &dyn ::std::error::Error, $($args)+)
28    };
29    ($level:expr, $($args:tt)*) => {
30        $crate::tracing::event!($level, $($args)*)
31    };
32}
33
34/// Logs a message at `ERROR` level. See [`event!`] for full syntax.
35#[macro_export]
36macro_rules! error {
37    ($($args:tt)*) => { $crate::event!($crate::tracing::Level::ERROR, $($args)*) };
38}
39
40/// Logs a message at `WARN` level. See [`event!`] for full syntax.
41#[macro_export]
42macro_rules! warn {
43    ($($args:tt)*) => { $crate::event!($crate::tracing::Level::WARN, $($args)*) };
44}
45
46/// Logs a message at `INFO` level. See [`event!`] for full syntax.
47#[macro_export]
48macro_rules! info {
49    ($($args:tt)*) => { $crate::event!($crate::tracing::Level::INFO, $($args)*) };
50}
51
52/// Logs a message at `DEBUG` level. See [`event!`] for full syntax.
53#[macro_export]
54macro_rules! debug {
55    ($($args:tt)*) => { $crate::event!($crate::tracing::Level::DEBUG, $($args)*) };
56}
57
58/// Logs a message at `TRACE` level. See [`event!`] for full syntax.
59#[macro_export]
60macro_rules! trace {
61    ($($args:tt)*) => { $crate::event!($crate::tracing::Level::TRACE, $($args)*) };
62}
63
64/// Dispatches a log event at a level determined at runtime.
65///
66/// The first argument is a [`tracing::Level`] value resolved at runtime; all remaining arguments
67/// (including an optional `!!<error>`) are forwarded to the appropriate level macro.
68///
69/// Prefer the level-specific macros (`error!`, `warn!`, …) when the level is known at compile
70/// time. Use this macro only when the level is dynamic.
71///
72/// # Examples
73///
74/// ```rust
75/// # use objectstore_log::Level;
76/// let level = Level::WARN;
77/// objectstore_log::event_dyn!(level, "something happened");
78/// objectstore_log::event_dyn!(level, key = "value", "with a field");
79/// ```
80#[macro_export]
81macro_rules! event_dyn {
82    ($level:expr, $($args:tt)*) => {
83        match $level {
84            $crate::tracing::Level::ERROR => $crate::error!($($args)*),
85            $crate::tracing::Level::WARN  => $crate::warn!($($args)*),
86            $crate::tracing::Level::INFO  => $crate::info!($($args)*),
87            $crate::tracing::Level::DEBUG => $crate::debug!($($args)*),
88            $crate::tracing::Level::TRACE => $crate::trace!($($args)*),
89        }
90    };
91}