tokio_trace/
macros.rs

1/// Constructs a new span.
2///
3/// # Examples
4///
5/// Creating a new span with no fields:
6/// ```
7/// # #[macro_use]
8/// # extern crate tokio_trace;
9/// # use tokio_trace::Level;
10/// # fn main() {
11/// let span = span!(Level::TRACE, "my span");
12/// span.enter(|| {
13///     // do work inside the span...
14/// });
15/// # }
16/// ```
17///
18/// Creating a span with fields:
19/// ```
20/// # #[macro_use]
21/// # extern crate tokio_trace;
22/// # use tokio_trace::Level;
23/// # fn main() {
24/// span!(Level::TRACE, "my span", foo = 2, bar = "a string").enter(|| {
25///     // do work inside the span...
26/// });
27/// # }
28/// ```
29///
30/// Note that a trailing comma on the final field is valid:
31/// ```
32/// # #[macro_use]
33/// # extern crate tokio_trace;
34/// # use tokio_trace::Level;
35/// # fn main() {
36/// span!(
37///     Level::TRACE,
38///     "my span",
39///     foo = 2,
40///     bar = "a string",
41/// );
42/// # }
43/// ```
44///
45/// Creating a span with custom target and log level:
46/// ```
47/// # #[macro_use]
48/// # extern crate tokio_trace;
49/// # use tokio_trace::Level;
50/// # fn main() {
51/// span!(
52///     Level::TRACE,
53///     target: "app_span",
54///     "my span",
55///     foo = 3,
56///     bar = "another string"
57/// );
58/// # }
59/// ```
60///
61/// Field values may be recorded after the span is created:
62/// ```
63/// # #[macro_use]
64/// # extern crate tokio_trace;
65/// # use tokio_trace::Level;
66/// # fn main() {
67/// let my_span = span!(Level::TRACE, "my span", foo = 2, bar);
68/// my_span.record("bar", &7);
69/// # }
70/// ```
71///
72/// Note that a span may have up to 32 fields. The following will not compile:
73/// ```rust,compile_fail
74///  # #[macro_use]
75/// # extern crate tokio_trace;
76/// # use tokio_trace::Level;
77/// # fn main() {
78/// span!(
79///     Level::TRACE,
80///     "too many fields!",
81///     a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9,
82///     j = 10, k = 11, l = 12, m = 13, n = 14, o = 15, p = 16, q = 17,
83///     r = 18, s = 19, t = 20, u = 21, v = 22, w = 23, x = 24, y = 25,
84///     z = 26, aa = 27, bb = 28, cc = 29, dd = 30, ee = 31, ff = 32, gg = 33
85/// );
86/// # }
87/// ```
88#[macro_export(local_inner_macros)]
89macro_rules! span {
90    ($lvl:expr, target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr )* ),*,) => {
91        span!(
92            $lvl,
93            target: $target,
94            parent: $parent,
95            $name,
96            $($($k).+ $( = $val)*),*
97        )
98    };
99    ($lvl:expr, target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr )* ),*) => {
100        {
101            use $crate::callsite;
102            use $crate::callsite::Callsite;
103            let callsite = callsite! {
104                name: $name,
105                kind: $crate::metadata::Kind::SPAN,
106                target: $target,
107                level: $lvl,
108                fields: $($($k).+),*
109            };
110            let meta = callsite.metadata();
111
112            if $lvl <= $crate::level_filters::STATIC_MAX_LEVEL && is_enabled!(callsite) {
113                $crate::Span::child_of(
114                    $parent,
115                    meta,
116                    &valueset!(meta.fields(), $($($k).+ $( = $val)*),*),
117                )
118            } else {
119                 __tokio_trace_disabled_span!(
120                    meta,
121                    &valueset!(meta.fields(), $($($k).+ $( = $val)*),*)
122                )
123            }
124        }
125    };
126    ($lvl:expr, target: $target:expr, $name:expr,$($($k:ident).+ $( = $val:expr )* ),*) => {
127        {
128            use $crate::callsite;
129            use $crate::callsite::Callsite;
130            let callsite = callsite! {
131                name: $name,
132                kind: $crate::metadata::Kind::SPAN,
133                target: $target,
134                level: $lvl,
135                fields: $( $($k).+ ),*
136            };
137            let meta = callsite.metadata();
138
139            if $lvl <= $crate::level_filters::STATIC_MAX_LEVEL && is_enabled!(callsite) {
140                $crate::Span::new(
141                    meta,
142                    &valueset!(meta.fields(), $($($k).+ $( = $val)*),*),
143                )
144            } else {
145                __tokio_trace_disabled_span!(
146                    meta,
147                    &valueset!(meta.fields(), $($($k).+ $( = $val)*),*)
148                )
149            }
150        }
151
152    };
153    ($lvl:expr, target: $target:expr, parent: $parent:expr, $name:expr) => {
154        span!($lvl, target: $target, parent: $parent, $name,)
155    };
156    ($lvl:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
157        span!(
158            $lvl,
159            target: __tokio_trace_module_path!(),
160            parent: $parent,
161            $name,
162            $($($k).+ $( = $val)*),*
163        )
164    };
165    ($lvl:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
166        span!(
167            $lvl,
168            target: __tokio_trace_module_path!(),
169            parent: $parent,
170            $name,
171            $($($k).+ $( = $val)*),*
172        )
173    };
174    ($lvl:expr, parent: $parent:expr, $name:expr) => {
175        span!(
176            $lvl,
177            target: __tokio_trace_module_path!(),
178            parent: $parent,
179            $name,
180        )
181    };
182    ($lvl:expr, target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr )* ),*,
183    ) => {
184        span!(
185            $lvl,
186            target: $target,
187            $name,
188            $($($k).+ $( = $val)*),*
189        )
190    };
191    ($lvl:expr, target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr )* ),*) => {
192        span!(
193            $lvl,
194            target: $target,
195            $name,
196            $($($k).+ $( = $val)*),*
197        )
198    };
199    ($lvl:expr, target: $target:expr, $name:expr) => {
200        span!($lvl, target: $target, $name,)
201    };
202    ($lvl:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
203        span!(
204            $lvl,
205            target: __tokio_trace_module_path!(),
206            $name,
207            $($($k).+ $( = $val)*),*
208        )
209    };
210    ($lvl:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
211        span!(
212            $lvl,
213            target: __tokio_trace_module_path!(),
214            $name,
215            $($($k).+ $( = $val)*),*
216        )
217    };
218    ($lvl:expr, $name:expr) => {
219        span!(
220            $lvl,
221            target: __tokio_trace_module_path!(),
222            $name,
223        )
224    };
225}
226
227/// Constructs a span at the trace level.
228///
229/// # Examples
230///
231/// ```rust
232/// # #[macro_use]
233/// # extern crate tokio_trace;
234/// # fn main() {
235/// let span = trace_span!("my span");
236/// span.enter(|| {
237///     // do work inside the span...
238/// });
239/// # }
240/// ```
241#[macro_export(local_inner_macros)]
242macro_rules! trace_span {
243    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
244        trace_span!(
245            target: $target,
246            parent: $parent,
247            $name,
248            $($($k).+ $( = $val)*),*
249        )
250    };
251    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
252        span!(
253            $crate::Level::TRACE,
254            target: $target,
255            parent: $parent,
256            $name,
257            $($($k).+ $( = $val)*),*
258        )
259    };
260    (target: $target:expr, parent: $parent:expr, $name:expr) => {
261        trace_span!(target: $target, parent: $parent, $name,)
262    };
263    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
264        trace_span!(
265            parent: $parent,
266            $name,
267            $($($k).+ $( = $val)*),*
268        )
269    };
270    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
271        span!(
272            $crate::Level::TRACE,
273            target: __tokio_trace_module_path!(),
274            $name,
275            $($($k).+ $( = $val)*),*
276        )
277    };
278    (parent: $parent:expr, $name:expr) => {
279        trace_span!(parent: $parent, $name,)
280    };
281    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
282        trace_span!(
283            target: $target,
284            $name,
285            $($($k).+ $( = $val)*),*
286        )
287    };
288    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
289        span!(
290            $crate::Level::TRACE,
291            target: $target,
292            $name,
293            $($($k).+ $( = $val)*),*
294        )
295    };
296    (target: $target:expr, $name:expr) => {
297        trace_span!(target: $target, $name,)
298    };
299    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
300        trace_span!(
301            $name,
302            $($($k).+ $( = $val)*),*
303        )
304    };
305    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
306        span!(
307            $crate::Level::TRACE,
308            target: __tokio_trace_module_path!(),
309            $name,
310            $($($k).+ $( = $val)*),*
311        )
312    };
313    ($name:expr) => {trace_span!($name,)};
314}
315
316/// Constructs a span at the debug level.
317///
318/// # Examples
319///
320/// ```rust
321/// # #[macro_use]
322/// # extern crate tokio_trace;
323/// # fn main() {
324/// let span = debug_span!("my span");
325/// span.enter(|| {
326///     // do work inside the span...
327/// });
328/// # }
329/// ```
330#[macro_export(local_inner_macros)]
331macro_rules! debug_span {
332    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
333        debug_span!(
334            target: $target,
335            parent: $parent,
336            $name,
337            $($($k).+ $( = $val)*),*
338        )
339    };
340    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
341        span!(
342            $crate::Level::DEBUG,
343            target: $target,
344            parent: $parent,
345            $name,
346            $($($k).+ $( = $val)*),*
347        )
348    };
349    (target: $target:expr, parent: $parent:expr, $name:expr) => {
350        debug_span!(target: $target, parent: $parent, $name,)
351    };
352    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
353        debug_span!(
354            parent: $parent,
355            $name,
356            $($($k).+ $( = $val)*),*
357        )
358    };
359    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
360        span!(
361            $crate::Level::DEBUG,
362            target: __tokio_trace_module_path!(),
363            $name,
364            $($($k).+ $( = $val)*),*
365        )
366    };
367    (parent: $parent:expr, $name:expr) => {
368        debug_span!(parent: $parent, $name,)
369    };
370    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
371        debug_span!(
372            target: $target,
373            $name,
374            $($($k).+ $( = $val)*),*
375        )
376    };
377    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
378        span!(
379            $crate::Level::DEBUG,
380            target: $target,
381            $name,
382            $($($k).+ $( = $val)*),*
383        )
384    };
385    (target: $target:expr, $name:expr) => {
386        debug_span!(target: $target, $name,)
387    };
388    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
389        debug_span!(
390            $name,
391            $($($k).+ $( = $val)*),*
392        )
393    };
394    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
395        span!(
396            $crate::Level::DEBUG,
397            target: __tokio_trace_module_path!(),
398            $name,
399            $($($k).+ $( = $val)*),*
400        )
401    };
402    ($name:expr) => {debug_span!($name,)};
403}
404
405/// Constructs a span at the info level.
406///
407/// # Examples
408///
409/// ```rust
410/// # #[macro_use]
411/// # extern crate tokio_trace;
412/// # fn main() {
413/// let span = info_span!("my span");
414/// span.enter(|| {
415///     // do work inside the span...
416/// });
417/// # }
418/// ```
419#[macro_export(local_inner_macros)]
420macro_rules! info_span {
421    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
422        info_span!(
423            target: $target,
424            parent: $parent,
425            $name,
426            $($($k).+ $( = $val)*),*
427        )
428    };
429    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
430        span!(
431            $crate::Level::INFO,
432            target: $target,
433            parent: $parent,
434            $name,
435            $($($k).+ $( = $val)*),*
436        )
437    };
438    (target: $target:expr, parent: $parent:expr, $name:expr) => {
439        info_span!(target: $target, parent: $parent, $name,)
440    };
441    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
442        info_span!(
443            parent: $parent,
444            $name,
445            $($($k).+ $( = $val)*),*
446        )
447    };
448    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
449        span!(
450            $crate::Level::INFO,
451            target: __tokio_trace_module_path!(),
452            $name,
453            $($($k).+ $( = $val)*),*
454        )
455    };
456    (parent: $parent:expr, $name:expr) => {
457        info_span!(parent: $parent, $name,)
458    };
459    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
460        info_span!(
461            target: $target,
462            $name,
463            $($($k).+ $( = $val)*),*
464        )
465    };
466    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
467        span!(
468            $crate::Level::INFO,
469            target: $target,
470            $name,
471            $($($k).+ $( = $val)*),*
472        )
473    };
474    (target: $target:expr, $name:expr) => {
475        info_span!(target: $target, $name,)
476    };
477    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
478        info_span!(
479            $name,
480            $($($k).+ $( = $val)*),*
481        )
482    };
483    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
484        span!(
485            $crate::Level::INFO,
486            target: __tokio_trace_module_path!(),
487            $name,
488            $($($k).+ $( = $val)*),*
489        )
490    };
491    ($name:expr) => {info_span!($name,)};
492}
493
494/// Constructs a span at the warn level.
495///
496/// # Examples
497///
498/// ```rust
499/// # #[macro_use]
500/// # extern crate tokio_trace;
501/// # fn main() {
502/// let span = warn_span!("my span");
503/// span.enter(|| {
504///     // do work inside the span...
505/// });
506/// # }
507/// ```
508#[macro_export(local_inner_macros)]
509macro_rules! warn_span {
510    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
511        warn_span!(
512            target: $target,
513            parent: $parent,
514            $name,
515            $($($k).+ $( = $val)*),*
516        )
517    };
518    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
519        span!(
520            $crate::Level::WARN,
521            target: $target,
522            parent: $parent,
523            $name,
524            $($($k).+ $( = $val)*),*
525        )
526    };
527    (target: $target:expr, parent: $parent:expr, $name:expr) => {
528        warn_span!(target: $target, parent: $parent, $name,)
529    };
530    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
531        warn_span!(
532            parent: $parent,
533            $name,
534            $($($k).+ $( = $val)*),*
535        )
536    };
537    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
538        span!(
539            $crate::Level::WARN,
540            target: __tokio_trace_module_path!(),
541            $name,
542            $($($k).+ $( = $val)*),*
543        )
544    };
545    (parent: $parent:expr, $name:expr) => {
546        warn_span!(parent: $parent, $name,)
547    };
548    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
549        warn_span!(
550            target: $target,
551            $name,
552            $($($k).+ $( = $val)*),*
553        )
554    };
555    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
556        span!(
557            $crate::Level::WARN,
558            target: $target,
559            $name,
560            $($($k).+ $( = $val)*),*
561        )
562    };
563    (target: $target:expr, $name:expr) => {
564        warn_span!(target: $target, $name,)
565    };
566    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
567        warn_span!(
568            $name,
569            $($($k).+ $( = $val)*),*
570        )
571    };
572    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
573        span!(
574            $crate::Level::WARN,
575            target: __tokio_trace_module_path!(),
576            $name,
577            $($($k).+ $( = $val)*),*
578        )
579    };
580    ($name:expr) => {warn_span!($name,)};
581}
582/// Constructs a span at the error level.
583///
584/// # Examples
585///
586/// ```rust
587/// # #[macro_use]
588/// # extern crate tokio_trace;
589/// # fn main() {
590/// let span = error_span!("my span");
591/// span.enter(|| {
592///     // do work inside the span...
593/// });
594/// # }
595/// ```
596#[macro_export(local_inner_macros)]
597macro_rules! error_span {
598    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
599        error_span!(
600            target: $target,
601            parent: $parent,
602            $name,
603            $($($k).+ $( = $val)*),*
604        )
605    };
606    (target: $target:expr, parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
607        span!(
608            $crate::Level::ERROR,
609            target: $target,
610            parent: $parent,
611            $name,
612            $($($k).+ $( = $val)*),*
613        )
614    };
615    (target: $target:expr, parent: $parent:expr, $name:expr) => {
616        error_span!(target: $target, parent: $parent, $name,)
617    };
618    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
619        error_span!(
620            parent: $parent,
621            $name,
622            $($($k).+ $( = $val)*),*
623        )
624    };
625    (parent: $parent:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
626        span!(
627            $crate::Level::ERROR,
628            target: __tokio_trace_module_path!(),
629            $name,
630            $($($k).+ $( = $val)*),*
631        )
632    };
633    (parent: $parent:expr, $name:expr) => {
634        error_span!(parent: $parent, $name,)
635    };
636    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
637        error_span!(
638            target: $target,
639            $name,
640            $($($k).+ $( = $val)*),*
641        )
642    };
643    (target: $target:expr, $name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
644        span!(
645            $crate::Level::ERROR,
646            target: $target,
647            $name,
648            $($($k).+ $( = $val)*),*
649        )
650    };
651    (target: $target:expr, $name:expr) => {
652        error_span!(target: $target, $name,)
653    };
654    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*,) => {
655        error_span!(
656            $name,
657            $($($k).+ $( = $val)*),*
658        )
659    };
660    ($name:expr, $($($k:ident).+ $( = $val:expr)*),*) => {
661        span!(
662            $crate::Level::ERROR,
663            target: __tokio_trace_module_path!(),
664            $name,
665            $($($k).+ $( = $val)*),*
666        )
667    };
668    ($name:expr) => {error_span!($name,)};
669}
670
671/// Constructs a new `Event`.
672///
673/// # Examples
674///
675/// ```rust
676/// # #[macro_use]
677/// # extern crate tokio_trace;
678/// use tokio_trace::{Level, field};
679///
680/// # fn main() {
681/// let data = (42, "fourty-two");
682/// let private_data = "private";
683/// let error = "a bad error";
684///
685/// event!(Level::ERROR, { error = field::display(error) }, "Received error");
686/// event!(target: "app_events", Level::WARN, {
687///         private_data = private_data,
688///         data = field::debug(data),
689///     },
690///     "App warning: {}", error
691/// );
692/// event!(Level::INFO, the_answer = data.0);
693/// # }
694/// ```
695///
696/// Note that *unlike `span!`*, `event!` requires a value for all fields. As
697/// events are recorded immediately when the macro is invoked, there is no
698/// opportunity for fields to be recorded later. A trailing comma on the final
699/// field is valid.
700///
701/// For example, the following does not compile:
702/// ```rust,compile_fail
703/// # #[macro_use]
704/// # extern crate tokio_trace;
705/// use tokio_trace::{Level, field};
706///
707/// # fn main() {
708///     event!(Level::Info, foo = 5, bad_field, bar = field::display("hello"))
709/// #}
710/// ```
711///
712/// Events may have up to 32 fields. The following will not compile:
713/// ```rust,compile_fail
714///  # #[macro_use]
715/// # extern crate tokio_trace;
716/// # use tokio_trace::Level;
717/// # fn main() {
718/// event!(Level::INFO,
719///     a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9,
720///     j = 10, k = 11, l = 12, m = 13, n = 14, o = 15, p = 16, q = 17,
721///     r = 18, s = 19, t = 20, u = 21, v = 22, w = 23, x = 24, y = 25,
722///     z = 26, aa = 27, bb = 28, cc = 29, dd = 30, ee = 31, ff = 32, gg = 33
723/// );
724/// # }
725/// ```
726#[macro_export(local_inner_macros)]
727macro_rules! event {
728    (target: $target:expr, $lvl:expr, { $( $($k:ident).+ = $val:expr ),* $(,)*} )=> ({
729        {
730            __tokio_trace_log!(
731                target: $target,
732                $lvl,
733                $( $($k).+ = $val ),*
734            );
735
736            if $lvl <= $crate::level_filters::STATIC_MAX_LEVEL {
737                #[allow(unused_imports)]
738                use $crate::{callsite, dispatcher, Event, field::{Value, ValueSet}};
739                use $crate::callsite::Callsite;
740                let callsite = callsite! {
741                    name: __tokio_trace_concat!(
742                        "event ",
743                        __tokio_trace_file!(),
744                        ":",
745                        __tokio_trace_line!()
746                    ),
747                    kind: $crate::metadata::Kind::EVENT,
748                    target: $target,
749                    level: $lvl,
750                    fields: $( $($k).+ ),*
751                };
752                if is_enabled!(callsite) {
753                    let meta = callsite.metadata();
754                    Event::dispatch(meta, &valueset!(meta.fields(), $( $($k).+ = $val),* ));
755                }
756            }
757        }
758    });
759    (
760        target: $target:expr,
761        $lvl:expr,
762        { $( $($k:ident).+ = $val:expr ),*, },
763        $($arg:tt)+
764    ) => ({
765        event!(
766            target: $target,
767            $lvl,
768            { message = __tokio_trace_format_args!($($arg)+), $( $($k).+ = $val ),* }
769        )
770    });
771    (
772        target: $target:expr,
773        $lvl:expr,
774        { $( $($k:ident).+ = $val:expr ),* },
775        $($arg:tt)+
776    ) => ({
777        event!(
778            target: $target,
779            $lvl,
780            { message = __tokio_trace_format_args!($($arg)+), $( $($k).+ = $val ),* }
781        )
782    });
783    (target: $target:expr, $lvl:expr, $( $($k:ident).+ = $val:expr ),+, ) => (
784        event!(target: $target, $lvl, { $($($k).+ = $val),+ })
785    );
786    (target: $target:expr, $lvl:expr, $( $($k:ident).+ = $val:expr ),+ ) => (
787        event!(target: $target, $lvl, { $($($k).+ = $val),+ })
788    );
789    (target: $target:expr, $lvl:expr, $($arg:tt)+ ) => (
790        event!(target: $target, $lvl, { }, $($arg)+)
791    );
792    ( $lvl:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
793        event!(
794            target: __tokio_trace_module_path!(),
795            $lvl,
796            { message = __tokio_trace_format_args!($($arg)+), $($($k).+ = $val),* }
797        )
798    );
799    ( $lvl:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
800        event!(
801            target: __tokio_trace_module_path!(),
802            $lvl,
803            { message = __tokio_trace_format_args!($($arg)+), $($($k).+ = $val),* }
804        )
805    );
806    ( $lvl:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
807        event!(target: __tokio_trace_module_path!(), $lvl, { $($($k).+ = $val),* })
808    );
809    ( $lvl:expr, $( $($k:ident).+ = $val:expr ),* ) => (
810        event!(target: __tokio_trace_module_path!(), $lvl, { $($($k).+ = $val),* })
811    );
812    ( $lvl:expr, $($arg:tt)+ ) => (
813        event!(target: __tokio_trace_module_path!(), $lvl, { }, $($arg)+)
814    );
815}
816
817/// Constructs an event at the trace level.
818///
819/// When both a message and fields are included, curly braces (`{` and `}`) are
820/// used to delimit the list of fields from the format string for the message.
821/// A trailing comma on the final field is valid.
822///
823/// # Examples
824///
825/// ```rust
826/// # #[macro_use]
827/// # extern crate tokio_trace;
828/// # use std::time::SystemTime;
829/// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 }
830/// # impl Position {
831/// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 };
832/// # fn dist(&self, other: Position) -> f32 {
833/// #    let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2();
834/// #    (x + y).sqrt()
835/// # }
836/// # }
837/// # fn main() {
838/// use tokio_trace::field;
839///
840/// let pos = Position { x: 3.234, y: -1.223 };
841/// let origin_dist = pos.dist(Position::ORIGIN);
842///
843/// trace!(position = field::debug(pos), origin_dist = field::debug(origin_dist));
844/// trace!(target: "app_events",
845///         { position = field::debug(pos) },
846///         "x is {} and y is {}",
847///        if pos.x >= 0.0 { "positive" } else { "negative" },
848///        if pos.y >= 0.0 { "positive" } else { "negative" });
849/// # }
850/// ```
851#[macro_export(local_inner_macros)]
852macro_rules! trace {
853    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
854        event!(target: $target, $crate::Level::TRACE, { $($($k).+ = $val),* }, $($arg)+)
855    );
856    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
857        event!(target: $target, $crate::Level::TRACE, { $($($k).+ = $val),* }, $($arg)+)
858    );
859    (target: $target:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
860        event!(target: $target, $crate::Level::TRACE, { $($($k).+ = $val),* })
861    );
862    (target: $target:expr, $( $($k:ident).+ = $val:expr ),* ) => (
863        event!(target: $target, $crate::Level::TRACE, { $($($k).+ = $val),* })
864    );
865    (target: $target:expr, $($arg:tt)+ ) => (
866        drop(event!(target: $target, $crate::Level::TRACE, {}, $($arg)+));
867    );
868    ({ $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
869        event!(
870            target: __tokio_trace_module_path!(),
871            $crate::Level::TRACE,
872            { $($($k).+ = $val),* },
873            $($arg)+
874        )
875    );
876    ({ $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
877        event!(
878            target: __tokio_trace_module_path!(),
879            $crate::Level::TRACE,
880            { $($($k).+ = $val),* },
881            $($arg)+
882        )
883    );
884    ($( $($k:ident).+ = $val:expr ),*, ) => (
885        event!(
886            target: __tokio_trace_module_path!(),
887            $crate::Level::TRACE,
888            { $($($k).+ = $val),* }
889        )
890    );
891    ($( $($k:ident).+ = $val:expr ),* ) => (
892        event!(
893            target: __tokio_trace_module_path!(),
894            $crate::Level::TRACE,
895            { $($($k).+ = $val),* }
896        )
897    );
898    ($($arg:tt)+ ) => (
899        event!(
900            target: __tokio_trace_module_path!(),
901            $crate::Level::TRACE,
902            {},
903            $($arg)+
904        )
905    );
906}
907
908/// Constructs an event at the debug level.
909///
910/// When both a message and fields are included, curly braces (`{` and `}`) are
911/// used to delimit the list of fields from the format string for the message.
912/// A trailing comma on the final field is valid.
913///
914/// # Examples
915///
916/// ```rust
917/// # #[macro_use]
918/// # extern crate tokio_trace;
919/// # fn main() {
920/// # #[derive(Debug)] struct Position { x: f32, y: f32 }
921/// use tokio_trace::field;
922///
923/// let pos = Position { x: 3.234, y: -1.223 };
924///
925/// debug!(x = field::debug(pos.x), y = field::debug(pos.y));
926/// debug!(target: "app_events", { position = field::debug(&pos) }, "New position");
927/// # }
928/// ```
929#[macro_export(local_inner_macros)]
930macro_rules! debug {
931    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
932        event!(target: $target, $crate::Level::DEBUG, { $($($k).+ = $val),* }, $($arg)+)
933    );
934    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
935        event!(target: $target, $crate::Level::DEBUG, { $($($k).+ = $val),* }, $($arg)+)
936    );
937    (target: $target:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
938        event!(target: $target, $crate::Level::DEBUG, { $($($k).+ = $val),* })
939    );
940    (target: $target:expr, $( $($k:ident).+ = $val:expr ),* ) => (
941        event!(target: $target, $crate::Level::DEBUG, { $($($k).+ = $val),* })
942    );
943    (target: $target:expr, $($arg:tt)+ ) => (
944        event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
945    );
946    ({ $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
947        event!(
948            target: __tokio_trace_module_path!(), $crate::Level::DEBUG, { $($($k).+ = $val),* }, $($arg)+)
949    );
950    ({ $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
951        event!(
952            target: __tokio_trace_module_path!(),
953            $crate::Level::DEBUG,
954            { $($($k).+ = $val),* },
955            $($arg)+
956        )
957    );
958    ($( $($k:ident).+ = $val:expr ),*, ) => (
959        event!(
960            target: __tokio_trace_module_path!(),
961            $crate::Level::DEBUG,
962            { $($($k).+ = $val),* }
963        )
964    );
965    ($( $($k:ident).+ = $val:expr ),* ) => (
966        event!(
967            target: __tokio_trace_module_path!(),
968            $crate::Level::DEBUG,
969            { $($($k).+ = $val),* }
970        )
971    );
972    ($($arg:tt)+ ) => (
973        event!(
974            target: __tokio_trace_module_path!(),
975            $crate::Level::DEBUG,
976            {},
977            $($arg)+
978        )
979    );
980}
981
982/// Constructs an event at the info level.
983///
984/// When both a message and fields are included, curly braces (`{` and `}`) are
985/// used to delimit the list of fields from the format string for the message.
986/// A trailing comma on the final field is valid.
987///
988/// # Examples
989///
990/// ```rust
991/// # #[macro_use]
992/// # extern crate tokio_trace;
993/// # use std::net::Ipv4Addr;
994/// # fn main() {
995/// # struct Connection { port: u32,  speed: f32 }
996/// use tokio_trace::field;
997///
998/// let addr = Ipv4Addr::new(127, 0, 0, 1);
999/// let conn_info = Connection { port: 40, speed: 3.20 };
1000///
1001/// info!({ port = conn_info.port }, "connected to {}", addr);
1002/// info!(
1003///     target: "connection_events",
1004///     ip = field::display(addr),
1005///     port = conn_info.port,
1006///     speed = field::debug(conn_info.speed)
1007/// );
1008/// # }
1009/// ```
1010#[macro_export(local_inner_macros)]
1011macro_rules! info {
1012    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1013        event!(target: $target, $crate::Level::INFO, { $($($k).+ = $val),* }, $($arg)+)
1014    );
1015    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1016        event!(target: $target, $crate::Level::INFO, { $($($k).+ = $val),* }, $($arg)+)
1017    );
1018    (target: $target:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
1019        event!(target: $target, $crate::Level::INFO, { $($($k).+ = $val),* })
1020    );
1021    (target: $target:expr, $( $($k:ident).+ = $val:expr ),* ) => (
1022        event!(target: $target, $crate::Level::INFO, { $($($k).+ = $val),* })
1023    );
1024    (target: $target:expr, $($arg:tt)+ ) => (
1025        event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
1026    );
1027    ({ $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1028        event!(
1029            target: __tokio_trace_module_path!(),
1030            $crate::Level::INFO,
1031            { $($($k).+ = $val),* },
1032            $($arg)+
1033        )
1034    );
1035    ({ $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1036        event!(
1037            target: __tokio_trace_module_path!(),
1038            $crate::Level::INFO,
1039            { $($($k).+ = $val),* },
1040            $($arg)+
1041        )
1042    );
1043    ($( $($k:ident).+ = $val:expr ),*, ) => (
1044        event!(
1045            target: __tokio_trace_module_path!(),
1046            $crate::Level::INFO,
1047            { $($($k).+ = $val),* }
1048        )
1049    );
1050    ($( $($k:ident).+ = $val:expr ),* ) => (
1051        event!(
1052            target: __tokio_trace_module_path!(),
1053            $crate::Level::INFO,
1054            { $($($k).+ = $val),* }
1055        )
1056    );
1057    ($($arg:tt)+ ) => (
1058        event!(
1059            target: __tokio_trace_module_path!(),
1060            $crate::Level::INFO,
1061            {},
1062            $($arg)+
1063        )
1064    );
1065}
1066
1067/// Constructs an event at the warn level.
1068///
1069/// When both a message and fields are included, curly braces (`{` and `}`) are
1070/// used to delimit the list of fields from the format string for the message.
1071/// A trailing comma on the final field is valid.
1072///
1073/// # Examples
1074///
1075/// ```rust
1076/// # #[macro_use]
1077/// # extern crate tokio_trace;
1078/// # fn main() {
1079/// use tokio_trace::field;
1080///
1081/// let warn_description = "Invalid Input";
1082/// let input = &[0x27, 0x45];
1083///
1084/// warn!(input = field::debug(input), warning = warn_description);
1085/// warn!(
1086///     target: "input_events",
1087///     { warning = warn_description },
1088///     "Received warning for input: {:?}", input,
1089/// );
1090/// # }
1091/// ```
1092#[macro_export(local_inner_macros)]
1093macro_rules! warn {
1094    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1095        event!(target: $target, $crate::Level::WARN, { $($($k).+ = $val),* }, $($arg)+)
1096    );
1097    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1098        event!(target: $target, $crate::Level::WARN, { $($($k).+ = $val),* }, $($arg)+)
1099    );
1100    (target: $target:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
1101        event!(target: $target, $crate::Level::WARN, { $($($k).+ = $val),* })
1102    );
1103    (target: $target:expr, $( $($k:ident).+ = $val:expr ),* ) => (
1104        event!(target: $target, $crate::Level::WARN, { $($($k).+ = $val),* })
1105    );
1106    (target: $target:expr, $($arg:tt)+ ) => (
1107        drop(event!(target: $target, $crate::Level::WARN, {}, $($arg)+));
1108    );
1109    ({ $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1110        event!(
1111            target: __tokio_trace_module_path!(),
1112            $crate::Level::WARN,
1113            { $($($k).+ = $val),* },
1114            $($arg)+
1115        )
1116    );
1117    ({ $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1118        event!(
1119            target: __tokio_trace_module_path!(),
1120            $crate::Level::WARN,
1121            { $($($k).+ = $val),* },
1122            $($arg)+
1123        )
1124    );
1125    ($( $($k:ident).+ = $val:expr ),*, ) => (
1126        event!(
1127            target: __tokio_trace_module_path!(),
1128            $crate::Level::WARN,{ $($($k).+ = $val),* }
1129        )
1130    );
1131    ($( $($k:ident).+ = $val:expr ),* ) => (
1132        event!(
1133            target: __tokio_trace_module_path!(),
1134            $crate::Level::WARN,
1135            { $($($k).+ = $val),* }
1136        )
1137    );
1138    ($($arg:tt)+ ) => (
1139        event!(
1140            target: __tokio_trace_module_path!(),
1141            $crate::Level::WARN,
1142            {},
1143            $($arg)+
1144        )
1145    );
1146}
1147
1148/// Constructs an event at the error level.
1149///
1150/// When both a message and fields are included, curly braces (`{` and `}`) are
1151/// used to delimit the list of fields from the format string for the message.
1152/// A trailing comma on the final field is valid.
1153///
1154/// # Examples
1155///
1156/// ```rust
1157/// # #[macro_use]
1158/// # extern crate tokio_trace;
1159/// # fn main() {
1160/// use tokio_trace::field;
1161/// let (err_info, port) = ("No connection", 22);
1162///
1163/// error!(port = port, error = field::display(err_info));
1164/// error!(target: "app_events", "App Error: {}", err_info);
1165/// error!({ info = err_info }, "error on port: {}", port);
1166/// # }
1167/// ```
1168#[macro_export(local_inner_macros)]
1169macro_rules! error {
1170    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1171        event!(target: $target, $crate::Level::ERROR, { $($($k).+ = $val),* }, $($arg)+)
1172    );
1173    (target: $target:expr, { $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1174        event!(target: $target, $crate::Level::ERROR, { $($($k).+ = $val),* }, $($arg)+)
1175    );
1176    (target: $target:expr, $( $($k:ident).+ = $val:expr ),*, ) => (
1177        event!(target: $target, $crate::Level::ERROR, { $($($k).+ = $val),* })
1178    );
1179    (target: $target:expr, $( $($k:ident).+ = $val:expr ),* ) => (
1180        event!(target: $target, $crate::Level::ERROR, { $($($k).+ = $val),* })
1181    );
1182    (target: $target:expr, $($arg:tt)+ ) => (
1183        event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
1184    );
1185    ({ $( $($k:ident).+ = $val:expr ),*, }, $($arg:tt)+ ) => (
1186        event!(
1187            target: __tokio_trace_module_path!(),
1188            $crate::Level::ERROR,
1189            { $($($k).+ = $val),* },
1190            $($arg)+
1191        )
1192    );
1193    ({ $( $($k:ident).+ = $val:expr ),* }, $($arg:tt)+ ) => (
1194        event!(
1195            target: __tokio_trace_module_path!(),
1196            $crate::Level::ERROR,
1197            { $($($k).+ = $val),* },
1198            $($arg)+
1199        )
1200    );
1201    ($( $($k:ident).+ = $val:expr ),*, ) => (
1202        event!(
1203            target: __tokio_trace_module_path!(),
1204            $crate::Level::ERROR,
1205            { $($($k).+ = $val),* }
1206        )
1207    );
1208    ($( $($k:ident).+ = $val:expr ),* ) => (
1209        event!(
1210            target: __tokio_trace_module_path!(),
1211            $crate::Level::ERROR,
1212            { $($($k).+ = $val),* }
1213        )
1214    );
1215    ($($arg:tt)+ ) => (
1216        event!(
1217            target: __tokio_trace_module_path!(),
1218            $crate::Level::ERROR,
1219            {},
1220            $($arg)+
1221        )
1222    );
1223}
1224
1225/// Constructs a new static callsite for a span or event.
1226#[doc(hidden)]
1227#[macro_export(local_inner_macros)]
1228macro_rules! callsite {
1229    (name: $name:expr, kind: $kind:expr, fields: $( $field_name:expr ),* $(,)*) => ({
1230        callsite! {
1231            name: $name,
1232            kind: $kind,
1233            target: __tokio_trace_module_path!(),
1234            level: $crate::Level::TRACE,
1235            fields: $( $field_name ),*
1236        }
1237    });
1238    (
1239        name: $name:expr,
1240        kind: $kind:expr,
1241        level: $lvl:expr,
1242        fields: $( $field_name:expr ),*  $(,)*
1243    ) => ({
1244        callsite! {
1245            name: $name,
1246            kind: $kind,
1247            target: __tokio_trace_module_path!(),
1248            level: $lvl,
1249            fields: $( $field_name ),*
1250        }
1251    });
1252    (
1253        name: $name:expr,
1254        kind: $kind:expr,
1255        target: $target:expr,
1256        level: $lvl:expr,
1257        fields: $( $field_name:expr ),*
1258        $(,)*
1259    ) => ({
1260        use std::sync::{Once, atomic::{self, AtomicUsize, Ordering}};
1261        use $crate::{callsite, Metadata, subscriber::Interest};
1262        struct MyCallsite;
1263        static META: Metadata<'static> = {
1264            metadata! {
1265                name: $name,
1266                target: $target,
1267                level: $lvl,
1268                fields: &[ $( __tokio_trace_stringify!($field_name) ),* ],
1269                callsite: &MyCallsite,
1270                kind: $kind,
1271            }
1272        };
1273        // FIXME: Rust 1.34 deprecated ATOMIC_USIZE_INIT. When Tokio's minimum
1274        // supported version is 1.34, replace this with the const fn `::new`.
1275        #[allow(deprecated)]
1276        static INTEREST: AtomicUsize = atomic::ATOMIC_USIZE_INIT;
1277        static REGISTRATION: Once = Once::new();
1278        impl MyCallsite {
1279            #[inline]
1280            fn interest(&self) -> Interest {
1281                match INTEREST.load(Ordering::Relaxed) {
1282                    0 => Interest::never(),
1283                    2 => Interest::always(),
1284                    _ => Interest::sometimes(),
1285                }
1286            }
1287        }
1288        impl callsite::Callsite for MyCallsite {
1289            fn set_interest(&self, interest: Interest) {
1290                let interest = match () {
1291                    _ if interest.is_never()  => 0,
1292                    _ if interest.is_always() => 2,
1293                    _ => 1,
1294                };
1295                INTEREST.store(interest, Ordering::SeqCst);
1296            }
1297
1298            fn metadata(&self) -> &Metadata {
1299                &META
1300            }
1301        }
1302        REGISTRATION.call_once(|| {
1303            callsite::register(&MyCallsite);
1304        });
1305        &MyCallsite
1306    })
1307}
1308
1309#[macro_export]
1310// TODO: determine if this ought to be public API?
1311#[doc(hidden)]
1312macro_rules! is_enabled {
1313    ($callsite:expr) => {{
1314        let interest = $callsite.interest();
1315        if interest.is_never() {
1316            false
1317        } else if interest.is_always() {
1318            true
1319        } else {
1320            let meta = $callsite.metadata();
1321            $crate::dispatcher::get_default(|current| current.enabled(meta))
1322        }
1323    }};
1324}
1325
1326#[doc(hidden)]
1327#[macro_export(local_inner_macros)]
1328macro_rules! valueset {
1329    ($fields:expr, $($($k:ident).+ $( = $val:expr )* ) ,*) => {
1330        {
1331            let mut iter = $fields.iter();
1332            $fields.value_set(&[
1333                $((
1334                    &iter.next().expect("FieldSet corrupted (this is a bug)"),
1335                    valueset!(@val $($k).+ $(= $val)*)
1336                )),*
1337            ])
1338        }
1339    };
1340    (@val $($k:ident).+ = $val:expr) => {
1341        Some(&$val as &$crate::field::Value)
1342    };
1343    (@val $($k:ident).+) => { None };
1344}
1345
1346// The macros above cannot invoke format_args directly because they use
1347// local_inner_macros. A format_args invocation there would resolve to
1348// $crate::format_args, which does not exist. Instead invoke format_args here
1349// outside of local_inner_macros so that it resolves (probably) to
1350// core::format_args or std::format_args. Same for the several macros that
1351// follow.
1352//
1353// This is a workaround until we drop support for pre-1.30 compilers. At that
1354// point we can remove use of local_inner_macros, use $crate:: when invoking
1355// local macros, and invoke format_args directly.
1356#[doc(hidden)]
1357#[macro_export]
1358macro_rules! __tokio_trace_format_args {
1359    ($($args:tt)*) => {
1360        format_args!($($args)*)
1361    };
1362}
1363
1364#[doc(hidden)]
1365#[macro_export]
1366macro_rules! __tokio_trace_module_path {
1367    () => {
1368        module_path!()
1369    };
1370}
1371
1372#[doc(hidden)]
1373#[macro_export]
1374macro_rules! __tokio_trace_file {
1375    () => {
1376        file!()
1377    };
1378}
1379
1380#[doc(hidden)]
1381#[macro_export]
1382macro_rules! __tokio_trace_line {
1383    () => {
1384        line!()
1385    };
1386}
1387
1388#[doc(hidden)]
1389#[macro_export]
1390macro_rules! __tokio_trace_concat {
1391    ($($e:expr),*) => {
1392        concat!($($e),*)
1393    };
1394}
1395
1396#[doc(hidden)]
1397#[macro_export]
1398macro_rules! __tokio_trace_stringify {
1399    ($s:expr) => {
1400        stringify!($s)
1401    };
1402}
1403
1404#[cfg(feature = "log")]
1405#[doc(hidden)]
1406#[macro_export]
1407macro_rules! level_to_log {
1408    ($level:expr) => {
1409        match $level {
1410            $crate::Level::ERROR => $crate::log::Level::Error,
1411            $crate::Level::WARN => $crate::log::Level::Warn,
1412            $crate::Level::INFO => $crate::log::Level::Info,
1413            $crate::Level::DEBUG => $crate::log::Level::Debug,
1414            _ => $crate::log::Level::Trace,
1415        }
1416    };
1417}
1418
1419#[cfg(feature = "log")]
1420#[doc(hidden)]
1421#[macro_export(local_inner_macros)]
1422macro_rules! __tokio_trace_log {
1423    (target: $target:expr, $level:expr, $( $($k:ident).+ $( = $val:expr )* ),* $(,)* ) => {
1424        use $crate::log;
1425        let level = level_to_log!($level);
1426        if level <= log::STATIC_MAX_LEVEL {
1427            let log_meta = log::Metadata::builder()
1428                .level(level)
1429                .target($target)
1430                .build();
1431            let logger = log::logger();
1432            if logger.enabled(&log_meta) {
1433                logger.log(&log::Record::builder()
1434                    .file(Some(__tokio_trace_file!()))
1435                    .module_path(Some(__tokio_trace_module_path!()))
1436                    .line(Some(__tokio_trace_line!()))
1437                    .metadata(log_meta)
1438                    .args(__tokio_trace_format_args!(
1439                        __tokio_trace_concat!(
1440                            $(__tokio_trace_log!(@key $($k).+)),*
1441                        ),
1442                        $(
1443                            __tokio_trace_log!(@val_or $($k).+ $( = $val)* )
1444                        ),*
1445                    ))
1446                    .build());
1447            }
1448        }
1449    };
1450    (@key message) => { "{} " };
1451    (@key $($k:ident).+) => { __tokio_trace_concat!(__tokio_trace_stringify!( $($k).+ ), "={:?} ") };
1452    (@val_or $($k:ident).+ = $v:expr) => { $v };
1453    (@val_or $($k:ident).+ ) => { __tokio_trace_format_args!("?") };
1454}
1455
1456#[cfg(not(feature = "log"))]
1457#[doc(hidden)]
1458#[macro_export]
1459macro_rules! __tokio_trace_log {
1460    (target: $target:expr, $level:expr, $( $($k:ident).+ $( = $val:expr )* ),* $(,)* ) => {};
1461}
1462
1463#[cfg(feature = "log")]
1464#[doc(hidden)]
1465#[macro_export]
1466macro_rules! __tokio_trace_disabled_span {
1467    ($meta:expr, $valueset:expr) => {{
1468        let span = $crate::Span::new_disabled($meta);
1469        span.record_all(&$valueset);
1470        span
1471    }};
1472}
1473
1474#[cfg(not(feature = "log"))]
1475#[doc(hidden)]
1476#[macro_export]
1477macro_rules! __tokio_trace_disabled_span {
1478    ($meta:expr, $valueset:expr) => {
1479        $crate::Span::new_disabled($meta)
1480    };
1481}
tokio_trace/macros.rs

tokio_trace/
macros.rs
