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