tracing/
macros.rs

Help
1/// Constructs a new span.
2///
3/// See [the top-level documentation][lib] for details on the syntax accepted by
4/// this macro.
5///
6/// [lib]: crate#using-the-macros
7///
8/// # Examples
9///
10/// Creating a new span:
11/// ```
12/// # use tracing::{span, Level};
13/// # fn main() {
14/// let span = span!(Level::TRACE, "my span");
15/// let _enter = span.enter();
16/// // do work inside the span...
17/// # }
18/// ```
19#[macro_export]
20macro_rules! span {
21    (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr) => {
22        $crate::span!(target: $target, parent: $parent, $lvl, $name,)
23    };
24    (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
25        {
26            use $crate::__macro_support::Callsite as _;
27            static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
28                name: $name,
29                kind: $crate::metadata::Kind::SPAN,
30                target: $target,
31                level: $lvl,
32                fields: $($fields)*
33            };
34            let mut interest = $crate::collect::Interest::never();
35            if $crate::level_enabled!($lvl)
36                && { interest = __CALLSITE.interest(); !interest.is_never() }
37                && __CALLSITE.is_enabled(interest)
38            {
39                let meta = __CALLSITE.metadata();
40                // span with explicit parent
41                $crate::Span::child_of(
42                    $parent,
43                    meta,
44                    &$crate::valueset!(meta.fields(), $($fields)*),
45                )
46            } else {
47                let span = __CALLSITE.disabled_span();
48                $crate::if_log_enabled! { $lvl, {
49                    span.record_all(&$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
50                }};
51                span
52            }
53        }
54    };
55    (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
56        {
57            use $crate::__macro_support::{Callsite as _, Registration};
58            static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
59                name: $name,
60                kind: $crate::metadata::Kind::SPAN,
61                target: $target,
62                level: $lvl,
63                fields: $($fields)*
64            };
65
66            let mut interest = $crate::collect::Interest::never();
67            if $crate::level_enabled!($lvl)
68                && { interest = __CALLSITE.interest(); !interest.is_never() }
69                && __CALLSITE.is_enabled(interest)
70            {
71                let meta = __CALLSITE.metadata();
72                // span with contextual parent
73                $crate::Span::new(
74                    meta,
75                    &$crate::valueset!(meta.fields(), $($fields)*),
76                )
77            } else {
78                let span = __CALLSITE.disabled_span();
79                $crate::if_log_enabled! { $lvl, {
80                    span.record_all(&$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
81                }};
82                span
83            }
84        }
85    };
86    (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr) => {
87        $crate::span!(target: $target, parent: $parent, $lvl, $name,)
88    };
89    (parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
90        $crate::span!(
91            target: module_path!(),
92            parent: $parent,
93            $lvl,
94            $name,
95            $($fields)*
96        )
97    };
98    (parent: $parent:expr, $lvl:expr, $name:expr) => {
99        $crate::span!(
100            target: module_path!(),
101            parent: $parent,
102            $lvl,
103            $name,
104        )
105    };
106    (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
107        $crate::span!(
108            target: $target,
109            $lvl,
110            $name,
111            $($fields)*
112        )
113    };
114    (target: $target:expr, $lvl:expr, $name:expr) => {
115        $crate::span!(target: $target, $lvl, $name,)
116    };
117    ($lvl:expr, $name:expr, $($fields:tt)*) => {
118        $crate::span!(
119            target: module_path!(),
120            $lvl,
121            $name,
122            $($fields)*
123        )
124    };
125    ($lvl:expr, $name:expr) => {
126        $crate::span!(
127            target: module_path!(),
128            $lvl,
129            $name,
130        )
131    };
132}
133
134/// Records multiple values on a span in a single call. As with recording
135/// individual values, all fields must be declared when the span is created.
136///
137/// This macro supports two optional sigils:
138/// - `%` uses the Display implementation.
139/// - `?` uses the Debug implementation.
140///
141/// For more details, see the [top-level documentation][lib].
142///
143/// [lib]: tracing/#recording-fields
144///
145/// # Examples
146///
147/// ```
148/// # use tracing::{field, info_span, record_all};
149/// let span = info_span!("my span", field1 = field::Empty, field2 = field::Empty, field3 = field::Empty).entered();
150/// record_all!(span, field1 = ?"1", field2 = %"2", field3 = 3);
151/// ```
152#[macro_export]
153macro_rules! record_all {
154    ($span:expr, $($fields:tt)*) => {
155        if let Some(meta) = $span.metadata() {
156            $span.record_all(&$crate::valueset!(
157                meta.fields(),
158                $($fields)*
159            ));
160        }
161    };
162}
163
164/// Constructs a span at the trace level.
165///
166/// [Fields] and [attributes] are set using the same syntax as the [`span!`]
167/// macro.
168///
169/// See [the top-level documentation][lib] for details on the syntax accepted by
170/// this macro.
171///
172/// [lib]: crate#using-the-macros
173/// [attributes]: crate#configuring-attributes
174/// [Fields]: crate#recording-fields
175/// [`span!`]: span!
176///
177/// # Examples
178///
179/// ```rust
180/// # use tracing::{trace_span, span, Level};
181/// # fn main() {
182/// trace_span!("my_span");
183/// // is equivalent to:
184/// span!(Level::TRACE, "my_span");
185/// # }
186/// ```
187///
188/// ```rust
189/// # use tracing::{trace_span, span, Level};
190/// # fn main() {
191/// let span = trace_span!("my span");
192/// span.in_scope(|| {
193///     // do work inside the span...
194/// });
195/// # }
196/// ```
197#[macro_export]
198macro_rules! trace_span {
199    (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
200        $crate::span!(
201            target: $target,
202            parent: $parent,
203            $crate::Level::TRACE,
204            $name,
205            $($field)*
206        )
207    };
208    (target: $target:expr, parent: $parent:expr, $name:expr) => {
209        $crate::trace_span!(target: $target, parent: $parent, $name,)
210    };
211    (parent: $parent:expr, $name:expr, $($field:tt)*) => {
212        $crate::span!(
213            target: module_path!(),
214            parent: $parent,
215            $crate::Level::TRACE,
216            $name,
217            $($field)*
218        )
219    };
220    (parent: $parent:expr, $name:expr) => {
221        $crate::trace_span!(parent: $parent, $name,)
222    };
223    (target: $target:expr, $name:expr, $($field:tt)*) => {
224        $crate::span!(
225            target: $target,
226            $crate::Level::TRACE,
227            $name,
228            $($field)*
229        )
230    };
231    (target: $target:expr, $name:expr) => {
232        $crate::trace_span!(target: $target, $name,)
233    };
234    ($name:expr, $($field:tt)*) => {
235        $crate::span!(
236            target: module_path!(),
237            $crate::Level::TRACE,
238            $name,
239            $($field)*
240        )
241    };
242    ($name:expr) => { $crate::trace_span!($name,) };
243}
244
245/// Constructs a span at the debug level.
246///
247/// [Fields] and [attributes] are set using the same syntax as the [`span!`]
248/// macro.
249///
250/// See [the top-level documentation][lib] for details on the syntax accepted by
251/// this macro.
252///
253/// [lib]: crate#using-the-macros
254/// [attributes]: crate#configuring-attributes
255/// [Fields]: crate#recording-fields
256/// [`span!`]: span!
257///
258/// # Examples
259///
260/// ```rust
261/// # use tracing::{debug_span, span, Level};
262/// # fn main() {
263/// debug_span!("my_span");
264/// // is equivalent to:
265/// span!(Level::DEBUG, "my_span");
266/// # }
267/// ```
268///
269/// ```rust
270/// # use tracing::debug_span;
271/// # fn main() {
272/// let span = debug_span!("my span");
273/// span.in_scope(|| {
274///     // do work inside the span...
275/// });
276/// # }
277/// ```
278#[macro_export]
279macro_rules! debug_span {
280    (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
281        $crate::span!(
282            target: $target,
283            parent: $parent,
284            $crate::Level::DEBUG,
285            $name,
286            $($field)*
287        )
288    };
289    (target: $target:expr, parent: $parent:expr, $name:expr) => {
290        $crate::debug_span!(target: $target, parent: $parent, $name,)
291    };
292    (parent: $parent:expr, $name:expr, $($field:tt)*) => {
293        $crate::span!(
294            target: module_path!(),
295            parent: $parent,
296            $crate::Level::DEBUG,
297            $name,
298            $($field)*
299        )
300    };
301    (parent: $parent:expr, $name:expr) => {
302        $crate::debug_span!(parent: $parent, $name,)
303    };
304    (target: $target:expr, $name:expr, $($field:tt)*) => {
305        $crate::span!(
306            target: $target,
307            $crate::Level::DEBUG,
308            $name,
309            $($field)*
310        )
311    };
312    (target: $target:expr, $name:expr) => {
313        $crate::debug_span!(target: $target, $name,)
314    };
315    ($name:expr, $($field:tt)*) => {
316        $crate::span!(
317            target: module_path!(),
318            $crate::Level::DEBUG,
319            $name,
320            $($field)*
321        )
322    };
323    ($name:expr) => {$crate::debug_span!($name,)};
324}
325
326/// Constructs a span at the info level.
327///
328/// [Fields] and [attributes] are set using the same syntax as the [`span!`]
329/// macro.
330///
331/// See [the top-level documentation][lib] for details on the syntax accepted by
332/// this macro.
333///
334/// [lib]: crate#using-the-macros
335/// [attributes]: crate#configuring-attributes
336/// [Fields]: crate#recording-fields
337/// [`span!`]: span!
338///
339/// # Examples
340///
341/// ```rust
342/// # use tracing::{span, info_span, Level};
343/// # fn main() {
344/// info_span!("my_span");
345/// // is equivalent to:
346/// span!(Level::INFO, "my_span");
347/// # }
348/// ```
349///
350/// ```rust
351/// # use tracing::info_span;
352/// # fn main() {
353/// let span = info_span!("my span");
354/// span.in_scope(|| {
355///     // do work inside the span...
356/// });
357/// # }
358/// ```
359#[macro_export]
360macro_rules! info_span {
361    (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
362        $crate::span!(
363            target: $target,
364            parent: $parent,
365            $crate::Level::INFO,
366            $name,
367            $($field)*
368        )
369    };
370    (target: $target:expr, parent: $parent:expr, $name:expr) => {
371        $crate::info_span!(target: $target, parent: $parent, $name,)
372    };
373    (parent: $parent:expr, $name:expr, $($field:tt)*) => {
374        $crate::span!(
375            target: module_path!(),
376            parent: $parent,
377            $crate::Level::INFO,
378            $name,
379            $($field)*
380        )
381    };
382    (parent: $parent:expr, $name:expr) => {
383        $crate::info_span!(parent: $parent, $name,)
384    };
385    (target: $target:expr, $name:expr, $($field:tt)*) => {
386        $crate::span!(
387            target: $target,
388            $crate::Level::INFO,
389            $name,
390            $($field)*
391        )
392    };
393    (target: $target:expr, $name:expr) => {
394        $crate::info_span!(target: $target, $name,)
395    };
396    ($name:expr, $($field:tt)*) => {
397        $crate::span!(
398            target: module_path!(),
399            $crate::Level::INFO,
400            $name,
401            $($field)*
402        )
403    };
404    ($name:expr) => {$crate::info_span!($name,)};
405}
406
407/// Constructs a span at the warn level.
408///
409/// [Fields] and [attributes] are set using the same syntax as the [`span!`]
410/// macro.
411///
412/// See [the top-level documentation][lib] for details on the syntax accepted by
413/// this macro.
414///
415/// [lib]: crate#using-the-macros
416/// [attributes]: crate#configuring-attributes
417/// [Fields]: crate#recording-fields
418/// [`span!`]: span!
419///
420/// # Examples
421///
422/// ```rust
423/// # use tracing::{warn_span, span, Level};
424/// # fn main() {
425/// warn_span!("my_span");
426/// // is equivalent to:
427/// span!(Level::WARN, "my_span");
428/// # }
429/// ```
430///
431/// ```rust
432/// use tracing::warn_span;
433/// # fn main() {
434/// let span = warn_span!("my span");
435/// span.in_scope(|| {
436///     // do work inside the span...
437/// });
438/// # }
439/// ```
440#[macro_export]
441macro_rules! warn_span {
442    (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
443        $crate::span!(
444            target: $target,
445            parent: $parent,
446            $crate::Level::WARN,
447            $name,
448            $($field)*
449        )
450    };
451    (target: $target:expr, parent: $parent:expr, $name:expr) => {
452        $crate::warn_span!(target: $target, parent: $parent, $name,)
453    };
454    (parent: $parent:expr, $name:expr, $($field:tt)*) => {
455        $crate::span!(
456            target: module_path!(),
457            parent: $parent,
458            $crate::Level::WARN,
459            $name,
460            $($field)*
461        )
462    };
463    (parent: $parent:expr, $name:expr) => {
464        $crate::warn_span!(parent: $parent, $name,)
465    };
466    (target: $target:expr, $name:expr, $($field:tt)*) => {
467        $crate::span!(
468            target: $target,
469            $crate::Level::WARN,
470            $name,
471            $($field)*
472        )
473    };
474    (target: $target:expr, $name:expr) => {
475        $crate::warn_span!(target: $target, $name,)
476    };
477    ($name:expr, $($field:tt)*) => {
478        $crate::span!(
479            target: module_path!(),
480            $crate::Level::WARN,
481            $name,
482            $($field)*
483        )
484    };
485    ($name:expr) => {$crate::warn_span!($name,)};
486}
487/// Constructs a span at the error level.
488///
489/// [Fields] and [attributes] are set using the same syntax as the [`span!`]
490/// macro.
491///
492/// See [the top-level documentation][lib] for details on the syntax accepted by
493/// this macro.
494///
495/// [lib]: crate#using-the-macros
496/// [attributes]: crate#configuring-attributes
497/// [Fields]: crate#recording-fields
498/// [`span!`]: span!
499///
500/// # Examples
501///
502/// ```rust
503/// # use tracing::{span, error_span, Level};
504/// # fn main() {
505/// error_span!("my_span");
506/// // is equivalent to:
507/// span!(Level::ERROR, "my_span");
508/// # }
509/// ```
510///
511/// ```rust
512/// # use tracing::error_span;
513/// # fn main() {
514/// let span = error_span!("my span");
515/// span.in_scope(|| {
516///     // do work inside the span...
517/// });
518/// # }
519/// ```
520#[macro_export]
521macro_rules! error_span {
522    (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
523        $crate::span!(
524            target: $target,
525            parent: $parent,
526            $crate::Level::ERROR,
527            $name,
528            $($field)*
529        )
530    };
531    (target: $target:expr, parent: $parent:expr, $name:expr) => {
532        $crate::error_span!(target: $target, parent: $parent, $name,)
533    };
534    (parent: $parent:expr, $name:expr, $($field:tt)*) => {
535        $crate::span!(
536            target: module_path!(),
537            parent: $parent,
538            $crate::Level::ERROR,
539            $name,
540            $($field)*
541        )
542    };
543    (parent: $parent:expr, $name:expr) => {
544        $crate::error_span!(parent: $parent, $name,)
545    };
546    (target: $target:expr, $name:expr, $($field:tt)*) => {
547        $crate::span!(
548            target: $target,
549            $crate::Level::ERROR,
550            $name,
551            $($field)*
552        )
553    };
554    (target: $target:expr, $name:expr) => {
555        $crate::error_span!(target: $target, $name,)
556    };
557    ($name:expr, $($field:tt)*) => {
558        $crate::span!(
559            target: module_path!(),
560            $crate::Level::ERROR,
561            $name,
562            $($field)*
563        )
564    };
565    ($name:expr) => {$crate::error_span!($name,)};
566}
567
568/// Constructs a new `Event`.
569///
570/// The event macro is invoked with a `Level` and up to 32 key-value fields.
571/// Optionally, a format string and arguments may follow the fields; this will
572/// be used to construct an implicit field named "message".
573///
574/// See [the top-level documentation][lib] for details on the syntax accepted by
575/// this macro.
576///
577/// [lib]: crate#using-the-macros
578///
579/// # Examples
580///
581/// ```rust
582/// use tracing::{event, Level};
583///
584/// # fn main() {
585/// let data = (42, "forty-two");
586/// let private_data = "private";
587/// let error = "a bad error";
588///
589/// event!(Level::ERROR, %error, "Received error");
590/// event!(
591///     target: "app_events",
592///     Level::WARN,
593///     private_data,
594///     ?data,
595///     "App warning: {}",
596///     error
597/// );
598/// event!(name: "answer", Level::INFO, the_answer = data.0);
599/// event!(Level::INFO, the_answer = data.0);
600/// # }
601/// ```
602///
603// /// Note that *unlike `span!`*, `event!` requires a value for all fields. As
604// /// events are recorded immediately when the macro is invoked, there is no
605// /// opportunity for fields to be recorded later. A trailing comma on the final
606// /// field is valid.
607// ///
608// /// For example, the following does not compile:
609// /// ```rust,compile_fail
610// /// # use tracing::{Level, event};
611// /// # fn main() {
612// /// event!(Level::INFO, foo = 5, bad_field, bar = "hello")
613// /// #}
614// /// ```
615#[macro_export]
616macro_rules! event {
617    // Name / target / parent.
618    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
619        use $crate::__macro_support::Callsite as _;
620        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
621            name: $name,
622            kind: $crate::metadata::Kind::EVENT,
623            target: $target,
624            level: $lvl,
625            fields: $($fields)*
626        };
627
628        let enabled = $crate::level_enabled!($lvl) && {
629            let interest = __CALLSITE.interest();
630            !interest.is_never() && __CALLSITE.is_enabled(interest)
631        };
632        if enabled {
633            (|value_set: $crate::field::ValueSet| {
634                $crate::__tracing_log!(
635                    $lvl,
636                    __CALLSITE,
637                    &value_set
638                );
639                let meta = __CALLSITE.metadata();
640                // event with explicit parent
641                $crate::Event::child_of(
642                    $parent,
643                    meta,
644                    &value_set
645                );
646            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
647        } else {
648            $crate::__tracing_log!(
649                $lvl,
650                __CALLSITE,
651                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
652            );
653        }
654    });
655    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
656        $crate::event!(
657            name: $name,
658            target: $target,
659            parent: $parent,
660            $lvl,
661            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
662        )
663    );
664    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
665        $crate::event!(name: $name, target: $target, parent: $parent, $lvl, { $($k).+ = $($fields)* })
666    );
667    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
668        $crate::event!(name: $name, target: $target, parent: $parent, $lvl, { $($arg)+ })
669    );
670
671    // Name / target.
672    (name: $name:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
673        use $crate::__macro_support::Callsite as _;
674        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
675            name: $name,
676            kind: $crate::metadata::Kind::EVENT,
677            target: $target,
678            level: $lvl,
679            fields: $($fields)*
680        };
681        let enabled = $crate::level_enabled!($lvl) && {
682            let interest = __CALLSITE.interest();
683            !interest.is_never() && __CALLSITE.is_enabled(interest)
684        };
685        if enabled {
686            (|value_set: $crate::field::ValueSet| {
687                let meta = __CALLSITE.metadata();
688                // event with contextual parent
689                $crate::Event::dispatch(
690                    meta,
691                    &value_set
692                );
693                $crate::__tracing_log!(
694                    $lvl,
695                    __CALLSITE,
696                    &value_set
697                );
698            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
699        } else {
700            $crate::__tracing_log!(
701                $lvl,
702                __CALLSITE,
703                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
704            );
705        }
706    });
707    (name: $name:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
708        $crate::event!(
709            name: $name,
710            target: $target,
711            $lvl,
712            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
713        )
714    );
715    (name: $name:expr, target: $target:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
716        $crate::event!(name: $name, target: $target, $lvl, { $($k).+ = $($fields)* })
717    );
718    (name: $name:expr, target: $target:expr, $lvl:expr, $($arg:tt)+) => (
719        $crate::event!(name: $name, target: $target, $lvl, { $($arg)+ })
720    );
721
722    // Target / parent.
723    (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
724        use $crate::__macro_support::Callsite as _;
725        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
726            name: $crate::__macro_support::concat!(
727                "event ",
728                $crate::__macro_support::file!(),
729                ":",
730                $crate::__macro_support::line!()
731            ),
732            kind: $crate::metadata::Kind::EVENT,
733            target: $target,
734            level: $lvl,
735            fields: $($fields)*
736        };
737
738        let enabled = $crate::level_enabled!($lvl) && {
739            let interest = __CALLSITE.interest();
740            !interest.is_never() && __CALLSITE.is_enabled(interest)
741        };
742        if enabled {
743            (|value_set: $crate::field::ValueSet| {
744                $crate::__tracing_log!(
745                    $lvl,
746                    __CALLSITE,
747                    &value_set
748                );
749                let meta = __CALLSITE.metadata();
750                // event with explicit parent
751                $crate::Event::child_of(
752                    $parent,
753                    meta,
754                    &value_set
755                );
756            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
757        } else {
758            $crate::__tracing_log!(
759                $lvl,
760                __CALLSITE,
761                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
762            );
763        }
764    });
765    (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
766        $crate::event!(
767            target: $target,
768            parent: $parent,
769            $lvl,
770            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
771        )
772    );
773    (target: $target:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
774        $crate::event!(target: $target, parent: $parent, $lvl, { $($k).+ = $($fields)* })
775    );
776    (target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
777        $crate::event!(target: $target, parent: $parent, $lvl, { $($arg)+ })
778    );
779
780    // Name / parent.
781    (name: $name:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
782        use $crate::__macro_support::Callsite as _;
783        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
784            name: $name,
785            kind: $crate::metadata::Kind::EVENT,
786            target: module_path!(),
787            level: $lvl,
788            fields: $($fields)*
789        };
790
791        let enabled = $crate::level_enabled!($lvl) && {
792            let interest = __CALLSITE.interest();
793            !interest.is_never() && __CALLSITE.is_enabled(interest)
794        };
795        if enabled {
796            (|value_set: $crate::field::ValueSet| {
797                $crate::__tracing_log!(
798                    $lvl,
799                    __CALLSITE,
800                    &value_set
801                );
802                let meta = __CALLSITE.metadata();
803                // event with explicit parent
804                $crate::Event::child_of(
805                    $parent,
806                    meta,
807                    &value_set
808                );
809            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
810        } else {
811            $crate::__tracing_log!(
812                $lvl,
813                __CALLSITE,
814                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
815            );
816        }
817    });
818    (name: $name:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
819        $crate::event!(
820            name: $name,
821            parent: $parent,
822            $lvl,
823            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
824        )
825    );
826    (name: $name:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
827        $crate::event!(name: $name, parent: $parent, $lvl, { $($k).+ = $($fields)* })
828    );
829    (name: $name:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
830        $crate::event!(name: $name, parent: $parent, $lvl, { $($arg)+ })
831    );
832
833    // Name.
834    (name: $name:expr, $lvl:expr, { $($fields:tt)* } )=> ({
835        use $crate::__macro_support::Callsite as _;
836        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
837            name: $name,
838            kind: $crate::metadata::Kind::EVENT,
839            target: module_path!(),
840            level: $lvl,
841            fields: $($fields)*
842        };
843        let enabled = $crate::level_enabled!($lvl) && {
844            let interest = __CALLSITE.interest();
845            !interest.is_never() && __CALLSITE.is_enabled(interest)
846        };
847        if enabled {
848            (|value_set: $crate::field::ValueSet| {
849                let meta = __CALLSITE.metadata();
850                // event with contextual parent
851                $crate::Event::dispatch(
852                    meta,
853                    &value_set
854                );
855                $crate::__tracing_log!(
856                    $lvl,
857                    __CALLSITE,
858                    &value_set
859                );
860            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
861        } else {
862            $crate::__tracing_log!(
863                $lvl,
864                __CALLSITE,
865                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
866            );
867        }
868    });
869    (name: $name:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
870        $crate::event!(
871            name: $name,
872            $lvl,
873            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
874        )
875    );
876    (name: $name:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
877        $crate::event!(name: $name, $lvl, { $($k).+ = $($fields)* })
878    );
879    (name: $name:expr, $lvl:expr, $($arg:tt)+ ) => (
880        $crate::event!(name: $name, $lvl, { $($arg)+ })
881    );
882
883    // Target.
884    (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
885        use $crate::__macro_support::Callsite as _;
886        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
887            name: $crate::__macro_support::concat!(
888                "event ",
889                $crate::__macro_support::file!(),
890                ":",
891                $crate::__macro_support::line!()
892            ),
893            kind: $crate::metadata::Kind::EVENT,
894            target: $target,
895            level: $lvl,
896            fields: $($fields)*
897        };
898        let enabled = $crate::level_enabled!($lvl) && {
899            let interest = __CALLSITE.interest();
900            !interest.is_never() && __CALLSITE.is_enabled(interest)
901        };
902        if enabled {
903            (|value_set: $crate::field::ValueSet| {
904                let meta = __CALLSITE.metadata();
905                // event with contextual parent
906                $crate::Event::dispatch(
907                    meta,
908                    &value_set
909                );
910                $crate::__tracing_log!(
911                    $lvl,
912                    __CALLSITE,
913                    &value_set
914                );
915            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
916        } else {
917            $crate::__tracing_log!(
918                $lvl,
919                __CALLSITE,
920                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
921            );
922        }
923    });
924    (target: $target:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
925        $crate::event!(
926            target: $target,
927            $lvl,
928            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
929        )
930    );
931    (target: $target:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
932        $crate::event!(target: $target, $lvl, { $($k).+ = $($fields)* })
933    );
934    (target: $target:expr, $lvl:expr, $($arg:tt)+ ) => (
935        $crate::event!(target: $target, $lvl, { $($arg)+ })
936    );
937
938    // Parent.
939    (parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
940        $crate::event!(
941            target: module_path!(),
942            parent: $parent,
943            $lvl,
944            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
945        )
946    );
947    (parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($field:tt)*) => (
948        $crate::event!(
949            target: module_path!(),
950            parent: $parent,
951            $lvl,
952            { $($k).+ = $($field)*}
953        )
954    );
955    (parent: $parent:expr, $lvl:expr, ?$($k:ident).+ = $($field:tt)*) => (
956        $crate::event!(
957            target: module_path!(),
958            parent: $parent,
959            $lvl,
960            { ?$($k).+ = $($field)*}
961        )
962    );
963    (parent: $parent:expr, $lvl:expr, %$($k:ident).+ = $($field:tt)*) => (
964        $crate::event!(
965            target: module_path!(),
966            parent: $parent,
967            $lvl,
968            { %$($k).+ = $($field)*}
969        )
970    );
971    (parent: $parent:expr, $lvl:expr, $($k:ident).+, $($field:tt)*) => (
972        $crate::event!(
973            target: module_path!(),
974            parent: $parent,
975            $lvl,
976            { $($k).+, $($field)*}
977        )
978    );
979    (parent: $parent:expr, $lvl:expr, %$($k:ident).+, $($field:tt)*) => (
980        $crate::event!(
981            target: module_path!(),
982            parent: $parent,
983            $lvl,
984            { %$($k).+, $($field)*}
985        )
986    );
987    (parent: $parent:expr, $lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
988        $crate::event!(
989            target: module_path!(),
990            parent: $parent,
991            $lvl,
992            { ?$($k).+, $($field)*}
993        )
994    );
995    (parent: $parent:expr, $lvl:expr, $($arg:tt)+ ) => (
996        $crate::event!(target: module_path!(), parent: $parent, $lvl, { $($arg)+ })
997    );
998
999    // ...
1000    ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
1001        $crate::event!(
1002            target: module_path!(),
1003            $lvl,
1004            { message = $crate::__macro_support::format_args!($($arg)+), $($fields)* }
1005        )
1006    );
1007    ($lvl:expr, $($k:ident).+ = $($field:tt)*) => (
1008        $crate::event!(
1009            target: module_path!(),
1010            $lvl,
1011            { $($k).+ = $($field)*}
1012        )
1013    );
1014    ($lvl:expr, $($k:ident).+, $($field:tt)*) => (
1015        $crate::event!(
1016            target: module_path!(),
1017            $lvl,
1018            { $($k).+, $($field)*}
1019        )
1020    );
1021    ($lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
1022        $crate::event!(
1023            target: module_path!(),
1024            $lvl,
1025            { ?$($k).+, $($field)*}
1026        )
1027    );
1028    ($lvl:expr, %$($k:ident).+, $($field:tt)*) => (
1029        $crate::event!(
1030            target: module_path!(),
1031            $lvl,
1032            { %$($k).+, $($field)*}
1033        )
1034    );
1035    ($lvl:expr, ?$($k:ident).+) => (
1036        $crate::event!($lvl, ?$($k).+,)
1037    );
1038    ($lvl:expr, %$($k:ident).+) => (
1039        $crate::event!($lvl, %$($k).+,)
1040    );
1041    ($lvl:expr, $($k:ident).+) => (
1042        $crate::event!($lvl, $($k).+,)
1043    );
1044    ( $lvl:expr, $($arg:tt)+ ) => (
1045        $crate::event!(target: module_path!(), $lvl, { $($arg)+ })
1046    );
1047}
1048
1049/// Tests whether an event with the specified level and target would be enabled.
1050///
1051/// This is similar to [`enabled!`], but queries the current collector specifically for
1052/// an event, whereas [`enabled!`] queries for an event _or_ span.
1053///
1054/// Although it shares the name, this *does not* call [`Collect::event_enabled`].
1055/// `Collect::event_enabled` is only called once the event fields are available.
1056///
1057/// See the documentation for [`enabled!]` for more details on using this macro.
1058/// See also [`span_enabled!`].
1059///
1060/// # Examples
1061///
1062/// ```rust
1063/// # use tracing::{event_enabled, Level};
1064/// if event_enabled!(target: "my_crate", Level::DEBUG) {
1065///     // some expensive work...
1066/// }
1067/// // simpler
1068/// if event_enabled!(Level::DEBUG) {
1069///     // some expensive work...
1070/// }
1071/// // with fields
1072/// if event_enabled!(Level::DEBUG, foo_field) {
1073///     // some expensive work...
1074/// }
1075/// ```
1076///
1077/// [`Collect::event_enabled`]: crate::Collect::event_enabled
1078/// [`enabled!`]: crate::enabled
1079/// [`span_enabled!`]: crate::span_enabled
1080#[macro_export]
1081macro_rules! event_enabled {
1082    ($($rest:tt)*)=> (
1083        $crate::enabled!(kind: $crate::metadata::Kind::EVENT, $($rest)*)
1084    )
1085}
1086
1087/// Tests whether a span with the specified level and target would be enabled.
1088///
1089/// This is similar to [`enabled!`], but queries the current collector specifically for
1090/// an event, whereas [`enabled!`] queries for an event _or_ span.
1091///
1092/// See the documentation for [`enabled!]` for more details on using this macro.
1093/// See also [`span_enabled!`].
1094///
1095/// # Examples
1096///
1097/// ```rust
1098/// # use tracing::{span_enabled, Level};
1099/// if span_enabled!(target: "my_crate", Level::DEBUG) {
1100///     // some expensive work...
1101/// }
1102/// // simpler
1103/// if span_enabled!(Level::DEBUG) {
1104///     // some expensive work...
1105/// }
1106/// // with fields
1107/// if span_enabled!(Level::DEBUG, foo_field) {
1108///     // some expensive work...
1109/// }
1110/// ```
1111///
1112/// [`enabled!`]: crate::enabled
1113/// [`span_enabled!`]: crate::span_enabled
1114#[macro_export]
1115macro_rules! span_enabled {
1116    ($($rest:tt)*)=> (
1117        $crate::enabled!(kind: $crate::metadata::Kind::SPAN, $($rest)*)
1118    )
1119}
1120
1121/// Checks whether a span or event is [enabled] based on the provided [metadata].
1122///
1123/// [enabled]: crate::Collect::enabled
1124/// [metadata]: crate::Metadata
1125///
1126/// This macro is a specialized tool: it is intended to be used prior
1127/// to an expensive computation required *just* for that event, but
1128/// *cannot* be done as part of an argument to that event, such as
1129/// when multiple events are emitted (e.g., iterating over a collection
1130/// and emitting an event for each item).
1131///
1132/// # Usage
1133///
1134/// [Collectors] can make filtering decisions based all the data included in a
1135/// span or event's [`Metadata`]. This means that it is possible for `enabled!`
1136/// to return a _false positive_ (indicating that something would be enabled
1137/// when it actually would not be) or a _false negative_ (indicating that
1138/// something would be disabled when it would actually be enabled).
1139///
1140/// [Collectors]: crate::collect::Collect
1141/// [`Metadata`]: crate::metadata::Metadata
1142///
1143/// This occurs when a subscriber is using a _more specific_ filter than the
1144/// metadata provided to the `enabled!` macro. Some situations that can result
1145/// in false positives or false negatives include:
1146///
1147/// - If a collector is using a filter which may enable a span or event based
1148///   on field names, but `enabled!` is invoked without listing field names,
1149///   `enabled!` may return a false negative if a specific field name would
1150///   cause the collector to enable something that would otherwise be disabled.
1151/// - If a collector is using a filter which enables or disables specific events by
1152///   file path and line number,  a particular event may be enabled/disabled
1153///   even if an `enabled!` invocation with the same level, target, and fields
1154///   indicated otherwise.
1155/// - The collector can choose to enable _only_ spans or _only_ events, which `enabled`
1156///   will not reflect.
1157///
1158/// `enabled!()` requires a [level](crate::Level) argument, an optional `target:`
1159/// argument, and an optional set of field names. If the fields are not provided,
1160/// they are considered to be unknown. `enabled!` attempts to match the
1161/// syntax of `event!()` as closely as possible, which can be seen in the
1162/// examples below.
1163///
1164/// # Examples
1165///
1166/// If the current collector is interested in recording `DEBUG`-level spans and
1167/// events in the current file and module path, this will evaluate to true:
1168/// ```rust
1169/// use tracing::{enabled, Level};
1170///
1171/// if enabled!(Level::DEBUG) {
1172///     // some expensive work...
1173/// }
1174/// ```
1175///
1176/// If the current collector is interested in recording spans and events
1177/// in the current file and module path, with the target "my_crate", and at the
1178/// level  `DEBUG`, this will evaluate to true:
1179/// ```rust
1180/// # use tracing::{enabled, Level};
1181/// if enabled!(target: "my_crate", Level::DEBUG) {
1182///     // some expensive work...
1183/// }
1184/// ```
1185///
1186/// If the current collector is interested in recording spans and events
1187/// in the current file and module path, with the target "my_crate", at
1188/// the level `DEBUG`, and with a field named "hello", this will evaluate
1189/// to true:
1190///
1191/// ```rust
1192/// # use tracing::{enabled, Level};
1193/// if enabled!(target: "my_crate", Level::DEBUG, hello) {
1194///     // some expensive work...
1195/// }
1196/// ```
1197///
1198/// # Alternatives
1199///
1200/// `enabled!` queries subscribers with [`Metadata`] where
1201/// [`is_event`] and [`is_span`] both return `false`. Alternatively,
1202/// use [`event_enabled!`] or [`span_enabled!`] to ensure one of these
1203/// returns true.
1204///
1205///
1206/// [`Metadata`]: crate::Metadata
1207/// [`is_event`]: crate::Metadata::is_event
1208/// [`is_span`]: crate::Metadata::is_span
1209/// [`enabled!`]: crate::enabled
1210/// [`span_enabled!`]: crate::span_enabled
1211#[macro_export]
1212macro_rules! enabled {
1213    (kind: $kind:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
1214        if $crate::level_enabled!($lvl) {
1215            use $crate::__macro_support::Callsite as _;
1216            static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
1217                name: $crate::__macro_support::concat!(
1218                    "enabled ",
1219                    $crate::__macro_support::file!(),
1220                    ":",
1221                    $crate::__macro_support::line!()
1222                ),
1223                kind: $kind.hint(),
1224                target: $target,
1225                level: $lvl,
1226                fields: $($fields)*
1227            };
1228            let interest = __CALLSITE.interest();
1229            if !interest.is_never() && __CALLSITE.is_enabled(interest)  {
1230                let meta = __CALLSITE.metadata();
1231                $crate::dispatch::get_default(|current| current.enabled(meta))
1232            } else {
1233                false
1234            }
1235        } else {
1236            false
1237        }
1238    });
1239    // Just target and level
1240    (kind: $kind:expr, target: $target:expr, $lvl:expr ) => (
1241        $crate::enabled!(kind: $kind, target: $target, $lvl, { })
1242    );
1243    (target: $target:expr, $lvl:expr ) => (
1244        $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: $target, $lvl, { })
1245    );
1246
1247    // These four cases handle fields with no values
1248    (kind: $kind:expr, target: $target:expr, $lvl:expr, $($field:tt)*) => (
1249        $crate::enabled!(
1250            kind: $kind,
1251            target: $target,
1252            $lvl,
1253            { $($field)*}
1254        )
1255    );
1256    (target: $target:expr, $lvl:expr, $($field:tt)*) => (
1257        $crate::enabled!(
1258            kind: $crate::metadata::Kind::HINT,
1259            target: $target,
1260            $lvl,
1261            { $($field)*}
1262        )
1263    );
1264
1265    // Level and field case
1266    (kind: $kind:expr, $lvl:expr, $($field:tt)*) => (
1267        $crate::enabled!(
1268            kind: $kind,
1269            target: module_path!(),
1270            $lvl,
1271            { $($field)*}
1272        )
1273    );
1274
1275    // Simplest `enabled!` case
1276    (kind: $kind:expr, $lvl:expr) => (
1277        $crate::enabled!(kind: $kind, target: module_path!(), $lvl, { })
1278    );
1279    ($lvl:expr) => (
1280        $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: module_path!(), $lvl, { })
1281    );
1282
1283    // Fallthrough from above
1284    ($lvl:expr, $($field:tt)*) => (
1285        $crate::enabled!(
1286            kind: $crate::metadata::Kind::HINT,
1287            target: module_path!(),
1288            $lvl,
1289            { $($field)*}
1290        )
1291    );
1292}
1293
1294/// Constructs an event at the trace level.
1295///
1296/// This functions similarly to the [`event!`] macro. See [the top-level
1297/// documentation][lib] for details on the syntax accepted by
1298/// this macro.
1299///
1300/// [`event!`]: event!
1301/// [lib]: crate#using-the-macros
1302///
1303/// # Examples
1304///
1305/// ```rust
1306/// use tracing::trace;
1307/// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 }
1308/// # impl Position {
1309/// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 };
1310/// # fn dist(&self, other: Position) -> f32 {
1311/// #    let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2();
1312/// #    (x + y).sqrt()
1313/// # }
1314/// # }
1315/// # fn main() {
1316/// let pos = Position { x: 3.234, y: -1.223 };
1317/// let origin_dist = pos.dist(Position::ORIGIN);
1318///
1319/// trace!(position = ?pos, ?origin_dist);
1320/// trace!(
1321///     target: "app_events",
1322///     position = ?pos,
1323///     "x is {} and y is {}",
1324///     if pos.x >= 0.0 { "positive" } else { "negative" },
1325///     if pos.y >= 0.0 { "positive" } else { "negative" }
1326/// );
1327/// trace!(name: "completed", position = ?pos);
1328/// # }
1329/// ```
1330#[macro_export]
1331macro_rules! trace {
1332    // Name / target / parent.
1333    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1334        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1335    );
1336    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1337        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)* })
1338    );
1339    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1340        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1341    );
1342    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1343        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { %$($k).+ $($field)* })
1344    );
1345    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1346        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
1347    );
1348
1349    // Name / target.
1350    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1351        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1352    );
1353    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1354        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($k).+ $($field)* })
1355    );
1356    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1357        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1358    );
1359    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1360        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* })
1361    );
1362    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
1363        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, {}, $($arg)+)
1364    );
1365
1366    // Target / parent.
1367    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1368        $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1369    );
1370    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1371        $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)* })
1372    );
1373    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1374        $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1375    );
1376    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1377        $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { %$($k).+ $($field)* })
1378    );
1379    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1380        $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
1381    );
1382
1383    // Name / parent.
1384    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1385        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1386    );
1387    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1388        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)* })
1389    );
1390    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1391        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1392    );
1393    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1394        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { %$($k).+ $($field)* })
1395    );
1396    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1397        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
1398    );
1399
1400    // Name.
1401    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1402        $crate::event!(name: $name, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1403    );
1404    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
1405        $crate::event!(name: $name, $crate::Level::TRACE, { $($k).+ $($field)* })
1406    );
1407    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
1408        $crate::event!(name: $name, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1409    );
1410    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
1411        $crate::event!(name: $name, $crate::Level::TRACE, { %$($k).+ $($field)* })
1412    );
1413    (name: $name:expr, $($arg:tt)+ ) => (
1414        $crate::event!(name: $name, $crate::Level::TRACE, {}, $($arg)+)
1415    );
1416
1417    // Target.
1418    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1419        $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1420    );
1421    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1422        $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)* })
1423    );
1424    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1425        $crate::event!(target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1426    );
1427    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1428        $crate::event!(target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* })
1429    );
1430    (target: $target:expr, $($arg:tt)+ ) => (
1431        $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+)
1432    );
1433
1434    // Parent.
1435    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1436        $crate::event!(
1437            target: module_path!(),
1438            parent: $parent,
1439            $crate::Level::TRACE,
1440            { $($field)+ },
1441            $($arg)+
1442        )
1443    );
1444    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1445        $crate::event!(
1446            target: module_path!(),
1447            parent: $parent,
1448            $crate::Level::TRACE,
1449            { $($k).+ = $($field)*}
1450        )
1451    );
1452    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1453        $crate::event!(
1454            target: module_path!(),
1455            parent: $parent,
1456            $crate::Level::TRACE,
1457            { ?$($k).+ = $($field)*}
1458        )
1459    );
1460    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1461        $crate::event!(
1462            target: module_path!(),
1463            parent: $parent,
1464            $crate::Level::TRACE,
1465            { %$($k).+ = $($field)*}
1466        )
1467    );
1468    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1469        $crate::event!(
1470            target: module_path!(),
1471            parent: $parent,
1472            $crate::Level::TRACE,
1473            { $($k).+, $($field)*}
1474        )
1475    );
1476    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1477        $crate::event!(
1478            target: module_path!(),
1479            parent: $parent,
1480            $crate::Level::TRACE,
1481            { ?$($k).+, $($field)*}
1482        )
1483    );
1484    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1485        $crate::event!(
1486            target: module_path!(),
1487            parent: $parent,
1488            $crate::Level::TRACE,
1489            { %$($k).+, $($field)*}
1490        )
1491    );
1492    (parent: $parent:expr, $($arg:tt)+) => (
1493        $crate::event!(
1494            target: module_path!(),
1495            parent: $parent,
1496            $crate::Level::TRACE,
1497            {},
1498            $($arg)+
1499        )
1500    );
1501
1502    // ...
1503    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1504        $crate::event!(
1505            target: module_path!(),
1506            $crate::Level::TRACE,
1507            { $($field)+ },
1508            $($arg)+
1509        )
1510    );
1511    ($($k:ident).+ = $($field:tt)*) => (
1512        $crate::event!(
1513            target: module_path!(),
1514            $crate::Level::TRACE,
1515            { $($k).+ = $($field)*}
1516        )
1517    );
1518    (?$($k:ident).+ = $($field:tt)*) => (
1519        $crate::event!(
1520            target: module_path!(),
1521            $crate::Level::TRACE,
1522            { ?$($k).+ = $($field)*}
1523        )
1524    );
1525    (%$($k:ident).+ = $($field:tt)*) => (
1526        $crate::event!(
1527            target: module_path!(),
1528            $crate::Level::TRACE,
1529            { %$($k).+ = $($field)*}
1530        )
1531    );
1532    ($($k:ident).+, $($field:tt)*) => (
1533        $crate::event!(
1534            target: module_path!(),
1535            $crate::Level::TRACE,
1536            { $($k).+, $($field)*}
1537        )
1538    );
1539    (?$($k:ident).+, $($field:tt)*) => (
1540        $crate::event!(
1541            target: module_path!(),
1542            $crate::Level::TRACE,
1543            { ?$($k).+, $($field)*}
1544        )
1545    );
1546    (%$($k:ident).+, $($field:tt)*) => (
1547        $crate::event!(
1548            target: module_path!(),
1549            $crate::Level::TRACE,
1550            { %$($k).+, $($field)*}
1551        )
1552    );
1553    (?$($k:ident).+) => (
1554        $crate::event!(
1555            target: module_path!(),
1556            $crate::Level::TRACE,
1557            { ?$($k).+ }
1558        )
1559    );
1560    (%$($k:ident).+) => (
1561        $crate::event!(
1562            target: module_path!(),
1563            $crate::Level::TRACE,
1564            { %$($k).+ }
1565        )
1566    );
1567    ($($k:ident).+) => (
1568        $crate::event!(
1569            target: module_path!(),
1570            $crate::Level::TRACE,
1571            { $($k).+ }
1572        )
1573    );
1574    ($($arg:tt)+) => (
1575        $crate::event!(
1576            target: module_path!(),
1577            $crate::Level::TRACE,
1578            $($arg)+
1579        )
1580    );
1581}
1582
1583/// Constructs an event at the debug level.
1584///
1585/// This functions similarly to the [`event!`] macro. See [the top-level
1586/// documentation][lib] for details on the syntax accepted by
1587/// this macro.
1588///
1589/// [`event!`]: event!
1590/// [lib]: crate#using-the-macros
1591///
1592/// # Examples
1593///
1594/// ```rust
1595/// use tracing::debug;
1596/// # fn main() {
1597/// # #[derive(Debug)] struct Position { x: f32, y: f32 }
1598///
1599/// let pos = Position { x: 3.234, y: -1.223 };
1600///
1601/// debug!(?pos.x, ?pos.y);
1602/// debug!(target: "app_events", position = ?pos, "New position");
1603/// debug!(name: "completed", position = ?pos);
1604/// # }
1605/// ```
1606#[macro_export]
1607macro_rules! debug {
1608    // Name / target / parent.
1609    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1610        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1611    );
1612    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1613        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
1614    );
1615    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1616        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1617    );
1618    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1619        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1620    );
1621    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1622        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
1623    );
1624
1625    // Name / target.
1626    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1627        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1628    );
1629    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1630        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
1631    );
1632    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1633        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1634    );
1635    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1636        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1637    );
1638    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
1639        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, {}, $($arg)+)
1640    );
1641
1642    // Target / parent.
1643    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1644        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1645    );
1646    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1647        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
1648    );
1649    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1650        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1651    );
1652    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1653        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1654    );
1655    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1656        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
1657    );
1658
1659    // Name / parent.
1660    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1661        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1662    );
1663    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1664        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
1665    );
1666    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1667        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1668    );
1669    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1670        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1671    );
1672    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1673        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
1674    );
1675
1676    // Name.
1677    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1678        $crate::event!(name: $name, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1679    );
1680    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
1681        $crate::event!(name: $name, $crate::Level::DEBUG, { $($k).+ $($field)* })
1682    );
1683    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
1684        $crate::event!(name: $name, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1685    );
1686    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
1687        $crate::event!(name: $name, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1688    );
1689    (name: $name:expr, $($arg:tt)+ ) => (
1690        $crate::event!(name: $name, $crate::Level::DEBUG, {}, $($arg)+)
1691    );
1692
1693    // Target.
1694    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1695        $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1696    );
1697    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1698        $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
1699    );
1700    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1701        $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1702    );
1703    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1704        $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1705    );
1706    (target: $target:expr, $($arg:tt)+ ) => (
1707        $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
1708    );
1709
1710    // Parent.
1711    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1712        $crate::event!(
1713            target: module_path!(),
1714            parent: $parent,
1715            $crate::Level::DEBUG,
1716            { $($field)+ },
1717            $($arg)+
1718        )
1719    );
1720    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1721        $crate::event!(
1722            target: module_path!(),
1723            parent: $parent,
1724            $crate::Level::DEBUG,
1725            { $($k).+ = $($field)*}
1726        )
1727    );
1728    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1729        $crate::event!(
1730            target: module_path!(),
1731            parent: $parent,
1732            $crate::Level::DEBUG,
1733            { ?$($k).+ = $($field)*}
1734        )
1735    );
1736    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1737        $crate::event!(
1738            target: module_path!(),
1739            parent: $parent,
1740            $crate::Level::DEBUG,
1741            { %$($k).+ = $($field)*}
1742        )
1743    );
1744    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1745        $crate::event!(
1746            target: module_path!(),
1747            parent: $parent,
1748            $crate::Level::DEBUG,
1749            { $($k).+, $($field)*}
1750        )
1751    );
1752    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1753        $crate::event!(
1754            target: module_path!(),
1755            parent: $parent,
1756            $crate::Level::DEBUG,
1757            { ?$($k).+, $($field)*}
1758        )
1759    );
1760    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1761        $crate::event!(
1762            target: module_path!(),
1763            parent: $parent,
1764            $crate::Level::DEBUG,
1765            { %$($k).+, $($field)*}
1766        )
1767    );
1768    (parent: $parent:expr, $($arg:tt)+) => (
1769        $crate::event!(
1770            target: module_path!(),
1771            parent: $parent,
1772            $crate::Level::DEBUG,
1773            {},
1774            $($arg)+
1775        )
1776    );
1777
1778    // ...
1779    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1780        $crate::event!(
1781            target: module_path!(),
1782            $crate::Level::DEBUG,
1783            { $($field)+ },
1784            $($arg)+
1785        )
1786    );
1787    ($($k:ident).+ = $($field:tt)*) => (
1788        $crate::event!(
1789            target: module_path!(),
1790            $crate::Level::DEBUG,
1791            { $($k).+ = $($field)*}
1792        )
1793    );
1794    (?$($k:ident).+ = $($field:tt)*) => (
1795        $crate::event!(
1796            target: module_path!(),
1797            $crate::Level::DEBUG,
1798            { ?$($k).+ = $($field)*}
1799        )
1800    );
1801    (%$($k:ident).+ = $($field:tt)*) => (
1802        $crate::event!(
1803            target: module_path!(),
1804            $crate::Level::DEBUG,
1805            { %$($k).+ = $($field)*}
1806        )
1807    );
1808    ($($k:ident).+, $($field:tt)*) => (
1809        $crate::event!(
1810            target: module_path!(),
1811            $crate::Level::DEBUG,
1812            { $($k).+, $($field)*}
1813        )
1814    );
1815    (?$($k:ident).+, $($field:tt)*) => (
1816        $crate::event!(
1817            target: module_path!(),
1818            $crate::Level::DEBUG,
1819            { ?$($k).+, $($field)*}
1820        )
1821    );
1822    (%$($k:ident).+, $($field:tt)*) => (
1823        $crate::event!(
1824            target: module_path!(),
1825            $crate::Level::DEBUG,
1826            { %$($k).+, $($field)*}
1827        )
1828    );
1829    (?$($k:ident).+) => (
1830        $crate::event!(
1831            target: module_path!(),
1832            $crate::Level::DEBUG,
1833            { ?$($k).+ }
1834        )
1835    );
1836    (%$($k:ident).+) => (
1837        $crate::event!(
1838            target: module_path!(),
1839            $crate::Level::DEBUG,
1840            { %$($k).+ }
1841        )
1842    );
1843    ($($k:ident).+) => (
1844        $crate::event!(
1845            target: module_path!(),
1846            $crate::Level::DEBUG,
1847            { $($k).+ }
1848        )
1849    );
1850    ($($arg:tt)+) => (
1851        $crate::event!(
1852            target: module_path!(),
1853            $crate::Level::DEBUG,
1854            $($arg)+
1855        )
1856    );
1857}
1858
1859/// Constructs an event at the info level.
1860///
1861/// This functions similarly to the [`event!`] macro. See [the top-level
1862/// documentation][lib] for details on the syntax accepted by
1863/// this macro.
1864///
1865/// [`event!`]: event!
1866/// [lib]: crate#using-the-macros
1867///
1868/// # Examples
1869///
1870/// ```rust
1871/// use tracing::info;
1872/// # // this is so the test will still work in no-std mode
1873/// # #[derive(Debug)]
1874/// # pub struct Ipv4Addr;
1875/// # impl Ipv4Addr { fn new(o1: u8, o2: u8, o3: u8, o4: u8) -> Self { Self } }
1876/// # fn main() {
1877/// # struct Connection { port: u32, speed: f32 }
1878/// use tracing::field;
1879///
1880/// let addr = Ipv4Addr::new(127, 0, 0, 1);
1881/// let conn = Connection { port: 40, speed: 3.20 };
1882///
1883/// info!(conn.port, "connected to {:?}", addr);
1884/// info!(
1885///     target: "connection_events",
1886///     ip = ?addr,
1887///     conn.port,
1888///     ?conn.speed,
1889/// );
1890/// info!(name: "completed", "completed connection to {:?}", addr);
1891/// # }
1892/// ```
1893#[macro_export]
1894macro_rules! info {
1895    // Name / target / parent.
1896    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1897        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
1898    );
1899    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1900        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)* })
1901    );
1902    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1903        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { ?$($k).+ $($field)* })
1904    );
1905    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1906        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { %$($k).+ $($field)* })
1907    );
1908    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1909        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
1910    );
1911
1912    // Name / target.
1913    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1914        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
1915    );
1916    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1917        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
1918    );
1919    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1920        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* })
1921    );
1922    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1923        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { %$($k).+ $($field)* })
1924    );
1925    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
1926        $crate::event!(name: $name, target: $target, $crate::Level::INFO, {}, $($arg)+)
1927    );
1928
1929    // Target / parent.
1930    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1931        $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
1932    );
1933    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1934        $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)* })
1935    );
1936    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1937        $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { ?$($k).+ $($field)* })
1938    );
1939    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1940        $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { %$($k).+ $($field)* })
1941    );
1942    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1943        $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
1944    );
1945
1946    // Name / parent.
1947    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1948        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
1949    );
1950    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
1951        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)* })
1952    );
1953    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
1954        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { ?$($k).+ $($field)* })
1955    );
1956    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
1957        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { %$($k).+ $($field)* })
1958    );
1959    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1960        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
1961    );
1962
1963    // Name.
1964    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1965        $crate::event!(name: $name, $crate::Level::INFO, { $($field)* }, $($arg)*)
1966    );
1967    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
1968        $crate::event!(name: $name, $crate::Level::INFO, { $($k).+ $($field)* })
1969    );
1970    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
1971        $crate::event!(name: $name, $crate::Level::INFO, { ?$($k).+ $($field)* })
1972    );
1973    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
1974        $crate::event!(name: $name, $crate::Level::INFO, { %$($k).+ $($field)* })
1975    );
1976    (name: $name:expr, $($arg:tt)+ ) => (
1977        $crate::event!(name: $name, $crate::Level::INFO, {}, $($arg)+)
1978    );
1979
1980    // Target.
1981    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1982        $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
1983    );
1984    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1985        $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
1986    );
1987    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1988        $crate::event!(target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* })
1989    );
1990    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1991        $crate::event!(target: $target, $crate::Level::INFO, { %$($k).+ $($field)* })
1992    );
1993    (target: $target:expr, $($arg:tt)+ ) => (
1994        $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
1995    );
1996
1997    // Parent.
1998    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1999        $crate::event!(
2000            target: module_path!(),
2001            parent: $parent,
2002            $crate::Level::INFO,
2003            { $($field)+ },
2004            $($arg)+
2005        )
2006    );
2007    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
2008        $crate::event!(
2009            target: module_path!(),
2010            parent: $parent,
2011            $crate::Level::INFO,
2012            { $($k).+ = $($field)*}
2013        )
2014    );
2015    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
2016        $crate::event!(
2017            target: module_path!(),
2018            parent: $parent,
2019            $crate::Level::INFO,
2020            { ?$($k).+ = $($field)*}
2021        )
2022    );
2023    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
2024        $crate::event!(
2025            target: module_path!(),
2026            parent: $parent,
2027            $crate::Level::INFO,
2028            { %$($k).+ = $($field)*}
2029        )
2030    );
2031    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
2032        $crate::event!(
2033            target: module_path!(),
2034            parent: $parent,
2035            $crate::Level::INFO,
2036            { $($k).+, $($field)*}
2037        )
2038    );
2039    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
2040        $crate::event!(
2041            target: module_path!(),
2042            parent: $parent,
2043            $crate::Level::INFO,
2044            { ?$($k).+, $($field)*}
2045        )
2046    );
2047    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
2048        $crate::event!(
2049            target: module_path!(),
2050            parent: $parent,
2051            $crate::Level::INFO,
2052            { %$($k).+, $($field)*}
2053        )
2054    );
2055    (parent: $parent:expr, $($arg:tt)+) => (
2056        $crate::event!(
2057            target: module_path!(),
2058            parent: $parent,
2059            $crate::Level::INFO,
2060            {},
2061            $($arg)+
2062        )
2063    );
2064
2065    // ...
2066    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
2067        $crate::event!(
2068            target: module_path!(),
2069            $crate::Level::INFO,
2070            { $($field)+ },
2071            $($arg)+
2072        )
2073    );
2074    ($($k:ident).+ = $($field:tt)*) => (
2075        $crate::event!(
2076            target: module_path!(),
2077            $crate::Level::INFO,
2078            { $($k).+ = $($field)*}
2079        )
2080    );
2081    (?$($k:ident).+ = $($field:tt)*) => (
2082        $crate::event!(
2083            target: module_path!(),
2084            $crate::Level::INFO,
2085            { ?$($k).+ = $($field)*}
2086        )
2087    );
2088    (%$($k:ident).+ = $($field:tt)*) => (
2089        $crate::event!(
2090            target: module_path!(),
2091            $crate::Level::INFO,
2092            { %$($k).+ = $($field)*}
2093        )
2094    );
2095    ($($k:ident).+, $($field:tt)*) => (
2096        $crate::event!(
2097            target: module_path!(),
2098            $crate::Level::INFO,
2099            { $($k).+, $($field)*}
2100        )
2101    );
2102    (?$($k:ident).+, $($field:tt)*) => (
2103        $crate::event!(
2104            target: module_path!(),
2105            $crate::Level::INFO,
2106            { ?$($k).+, $($field)*}
2107        )
2108    );
2109    (%$($k:ident).+, $($field:tt)*) => (
2110        $crate::event!(
2111            target: module_path!(),
2112            $crate::Level::INFO,
2113            { %$($k).+, $($field)*}
2114        )
2115    );
2116    (?$($k:ident).+) => (
2117        $crate::event!(
2118            target: module_path!(),
2119            $crate::Level::INFO,
2120            { ?$($k).+ }
2121        )
2122    );
2123    (%$($k:ident).+) => (
2124        $crate::event!(
2125            target: module_path!(),
2126            $crate::Level::INFO,
2127            { %$($k).+ }
2128        )
2129    );
2130    ($($k:ident).+) => (
2131        $crate::event!(
2132            target: module_path!(),
2133            $crate::Level::INFO,
2134            { $($k).+ }
2135        )
2136    );
2137    ($($arg:tt)+) => (
2138        $crate::event!(
2139            target: module_path!(),
2140            $crate::Level::INFO,
2141            $($arg)+
2142        )
2143    );
2144}
2145
2146/// Constructs an event at the warn level.
2147///
2148/// This functions similarly to the [`event!`] macro. See [the top-level
2149/// documentation][lib] for details on the syntax accepted by
2150/// this macro.
2151///
2152/// [`event!`]: event!
2153/// [lib]: crate#using-the-macros
2154///
2155/// # Examples
2156///
2157/// ```rust
2158/// use tracing::warn;
2159/// # fn main() {
2160///
2161/// let warn_description = "Invalid Input";
2162/// let input = &[0x27, 0x45];
2163///
2164/// warn!(?input, warning = warn_description);
2165/// warn!(
2166///     target: "input_events",
2167///     warning = warn_description,
2168///     "Received warning for input: {:?}", input,
2169/// );
2170/// warn!(name: "invalid", ?input);
2171/// # }
2172/// ```
2173#[macro_export]
2174macro_rules! warn {
2175    // Name / target / parent.
2176    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2177        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
2178    );
2179    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2180        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)* })
2181    );
2182    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2183        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { ?$($k).+ $($field)* })
2184    );
2185    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2186        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { %$($k).+ $($field)* })
2187    );
2188    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2189        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
2190    );
2191
2192    // Name / target.
2193    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2194        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
2195    );
2196    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
2197        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($k).+ $($field)* })
2198    );
2199    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
2200        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* })
2201    );
2202    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
2203        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { %$($k).+ $($field)* })
2204    );
2205    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
2206        $crate::event!(name: $name, target: $target, $crate::Level::WARN, {}, $($arg)+)
2207    );
2208
2209    // Target / parent.
2210    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2211        $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
2212    );
2213    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2214        $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)* })
2215    );
2216    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2217        $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { ?$($k).+ $($field)* })
2218    );
2219    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2220        $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { %$($k).+ $($field)* })
2221    );
2222    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2223        $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
2224    );
2225
2226    // Name / parent.
2227    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2228        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
2229    );
2230    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2231        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)* })
2232    );
2233    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2234        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { ?$($k).+ $($field)* })
2235    );
2236    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2237        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { %$($k).+ $($field)* })
2238    );
2239    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2240        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
2241    );
2242
2243    // Name.
2244    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2245        $crate::event!(name: $name, $crate::Level::WARN, { $($field)* }, $($arg)*)
2246    );
2247    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
2248        $crate::event!(name: $name, $crate::Level::WARN, { $($k).+ $($field)* })
2249    );
2250    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
2251        $crate::event!(name: $name, $crate::Level::WARN, { ?$($k).+ $($field)* })
2252    );
2253    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
2254        $crate::event!(name: $name, $crate::Level::WARN, { %$($k).+ $($field)* })
2255    );
2256    (name: $name:expr, $($arg:tt)+ ) => (
2257        $crate::event!(name: $name, $crate::Level::WARN, {}, $($arg)+)
2258    );
2259
2260    // Target.
2261    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2262        $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
2263    );
2264    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
2265        $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)* })
2266    );
2267    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
2268        $crate::event!(target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* })
2269    );
2270    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
2271        $crate::event!(target: $target, $crate::Level::WARN, { %$($k).+ $($field)* })
2272    );
2273    (target: $target:expr, $($arg:tt)+ ) => (
2274        $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+)
2275    );
2276
2277    // Parent.
2278    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
2279        $crate::event!(
2280            target: module_path!(),
2281            parent: $parent,
2282            $crate::Level::WARN,
2283            { $($field)+ },
2284            $($arg)+
2285        )
2286    );
2287    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
2288        $crate::event!(
2289            target: module_path!(),
2290            parent: $parent,
2291            $crate::Level::WARN,
2292            { $($k).+ = $($field)*}
2293        )
2294    );
2295    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
2296        $crate::event!(
2297            target: module_path!(),
2298            parent: $parent,
2299            $crate::Level::WARN,
2300            { ?$($k).+ = $($field)*}
2301        )
2302    );
2303    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
2304        $crate::event!(
2305            target: module_path!(),
2306            parent: $parent,
2307            $crate::Level::WARN,
2308            { %$($k).+ = $($field)*}
2309        )
2310    );
2311    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
2312        $crate::event!(
2313            target: module_path!(),
2314            parent: $parent,
2315            $crate::Level::WARN,
2316            { $($k).+, $($field)*}
2317        )
2318    );
2319    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
2320        $crate::event!(
2321            target: module_path!(),
2322            parent: $parent,
2323            $crate::Level::WARN,
2324            { ?$($k).+, $($field)*}
2325        )
2326    );
2327    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
2328        $crate::event!(
2329            target: module_path!(),
2330            parent: $parent,
2331            $crate::Level::WARN,
2332            { %$($k).+, $($field)*}
2333        )
2334    );
2335    (parent: $parent:expr, $($arg:tt)+) => (
2336        $crate::event!(
2337            target: module_path!(),
2338            parent: $parent,
2339            $crate::Level::WARN,
2340            {},
2341            $($arg)+
2342        )
2343    );
2344
2345    // ...
2346    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
2347        $crate::event!(
2348            target: module_path!(),
2349            $crate::Level::WARN,
2350            { $($field)+ },
2351            $($arg)+
2352        )
2353    );
2354    ($($k:ident).+ = $($field:tt)*) => (
2355        $crate::event!(
2356            target: module_path!(),
2357            $crate::Level::WARN,
2358            { $($k).+ = $($field)*}
2359        )
2360    );
2361    (?$($k:ident).+ = $($field:tt)*) => (
2362        $crate::event!(
2363            target: module_path!(),
2364            $crate::Level::WARN,
2365            { ?$($k).+ = $($field)*}
2366        )
2367    );
2368    (%$($k:ident).+ = $($field:tt)*) => (
2369        $crate::event!(
2370            target: module_path!(),
2371            $crate::Level::WARN,
2372            { %$($k).+ = $($field)*}
2373        )
2374    );
2375    ($($k:ident).+, $($field:tt)*) => (
2376        $crate::event!(
2377            target: module_path!(),
2378            $crate::Level::WARN,
2379            { $($k).+, $($field)*}
2380        )
2381    );
2382    (?$($k:ident).+, $($field:tt)*) => (
2383        $crate::event!(
2384            target: module_path!(),
2385            $crate::Level::WARN,
2386            { ?$($k).+, $($field)*}
2387        )
2388    );
2389    (%$($k:ident).+, $($field:tt)*) => (
2390        $crate::event!(
2391            target: module_path!(),
2392            $crate::Level::WARN,
2393            { %$($k).+, $($field)*}
2394        )
2395    );
2396    (?$($k:ident).+) => (
2397        $crate::event!(
2398            target: module_path!(),
2399            $crate::Level::WARN,
2400            { ?$($k).+ }
2401        )
2402    );
2403    (%$($k:ident).+) => (
2404        $crate::event!(
2405            target: module_path!(),
2406            $crate::Level::WARN,
2407            { %$($k).+ }
2408        )
2409    );
2410    ($($k:ident).+) => (
2411        $crate::event!(
2412            target: module_path!(),
2413            $crate::Level::WARN,
2414            { $($k).+ }
2415        )
2416    );
2417    ($($arg:tt)+) => (
2418        $crate::event!(
2419            target: module_path!(),
2420            $crate::Level::WARN,
2421            $($arg)+
2422        )
2423    );
2424}
2425
2426/// Constructs an event at the error level.
2427///
2428/// This functions similarly to the [`event!`] macro. See [the top-level
2429/// documentation][lib] for details on the syntax accepted by
2430/// this macro.
2431///
2432/// [`event!`]: event!
2433/// [lib]: crate#using-the-macros
2434///
2435/// # Examples
2436///
2437/// ```rust
2438/// use tracing::error;
2439/// # fn main() {
2440///
2441/// let (err_info, port) = ("No connection", 22);
2442///
2443/// error!(port, error = %err_info);
2444/// error!(target: "app_events", "App Error: {}", err_info);
2445/// error!({ info = err_info }, "error on port: {}", port);
2446/// error!(name: "invalid_input", "Invalid input: {}", err_info);
2447/// # }
2448/// ```
2449#[macro_export]
2450macro_rules! error {
2451    // Name / target / parent.
2452    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2453        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2454    );
2455    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2456        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)* })
2457    );
2458    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2459        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2460    );
2461    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2462        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { %$($k).+ $($field)* })
2463    );
2464    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2465        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
2466    );
2467
2468    // Name / target.
2469    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2470        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2471    );
2472    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
2473        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($k).+ $($field)* })
2474    );
2475    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
2476        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2477    );
2478    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
2479        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* })
2480    );
2481    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
2482        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, {}, $($arg)+)
2483    );
2484
2485    // Target / parent.
2486    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2487        $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2488    );
2489    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2490        $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)* })
2491    );
2492    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2493        $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2494    );
2495    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2496        $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { %$($k).+ $($field)* })
2497    );
2498    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2499        $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
2500    );
2501
2502    // Name / parent.
2503    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2504        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2505    );
2506    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
2507        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)* })
2508    );
2509    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
2510        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2511    );
2512    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
2513        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { %$($k).+ $($field)* })
2514    );
2515    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
2516        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
2517    );
2518
2519    // Name.
2520    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2521        $crate::event!(name: $name, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2522    );
2523    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
2524        $crate::event!(name: $name, $crate::Level::ERROR, { $($k).+ $($field)* })
2525    );
2526    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
2527        $crate::event!(name: $name, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2528    );
2529    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
2530        $crate::event!(name: $name, $crate::Level::ERROR, { %$($k).+ $($field)* })
2531    );
2532    (name: $name:expr, $($arg:tt)+ ) => (
2533        $crate::event!(name: $name, $crate::Level::ERROR, {}, $($arg)+)
2534    );
2535
2536    // Target.
2537    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
2538        $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
2539    );
2540    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
2541        $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)* })
2542    );
2543    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
2544        $crate::event!(target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* })
2545    );
2546    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
2547        $crate::event!(target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* })
2548    );
2549    (target: $target:expr, $($arg:tt)+ ) => (
2550        $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
2551    );
2552
2553    // Parent.
2554    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
2555        $crate::event!(
2556            target: module_path!(),
2557            parent: $parent,
2558            $crate::Level::ERROR,
2559            { $($field)+ },
2560            $($arg)+
2561        )
2562    );
2563    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
2564        $crate::event!(
2565            target: module_path!(),
2566            parent: $parent,
2567            $crate::Level::ERROR,
2568            { $($k).+ = $($field)*}
2569        )
2570    );
2571    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
2572        $crate::event!(
2573            target: module_path!(),
2574            parent: $parent,
2575            $crate::Level::ERROR,
2576            { ?$($k).+ = $($field)*}
2577        )
2578    );
2579    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
2580        $crate::event!(
2581            target: module_path!(),
2582            parent: $parent,
2583            $crate::Level::ERROR,
2584            { %$($k).+ = $($field)*}
2585        )
2586    );
2587    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
2588        $crate::event!(
2589            target: module_path!(),
2590            parent: $parent,
2591            $crate::Level::ERROR,
2592            { $($k).+, $($field)*}
2593        )
2594    );
2595    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
2596        $crate::event!(
2597            target: module_path!(),
2598            parent: $parent,
2599            $crate::Level::ERROR,
2600            { ?$($k).+, $($field)*}
2601        )
2602    );
2603    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
2604        $crate::event!(
2605            target: module_path!(),
2606            parent: $parent,
2607            $crate::Level::ERROR,
2608            { %$($k).+, $($field)*}
2609        )
2610    );
2611    (parent: $parent:expr, $($arg:tt)+) => (
2612        $crate::event!(
2613            target: module_path!(),
2614            parent: $parent,
2615            $crate::Level::ERROR,
2616            {},
2617            $($arg)+
2618        )
2619    );
2620
2621    // ...
2622    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
2623        $crate::event!(
2624            target: module_path!(),
2625            $crate::Level::ERROR,
2626            { $($field)+ },
2627            $($arg)+
2628        )
2629    );
2630    ($($k:ident).+ = $($field:tt)*) => (
2631        $crate::event!(
2632            target: module_path!(),
2633            $crate::Level::ERROR,
2634            { $($k).+ = $($field)*}
2635        )
2636    );
2637    (?$($k:ident).+ = $($field:tt)*) => (
2638        $crate::event!(
2639            target: module_path!(),
2640            $crate::Level::ERROR,
2641            { ?$($k).+ = $($field)*}
2642        )
2643    );
2644    (%$($k:ident).+ = $($field:tt)*) => (
2645        $crate::event!(
2646            target: module_path!(),
2647            $crate::Level::ERROR,
2648            { %$($k).+ = $($field)*}
2649        )
2650    );
2651    ($($k:ident).+, $($field:tt)*) => (
2652        $crate::event!(
2653            target: module_path!(),
2654            $crate::Level::ERROR,
2655            { $($k).+, $($field)*}
2656        )
2657    );
2658    (?$($k:ident).+, $($field:tt)*) => (
2659        $crate::event!(
2660            target: module_path!(),
2661            $crate::Level::ERROR,
2662            { ?$($k).+, $($field)*}
2663        )
2664    );
2665    (%$($k:ident).+, $($field:tt)*) => (
2666        $crate::event!(
2667            target: module_path!(),
2668            $crate::Level::ERROR,
2669            { %$($k).+, $($field)*}
2670        )
2671    );
2672    (?$($k:ident).+) => (
2673        $crate::event!(
2674            target: module_path!(),
2675            $crate::Level::ERROR,
2676            { ?$($k).+ }
2677        )
2678    );
2679    (%$($k:ident).+) => (
2680        $crate::event!(
2681            target: module_path!(),
2682            $crate::Level::ERROR,
2683            { %$($k).+ }
2684        )
2685    );
2686    ($($k:ident).+) => (
2687        $crate::event!(
2688            target: module_path!(),
2689            $crate::Level::ERROR,
2690            { $($k).+ }
2691        )
2692    );
2693    ($($arg:tt)+) => (
2694        $crate::event!(
2695            target: module_path!(),
2696            $crate::Level::ERROR,
2697            $($arg)+
2698        )
2699    );
2700}
2701
2702/// Constructs a new static callsite for a span or event.
2703#[doc(hidden)]
2704#[macro_export]
2705macro_rules! callsite {
2706    (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{
2707        $crate::callsite! {
2708            name: $name,
2709            kind: $kind,
2710            target: module_path!(),
2711            level: $crate::Level::TRACE,
2712            fields: $($fields)*
2713        }
2714    }};
2715    (
2716        name: $name:expr,
2717        kind: $kind:expr,
2718        level: $lvl:expr,
2719        fields: $($fields:tt)*
2720    ) => {{
2721        $crate::callsite! {
2722            name: $name,
2723            kind: $kind,
2724            target: module_path!(),
2725            level: $lvl,
2726            fields: $($fields)*
2727        }
2728    }};
2729    (
2730        name: $name:expr,
2731        kind: $kind:expr,
2732        target: $target:expr,
2733        level: $lvl:expr,
2734        fields: $($fields:tt)*
2735    ) => {{
2736        use $crate::__macro_support::{MacroCallsite, Registration};
2737        static __META: $crate::Metadata<'static> = {
2738            $crate::metadata! {
2739                name: $name,
2740                target: $target,
2741                level: $lvl,
2742                fields: $crate::fieldset!( $($fields)* ),
2743                callsite: &__CALLSITE,
2744                kind: $kind,
2745            }
2746        };
2747        static REG: Registration = Registration::new(&__CALLSITE);
2748        static __CALLSITE: MacroCallsite = MacroCallsite::new(&__META, &REG);
2749        __CALLSITE.register();
2750        &__CALLSITE
2751    }};
2752}
2753
2754/// Constructs a new static callsite for a span or event.
2755#[doc(hidden)]
2756#[macro_export]
2757macro_rules! callsite2 {
2758    (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{
2759        $crate::callsite2! {
2760            name: $name,
2761            kind: $kind,
2762            target: module_path!(),
2763            level: $crate::Level::TRACE,
2764            fields: $($fields)*
2765        }
2766    }};
2767    (
2768        name: $name:expr,
2769        kind: $kind:expr,
2770        level: $lvl:expr,
2771        fields: $($fields:tt)*
2772    ) => {{
2773        $crate::callsite2! {
2774            name: $name,
2775            kind: $kind,
2776            target: module_path!(),
2777            level: $lvl,
2778            fields: $($fields)*
2779        }
2780    }};
2781    (
2782        name: $name:expr,
2783        kind: $kind:expr,
2784        target: $target:expr,
2785        level: $lvl:expr,
2786        fields: $($fields:tt)*
2787    ) => {{
2788        use $crate::__macro_support::{MacroCallsite, Registration};
2789        static __META: $crate::Metadata<'static> = {
2790            $crate::metadata! {
2791                name: $name,
2792                target: $target,
2793                level: $lvl,
2794                fields: $crate::fieldset!( $($fields)* ),
2795                callsite: &__CALLSITE,
2796                kind: $kind,
2797            }
2798        };
2799        static REG: Registration = Registration::new(&__CALLSITE);
2800
2801        MacroCallsite::new(&__META, &REG)
2802    }};
2803}
2804
2805#[macro_export]
2806// TODO: determine if this ought to be public API?`
2807#[doc(hidden)]
2808macro_rules! level_enabled {
2809    ($lvl:expr) => {
2810        $lvl <= $crate::level_filters::STATIC_MAX_LEVEL
2811            && $lvl <= $crate::level_filters::LevelFilter::current()
2812    };
2813}
2814
2815#[doc(hidden)]
2816#[macro_export]
2817macro_rules! valueset {
2818
2819    // === base case ===
2820    (@ { $(,)* $($val:expr),* $(,)* }, $next:expr $(,)*) => {
2821        &[ $($val),* ]
2822    };
2823
2824    // === recursive case (more tts) ===
2825
2826    // TODO(#1138): determine a new syntax for uninitialized span fields, and
2827    // re-enable this.
2828    // (@{ $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = _, $($rest:tt)*) => {
2829    //     $crate::valueset!(@ { $($out),*, (&$next, None) }, $next, $($rest)*)
2830    // };
2831    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
2832        $crate::valueset!(
2833            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$val) as &dyn Value)) },
2834            $next,
2835            $($rest)*
2836        )
2837    };
2838    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
2839        $crate::valueset!(
2840            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$val) as &dyn Value)) },
2841            $next,
2842            $($rest)*
2843        )
2844    };
2845    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr, $($rest:tt)*) => {
2846        $crate::valueset!(
2847            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$val as &dyn Value)) },
2848            $next,
2849            $($rest)*
2850        )
2851    };
2852    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+, $($rest:tt)*) => {
2853        $crate::valueset!(
2854            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$($k).+ as &dyn Value)) },
2855            $next,
2856            $($rest)*
2857        )
2858    };
2859    (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+, $($rest:tt)*) => {
2860        $crate::valueset!(
2861            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$($k).+) as &dyn Value)) },
2862            $next,
2863            $($rest)*
2864        )
2865    };
2866    (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+, $($rest:tt)*) => {
2867        $crate::valueset!(
2868            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$($k).+) as &dyn Value)) },
2869            $next,
2870            $($rest)*
2871        )
2872    };
2873    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr) => {
2874        $crate::valueset!(
2875            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$val) as &dyn Value)) },
2876            $next,
2877        )
2878    };
2879    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr) => {
2880        $crate::valueset!(
2881            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$val) as &dyn Value)) },
2882            $next,
2883        )
2884    };
2885    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr) => {
2886        $crate::valueset!(
2887            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$val as &dyn Value)) },
2888            $next,
2889        )
2890    };
2891    (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+) => {
2892        $crate::valueset!(
2893            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$($k).+ as &dyn Value)) },
2894            $next,
2895        )
2896    };
2897    (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+) => {
2898        $crate::valueset!(
2899            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$($k).+) as &dyn Value)) },
2900            $next,
2901        )
2902    };
2903    (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+) => {
2904        $crate::valueset!(
2905            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$($k).+) as &dyn Value)) },
2906            $next,
2907        )
2908    };
2909
2910    // Handle literal names
2911    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr, $($rest:tt)*) => {
2912        $crate::valueset!(
2913            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$val) as &dyn Value)) },
2914            $next,
2915            $($rest)*
2916        )
2917    };
2918    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr, $($rest:tt)*) => {
2919        $crate::valueset!(
2920            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$val) as &dyn Value)) },
2921            $next,
2922            $($rest)*
2923        )
2924    };
2925    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr, $($rest:tt)*) => {
2926        $crate::valueset!(
2927            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$val as &dyn Value)) },
2928            $next,
2929            $($rest)*
2930        )
2931    };
2932    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr) => {
2933        $crate::valueset!(
2934            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&debug(&$val) as &dyn Value)) },
2935            $next,
2936        )
2937    };
2938    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr) => {
2939        $crate::valueset!(
2940            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&display(&$val) as &dyn Value)) },
2941            $next,
2942        )
2943    };
2944    (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr) => {
2945        $crate::valueset!(
2946            @ { $($out),*, (&$next, $crate::__macro_support::Option::Some(&$val as &dyn Value)) },
2947            $next,
2948        )
2949    };
2950
2951    // Handle constant names
2952    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = ?$val:expr, $($rest:tt)*) => {
2953        $crate::valueset!(
2954            @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) },
2955            $next,
2956            $($rest)*
2957        )
2958    };
2959    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = %$val:expr, $($rest:tt)*) => {
2960        $crate::valueset!(
2961            @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) },
2962            $next,
2963            $($rest)*
2964        )
2965    };
2966    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = $val:expr, $($rest:tt)*) => {
2967        $crate::valueset!(
2968            @ { $($out),*, (&$next, Some(&$val as &dyn Value)) },
2969            $next,
2970            $($rest)*
2971        )
2972    };
2973    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = ?$val:expr) => {
2974        $crate::valueset!(
2975            @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) },
2976            $next,
2977        )
2978    };
2979    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = %$val:expr) => {
2980        $crate::valueset!(
2981            @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) },
2982            $next,
2983        )
2984    };
2985    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = $val:expr) => {
2986        $crate::valueset!(
2987            @ { $($out),*, (&$next, Some(&$val as &dyn Value)) },
2988            $next,
2989        )
2990    };
2991
2992    // Remainder is unparsable, but exists --- must be format args!
2993    (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => {
2994        $crate::valueset!(@ { (&$next, $crate::__macro_support::Option::Some(&$crate::__macro_support::format_args!($($rest)+) as &dyn Value)), $($out),* }, $next, )
2995    };
2996
2997    // === entry ===
2998    ($fields:expr, $($kvs:tt)+) => {
2999        {
3000            #[allow(unused_imports)]
3001            use $crate::field::{debug, display, Value};
3002            let mut iter = $fields.iter();
3003            $fields.value_set($crate::valueset!(
3004                @ { },
3005                $crate::__macro_support::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"),
3006                $($kvs)+
3007            ))
3008        }
3009    };
3010    ($fields:expr,) => {
3011        {
3012            $fields.value_set(&[])
3013        }
3014    };
3015}
3016
3017#[doc(hidden)]
3018#[macro_export]
3019macro_rules! fieldset {
3020    // == base case ==
3021    (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => {
3022        &[ $($out),* ]
3023    };
3024
3025    // == recursive cases (more tts) ==
3026    (@ { $(,)* $($out:expr),* } $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
3027        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3028    };
3029    (@ { $(,)* $($out:expr),* } $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
3030        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3031    };
3032    (@ { $(,)* $($out:expr),* } $($k:ident).+ = $val:expr, $($rest:tt)*) => {
3033        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3034    };
3035    // TODO(#1138): determine a new syntax for uninitialized span fields, and
3036    // re-enable this.
3037    // (@ { $($out:expr),* } $($k:ident).+ = _, $($rest:tt)*) => {
3038    //     $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3039    // };
3040    (@ { $(,)* $($out:expr),* } ?$($k:ident).+, $($rest:tt)*) => {
3041        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3042    };
3043    (@ { $(,)* $($out:expr),* } %$($k:ident).+, $($rest:tt)*) => {
3044        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3045    };
3046    (@ { $(,)* $($out:expr),* } $($k:ident).+, $($rest:tt)*) => {
3047        $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
3048    };
3049
3050    // Handle literal names
3051    (@ { $(,)* $($out:expr),* } $k:literal = ?$val:expr, $($rest:tt)*) => {
3052        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3053    };
3054    (@ { $(,)* $($out:expr),* } $k:literal = %$val:expr, $($rest:tt)*) => {
3055        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3056    };
3057    (@ { $(,)* $($out:expr),* } $k:literal = $val:expr, $($rest:tt)*) => {
3058        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3059    };
3060
3061    // Handle constant names
3062    (@ { $(,)* $($out:expr),* } { $k:expr } = ?$val:expr, $($rest:tt)*) => {
3063        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3064    };
3065    (@ { $(,)* $($out:expr),* } { $k:expr } = %$val:expr, $($rest:tt)*) => {
3066        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3067    };
3068    (@ { $(,)* $($out:expr),* } { $k:expr } = $val:expr, $($rest:tt)*) => {
3069        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
3070    };
3071
3072    // Remainder is unparsable, but exists --- must be format args!
3073    (@ { $(,)* $($out:expr),* } $($rest:tt)+) => {
3074        $crate::fieldset!(@ { "message", $($out),*, })
3075    };
3076
3077    // == entry ==
3078    ($($args:tt)*) => {
3079        $crate::fieldset!(@ { } $($args)*,)
3080    };
3081
3082}
3083
3084#[cfg(feature = "log")]
3085#[doc(hidden)]
3086#[macro_export]
3087macro_rules! level_to_log {
3088    ($level:expr) => {
3089        match $level {
3090            $crate::Level::ERROR => $crate::log::Level::Error,
3091            $crate::Level::WARN => $crate::log::Level::Warn,
3092            $crate::Level::INFO => $crate::log::Level::Info,
3093            $crate::Level::DEBUG => $crate::log::Level::Debug,
3094            _ => $crate::log::Level::Trace,
3095        }
3096    };
3097}
3098
3099#[doc(hidden)]
3100#[macro_export]
3101macro_rules! __tracing_stringify {
3102    ($($k:ident).+) => {{
3103        const NAME: $crate::__macro_support::FieldName<{
3104            $crate::__macro_support::FieldName::len($crate::__macro_support::stringify!($($k).+))
3105        }> = $crate::__macro_support::FieldName::new($crate::__macro_support::stringify!($($k).+));
3106        NAME.as_str()
3107    }};
3108}
3109
3110#[cfg(not(feature = "log"))]
3111#[doc(hidden)]
3112#[macro_export]
3113macro_rules! __tracing_log {
3114    ($level:expr, $callsite:expr, $value_set:expr) => {};
3115}
3116
3117#[cfg(feature = "log")]
3118#[doc(hidden)]
3119#[macro_export]
3120macro_rules! __tracing_log {
3121    ($level:expr, $callsite:expr, $value_set:expr) => {
3122        $crate::if_log_enabled! { $level, {
3123            use $crate::log;
3124            let level = $crate::level_to_log!($level);
3125            if level <= log::max_level() {
3126                let log_meta = log::Metadata::builder()
3127                    .level(level)
3128                    .target(__CALLSITE.metadata().target())
3129                    .build();
3130                let logger = log::logger();
3131                if logger.enabled(&log_meta) {
3132                    $callsite.log(logger, log_meta, $value_set)
3133                }
3134            }
3135        }}
3136    };
3137}
3138
3139#[cfg(not(feature = "log"))]
3140#[doc(hidden)]
3141#[macro_export]
3142macro_rules! if_log_enabled {
3143    ($lvl:expr, $e:expr;) => {
3144        $crate::if_log_enabled! { $lvl, $e }
3145    };
3146    ($lvl:expr, $if_log:block) => {
3147        $crate::if_log_enabled! { $lvl, $if_log else {} }
3148    };
3149    ($lvl:expr, $if_log:block else $else_block:block) => {
3150        $else_block
3151    };
3152}
3153
3154#[cfg(all(feature = "log", not(feature = "log-always")))]
3155#[doc(hidden)]
3156#[macro_export]
3157macro_rules! if_log_enabled {
3158    ($lvl:expr, $e:expr;) => {
3159        $crate::if_log_enabled! { $lvl, $e }
3160    };
3161    ($lvl:expr, $if_log:block) => {
3162        $crate::if_log_enabled! { $lvl, $if_log else {} }
3163    };
3164    ($lvl:expr, $if_log:block else $else_block:block) => {
3165        if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL {
3166            if !$crate::dispatch::has_been_set() {
3167                $if_log
3168            } else {
3169                $else_block
3170            }
3171        } else {
3172            $else_block
3173        }
3174    };
3175}
3176
3177#[cfg(all(feature = "log", feature = "log-always"))]
3178#[doc(hidden)]
3179#[macro_export]
3180macro_rules! if_log_enabled {
3181    ($lvl:expr, $e:expr;) => {
3182        $crate::if_log_enabled! { $lvl, $e }
3183    };
3184    ($lvl:expr, $if_log:block) => {
3185        $crate::if_log_enabled! { $lvl, $if_log else {} }
3186    };
3187    ($lvl:expr, $if_log:block else $else_block:block) => {
3188        if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL {
3189            #[allow(unused_braces)]
3190            $if_log
3191        } else {
3192            $else_block
3193        }
3194    };
3195}
tracing/macros.rs

tracing/
macros.rs
