vendor/tracing/src/macros.rs

   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]
  20 macro_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                 && CALLSITE.is_enabled(interest)
  38             {
  39                 let meta = CALLSITE.metadata();
  40                 // span with explicit parent
  41                 $crate::Span::child_of(
  42                     $parent,
  43                     meta,
  44                     &$crate::valueset!(meta.fields(), $($fields)*),
  45                 )
  46             } else {
  47                 let span = CALLSITE.disabled_span();
  48                 $crate::if_log_enabled! { $lvl, {
  49                     span.record_all(&$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
  50                 }};
  51                 span
  52             }
  53         }
  54     };
  55     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
  56         {
  57             use $crate::__macro_support::Callsite as _;
  58             static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
  59                 name: $name,
  60                 kind: $crate::metadata::Kind::SPAN,
  61                 target: $target,
  62                 level: $lvl,
  63                 fields: $($fields)*
  64             };
  65             let mut interest = $crate::subscriber::Interest::never();
  66             if $crate::level_enabled!($lvl)
  67                 && { interest = CALLSITE.interest(); !interest.is_never() }
  68                 && CALLSITE.is_enabled(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 = CALLSITE.disabled_span();
  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]
 167 macro_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]
 248 macro_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]
 329 macro_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]
 410 macro_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]
 490 macro_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!(Level::INFO, the_answer = data.0);
 568 /// # }
 569 /// ```
 570 ///
 571 // /// Note that *unlike `span!`*, `event!` requires a value for all fields. As
 572 // /// events are recorded immediately when the macro is invoked, there is no
 573 // /// opportunity for fields to be recorded later. A trailing comma on the final
 574 // /// field is valid.
 575 // ///
 576 // /// For example, the following does not compile:
 577 // /// ```rust,compile_fail
 578 // /// # use tracing::{Level, event};
 579 // /// # fn main() {
 580 // /// event!(Level::INFO, foo = 5, bad_field, bar = "hello")
 581 // /// #}
 582 // /// ```
 583 #[macro_export]
 584 macro_rules! event {
 585     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
 586         use $crate::__macro_support::Callsite as _;
 587         static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
 588             name: $crate::__macro_support::concat!(
 589                 "event ",
 590                 file!(),
 591                 ":",
 592                 line!()
 593             ),
 594             kind: $crate::metadata::Kind::EVENT,
 595             target: $target,
 596             level: $lvl,
 597             fields: $($fields)*
 598         };
 599
 600         let enabled = $crate::level_enabled!($lvl) && {
 601             let interest = CALLSITE.interest();
 602             !interest.is_never() && CALLSITE.is_enabled(interest)
 603         };
 604         if enabled {
 605             (|value_set: $crate::field::ValueSet| {
 606                 $crate::__tracing_log!(
 607                     $lvl,
 608                     CALLSITE,
 609                     &value_set
 610                 );
 611                 let meta = CALLSITE.metadata();
 612                 // event with explicit parent
 613                 $crate::Event::child_of(
 614                     $parent,
 615                     meta,
 616                     &value_set
 617                 );
 618             })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
 619         } else {
 620             $crate::__tracing_log!(
 621                 $lvl,
 622                 CALLSITE,
 623                 &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
 624             );
 625         }
 626     });
 627
 628     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 629         $crate::event!(
 630             target: $target,
 631             parent: $parent,
 632             $lvl,
 633             { message = format_args!($($arg)+), $($fields)* }
 634         )
 635     );
 636     (target: $target:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
 637         $crate::event!(target: $target, parent: $parent, $lvl, { $($k).+ = $($fields)* })
 638     );
 639     (target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
 640         $crate::event!(target: $target, parent: $parent, $lvl, { $($arg)+ })
 641     );
 642     (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
 643         use $crate::__macro_support::Callsite as _;
 644         static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
 645             name: $crate::__macro_support::concat!(
 646                 "event ",
 647                 file!(),
 648                 ":",
 649                 line!()
 650             ),
 651             kind: $crate::metadata::Kind::EVENT,
 652             target: $target,
 653             level: $lvl,
 654             fields: $($fields)*
 655         };
 656         let enabled = $crate::level_enabled!($lvl) && {
 657             let interest = CALLSITE.interest();
 658             !interest.is_never() && CALLSITE.is_enabled(interest)
 659         };
 660         if enabled {
 661             (|value_set: $crate::field::ValueSet| {
 662                 let meta = CALLSITE.metadata();
 663                 // event with contextual parent
 664                 $crate::Event::dispatch(
 665                     meta,
 666                     &value_set
 667                 );
 668                 $crate::__tracing_log!(
 669                     $lvl,
 670                     CALLSITE,
 671                     &value_set
 672                 );
 673             })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
 674         } else {
 675             $crate::__tracing_log!(
 676                 $lvl,
 677                 CALLSITE,
 678                 &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
 679             );
 680         }
 681     });
 682     (target: $target:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 683         $crate::event!(
 684             target: $target,
 685             $lvl,
 686             { message = format_args!($($arg)+), $($fields)* }
 687         )
 688     );
 689     (target: $target:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
 690         $crate::event!(target: $target, $lvl, { $($k).+ = $($fields)* })
 691     );
 692     (target: $target:expr, $lvl:expr, $($arg:tt)+ ) => (
 693         $crate::event!(target: $target, $lvl, { $($arg)+ })
 694     );
 695     (parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 696         $crate::event!(
 697             target: module_path!(),
 698             parent: $parent,
 699             $lvl,
 700             { message = format_args!($($arg)+), $($fields)* }
 701         )
 702     );
 703     (parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($field:tt)*) => (
 704         $crate::event!(
 705             target: module_path!(),
 706             parent: $parent,
 707             $lvl,
 708             { $($k).+ = $($field)*}
 709         )
 710     );
 711     (parent: $parent:expr, $lvl:expr, ?$($k:ident).+ = $($field:tt)*) => (
 712         $crate::event!(
 713             target: module_path!(),
 714             parent: $parent,
 715             $lvl,
 716             { ?$($k).+ = $($field)*}
 717         )
 718     );
 719     (parent: $parent:expr, $lvl:expr, %$($k:ident).+ = $($field:tt)*) => (
 720         $crate::event!(
 721             target: module_path!(),
 722             parent: $parent,
 723             $lvl,
 724             { %$($k).+ = $($field)*}
 725         )
 726     );
 727     (parent: $parent:expr, $lvl:expr, $($k:ident).+, $($field:tt)*) => (
 728         $crate::event!(
 729             target: module_path!(),
 730             parent: $parent,
 731             $lvl,
 732             { $($k).+, $($field)*}
 733         )
 734     );
 735     (parent: $parent:expr, $lvl:expr, %$($k:ident).+, $($field:tt)*) => (
 736         $crate::event!(
 737             target: module_path!(),
 738             parent: $parent,
 739             $lvl,
 740             { %$($k).+, $($field)*}
 741         )
 742     );
 743     (parent: $parent:expr, $lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
 744         $crate::event!(
 745             target: module_path!(),
 746             parent: $parent,
 747             $lvl,
 748             { ?$($k).+, $($field)*}
 749         )
 750     );
 751     (parent: $parent:expr, $lvl:expr, $($arg:tt)+ ) => (
 752         $crate::event!(target: module_path!(), parent: $parent, $lvl, { $($arg)+ })
 753     );
 754     ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 755         $crate::event!(
 756             target: module_path!(),
 757             $lvl,
 758             { message = format_args!($($arg)+), $($fields)* }
 759         )
 760     );
 761     ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 762         $crate::event!(
 763             target: module_path!(),
 764             $lvl,
 765             { message = format_args!($($arg)+), $($fields)* }
 766         )
 767     );
 768     ($lvl:expr, $($k:ident).+ = $($field:tt)*) => (
 769         $crate::event!(
 770             target: module_path!(),
 771             $lvl,
 772             { $($k).+ = $($field)*}
 773         )
 774     );
 775     ($lvl:expr, $($k:ident).+, $($field:tt)*) => (
 776         $crate::event!(
 777             target: module_path!(),
 778             $lvl,
 779             { $($k).+, $($field)*}
 780         )
 781     );
 782     ($lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
 783         $crate::event!(
 784             target: module_path!(),
 785             $lvl,
 786             { ?$($k).+, $($field)*}
 787         )
 788     );
 789     ($lvl:expr, %$($k:ident).+, $($field:tt)*) => (
 790         $crate::event!(
 791             target: module_path!(),
 792             $lvl,
 793             { %$($k).+, $($field)*}
 794         )
 795     );
 796     ($lvl:expr, ?$($k:ident).+) => (
 797         $crate::event!($lvl, ?$($k).+,)
 798     );
 799     ($lvl:expr, %$($k:ident).+) => (
 800         $crate::event!($lvl, %$($k).+,)
 801     );
 802     ($lvl:expr, $($k:ident).+) => (
 803         $crate::event!($lvl, $($k).+,)
 804     );
 805     ( $lvl:expr, $($arg:tt)+ ) => (
 806         $crate::event!(target: module_path!(), $lvl, { $($arg)+ })
 807     );
 808 }
 809
 810 /// Tests whether an event with the specified level and target would be enabled.
 811 ///
 812 /// This is similar to [`enabled!`], but queries the current subscriber specifically for
 813 /// an event, whereas [`enabled!`] queries for an event _or_ span.
 814 ///
 815 /// See the documentation for [`enabled!]` for more details on using this macro.
 816 /// See also [`span_enabled!`].
 817 ///
 818 /// # Examples
 819 ///
 820 /// ```rust
 821 /// # use tracing::{event_enabled, Level};
 822 /// if event_enabled!(target: "my_crate", Level::DEBUG) {
 823 ///     // some expensive work...
 824 /// }
 825 /// // simpler
 826 /// if event_enabled!(Level::DEBUG) {
 827 ///     // some expensive work...
 828 /// }
 829 /// // with fields
 830 /// if event_enabled!(Level::DEBUG, foo_field) {
 831 ///     // some expensive work...
 832 /// }
 833 /// ```
 834 ///
 835 #[macro_export]
 836 macro_rules! event_enabled {
 837     ($($rest:tt)*)=> (
 838         $crate::enabled!(kind: $crate::metadata::Kind::EVENT, $($rest)*)
 839     )
 840 }
 841
 842 /// Tests whether a span with the specified level and target would be enabled.
 843 ///
 844 /// This is similar to [`enabled!`], but queries the current subscriber specifically for
 845 /// an event, whereas [`enabled!`] queries for an event _or_ span.
 846 ///
 847 /// See the documentation for [`enabled!]` for more details on using this macro.
 848 /// See also [`span_enabled!`].
 849 ///
 850 /// # Examples
 851 ///
 852 /// ```rust
 853 /// # use tracing::{span_enabled, Level};
 854 /// if span_enabled!(target: "my_crate", Level::DEBUG) {
 855 ///     // some expensive work...
 856 /// }
 857 /// // simpler
 858 /// if span_enabled!(Level::DEBUG) {
 859 ///     // some expensive work...
 860 /// }
 861 /// // with fields
 862 /// if span_enabled!(Level::DEBUG, foo_field) {
 863 ///     // some expensive work...
 864 /// }
 865 /// ```
 866 ///
 867 #[macro_export]
 868 macro_rules! span_enabled {
 869     ($($rest:tt)*)=> (
 870         $crate::enabled!(kind: $crate::metadata::Kind::SPAN, $($rest)*)
 871     )
 872 }
 873
 874 /// Checks whether a span or event is [enabled] based on the provided [metadata].
 875 ///
 876 /// [enabled]: crate::Subscriber::enabled
 877 /// [metadata]: crate::Metadata
 878 ///
 879 /// This macro is a specialized tool: it is intended to be used prior
 880 /// to an expensive computation required *just* for that event, but
 881 /// *cannot* be done as part of an argument to that event, such as
 882 /// when multiple events are emitted (e.g., iterating over a collection
 883 /// and emitting an event for each item).
 884 ///
 885 /// # Usage
 886 ///
 887 /// [Subscribers] can make filtering decisions based all the data included in a
 888 /// span or event's [`Metadata`]. This means that it is possible for `enabled!`
 889 /// to return a _false positive_ (indicating that something would be enabled
 890 /// when it actually would not be) or a _false negative_ (indicating that
 891 /// something would be disabled when it would actually be enabled).
 892 ///
 893 /// [Subscribers]: crate::subscriber::Subscriber
 894 /// [`Metadata`]: crate::metadata::Metadata
 895 ///
 896 /// This occurs when a subscriber is using a _more specific_ filter than the
 897 /// metadata provided to the `enabled!` macro. Some situations that can result
 898 /// in false positives or false negatives include:
 899 ///
 900 /// - If a subscriber is using a filter which may enable a span or event based
 901 /// on field names, but `enabled!` is invoked without listing field names,
 902 /// `enabled!` may return a false negative if a specific field name would
 903 /// cause the subscriber to enable something that would otherwise be disabled.
 904 /// - If a subscriber is using a filter which enables or disables specific events by
 905 /// file path and line number,  a particular event may be enabled/disabled
 906 /// even if an `enabled!` invocation with the same level, target, and fields
 907 /// indicated otherwise.
 908 /// - The subscriber can choose to enable _only_ spans or _only_ events, which `enabled`
 909 /// will not reflect.
 910 ///
 911 /// `enabled!()` requires a [level](crate::Level) argument, an optional `target:`
 912 /// argument, and an optional set of field names. If the fields are not provided,
 913 /// they are considered to be unknown. `enabled!` attempts to match the
 914 /// syntax of `event!()` as closely as possible, which can be seen in the
 915 /// examples below.
 916 ///
 917 /// # Examples
 918 ///
 919 /// If the current subscriber is interested in recording `DEBUG`-level spans and
 920 /// events in the current file and module path, this will evaluate to true:
 921 /// ```rust
 922 /// use tracing::{enabled, Level};
 923 ///
 924 /// if enabled!(Level::DEBUG) {
 925 ///     // some expensive work...
 926 /// }
 927 /// ```
 928 ///
 929 /// If the current subscriber is interested in recording spans and events
 930 /// in the current file and module path, with the target "my_crate", and at the
 931 /// level  `DEBUG`, this will evaluate to true:
 932 /// ```rust
 933 /// # use tracing::{enabled, Level};
 934 /// if enabled!(target: "my_crate", Level::DEBUG) {
 935 ///     // some expensive work...
 936 /// }
 937 /// ```
 938 ///
 939 /// If the current subscriber is interested in recording spans and events
 940 /// in the current file and module path, with the target "my_crate", at
 941 /// the level `DEBUG`, and with a field named "hello", this will evaluate
 942 /// to true:
 943 ///
 944 /// ```rust
 945 /// # use tracing::{enabled, Level};
 946 /// if enabled!(target: "my_crate", Level::DEBUG, hello) {
 947 ///     // some expensive work...
 948 /// }
 949 /// ```
 950 ///
 951 /// # Alternatives
 952 ///
 953 /// `enabled!` queries subscribers with [`Metadata`] where
 954 /// [`is_event`] and [`is_span`] both return `false`. Alternatively,
 955 /// use [`event_enabled!`] or [`span_enabled!`] to ensure one of these
 956 /// returns true.
 957 ///
 958 ///
 959 /// [`Metadata`]: crate::Metadata
 960 /// [`is_event`]: crate::Metadata::is_event
 961 /// [`is_span`]: crate::Metadata::is_span
 962 ///
 963 #[macro_export]
 964 macro_rules! enabled {
 965     (kind: $kind:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
 966         if $crate::level_enabled!($lvl) {
 967             use $crate::__macro_support::Callsite as _;
 968             static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
 969                 name: $crate::__macro_support::concat!(
 970                     "enabled ",
 971                     file!(),
 972                     ":",
 973                     line!()
 974                 ),
 975                 kind: $kind.hint(),
 976                 target: $target,
 977                 level: $lvl,
 978                 fields: $($fields)*
 979             };
 980             let interest = CALLSITE.interest();
 981             if !interest.is_never() && CALLSITE.is_enabled(interest)  {
 982                 let meta = CALLSITE.metadata();
 983                 $crate::dispatcher::get_default(|current| current.enabled(meta))
 984             } else {
 985                 false
 986             }
 987         } else {
 988             false
 989         }
 990     });
 991     // Just target and level
 992     (kind: $kind:expr, target: $target:expr, $lvl:expr ) => (
 993         $crate::enabled!(kind: $kind, target: $target, $lvl, { })
 994     );
 995     (target: $target:expr, $lvl:expr ) => (
 996         $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: $target, $lvl, { })
 997     );
 998
 999     // These four cases handle fields with no values
1000     (kind: $kind:expr, target: $target:expr, $lvl:expr, $($field:tt)*) => (
1001         $crate::enabled!(
1002             kind: $kind,
1003             target: $target,
1004             $lvl,
1005             { $($field)*}
1006         )
1007     );
1008     (target: $target:expr, $lvl:expr, $($field:tt)*) => (
1009         $crate::enabled!(
1010             kind: $crate::metadata::Kind::HINT,
1011             target: $target,
1012             $lvl,
1013             { $($field)*}
1014         )
1015     );
1016
1017     // Level and field case
1018     (kind: $kind:expr, $lvl:expr, $($field:tt)*) => (
1019         $crate::enabled!(
1020             kind: $kind,
1021             target: module_path!(),
1022             $lvl,
1023             { $($field)*}
1024         )
1025     );
1026
1027     // Simplest `enabled!` case
1028     (kind: $kind:expr, $lvl:expr) => (
1029         $crate::enabled!(kind: $kind, target: module_path!(), $lvl, { })
1030     );
1031     ($lvl:expr) => (
1032         $crate::enabled!(kind: $crate::metadata::Kind::HINT, target: module_path!(), $lvl, { })
1033     );
1034
1035     // Fallthrough from above
1036     ($lvl:expr, $($field:tt)*) => (
1037         $crate::enabled!(
1038             kind: $crate::metadata::Kind::HINT,
1039             target: module_path!(),
1040             $lvl,
1041             { $($field)*}
1042         )
1043     );
1044 }
1045
1046 /// Constructs an event at the trace level.
1047 ///
1048 /// This functions similarly to the [`event!`] macro. See [the top-level
1049 /// documentation][lib] for details on the syntax accepted by
1050 /// this macro.
1051 ///
1052 /// [`event!`]: crate::event!
1053 /// [lib]: crate#using-the-macros
1054 ///
1055 /// # Examples
1056 ///
1057 /// ```rust
1058 /// use tracing::trace;
1059 /// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 }
1060 /// # impl Position {
1061 /// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 };
1062 /// # fn dist(&self, other: Position) -> f32 {
1063 /// #    let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2();
1064 /// #    (x + y).sqrt()
1065 /// # }
1066 /// # }
1067 /// # fn main() {
1068 /// let pos = Position { x: 3.234, y: -1.223 };
1069 /// let origin_dist = pos.dist(Position::ORIGIN);
1070 ///
1071 /// trace!(position = ?pos, ?origin_dist);
1072 /// trace!(
1073 ///     target: "app_events",
1074 ///     position = ?pos,
1075 ///     "x is {} and y is {}",
1076 ///     if pos.x >= 0.0 { "positive" } else { "negative" },
1077 ///     if pos.y >= 0.0 { "positive" } else { "negative" }
1078 /// );
1079 /// # }
1080 /// ```
1081 #[macro_export]
1082 macro_rules! trace {
1083     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1084         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1085     );
1086     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1087         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
1088     );
1089     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1090         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
1091     );
1092     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1093         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
1094     );
1095     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1096         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
1097     );
1098     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1099         $crate::event!(
1100             target: module_path!(),
1101             parent: $parent,
1102             $crate::Level::TRACE,
1103             { $($field)+ },
1104             $($arg)+
1105         )
1106     );
1107     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1108         $crate::event!(
1109             target: module_path!(),
1110             parent: $parent,
1111             $crate::Level::TRACE,
1112             { $($k).+ = $($field)*}
1113         )
1114     );
1115     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1116         $crate::event!(
1117             target: module_path!(),
1118             parent: $parent,
1119             $crate::Level::TRACE,
1120             { ?$($k).+ = $($field)*}
1121         )
1122     );
1123     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1124         $crate::event!(
1125             target: module_path!(),
1126             parent: $parent,
1127             $crate::Level::TRACE,
1128             { %$($k).+ = $($field)*}
1129         )
1130     );
1131     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1132         $crate::event!(
1133             target: module_path!(),
1134             parent: $parent,
1135             $crate::Level::TRACE,
1136             { $($k).+, $($field)*}
1137         )
1138     );
1139     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1140         $crate::event!(
1141             target: module_path!(),
1142             parent: $parent,
1143             $crate::Level::TRACE,
1144             { ?$($k).+, $($field)*}
1145         )
1146     );
1147     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1148         $crate::event!(
1149             target: module_path!(),
1150             parent: $parent,
1151             $crate::Level::TRACE,
1152             { %$($k).+, $($field)*}
1153         )
1154     );
1155     (parent: $parent:expr, $($arg:tt)+) => (
1156         $crate::event!(
1157             target: module_path!(),
1158             parent: $parent,
1159             $crate::Level::TRACE,
1160             {},
1161             $($arg)+
1162         )
1163     );
1164     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1165         $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
1166     );
1167     (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1168         $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)* })
1169     );
1170     (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1171         $crate::event!(target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* })
1172     );
1173     (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1174         $crate::event!(target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* })
1175     );
1176     (target: $target:expr, $($arg:tt)+ ) => (
1177         $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+)
1178     );
1179     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1180         $crate::event!(
1181             target: module_path!(),
1182             $crate::Level::TRACE,
1183             { $($field)+ },
1184             $($arg)+
1185         )
1186     );
1187     ($($k:ident).+ = $($field:tt)*) => (
1188         $crate::event!(
1189             target: module_path!(),
1190             $crate::Level::TRACE,
1191             { $($k).+ = $($field)*}
1192         )
1193     );
1194     ($($k:ident).+, $($field:tt)*) => (
1195         $crate::event!(
1196             target: module_path!(),
1197             $crate::Level::TRACE,
1198             { $($k).+, $($field)*}
1199         )
1200     );
1201     (?$($k:ident).+, $($field:tt)*) => (
1202         $crate::event!(
1203             target: module_path!(),
1204             $crate::Level::TRACE,
1205             { ?$($k).+, $($field)*}
1206         )
1207     );
1208     (%$($k:ident).+, $($field:tt)*) => (
1209         $crate::event!(
1210             target: module_path!(),
1211             $crate::Level::TRACE,
1212             { %$($k).+, $($field)*}
1213         )
1214     );
1215     (?$($k:ident).+) => (
1216         $crate::event!(
1217             target: module_path!(),
1218             $crate::Level::TRACE,
1219             { ?$($k).+ }
1220         )
1221     );
1222     (%$($k:ident).+) => (
1223         $crate::event!(
1224             target: module_path!(),
1225             $crate::Level::TRACE,
1226             { %$($k).+ }
1227         )
1228     );
1229     ($($k:ident).+) => (
1230         $crate::event!(
1231             target: module_path!(),
1232             $crate::Level::TRACE,
1233             { $($k).+ }
1234         )
1235     );
1236     ($($arg:tt)+) => (
1237         $crate::event!(
1238             target: module_path!(),
1239             $crate::Level::TRACE,
1240             {},
1241             $($arg)+
1242         )
1243     );
1244 }
1245
1246 /// Constructs an event at the debug level.
1247 ///
1248 /// This functions similarly to the [`event!`] macro. See [the top-level
1249 /// documentation][lib] for details on the syntax accepted by
1250 /// this macro.
1251 ///
1252 /// [`event!`]: crate::event!
1253 /// [lib]: crate#using-the-macros
1254 ///
1255 /// # Examples
1256 ///
1257 /// ```rust
1258 /// use tracing::debug;
1259 /// # fn main() {
1260 /// # #[derive(Debug)] struct Position { x: f32, y: f32 }
1261 ///
1262 /// let pos = Position { x: 3.234, y: -1.223 };
1263 ///
1264 /// debug!(?pos.x, ?pos.y);
1265 /// debug!(target: "app_events", position = ?pos, "New position");
1266 /// # }
1267 /// ```
1268 #[macro_export]
1269 macro_rules! debug {
1270     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1271         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1272     );
1273     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1274         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1275     );
1276     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1277         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1278     );
1279     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1280         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1281     );
1282     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1283         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
1284     );
1285     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1286         $crate::event!(
1287             target: module_path!(),
1288             parent: $parent,
1289             $crate::Level::DEBUG,
1290             { $($field)+ },
1291             $($arg)+
1292         )
1293     );
1294     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1295         $crate::event!(
1296             target: module_path!(),
1297             parent: $parent,
1298             $crate::Level::DEBUG,
1299             { $($k).+ = $($field)*}
1300         )
1301     );
1302     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1303         $crate::event!(
1304             target: module_path!(),
1305             parent: $parent,
1306             $crate::Level::DEBUG,
1307             { ?$($k).+ = $($field)*}
1308         )
1309     );
1310     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1311         $crate::event!(
1312             target: module_path!(),
1313             parent: $parent,
1314             $crate::Level::DEBUG,
1315             { %$($k).+ = $($field)*}
1316         )
1317     );
1318     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1319         $crate::event!(
1320             target: module_path!(),
1321             parent: $parent,
1322             $crate::Level::DEBUG,
1323             { $($k).+, $($field)*}
1324         )
1325     );
1326     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1327         $crate::event!(
1328             target: module_path!(),
1329             parent: $parent,
1330             $crate::Level::DEBUG,
1331             { ?$($k).+, $($field)*}
1332         )
1333     );
1334     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1335         $crate::event!(
1336             target: module_path!(),
1337             parent: $parent,
1338             $crate::Level::DEBUG,
1339             { %$($k).+, $($field)*}
1340         )
1341     );
1342     (parent: $parent:expr, $($arg:tt)+) => (
1343         $crate::event!(
1344             target: module_path!(),
1345             parent: $parent,
1346             $crate::Level::DEBUG,
1347             {},
1348             $($arg)+
1349         )
1350     );
1351     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1352         $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1353     );
1354     (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1355         $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
1356     );
1357     (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1358         $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
1359     );
1360     (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1361         $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
1362     );
1363     (target: $target:expr, $($arg:tt)+ ) => (
1364         $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
1365     );
1366     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1367         $crate::event!(
1368             target: module_path!(),
1369             $crate::Level::DEBUG,
1370             { $($field)+ },
1371             $($arg)+
1372         )
1373     );
1374     ($($k:ident).+ = $($field:tt)*) => (
1375         $crate::event!(
1376             target: module_path!(),
1377             $crate::Level::DEBUG,
1378             { $($k).+ = $($field)*}
1379         )
1380     );
1381     (?$($k:ident).+ = $($field:tt)*) => (
1382         $crate::event!(
1383             target: module_path!(),
1384             $crate::Level::DEBUG,
1385             { ?$($k).+ = $($field)*}
1386         )
1387     );
1388     (%$($k:ident).+ = $($field:tt)*) => (
1389         $crate::event!(
1390             target: module_path!(),
1391             $crate::Level::DEBUG,
1392             { %$($k).+ = $($field)*}
1393         )
1394     );
1395     ($($k:ident).+, $($field:tt)*) => (
1396         $crate::event!(
1397             target: module_path!(),
1398             $crate::Level::DEBUG,
1399             { $($k).+, $($field)*}
1400         )
1401     );
1402     (?$($k:ident).+, $($field:tt)*) => (
1403         $crate::event!(
1404             target: module_path!(),
1405             $crate::Level::DEBUG,
1406             { ?$($k).+, $($field)*}
1407         )
1408     );
1409     (%$($k:ident).+, $($field:tt)*) => (
1410         $crate::event!(
1411             target: module_path!(),
1412             $crate::Level::DEBUG,
1413             { %$($k).+, $($field)*}
1414         )
1415     );
1416     (?$($k:ident).+) => (
1417         $crate::event!(
1418             target: module_path!(),
1419             $crate::Level::DEBUG,
1420             { ?$($k).+ }
1421         )
1422     );
1423     (%$($k:ident).+) => (
1424         $crate::event!(
1425             target: module_path!(),
1426             $crate::Level::DEBUG,
1427             { %$($k).+ }
1428         )
1429     );
1430     ($($k:ident).+) => (
1431         $crate::event!(
1432             target: module_path!(),
1433             $crate::Level::DEBUG,
1434             { $($k).+ }
1435         )
1436     );
1437     ($($arg:tt)+) => (
1438         $crate::event!(
1439             target: module_path!(),
1440             $crate::Level::DEBUG,
1441             {},
1442             $($arg)+
1443         )
1444     );
1445 }
1446
1447 /// Constructs an event at the info level.
1448 ///
1449 /// This functions similarly to the [`event!`] macro. See [the top-level
1450 /// documentation][lib] for details on the syntax accepted by
1451 /// this macro.
1452 ///
1453 /// [`event!`]: crate::event!
1454 /// [lib]: crate#using-the-macros
1455 ///
1456 /// # Examples
1457 ///
1458 /// ```rust
1459 /// use tracing::info;
1460 /// # // this is so the test will still work in no-std mode
1461 /// # #[derive(Debug)]
1462 /// # pub struct Ipv4Addr;
1463 /// # impl Ipv4Addr { fn new(o1: u8, o2: u8, o3: u8, o4: u8) -> Self { Self } }
1464 /// # fn main() {
1465 /// # struct Connection { port: u32, speed: f32 }
1466 /// use tracing::field;
1467 ///
1468 /// let addr = Ipv4Addr::new(127, 0, 0, 1);
1469 /// let conn = Connection { port: 40, speed: 3.20 };
1470 ///
1471 /// info!(conn.port, "connected to {:?}", addr);
1472 /// info!(
1473 ///     target: "connection_events",
1474 ///     ip = ?addr,
1475 ///     conn.port,
1476 ///     ?conn.speed,
1477 /// );
1478 /// # }
1479 /// ```
1480 #[macro_export]
1481 macro_rules! info {
1482      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1483         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
1484     );
1485     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1486         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1487     );
1488     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1489         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1490     );
1491     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1492         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1493     );
1494     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1495         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
1496     );
1497     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1498         $crate::event!(
1499             target: module_path!(),
1500             parent: $parent,
1501             $crate::Level::INFO,
1502             { $($field)+ },
1503             $($arg)+
1504         )
1505     );
1506     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1507         $crate::event!(
1508             target: module_path!(),
1509             parent: $parent,
1510             $crate::Level::INFO,
1511             { $($k).+ = $($field)*}
1512         )
1513     );
1514     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1515         $crate::event!(
1516             target: module_path!(),
1517             parent: $parent,
1518             $crate::Level::INFO,
1519             { ?$($k).+ = $($field)*}
1520         )
1521     );
1522     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1523         $crate::event!(
1524             target: module_path!(),
1525             parent: $parent,
1526             $crate::Level::INFO,
1527             { %$($k).+ = $($field)*}
1528         )
1529     );
1530     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1531         $crate::event!(
1532             target: module_path!(),
1533             parent: $parent,
1534             $crate::Level::INFO,
1535             { $($k).+, $($field)*}
1536         )
1537     );
1538     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1539         $crate::event!(
1540             target: module_path!(),
1541             parent: $parent,
1542             $crate::Level::INFO,
1543             { ?$($k).+, $($field)*}
1544         )
1545     );
1546     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1547         $crate::event!(
1548             target: module_path!(),
1549             parent: $parent,
1550             $crate::Level::INFO,
1551             { %$($k).+, $($field)*}
1552         )
1553     );
1554     (parent: $parent:expr, $($arg:tt)+) => (
1555         $crate::event!(
1556             target: module_path!(),
1557             parent: $parent,
1558             $crate::Level::INFO,
1559             {},
1560             $($arg)+
1561         )
1562     );
1563     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1564         $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
1565     );
1566     (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1567         $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
1568     );
1569     (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1570         $crate::event!(target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* })
1571     );
1572     (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1573         $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
1574     );
1575     (target: $target:expr, $($arg:tt)+ ) => (
1576         $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
1577     );
1578     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1579         $crate::event!(
1580             target: module_path!(),
1581             $crate::Level::INFO,
1582             { $($field)+ },
1583             $($arg)+
1584         )
1585     );
1586     ($($k:ident).+ = $($field:tt)*) => (
1587         $crate::event!(
1588             target: module_path!(),
1589             $crate::Level::INFO,
1590             { $($k).+ = $($field)*}
1591         )
1592     );
1593     (?$($k:ident).+ = $($field:tt)*) => (
1594         $crate::event!(
1595             target: module_path!(),
1596             $crate::Level::INFO,
1597             { ?$($k).+ = $($field)*}
1598         )
1599     );
1600     (%$($k:ident).+ = $($field:tt)*) => (
1601         $crate::event!(
1602             target: module_path!(),
1603             $crate::Level::INFO,
1604             { %$($k).+ = $($field)*}
1605         )
1606     );
1607     ($($k:ident).+, $($field:tt)*) => (
1608         $crate::event!(
1609             target: module_path!(),
1610             $crate::Level::INFO,
1611             { $($k).+, $($field)*}
1612         )
1613     );
1614     (?$($k:ident).+, $($field:tt)*) => (
1615         $crate::event!(
1616             target: module_path!(),
1617             $crate::Level::INFO,
1618             { ?$($k).+, $($field)*}
1619         )
1620     );
1621     (%$($k:ident).+, $($field:tt)*) => (
1622         $crate::event!(
1623             target: module_path!(),
1624             $crate::Level::INFO,
1625             { %$($k).+, $($field)*}
1626         )
1627     );
1628     (?$($k:ident).+) => (
1629         $crate::event!(
1630             target: module_path!(),
1631             $crate::Level::INFO,
1632             { ?$($k).+ }
1633         )
1634     );
1635     (%$($k:ident).+) => (
1636         $crate::event!(
1637             target: module_path!(),
1638             $crate::Level::INFO,
1639             { %$($k).+ }
1640         )
1641     );
1642     ($($k:ident).+) => (
1643         $crate::event!(
1644             target: module_path!(),
1645             $crate::Level::INFO,
1646             { $($k).+ }
1647         )
1648     );
1649     ($($arg:tt)+) => (
1650         $crate::event!(
1651             target: module_path!(),
1652             $crate::Level::INFO,
1653             {},
1654             $($arg)+
1655         )
1656     );
1657 }
1658
1659 /// Constructs an event at the warn level.
1660 ///
1661 /// This functions similarly to the [`event!`] macro. See [the top-level
1662 /// documentation][lib] for details on the syntax accepted by
1663 /// this macro.
1664 ///
1665 /// [`event!`]: crate::event!
1666 /// [lib]: crate#using-the-macros
1667 ///
1668 /// # Examples
1669 ///
1670 /// ```rust
1671 /// use tracing::warn;
1672 /// # fn main() {
1673 ///
1674 /// let warn_description = "Invalid Input";
1675 /// let input = &[0x27, 0x45];
1676 ///
1677 /// warn!(?input, warning = warn_description);
1678 /// warn!(
1679 ///     target: "input_events",
1680 ///     warning = warn_description,
1681 ///     "Received warning for input: {:?}", input,
1682 /// );
1683 /// # }
1684 /// ```
1685 #[macro_export]
1686 macro_rules! warn {
1687      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1688         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
1689     );
1690     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1691         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1692     );
1693     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1694         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1695     );
1696     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1697         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1698     );
1699     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1700         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
1701     );
1702     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1703         $crate::event!(
1704             target: module_path!(),
1705             parent: $parent,
1706             $crate::Level::WARN,
1707             { $($field)+ },
1708             $($arg)+
1709         )
1710     );
1711     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1712         $crate::event!(
1713             target: module_path!(),
1714             parent: $parent,
1715             $crate::Level::WARN,
1716             { $($k).+ = $($field)*}
1717         )
1718     );
1719     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1720         $crate::event!(
1721             target: module_path!(),
1722             parent: $parent,
1723             $crate::Level::WARN,
1724             { ?$($k).+ = $($field)*}
1725         )
1726     );
1727     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1728         $crate::event!(
1729             target: module_path!(),
1730             parent: $parent,
1731             $crate::Level::WARN,
1732             { %$($k).+ = $($field)*}
1733         )
1734     );
1735     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1736         $crate::event!(
1737             target: module_path!(),
1738             parent: $parent,
1739             $crate::Level::WARN,
1740             { $($k).+, $($field)*}
1741         )
1742     );
1743     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1744         $crate::event!(
1745             target: module_path!(),
1746             parent: $parent,
1747             $crate::Level::WARN,
1748             { ?$($k).+, $($field)*}
1749         )
1750     );
1751     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1752         $crate::event!(
1753             target: module_path!(),
1754             parent: $parent,
1755             $crate::Level::WARN,
1756             { %$($k).+, $($field)*}
1757         )
1758     );
1759     (parent: $parent:expr, $($arg:tt)+) => (
1760         $crate::event!(
1761             target: module_path!(),
1762             parent: $parent,
1763             $crate::Level::WARN,
1764             {},
1765             $($arg)+
1766         )
1767     );
1768     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1769         $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
1770     );
1771     (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1772         $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)* })
1773     );
1774     (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1775         $crate::event!(target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* })
1776     );
1777     (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1778         $crate::event!(target: $target, $crate::Level::WARN, { %$($k).+ $($field)* })
1779     );
1780     (target: $target:expr, $($arg:tt)+ ) => (
1781         $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+)
1782     );
1783     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1784         $crate::event!(
1785             target: module_path!(),
1786             $crate::Level::WARN,
1787             { $($field)+ },
1788             $($arg)+
1789         )
1790     );
1791     ($($k:ident).+ = $($field:tt)*) => (
1792         $crate::event!(
1793             target: module_path!(),
1794             $crate::Level::WARN,
1795             { $($k).+ = $($field)*}
1796         )
1797     );
1798     (?$($k:ident).+ = $($field:tt)*) => (
1799         $crate::event!(
1800             target: module_path!(),
1801             $crate::Level::WARN,
1802             { ?$($k).+ = $($field)*}
1803         )
1804     );
1805     (%$($k:ident).+ = $($field:tt)*) => (
1806         $crate::event!(
1807             target: module_path!(),
1808             $crate::Level::WARN,
1809             { %$($k).+ = $($field)*}
1810         )
1811     );
1812     ($($k:ident).+, $($field:tt)*) => (
1813         $crate::event!(
1814             target: module_path!(),
1815             $crate::Level::WARN,
1816             { $($k).+, $($field)*}
1817         )
1818     );
1819     (?$($k:ident).+, $($field:tt)*) => (
1820         $crate::event!(
1821             target: module_path!(),
1822             $crate::Level::WARN,
1823             { ?$($k).+, $($field)*}
1824         )
1825     );
1826     (%$($k:ident).+, $($field:tt)*) => (
1827         $crate::event!(
1828             target: module_path!(),
1829             $crate::Level::WARN,
1830             { %$($k).+, $($field)*}
1831         )
1832     );
1833     (?$($k:ident).+) => (
1834         $crate::event!(
1835             target: module_path!(),
1836             $crate::Level::WARN,
1837             { ?$($k).+ }
1838         )
1839     );
1840     (%$($k:ident).+) => (
1841         $crate::event!(
1842             target: module_path!(),
1843             $crate::Level::WARN,
1844             { %$($k).+ }
1845         )
1846     );
1847     ($($k:ident).+) => (
1848         $crate::event!(
1849             target: module_path!(),
1850             $crate::Level::WARN,
1851             { $($k).+ }
1852         )
1853     );
1854     ($($arg:tt)+) => (
1855         $crate::event!(
1856             target: module_path!(),
1857             $crate::Level::WARN,
1858             {},
1859             $($arg)+
1860         )
1861     );
1862 }
1863
1864 /// Constructs an event at the error level.
1865 ///
1866 /// This functions similarly to the [`event!`] macro. See [the top-level
1867 /// documentation][lib] for details on the syntax accepted by
1868 /// this macro.
1869 ///
1870 /// [`event!`]: crate::event!
1871 /// [lib]: crate#using-the-macros
1872 ///
1873 /// # Examples
1874 ///
1875 /// ```rust
1876 /// use tracing::error;
1877 /// # fn main() {
1878 ///
1879 /// let (err_info, port) = ("No connection", 22);
1880 ///
1881 /// error!(port, error = %err_info);
1882 /// error!(target: "app_events", "App Error: {}", err_info);
1883 /// error!({ info = err_info }, "error on port: {}", port);
1884 /// # }
1885 /// ```
1886 #[macro_export]
1887 macro_rules! error {
1888      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1889         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
1890     );
1891     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1892         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1893     );
1894     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1895         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1896     );
1897     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1898         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1899     );
1900     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1901         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
1902     );
1903     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1904         $crate::event!(
1905             target: module_path!(),
1906             parent: $parent,
1907             $crate::Level::ERROR,
1908             { $($field)+ },
1909             $($arg)+
1910         )
1911     );
1912     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1913         $crate::event!(
1914             target: module_path!(),
1915             parent: $parent,
1916             $crate::Level::ERROR,
1917             { $($k).+ = $($field)*}
1918         )
1919     );
1920     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1921         $crate::event!(
1922             target: module_path!(),
1923             parent: $parent,
1924             $crate::Level::ERROR,
1925             { ?$($k).+ = $($field)*}
1926         )
1927     );
1928     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1929         $crate::event!(
1930             target: module_path!(),
1931             parent: $parent,
1932             $crate::Level::ERROR,
1933             { %$($k).+ = $($field)*}
1934         )
1935     );
1936     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1937         $crate::event!(
1938             target: module_path!(),
1939             parent: $parent,
1940             $crate::Level::ERROR,
1941             { $($k).+, $($field)*}
1942         )
1943     );
1944     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1945         $crate::event!(
1946             target: module_path!(),
1947             parent: $parent,
1948             $crate::Level::ERROR,
1949             { ?$($k).+, $($field)*}
1950         )
1951     );
1952     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1953         $crate::event!(
1954             target: module_path!(),
1955             parent: $parent,
1956             $crate::Level::ERROR,
1957             { %$($k).+, $($field)*}
1958         )
1959     );
1960     (parent: $parent:expr, $($arg:tt)+) => (
1961         $crate::event!(
1962             target: module_path!(),
1963             parent: $parent,
1964             $crate::Level::ERROR,
1965             {},
1966             $($arg)+
1967         )
1968     );
1969     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1970         $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
1971     );
1972     (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
1973         $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)* })
1974     );
1975     (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
1976         $crate::event!(target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* })
1977     );
1978     (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
1979         $crate::event!(target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* })
1980     );
1981     (target: $target:expr, $($arg:tt)+ ) => (
1982         $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
1983     );
1984     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1985         $crate::event!(
1986             target: module_path!(),
1987             $crate::Level::ERROR,
1988             { $($field)+ },
1989             $($arg)+
1990         )
1991     );
1992     ($($k:ident).+ = $($field:tt)*) => (
1993         $crate::event!(
1994             target: module_path!(),
1995             $crate::Level::ERROR,
1996             { $($k).+ = $($field)*}
1997         )
1998     );
1999     (?$($k:ident).+ = $($field:tt)*) => (
2000         $crate::event!(
2001             target: module_path!(),
2002             $crate::Level::ERROR,
2003             { ?$($k).+ = $($field)*}
2004         )
2005     );
2006     (%$($k:ident).+ = $($field:tt)*) => (
2007         $crate::event!(
2008             target: module_path!(),
2009             $crate::Level::ERROR,
2010             { %$($k).+ = $($field)*}
2011         )
2012     );
2013     ($($k:ident).+, $($field:tt)*) => (
2014         $crate::event!(
2015             target: module_path!(),
2016             $crate::Level::ERROR,
2017             { $($k).+, $($field)*}
2018         )
2019     );
2020     (?$($k:ident).+, $($field:tt)*) => (
2021         $crate::event!(
2022             target: module_path!(),
2023             $crate::Level::ERROR,
2024             { ?$($k).+, $($field)*}
2025         )
2026     );
2027     (%$($k:ident).+, $($field:tt)*) => (
2028         $crate::event!(
2029             target: module_path!(),
2030             $crate::Level::ERROR,
2031             { %$($k).+, $($field)*}
2032         )
2033     );
2034     (?$($k:ident).+) => (
2035         $crate::event!(
2036             target: module_path!(),
2037             $crate::Level::ERROR,
2038             { ?$($k).+ }
2039         )
2040     );
2041     (%$($k:ident).+) => (
2042         $crate::event!(
2043             target: module_path!(),
2044             $crate::Level::ERROR,
2045             { %$($k).+ }
2046         )
2047     );
2048     ($($k:ident).+) => (
2049         $crate::event!(
2050             target: module_path!(),
2051             $crate::Level::ERROR,
2052             { $($k).+ }
2053         )
2054     );
2055     ($($arg:tt)+) => (
2056         $crate::event!(
2057             target: module_path!(),
2058             $crate::Level::ERROR,
2059             {},
2060             $($arg)+
2061         )
2062     );
2063 }
2064
2065 /// Constructs a new static callsite for a span or event.
2066 #[doc(hidden)]
2067 #[macro_export]
2068 macro_rules! callsite {
2069     (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{
2070         $crate::callsite! {
2071             name: $name,
2072             kind: $kind,
2073             target: module_path!(),
2074             level: $crate::Level::TRACE,
2075             fields: $($fields)*
2076         }
2077     }};
2078     (
2079         name: $name:expr,
2080         kind: $kind:expr,
2081         level: $lvl:expr,
2082         fields: $($fields:tt)*
2083     ) => {{
2084         $crate::callsite! {
2085             name: $name,
2086             kind: $kind,
2087             target: module_path!(),
2088             level: $lvl,
2089             fields: $($fields)*
2090         }
2091     }};
2092     (
2093         name: $name:expr,
2094         kind: $kind:expr,
2095         target: $target:expr,
2096         level: $lvl:expr,
2097         fields: $($fields:tt)*
2098     ) => {{
2099         use $crate::__macro_support::MacroCallsite;
2100         static META: $crate::Metadata<'static> = {
2101             $crate::metadata! {
2102                 name: $name,
2103                 target: $target,
2104                 level: $lvl,
2105                 fields: $crate::fieldset!( $($fields)* ),
2106                 callsite: &CALLSITE,
2107                 kind: $kind,
2108             }
2109         };
2110         static CALLSITE: MacroCallsite = MacroCallsite::new(&META);
2111         CALLSITE.register();
2112         &CALLSITE
2113     }};
2114 }
2115
2116 /// Constructs a new static callsite for a span or event.
2117 #[doc(hidden)]
2118 #[macro_export]
2119 macro_rules! callsite2 {
2120     (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{
2121         $crate::callsite2! {
2122             name: $name,
2123             kind: $kind,
2124             target: module_path!(),
2125             level: $crate::Level::TRACE,
2126             fields: $($fields)*
2127         }
2128     }};
2129     (
2130         name: $name:expr,
2131         kind: $kind:expr,
2132         level: $lvl:expr,
2133         fields: $($fields:tt)*
2134     ) => {{
2135         $crate::callsite2! {
2136             name: $name,
2137             kind: $kind,
2138             target: module_path!(),
2139             level: $lvl,
2140             fields: $($fields)*
2141         }
2142     }};
2143     (
2144         name: $name:expr,
2145         kind: $kind:expr,
2146         target: $target:expr,
2147         level: $lvl:expr,
2148         fields: $($fields:tt)*
2149     ) => {{
2150         use $crate::__macro_support::MacroCallsite;
2151         static META: $crate::Metadata<'static> = {
2152             $crate::metadata! {
2153                 name: $name,
2154                 target: $target,
2155                 level: $lvl,
2156                 fields: $crate::fieldset!( $($fields)* ),
2157                 callsite: &CALLSITE,
2158                 kind: $kind,
2159             }
2160         };
2161         MacroCallsite::new(&META)
2162     }};
2163 }
2164
2165 #[macro_export]
2166 // TODO: determine if this ought to be public API?`
2167 #[doc(hidden)]
2168 macro_rules! level_enabled {
2169     ($lvl:expr) => {
2170         $lvl <= $crate::level_filters::STATIC_MAX_LEVEL
2171             && $lvl <= $crate::level_filters::LevelFilter::current()
2172     };
2173 }
2174
2175 #[doc(hidden)]
2176 #[macro_export]
2177 macro_rules! valueset {
2178
2179     // === base case ===
2180     (@ { $(,)* $($val:expr),* $(,)* }, $next:expr $(,)*) => {
2181         &[ $($val),* ]
2182     };
2183
2184     // === recursive case (more tts) ===
2185
2186     // TODO(#1138): determine a new syntax for uninitialized span fields, and
2187     // re-enable this.
2188     // (@{ $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = _, $($rest:tt)*) => {
2189     //     $crate::valueset!(@ { $($out),*, (&$next, None) }, $next, $($rest)*)
2190     // };
2191     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
2192         $crate::valueset!(
2193             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
2194             $next,
2195             $($rest)*
2196         )
2197     };
2198     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
2199         $crate::valueset!(
2200             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
2201             $next,
2202             $($rest)*
2203         )
2204     };
2205     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr, $($rest:tt)*) => {
2206         $crate::valueset!(
2207             @ { $($out),*, (&$next, Some(&$val as &Value)) },
2208             $next,
2209             $($rest)*
2210         )
2211     };
2212     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+, $($rest:tt)*) => {
2213         $crate::valueset!(
2214             @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) },
2215             $next,
2216             $($rest)*
2217         )
2218     };
2219     (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+, $($rest:tt)*) => {
2220         $crate::valueset!(
2221             @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) },
2222             $next,
2223             $($rest)*
2224         )
2225     };
2226     (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+, $($rest:tt)*) => {
2227         $crate::valueset!(
2228             @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) },
2229             $next,
2230             $($rest)*
2231         )
2232     };
2233     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr) => {
2234         $crate::valueset!(
2235             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
2236             $next,
2237         )
2238     };
2239     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr) => {
2240         $crate::valueset!(
2241             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
2242             $next,
2243         )
2244     };
2245     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr) => {
2246         $crate::valueset!(
2247             @ { $($out),*, (&$next, Some(&$val as &Value)) },
2248             $next,
2249         )
2250     };
2251     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+) => {
2252         $crate::valueset!(
2253             @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) },
2254             $next,
2255         )
2256     };
2257     (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+) => {
2258         $crate::valueset!(
2259             @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) },
2260             $next,
2261         )
2262     };
2263     (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+) => {
2264         $crate::valueset!(
2265             @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) },
2266             $next,
2267         )
2268     };
2269
2270     // Handle literal names
2271     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr, $($rest:tt)*) => {
2272         $crate::valueset!(
2273             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
2274             $next,
2275             $($rest)*
2276         )
2277     };
2278     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr, $($rest:tt)*) => {
2279         $crate::valueset!(
2280             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
2281             $next,
2282             $($rest)*
2283         )
2284     };
2285     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr, $($rest:tt)*) => {
2286         $crate::valueset!(
2287             @ { $($out),*, (&$next, Some(&$val as &Value)) },
2288             $next,
2289             $($rest)*
2290         )
2291     };
2292     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr) => {
2293         $crate::valueset!(
2294             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
2295             $next,
2296         )
2297     };
2298     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr) => {
2299         $crate::valueset!(
2300             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
2301             $next,
2302         )
2303     };
2304     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr) => {
2305         $crate::valueset!(
2306             @ { $($out),*, (&$next, Some(&$val as &Value)) },
2307             $next,
2308         )
2309     };
2310
2311     // Remainder is unparseable, but exists --- must be format args!
2312     (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => {
2313         $crate::valueset!(@ { (&$next, Some(&format_args!($($rest)+) as &Value)), $($out),* }, $next, )
2314     };
2315
2316     // === entry ===
2317     ($fields:expr, $($kvs:tt)+) => {
2318         {
2319             #[allow(unused_imports)]
2320             use $crate::field::{debug, display, Value};
2321             let mut iter = $fields.iter();
2322             $fields.value_set($crate::valueset!(
2323                 @ { },
2324                 iter.next().expect("FieldSet corrupted (this is a bug)"),
2325                 $($kvs)+
2326             ))
2327         }
2328     };
2329     ($fields:expr,) => {
2330         {
2331             $fields.value_set(&[])
2332         }
2333     };
2334 }
2335
2336 #[doc(hidden)]
2337 #[macro_export]
2338 macro_rules! fieldset {
2339     // == base case ==
2340     (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => {
2341         &[ $($out),* ]
2342     };
2343
2344     // == recursive cases (more tts) ==
2345     (@ { $(,)* $($out:expr),* } $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
2346         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2347     };
2348     (@ { $(,)* $($out:expr),* } $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
2349         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2350     };
2351     (@ { $(,)* $($out:expr),* } $($k:ident).+ = $val:expr, $($rest:tt)*) => {
2352         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2353     };
2354     // TODO(#1138): determine a new syntax for uninitialized span fields, and
2355     // re-enable this.
2356     // (@ { $($out:expr),* } $($k:ident).+ = _, $($rest:tt)*) => {
2357     //     $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2358     // };
2359     (@ { $(,)* $($out:expr),* } ?$($k:ident).+, $($rest:tt)*) => {
2360         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2361     };
2362     (@ { $(,)* $($out:expr),* } %$($k:ident).+, $($rest:tt)*) => {
2363         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2364     };
2365     (@ { $(,)* $($out:expr),* } $($k:ident).+, $($rest:tt)*) => {
2366         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2367     };
2368
2369     // Handle literal names
2370     (@ { $(,)* $($out:expr),* } $k:literal = ?$val:expr, $($rest:tt)*) => {
2371         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2372     };
2373     (@ { $(,)* $($out:expr),* } $k:literal = %$val:expr, $($rest:tt)*) => {
2374         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2375     };
2376     (@ { $(,)* $($out:expr),* } $k:literal = $val:expr, $($rest:tt)*) => {
2377         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2378     };
2379
2380     // Remainder is unparseable, but exists --- must be format args!
2381     (@ { $(,)* $($out:expr),* } $($rest:tt)+) => {
2382         $crate::fieldset!(@ { "message", $($out),*, })
2383     };
2384
2385     // == entry ==
2386     ($($args:tt)*) => {
2387         $crate::fieldset!(@ { } $($args)*,)
2388     };
2389
2390 }
2391
2392 #[cfg(feature = "log")]
2393 #[doc(hidden)]
2394 #[macro_export]
2395 macro_rules! level_to_log {
2396     ($level:expr) => {
2397         match $level {
2398             $crate::Level::ERROR => $crate::log::Level::Error,
2399             $crate::Level::WARN => $crate::log::Level::Warn,
2400             $crate::Level::INFO => $crate::log::Level::Info,
2401             $crate::Level::DEBUG => $crate::log::Level::Debug,
2402             _ => $crate::log::Level::Trace,
2403         }
2404     };
2405 }
2406
2407 #[doc(hidden)]
2408 #[macro_export]
2409 macro_rules! __tracing_stringify {
2410     ($s:expr) => {
2411         stringify!($s)
2412     };
2413 }
2414
2415 #[cfg(not(feature = "log"))]
2416 #[doc(hidden)]
2417 #[macro_export]
2418 macro_rules! __tracing_log {
2419     ($level:expr, $callsite:expr, $value_set:expr) => {};
2420 }
2421
2422 #[cfg(feature = "log")]
2423 #[doc(hidden)]
2424 #[macro_export]
2425 macro_rules! __tracing_log {
2426     ($level:expr, $callsite:expr, $value_set:expr) => {
2427         $crate::if_log_enabled! { $level, {
2428             use $crate::log;
2429             let level = $crate::level_to_log!($level);
2430             if level <= log::max_level() {
2431                 let log_meta = log::Metadata::builder()
2432                     .level(level)
2433                     .target(CALLSITE.metadata().target())
2434                     .build();
2435                 let logger = log::logger();
2436                 if logger.enabled(&log_meta) {
2437                     $callsite.log(logger, log_meta, $value_set)
2438                 }
2439             }
2440         }}
2441     };
2442 }
2443
2444 #[cfg(not(feature = "log"))]
2445 #[doc(hidden)]
2446 #[macro_export]
2447 macro_rules! if_log_enabled {
2448     ($lvl:expr, $e:expr;) => {
2449         $crate::if_log_enabled! { $lvl, $e }
2450     };
2451     ($lvl:expr, $if_log:block) => {
2452         $crate::if_log_enabled! { $lvl, $if_log else {} }
2453     };
2454     ($lvl:expr, $if_log:block else $else_block:block) => {
2455         $else_block
2456     };
2457 }
2458
2459 #[cfg(all(feature = "log", not(feature = "log-always")))]
2460 #[doc(hidden)]
2461 #[macro_export]
2462 macro_rules! if_log_enabled {
2463     ($lvl:expr, $e:expr;) => {
2464         $crate::if_log_enabled! { $lvl, $e }
2465     };
2466     ($lvl:expr, $if_log:block) => {
2467         $crate::if_log_enabled! { $lvl, $if_log else {} }
2468     };
2469     ($lvl:expr, $if_log:block else $else_block:block) => {
2470         if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL {
2471             if !$crate::dispatcher::has_been_set() {
2472                 $if_log
2473             } else {
2474                 $else_block
2475             }
2476         } else {
2477             $else_block
2478         }
2479     };
2480 }
2481
2482 #[cfg(all(feature = "log", feature = "log-always"))]
2483 #[doc(hidden)]
2484 #[macro_export]
2485 macro_rules! if_log_enabled {
2486     ($lvl:expr, $e:expr;) => {
2487         $crate::if_log_enabled! { $lvl, $e }
2488     };
2489     ($lvl:expr, $if_log:block) => {
2490         $crate::if_log_enabled! { $lvl, $if_log else {} }
2491     };
2492     ($lvl:expr, $if_log:block else $else_block:block) => {
2493         if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL {
2494             #[allow(unused_braces)]
2495             $if_log
2496         } else {
2497             $else_block
2498         }
2499     };
2500 }