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]: index.html#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         $crate::__tracing_mk_span!(target: $target, parent: $parent, $lvl, $name, $($fields)*)
  26     };
  27     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
  28         $crate::__tracing_mk_span!(target: $target, $lvl, $name, $($fields)*)
  29     };
  30     (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr) => {
  31         $crate::span!(target: $target, parent: $parent, $lvl, $name,)
  32     };
  33     (parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
  34         $crate::span!(
  35             target: module_path!(),
  36             parent: $parent,
  37             $lvl,
  38             $name,
  39             $($fields)*
  40         )
  41     };
  42     (parent: $parent:expr, $lvl:expr, $name:expr) => {
  43         $crate::span!(
  44             target: module_path!(),
  45             parent: $parent,
  46             $lvl,
  47             $name,
  48         )
  49     };
  50     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
  51         $crate::span!(
  52             target: $target,
  53             $lvl,
  54             $name,
  55             $($fields)*
  56         )
  57     };
  58     (target: $target:expr, $lvl:expr, $name:expr) => {
  59         $crate::span!(target: $target, $lvl, $name,)
  60     };
  61     ($lvl:expr, $name:expr, $($fields:tt)*) => {
  62         $crate::span!(
  63             target: module_path!(),
  64             $lvl,
  65             $name,
  66             $($fields)*
  67         )
  68     };
  69     ($lvl:expr, $name:expr) => {
  70         $crate::span!(
  71             target: module_path!(),
  72             $lvl,
  73             $name,
  74         )
  75     };
  76 }
  77
  78 /// Constructs a span at the trace level.
  79 ///
  80 /// [Fields] and [attributes] are set using the same syntax as the [`span!`]
  81 /// macro.
  82 ///
  83 /// See [the top-level documentation][lib] for details on the syntax accepted by
  84 /// this macro.
  85 ///
  86 /// [lib]: index.html#using-the-macros
  87 /// [attributes]: index.html#configuring-attributes
  88 /// [Fields]: index.html#recording-fields
  89 /// [`span!`]: macro.span.html
  90 ///
  91 /// # Examples
  92 ///
  93 /// ```rust
  94 /// # use tracing::{trace_span, span, Level};
  95 /// # fn main() {
  96 /// trace_span!("my_span");
  97 /// // is equivalent to:
  98 /// span!(Level::TRACE, "my_span");
  99 /// # }
 100 /// ```
 101 ///
 102 /// ```rust
 103 /// # use tracing::{trace_span, span, Level};
 104 /// # fn main() {
 105 /// let span = trace_span!("my span");
 106 /// span.in_scope(|| {
 107 ///     // do work inside the span...
 108 /// });
 109 /// # }
 110 /// ```
 111 #[macro_export]
 112 macro_rules! trace_span {
 113     (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
 114         $crate::span!(
 115             target: $target,
 116             parent: $parent,
 117             $crate::Level::TRACE,
 118             $name,
 119             $($field)*
 120         )
 121     };
 122     (target: $target:expr, parent: $parent:expr, $name:expr) => {
 123         $crate::trace_span!(target: $target, parent: $parent, $name,)
 124     };
 125     (parent: $parent:expr, $name:expr, $($field:tt)*) => {
 126         $crate::span!(
 127             target: module_path!(),
 128             parent: $parent,
 129             $crate::Level::TRACE,
 130             $name,
 131             $($field)*
 132         )
 133     };
 134     (parent: $parent:expr, $name:expr) => {
 135         $crate::trace_span!(parent: $parent, $name,)
 136     };
 137     (target: $target:expr, $name:expr, $($field:tt)*) => {
 138         $crate::span!(
 139             target: $target,
 140             $crate::Level::TRACE,
 141             $name,
 142             $($field)*
 143         )
 144     };
 145     (target: $target:expr, $name:expr) => {
 146         $crate::trace_span!(target: $target, $name,)
 147     };
 148     ($name:expr, $($field:tt)*) => {
 149         $crate::span!(
 150             target: module_path!(),
 151             $crate::Level::TRACE,
 152             $name,
 153             $($field)*
 154         )
 155     };
 156     ($name:expr) => { $crate::trace_span!($name,) };
 157 }
 158
 159 /// Constructs a span at the debug level.
 160 ///
 161 /// [Fields] and [attributes] are set using the same syntax as the [`span!`]
 162 /// macro.
 163 ///
 164 /// See [the top-level documentation][lib] for details on the syntax accepted by
 165 /// this macro.
 166 ///
 167 /// [lib]: index.html#using-the-macros
 168 /// [attributes]: index.html#configuring-attributes
 169 /// [Fields]: index.html#recording-fields
 170 /// [`span!`]: macro.span.html
 171 ///
 172 /// # Examples
 173 ///
 174 /// ```rust
 175 /// # use tracing::{debug_span, span, Level};
 176 /// # fn main() {
 177 /// debug_span!("my_span");
 178 /// // is equivalent to:
 179 /// span!(Level::DEBUG, "my_span");
 180 /// # }
 181 /// ```
 182 ///
 183 /// ```rust
 184 /// # use tracing::debug_span;
 185 /// # fn main() {
 186 /// let span = debug_span!("my span");
 187 /// span.in_scope(|| {
 188 ///     // do work inside the span...
 189 /// });
 190 /// # }
 191 /// ```
 192 #[macro_export]
 193 macro_rules! debug_span {
 194     (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
 195         $crate::span!(
 196             target: $target,
 197             parent: $parent,
 198             $crate::Level::DEBUG,
 199             $name,
 200             $($field)*
 201         )
 202     };
 203     (target: $target:expr, parent: $parent:expr, $name:expr) => {
 204         $crate::debug_span!(target: $target, parent: $parent, $name,)
 205     };
 206     (parent: $parent:expr, $name:expr, $($field:tt)*) => {
 207         $crate::span!(
 208             target: module_path!(),
 209             parent: $parent,
 210             $crate::Level::DEBUG,
 211             $name,
 212             $($field)*
 213         )
 214     };
 215     (parent: $parent:expr, $name:expr) => {
 216         $crate::debug_span!(parent: $parent, $name,)
 217     };
 218     (target: $target:expr, $name:expr, $($field:tt)*) => {
 219         $crate::span!(
 220             target: $target,
 221             $crate::Level::DEBUG,
 222             $name,
 223             $($field)*
 224         )
 225     };
 226     (target: $target:expr, $name:expr) => {
 227         $crate::debug_span!(target: $target, $name,)
 228     };
 229     ($name:expr, $($field:tt)*) => {
 230         $crate::span!(
 231             target: module_path!(),
 232             $crate::Level::DEBUG,
 233             $name,
 234             $($field)*
 235         )
 236     };
 237     ($name:expr) => {$crate::debug_span!($name,)};
 238 }
 239
 240 /// Constructs a span at the info level.
 241 ///
 242 /// [Fields] and [attributes] are set using the same syntax as the [`span!`]
 243 /// macro.
 244 ///
 245 /// See [the top-level documentation][lib] for details on the syntax accepted by
 246 /// this macro.
 247 ///
 248 /// [lib]: index.html#using-the-macros
 249 /// [attributes]: index.html#configuring-attributes
 250 /// [Fields]: index.html#recording-fields
 251 /// [`span!`]: macro.span.html
 252 ///
 253 /// # Examples
 254 ///
 255 /// ```rust
 256 /// # use tracing::{span, info_span, Level};
 257 /// # fn main() {
 258 /// info_span!("my_span");
 259 /// // is equivalent to:
 260 /// span!(Level::INFO, "my_span");
 261 /// # }
 262 /// ```
 263 ///
 264 /// ```rust
 265 /// # use tracing::info_span;
 266 /// # fn main() {
 267 /// let span = info_span!("my span");
 268 /// span.in_scope(|| {
 269 ///     // do work inside the span...
 270 /// });
 271 /// # }
 272 /// ```
 273 #[macro_export]
 274 macro_rules! info_span {
 275     (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
 276         $crate::span!(
 277             target: $target,
 278             parent: $parent,
 279             $crate::Level::INFO,
 280             $name,
 281             $($field)*
 282         )
 283     };
 284     (target: $target:expr, parent: $parent:expr, $name:expr) => {
 285         $crate::info_span!(target: $target, parent: $parent, $name,)
 286     };
 287     (parent: $parent:expr, $name:expr, $($field:tt)*) => {
 288         $crate::span!(
 289             target: module_path!(),
 290             parent: $parent,
 291             $crate::Level::INFO,
 292             $name,
 293             $($field)*
 294         )
 295     };
 296     (parent: $parent:expr, $name:expr) => {
 297         $crate::info_span!(parent: $parent, $name,)
 298     };
 299     (target: $target:expr, $name:expr, $($field:tt)*) => {
 300         $crate::span!(
 301             target: $target,
 302             $crate::Level::INFO,
 303             $name,
 304             $($field)*
 305         )
 306     };
 307     (target: $target:expr, $name:expr) => {
 308         $crate::info_span!(target: $target, $name,)
 309     };
 310     ($name:expr, $($field:tt)*) => {
 311         $crate::span!(
 312             target: module_path!(),
 313             $crate::Level::INFO,
 314             $name,
 315             $($field)*
 316         )
 317     };
 318     ($name:expr) => {$crate::info_span!($name,)};
 319 }
 320
 321 /// Constructs a span at the warn level.
 322 ///
 323 /// [Fields] and [attributes] are set using the same syntax as the [`span!`]
 324 /// macro.
 325 ///
 326 /// See [the top-level documentation][lib] for details on the syntax accepted by
 327 /// this macro.
 328 ///
 329 /// [lib]: index.html#using-the-macros
 330 /// [attributes]: index.html#configuring-attributes
 331 /// [Fields]: index.html#recording-fields
 332 /// [`span!`]: macro.span.html
 333 ///
 334 /// # Examples
 335 ///
 336 /// ```rust
 337 /// # use tracing::{warn_span, span, Level};
 338 /// # fn main() {
 339 /// warn_span!("my_span");
 340 /// // is equivalent to:
 341 /// span!(Level::WARN, "my_span");
 342 /// # }
 343 /// ```
 344 ///
 345 /// ```rust
 346 /// use tracing::warn_span;
 347 /// # fn main() {
 348 /// let span = warn_span!("my span");
 349 /// span.in_scope(|| {
 350 ///     // do work inside the span...
 351 /// });
 352 /// # }
 353 /// ```
 354 #[macro_export]
 355 macro_rules! warn_span {
 356     (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
 357         $crate::span!(
 358             target: $target,
 359             parent: $parent,
 360             $crate::Level::WARN,
 361             $name,
 362             $($field)*
 363         )
 364     };
 365     (target: $target:expr, parent: $parent:expr, $name:expr) => {
 366         $crate::warn_span!(target: $target, parent: $parent, $name,)
 367     };
 368     (parent: $parent:expr, $name:expr, $($field:tt)*) => {
 369         $crate::span!(
 370             target: module_path!(),
 371             parent: $parent,
 372             $crate::Level::WARN,
 373             $name,
 374             $($field)*
 375         )
 376     };
 377     (parent: $parent:expr, $name:expr) => {
 378         $crate::warn_span!(parent: $parent, $name,)
 379     };
 380     (target: $target:expr, $name:expr, $($field:tt)*) => {
 381         $crate::span!(
 382             target: $target,
 383             $crate::Level::WARN,
 384             $name,
 385             $($field)*
 386         )
 387     };
 388     (target: $target:expr, $name:expr) => {
 389         $crate::warn_span!(target: $target, $name,)
 390     };
 391     ($name:expr, $($field:tt)*) => {
 392         $crate::span!(
 393             target: module_path!(),
 394             $crate::Level::WARN,
 395             $name,
 396             $($field)*
 397         )
 398     };
 399     ($name:expr) => {$crate::warn_span!($name,)};
 400 }
 401 /// Constructs a span at the error level.
 402 ///
 403 /// [Fields] and [attributes] are set using the same syntax as the [`span!`]
 404 /// macro.
 405 ///
 406 /// See [the top-level documentation][lib] for details on the syntax accepted by
 407 /// this macro.
 408 ///
 409 /// [lib]: index.html#using-the-macros
 410 /// [attributes]: index.html#configuring-attributes
 411 /// [Fields]: index.html#recording-fields
 412 /// [`span!`]: macro.span.html
 413 ///
 414 /// # Examples
 415 ///
 416 /// ```rust
 417 /// # use tracing::{span, error_span, Level};
 418 /// # fn main() {
 419 /// error_span!("my_span");
 420 /// // is equivalent to:
 421 /// span!(Level::ERROR, "my_span");
 422 /// # }
 423 /// ```
 424 ///
 425 /// ```rust
 426 /// # use tracing::error_span;
 427 /// # fn main() {
 428 /// let span = error_span!("my span");
 429 /// span.in_scope(|| {
 430 ///     // do work inside the span...
 431 /// });
 432 /// # }
 433 /// ```
 434 #[macro_export]
 435 macro_rules! error_span {
 436     (target: $target:expr, parent: $parent:expr, $name:expr, $($field:tt)*) => {
 437         $crate::span!(
 438             target: $target,
 439             parent: $parent,
 440             $crate::Level::ERROR,
 441             $name,
 442             $($field)*
 443         )
 444     };
 445     (target: $target:expr, parent: $parent:expr, $name:expr) => {
 446         $crate::error_span!(target: $target, parent: $parent, $name,)
 447     };
 448     (parent: $parent:expr, $name:expr, $($field:tt)*) => {
 449         $crate::span!(
 450             target: module_path!(),
 451             parent: $parent,
 452             $crate::Level::ERROR,
 453             $name,
 454             $($field)*
 455         )
 456     };
 457     (parent: $parent:expr, $name:expr) => {
 458         $crate::error_span!(parent: $parent, $name,)
 459     };
 460     (target: $target:expr, $name:expr, $($field:tt)*) => {
 461         $crate::span!(
 462             target: $target,
 463             $crate::Level::ERROR,
 464             $name,
 465             $($field)*
 466         )
 467     };
 468     (target: $target:expr, $name:expr) => {
 469         $crate::error_span!(target: $target, $name,)
 470     };
 471     ($name:expr, $($field:tt)*) => {
 472         $crate::span!(
 473             target: module_path!(),
 474             $crate::Level::ERROR,
 475             $name,
 476             $($field)*
 477         )
 478     };
 479     ($name:expr) => {$crate::error_span!($name,)};
 480 }
 481
 482 /// Constructs a new `Event`.
 483 ///
 484 /// The event macro is invoked with a `Level` and up to 32 key-value fields.
 485 /// Optionally, a format string and arguments may follow the fields; this will
 486 /// be used to construct an implicit field named "message".
 487 ///
 488 /// See [the top-level documentation][lib] for details on the syntax accepted by
 489 /// this macro.
 490 ///
 491 /// [lib]: index.html#using-the-macros
 492 ///
 493 /// # Examples
 494 ///
 495 /// ```rust
 496 /// use tracing::{event, Level};
 497 ///
 498 /// # fn main() {
 499 /// let data = (42, "forty-two");
 500 /// let private_data = "private";
 501 /// let error = "a bad error";
 502 ///
 503 /// event!(Level::ERROR, %error, "Received error");
 504 /// event!(
 505 ///     target: "app_events",
 506 ///     Level::WARN,
 507 ///     private_data,
 508 ///     ?data,
 509 ///     "App warning: {}",
 510 ///     error
 511 /// );
 512 /// event!(Level::INFO, the_answer = data.0);
 513 /// # }
 514 /// ```
 515 ///
 516 // /// Note that *unlike `span!`*, `event!` requires a value for all fields. As
 517 // /// events are recorded immediately when the macro is invoked, there is no
 518 // /// opportunity for fields to be recorded later. A trailing comma on the final
 519 // /// field is valid.
 520 // ///
 521 // /// For example, the following does not compile:
 522 // /// ```rust,compile_fail
 523 // /// # #[macro_use]
 524 // /// # extern crate tracing;
 525 // /// # use tracing::Level;
 526 // /// # fn main() {
 527 // /// event!(Level::INFO, foo = 5, bad_field, bar = "hello")
 528 // /// #}
 529 // /// ```
 530 #[macro_export]
 531 macro_rules! event {
 532     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> (
 533         $crate::__tracing_log!(
 534             target: $target,
 535             $lvl,
 536             $($fields)*
 537         );
 538
 539         if $crate::level_enabled!($lvl) {
 540             use $crate::__macro_support::*;
 541             let callsite = $crate::callsite! {
 542                 name: concat!(
 543                     "event ",
 544                     file!(),
 545                     ":",
 546                     line!()
 547                 ),
 548                 kind: $crate::metadata::Kind::EVENT,
 549                 target: $target,
 550                 level: $lvl,
 551                 fields: $($fields)*
 552             };
 553             if callsite.is_enabled() {
 554                 let meta = callsite.metadata();
 555                 $crate::Event::child_of($parent, meta, &$crate::valueset!(meta.fields(), $($fields)*) );
 556             }
 557         }
 558     );
 559
 560     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 561         $crate::event!(
 562             target: $target,
 563             parent: $parent,
 564             $lvl,
 565             { message = format_args!($($arg)+), $($fields)* }
 566         )
 567     );
 568     (target: $target:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
 569         $crate::event!(target: $target, parent: $parent, $lvl, { $($k).+ = $($fields)* })
 570     );
 571     (target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
 572         $crate::event!(target: $target, parent: $parent, $lvl, { $($arg)+ })
 573     );
 574     (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
 575         $crate::__tracing_log!(
 576             target: $target,
 577             $lvl,
 578             $($fields)*
 579         );
 580         if $crate::level_enabled!($lvl) {
 581             use $crate::__macro_support::*;
 582             let callsite = $crate::callsite! {
 583                 name: concat!(
 584                     "event ",
 585                     file!(),
 586                     ":",
 587                     line!()
 588                 ),
 589                 kind: $crate::metadata::Kind::EVENT,
 590                 target: $target,
 591                 level: $lvl,
 592                 fields: $($fields)*
 593             };
 594             if callsite.is_enabled() {
 595                 let meta = callsite.metadata();
 596                 $crate::Event::dispatch(meta, &$crate::valueset!(meta.fields(), $($fields)*) );
 597             }
 598         }
 599     });
 600     (target: $target:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 601         $crate::event!(
 602             target: $target,
 603             $lvl,
 604             { message = format_args!($($arg)+), $($fields)* }
 605         )
 606     );
 607     (target: $target:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
 608         $crate::event!(target: $target, $lvl, { $($k).+ = $($fields)* })
 609     );
 610     (target: $target:expr, $lvl:expr, $($arg:tt)+ ) => (
 611         $crate::event!(target: $target, $lvl, { $($arg)+ })
 612     );
 613     (parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 614         $crate::event!(
 615             target: module_path!(),
 616             parent: $parent,
 617             $lvl,
 618             { message = format_args!($($arg)+), $($fields)* }
 619         )
 620     );
 621     (parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 622         $crate::event!(
 623             target: module_path!(),
 624             $lvl,
 625             parent: $parent,
 626             { message = format_args!($($arg)+), $($fields)* }
 627         )
 628     );
 629     (parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($field:tt)*) => (
 630         $crate::event!(
 631             target: module_path!(),
 632             parent: $parent,
 633             $lvl,
 634             { $($k).+ = $($field)*}
 635         )
 636     );
 637     (parent: $parent:expr, $lvl:expr, ?$($k:ident).+ = $($field:tt)*) => (
 638         $crate::event!(
 639             target: module_path!(),
 640             parent: $parent,
 641             $lvl,
 642             { ?$($k).+ = $($field)*}
 643         )
 644     );
 645     (parent: $parent:expr, $lvl:expr, %$($k:ident).+ = $($field:tt)*) => (
 646         $crate::event!(
 647             target: module_path!(),
 648             parent: $parent,
 649             $lvl,
 650             { %$($k).+ = $($field)*}
 651         )
 652     );
 653     (parent: $parent:expr, $lvl:expr, $($k:ident).+, $($field:tt)*) => (
 654         $crate::event!(
 655             target: module_path!(),
 656             parent: $parent,
 657             $lvl,
 658             { $($k).+, $($field)*}
 659         )
 660     );
 661     (parent: $parent:expr, $lvl:expr, %$($k:ident).+, $($field:tt)*) => (
 662         $crate::event!(
 663             target: module_path!(),
 664             parent: $parent,
 665             $lvl,
 666             { %$($k).+, $($field)*}
 667         )
 668     );
 669     (parent: $parent:expr, $lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
 670         $crate::event!(
 671             target: module_path!(),
 672             parent: $parent,
 673             $lvl,
 674             { ?$($k).+, $($field)*}
 675         )
 676     );
 677     (parent: $parent:expr, $lvl:expr, $($arg:tt)+ ) => (
 678         $crate::event!(target: module_path!(), parent: $parent, $lvl, { $($arg)+ })
 679     );
 680     ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 681         $crate::event!(
 682             target: module_path!(),
 683             $lvl,
 684             { message = format_args!($($arg)+), $($fields)* }
 685         )
 686     );
 687     ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
 688         $crate::event!(
 689             target: module_path!(),
 690             $lvl,
 691             { message = format_args!($($arg)+), $($fields)* }
 692         )
 693     );
 694     ($lvl:expr, $($k:ident).+ = $($field:tt)*) => (
 695         $crate::event!(
 696             target: module_path!(),
 697             $lvl,
 698             { $($k).+ = $($field)*}
 699         )
 700     );
 701     ($lvl:expr, $($k:ident).+, $($field:tt)*) => (
 702         $crate::event!(
 703             target: module_path!(),
 704             $lvl,
 705             { $($k).+, $($field)*}
 706         )
 707     );
 708     ($lvl:expr, ?$($k:ident).+, $($field:tt)*) => (
 709         $crate::event!(
 710             target: module_path!(),
 711             $lvl,
 712             { ?$($k).+, $($field)*}
 713         )
 714     );
 715     ($lvl:expr, %$($k:ident).+, $($field:tt)*) => (
 716         $crate::event!(
 717             target: module_path!(),
 718             $lvl,
 719             { %$($k).+, $($field)*}
 720         )
 721     );
 722     ($lvl:expr, ?$($k:ident).+) => (
 723         $crate::event!($lvl, ?$($k).+,)
 724     );
 725     ($lvl:expr, %$($k:ident).+) => (
 726         $crate::event!($lvl, %$($k).+,)
 727     );
 728     ($lvl:expr, $($k:ident).+) => (
 729         $crate::event!($lvl, $($k).+,)
 730     );
 731     ( $lvl:expr, $($arg:tt)+ ) => (
 732         $crate::event!(target: module_path!(), $lvl, { $($arg)+ })
 733     );
 734 }
 735
 736 /// Constructs an event at the trace level.
 737 ///
 738 /// This functions similarly to the [`event!`] macro. See [the top-level
 739 /// documentation][lib] for details on the syntax accepted by
 740 /// this macro.
 741 ///
 742 /// [`event!`]: macro.event.html
 743 /// [lib]: index.html#using-the-macros
 744 ///
 745 /// # Examples
 746 ///
 747 /// ```rust
 748 /// use tracing::trace;
 749 /// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 }
 750 /// # impl Position {
 751 /// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 };
 752 /// # fn dist(&self, other: Position) -> f32 {
 753 /// #    let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2();
 754 /// #    (x + y).sqrt()
 755 /// # }
 756 /// # }
 757 /// # fn main() {
 758 /// let pos = Position { x: 3.234, y: -1.223 };
 759 /// let origin_dist = pos.dist(Position::ORIGIN);
 760 ///
 761 /// trace!(position = ?pos, ?origin_dist);
 762 /// trace!(
 763 ///     target: "app_events",
 764 ///     position = ?pos,
 765 ///     "x is {} and y is {}",
 766 ///     if pos.x >= 0.0 { "positive" } else { "negative" },
 767 ///     if pos.y >= 0.0 { "positive" } else { "negative" }
 768 /// );
 769 /// # }
 770 /// ```
 771 #[macro_export]
 772 macro_rules! trace {
 773     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
 774         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
 775     );
 776     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
 777         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
 778     );
 779     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
 780         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
 781     );
 782     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
 783         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
 784     );
 785     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
 786         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
 787     );
 788     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
 789         $crate::event!(
 790             target: module_path!(),
 791             parent: $parent,
 792             $crate::Level::TRACE,
 793             { $($field)+ },
 794             $($arg)+
 795         )
 796     );
 797     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
 798         $crate::event!(
 799             target: module_path!(),
 800             parent: $parent,
 801             $crate::Level::TRACE,
 802             { $($k).+ = $($field)*}
 803         )
 804     );
 805     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
 806         $crate::event!(
 807             target: module_path!(),
 808             parent: $parent,
 809             $crate::Level::TRACE,
 810             { ?$($k).+ = $($field)*}
 811         )
 812     );
 813     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
 814         $crate::event!(
 815             target: module_path!(),
 816             parent: $parent,
 817             $crate::Level::TRACE,
 818             { %$($k).+ = $($field)*}
 819         )
 820     );
 821     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
 822         $crate::event!(
 823             target: module_path!(),
 824             parent: $parent,
 825             $crate::Level::TRACE,
 826             { $($k).+, $($field)*}
 827         )
 828     );
 829     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
 830         $crate::event!(
 831             target: module_path!(),
 832             parent: $parent,
 833             $crate::Level::TRACE,
 834             { ?$($k).+, $($field)*}
 835         )
 836     );
 837     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
 838         $crate::event!(
 839             target: module_path!(),
 840             parent: $parent,
 841             $crate::Level::TRACE,
 842             { %$($k).+, $($field)*}
 843         )
 844     );
 845     (parent: $parent:expr, $($arg:tt)+) => (
 846         $crate::event!(
 847             target: module_path!(),
 848             parent: $parent,
 849             $crate::Level::TRACE,
 850             {},
 851             $($arg)+
 852         )
 853     );
 854     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
 855         $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
 856     );
 857     (target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
 858         $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
 859     );
 860     (target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
 861         $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
 862     );
 863     (target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
 864         $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
 865     );
 866     (target: $target:expr, $($arg:tt)+ ) => (
 867         $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+)
 868     );
 869     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
 870         $crate::event!(
 871             target: module_path!(),
 872             $crate::Level::TRACE,
 873             { $($field)+ },
 874             $($arg)+
 875         )
 876     );
 877     ($($k:ident).+ = $($field:tt)*) => (
 878         $crate::event!(
 879             target: module_path!(),
 880             $crate::Level::TRACE,
 881             { $($k).+ = $($field)*}
 882         )
 883     );
 884     ($($k:ident).+, $($field:tt)*) => (
 885         $crate::event!(
 886             target: module_path!(),
 887             $crate::Level::TRACE,
 888             { $($k).+, $($field)*}
 889         )
 890     );
 891     (?$($k:ident).+, $($field:tt)*) => (
 892         $crate::event!(
 893             target: module_path!(),
 894             $crate::Level::TRACE,
 895             { ?$($k).+, $($field)*}
 896         )
 897     );
 898     (%$($k:ident).+, $($field:tt)*) => (
 899         $crate::event!(
 900             target: module_path!(),
 901             $crate::Level::TRACE,
 902             { %$($k).+, $($field)*}
 903         )
 904     );
 905     (?$($k:ident).+) => (
 906         $crate::event!(
 907             target: module_path!(),
 908             $crate::Level::TRACE,
 909             { ?$($k).+ }
 910         )
 911     );
 912     (%$($k:ident).+) => (
 913         $crate::event!(
 914             target: module_path!(),
 915             $crate::Level::TRACE,
 916             { %$($k).+ }
 917         )
 918     );
 919     ($($k:ident).+) => (
 920         $crate::event!(
 921             target: module_path!(),
 922             $crate::Level::TRACE,
 923             { $($k).+ }
 924         )
 925     );
 926     ($($arg:tt)+) => (
 927         $crate::event!(
 928             target: module_path!(),
 929             $crate::Level::TRACE,
 930             {},
 931             $($arg)+
 932         )
 933     );
 934 }
 935
 936 /// Constructs an event at the debug level.
 937 ///
 938 /// This functions similarly to the [`event!`] macro. See [the top-level
 939 /// documentation][lib] for details on the syntax accepted by
 940 /// this macro.
 941 ///
 942 /// [`event!`]: macro.event.html
 943 /// [lib]: index.html#using-the-macros
 944 ///
 945 /// # Examples
 946 ///
 947 /// ```rust
 948 /// use tracing::debug;
 949 /// # fn main() {
 950 /// # #[derive(Debug)] struct Position { x: f32, y: f32 }
 951 ///
 952 /// let pos = Position { x: 3.234, y: -1.223 };
 953 ///
 954 /// debug!(?pos.x, ?pos.y);
 955 /// debug!(target: "app_events", position = ?pos, "New position");
 956 /// # }
 957 /// ```
 958 #[macro_export]
 959 macro_rules! debug {
 960     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
 961         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
 962     );
 963     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
 964         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
 965     );
 966     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
 967         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
 968     );
 969     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
 970         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
 971     );
 972     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
 973         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
 974     );
 975     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
 976         $crate::event!(
 977             target: module_path!(),
 978             parent: $parent,
 979             $crate::Level::DEBUG,
 980             { $($field)+ },
 981             $($arg)+
 982         )
 983     );
 984     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
 985         $crate::event!(
 986             target: module_path!(),
 987             parent: $parent,
 988             $crate::Level::DEBUG,
 989             { $($k).+ = $($field)*}
 990         )
 991     );
 992     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
 993         $crate::event!(
 994             target: module_path!(),
 995             parent: $parent,
 996             $crate::Level::DEBUG,
 997             { ?$($k).+ = $($field)*}
 998         )
 999     );
1000     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1001         $crate::event!(
1002             target: module_path!(),
1003             parent: $parent,
1004             $crate::Level::DEBUG,
1005             { %$($k).+ = $($field)*}
1006         )
1007     );
1008     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1009         $crate::event!(
1010             target: module_path!(),
1011             parent: $parent,
1012             $crate::Level::DEBUG,
1013             { $($k).+, $($field)*}
1014         )
1015     );
1016     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1017         $crate::event!(
1018             target: module_path!(),
1019             parent: $parent,
1020             $crate::Level::DEBUG,
1021             { ?$($k).+, $($field)*}
1022         )
1023     );
1024     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1025         $crate::event!(
1026             target: module_path!(),
1027             parent: $parent,
1028             $crate::Level::DEBUG,
1029             { %$($k).+, $($field)*}
1030         )
1031     );
1032     (parent: $parent:expr, $($arg:tt)+) => (
1033         $crate::event!(
1034             target: module_path!(),
1035             parent: $parent,
1036             $crate::Level::DEBUG,
1037             {},
1038             $($arg)+
1039         )
1040     );
1041     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1042         $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
1043     );
1044     (target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
1045         $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1046     );
1047     (target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1048         $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1049     );
1050     (target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
1051         $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
1052     );
1053     (target: $target:expr, $($arg:tt)+ ) => (
1054         $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
1055     );
1056     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1057         $crate::event!(
1058             target: module_path!(),
1059             $crate::Level::DEBUG,
1060             { $($field)+ },
1061             $($arg)+
1062         )
1063     );
1064     ($($k:ident).+ = $($field:tt)*) => (
1065         $crate::event!(
1066             target: module_path!(),
1067             $crate::Level::DEBUG,
1068             { $($k).+ = $($field)*}
1069         )
1070     );
1071     (?$($k:ident).+ = $($field:tt)*) => (
1072         $crate::event!(
1073             target: module_path!(),
1074             $crate::Level::DEBUG,
1075             { ?$($k).+ = $($field)*}
1076         )
1077     );
1078     (%$($k:ident).+ = $($field:tt)*) => (
1079         $crate::event!(
1080             target: module_path!(),
1081             $crate::Level::DEBUG,
1082             { %$($k).+ = $($field)*}
1083         )
1084     );
1085     ($($k:ident).+, $($field:tt)*) => (
1086         $crate::event!(
1087             target: module_path!(),
1088             $crate::Level::DEBUG,
1089             { $($k).+, $($field)*}
1090         )
1091     );
1092     (?$($k:ident).+, $($field:tt)*) => (
1093         $crate::event!(
1094             target: module_path!(),
1095             $crate::Level::DEBUG,
1096             { ?$($k).+, $($field)*}
1097         )
1098     );
1099     (%$($k:ident).+, $($field:tt)*) => (
1100         $crate::event!(
1101             target: module_path!(),
1102             $crate::Level::DEBUG,
1103             { %$($k).+, $($field)*}
1104         )
1105     );
1106     (?$($k:ident).+) => (
1107         $crate::event!(
1108             target: module_path!(),
1109             $crate::Level::DEBUG,
1110             { ?$($k).+ }
1111         )
1112     );
1113     (%$($k:ident).+) => (
1114         $crate::event!(
1115             target: module_path!(),
1116             $crate::Level::DEBUG,
1117             { %$($k).+ }
1118         )
1119     );
1120     ($($k:ident).+) => (
1121         $crate::event!(
1122             target: module_path!(),
1123             $crate::Level::DEBUG,
1124             { $($k).+ }
1125         )
1126     );
1127     ($($arg:tt)+) => (
1128         $crate::event!(
1129             target: module_path!(),
1130             $crate::Level::DEBUG,
1131             {},
1132             $($arg)+
1133         )
1134     );
1135 }
1136
1137 /// Constructs an event at the info level.
1138 ///
1139 /// This functions similarly to the [`event!`] macro. See [the top-level
1140 /// documentation][lib] for details on the syntax accepted by
1141 /// this macro.
1142 ///
1143 /// [`event!`]: macro.event.html
1144 /// [lib]: index.html#using-the-macros
1145 ///
1146 /// # Examples
1147 ///
1148 /// ```rust
1149 /// use tracing::info;
1150 /// # // this is so the test will still work in no-std mode
1151 /// # #[derive(Debug)]
1152 /// # pub struct Ipv4Addr;
1153 /// # impl Ipv4Addr { fn new(o1: u8, o2: u8, o3: u8, o4: u8) -> Self { Self } }
1154 /// # fn main() {
1155 /// # struct Connection { port: u32, speed: f32 }
1156 /// use tracing::field;
1157 ///
1158 /// let addr = Ipv4Addr::new(127, 0, 0, 1);
1159 /// let conn = Connection { port: 40, speed: 3.20 };
1160 ///
1161 /// info!(conn.port, "connected to {:?}", addr);
1162 /// info!(
1163 ///     target: "connection_events",
1164 ///     ip = ?addr,
1165 ///     conn.port,
1166 ///     ?conn.speed,
1167 /// );
1168 /// # }
1169 /// ```
1170 #[macro_export]
1171 macro_rules! info {
1172      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1173         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
1174     );
1175     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1176         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1177     );
1178     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1179         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1180     );
1181     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1182         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
1183     );
1184     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1185         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
1186     );
1187     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1188         $crate::event!(
1189             target: module_path!(),
1190             parent: $parent,
1191             $crate::Level::INFO,
1192             { $($field)+ },
1193             $($arg)+
1194         )
1195     );
1196     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1197         $crate::event!(
1198             target: module_path!(),
1199             parent: $parent,
1200             $crate::Level::INFO,
1201             { $($k).+ = $($field)*}
1202         )
1203     );
1204     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1205         $crate::event!(
1206             target: module_path!(),
1207             parent: $parent,
1208             $crate::Level::INFO,
1209             { ?$($k).+ = $($field)*}
1210         )
1211     );
1212     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1213         $crate::event!(
1214             target: module_path!(),
1215             parent: $parent,
1216             $crate::Level::INFO,
1217             { %$($k).+ = $($field)*}
1218         )
1219     );
1220     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1221         $crate::event!(
1222             target: module_path!(),
1223             parent: $parent,
1224             $crate::Level::INFO,
1225             { $($k).+, $($field)*}
1226         )
1227     );
1228     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1229         $crate::event!(
1230             target: module_path!(),
1231             parent: $parent,
1232             $crate::Level::INFO,
1233             { ?$($k).+, $($field)*}
1234         )
1235     );
1236     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1237         $crate::event!(
1238             target: module_path!(),
1239             parent: $parent,
1240             $crate::Level::INFO,
1241             { %$($k).+, $($field)*}
1242         )
1243     );
1244     (parent: $parent:expr, $($arg:tt)+) => (
1245         $crate::event!(
1246             target: module_path!(),
1247             parent: $parent,
1248             $crate::Level::INFO,
1249             {},
1250             $($arg)+
1251         )
1252     );
1253     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1254         $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
1255     );
1256     (target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
1257         $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
1258     );
1259     (target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1260         $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
1261     );
1262     (target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
1263         $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
1264     );
1265     (target: $target:expr, $($arg:tt)+ ) => (
1266         $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
1267     );
1268     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1269         $crate::event!(
1270             target: module_path!(),
1271             $crate::Level::INFO,
1272             { $($field)+ },
1273             $($arg)+
1274         )
1275     );
1276     ($($k:ident).+ = $($field:tt)*) => (
1277         $crate::event!(
1278             target: module_path!(),
1279             $crate::Level::INFO,
1280             { $($k).+ = $($field)*}
1281         )
1282     );
1283     (?$($k:ident).+ = $($field:tt)*) => (
1284         $crate::event!(
1285             target: module_path!(),
1286             $crate::Level::INFO,
1287             { ?$($k).+ = $($field)*}
1288         )
1289     );
1290     (%$($k:ident).+ = $($field:tt)*) => (
1291         $crate::event!(
1292             target: module_path!(),
1293             $crate::Level::TRACE,
1294             { %$($k).+ = $($field)*}
1295         )
1296     );
1297     ($($k:ident).+, $($field:tt)*) => (
1298         $crate::event!(
1299             target: module_path!(),
1300             $crate::Level::INFO,
1301             { $($k).+, $($field)*}
1302         )
1303     );
1304     (?$($k:ident).+, $($field:tt)*) => (
1305         $crate::event!(
1306             target: module_path!(),
1307             $crate::Level::INFO,
1308             { ?$($k).+, $($field)*}
1309         )
1310     );
1311     (%$($k:ident).+, $($field:tt)*) => (
1312         $crate::event!(
1313             target: module_path!(),
1314             $crate::Level::INFO,
1315             { %$($k).+, $($field)*}
1316         )
1317     );
1318     (?$($k:ident).+) => (
1319         $crate::event!(
1320             target: module_path!(),
1321             $crate::Level::INFO,
1322             { ?$($k).+ }
1323         )
1324     );
1325     (%$($k:ident).+) => (
1326         $crate::event!(
1327             target: module_path!(),
1328             $crate::Level::INFO,
1329             { %$($k).+ }
1330         )
1331     );
1332     ($($k:ident).+) => (
1333         $crate::event!(
1334             target: module_path!(),
1335             $crate::Level::INFO,
1336             { $($k).+ }
1337         )
1338     );
1339     ($($arg:tt)+) => (
1340         $crate::event!(
1341             target: module_path!(),
1342             $crate::Level::INFO,
1343             {},
1344             $($arg)+
1345         )
1346     );
1347 }
1348
1349 /// Constructs an event at the warn level.
1350 ///
1351 /// This functions similarly to the [`event!`] macro. See [the top-level
1352 /// documentation][lib] for details on the syntax accepted by
1353 /// this macro.
1354 ///
1355 /// [`event!`]: macro.event.html
1356 /// [lib]: index.html#using-the-macros
1357 ///
1358 /// # Examples
1359 ///
1360 /// ```rust
1361 /// use tracing::warn;
1362 /// # fn main() {
1363 ///
1364 /// let warn_description = "Invalid Input";
1365 /// let input = &[0x27, 0x45];
1366 ///
1367 /// warn!(?input, warning = warn_description);
1368 /// warn!(
1369 ///     target: "input_events",
1370 ///     warning = warn_description,
1371 ///     "Received warning for input: {:?}", input,
1372 /// );
1373 /// # }
1374 /// ```
1375 #[macro_export]
1376 macro_rules! warn {
1377      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1378         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
1379     );
1380     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1381         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1382     );
1383     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1384         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1385     );
1386     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1387         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
1388     );
1389     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1390         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
1391     );
1392     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1393         $crate::event!(
1394             target: module_path!(),
1395             parent: $parent,
1396             $crate::Level::WARN,
1397             { $($field)+ },
1398             $($arg)+
1399         )
1400     );
1401     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1402         $crate::event!(
1403             target: module_path!(),
1404             parent: $parent,
1405             $crate::Level::WARN,
1406             { $($k).+ = $($field)*}
1407         )
1408     );
1409     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1410         $crate::event!(
1411             target: module_path!(),
1412             parent: $parent,
1413             $crate::Level::WARN,
1414             { ?$($k).+ = $($field)*}
1415         )
1416     );
1417     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1418         $crate::event!(
1419             target: module_path!(),
1420             parent: $parent,
1421             $crate::Level::WARN,
1422             { %$($k).+ = $($field)*}
1423         )
1424     );
1425     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1426         $crate::event!(
1427             target: module_path!(),
1428             parent: $parent,
1429             $crate::Level::WARN,
1430             { $($k).+, $($field)*}
1431         )
1432     );
1433     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1434         $crate::event!(
1435             target: module_path!(),
1436             parent: $parent,
1437             $crate::Level::WARN,
1438             { ?$($k).+, $($field)*}
1439         )
1440     );
1441     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1442         $crate::event!(
1443             target: module_path!(),
1444             parent: $parent,
1445             $crate::Level::WARN,
1446             { %$($k).+, $($field)*}
1447         )
1448     );
1449     (parent: $parent:expr, $($arg:tt)+) => (
1450         $crate::event!(
1451             target: module_path!(),
1452             parent: $parent,
1453             $crate::Level::WARN,
1454             {},
1455             $($arg)+
1456         )
1457     );
1458     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1459         $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
1460     );
1461     (target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
1462         $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
1463     );
1464     (target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1465         $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
1466     );
1467     (target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
1468         $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
1469     );
1470     (target: $target:expr, $($arg:tt)+ ) => (
1471         $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+)
1472     );
1473     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1474         $crate::event!(
1475             target: module_path!(),
1476             $crate::Level::WARN,
1477             { $($field)+ },
1478             $($arg)+
1479         )
1480     );
1481     ($($k:ident).+ = $($field:tt)*) => (
1482         $crate::event!(
1483             target: module_path!(),
1484             $crate::Level::WARN,
1485             { $($k).+ = $($field)*}
1486         )
1487     );
1488     (?$($k:ident).+ = $($field:tt)*) => (
1489         $crate::event!(
1490             target: module_path!(),
1491             $crate::Level::WARN,
1492             { ?$($k).+ = $($field)*}
1493         )
1494     );
1495     (%$($k:ident).+ = $($field:tt)*) => (
1496         $crate::event!(
1497             target: module_path!(),
1498             $crate::Level::TRACE,
1499             { %$($k).+ = $($field)*}
1500         )
1501     );
1502     ($($k:ident).+, $($field:tt)*) => (
1503         $crate::event!(
1504             target: module_path!(),
1505             $crate::Level::WARN,
1506             { $($k).+, $($field)*}
1507         )
1508     );
1509     (?$($k:ident).+, $($field:tt)*) => (
1510         $crate::event!(
1511             target: module_path!(),
1512             $crate::Level::WARN,
1513             { ?$($k).+, $($field)*}
1514         )
1515     );
1516     (%$($k:ident).+, $($field:tt)*) => (
1517         $crate::event!(
1518             target: module_path!(),
1519             $crate::Level::WARN,
1520             { %$($k).+, $($field)*}
1521         )
1522     );
1523     (?$($k:ident).+) => (
1524         $crate::event!(
1525             target: module_path!(),
1526             $crate::Level::WARN,
1527             { ?$($k).+ }
1528         )
1529     );
1530     (%$($k:ident).+) => (
1531         $crate::event!(
1532             target: module_path!(),
1533             $crate::Level::WARN,
1534             { %$($k).+ }
1535         )
1536     );
1537     ($($k:ident).+) => (
1538         $crate::event!(
1539             target: module_path!(),
1540             $crate::Level::WARN,
1541             { $($k).+ }
1542         )
1543     );
1544     ($($arg:tt)+) => (
1545         $crate::event!(
1546             target: module_path!(),
1547             $crate::Level::WARN,
1548             {},
1549             $($arg)+
1550         )
1551     );
1552 }
1553
1554 /// Constructs an event at the error level.
1555 ///
1556 /// This functions similarly to the [`event!`] macro. See [the top-level
1557 /// documentation][lib] for details on the syntax accepted by
1558 /// this macro.
1559 ///
1560 /// [`event!`]: macro.event.html
1561 /// [lib]: index.html#using-the-macros
1562 ///
1563 /// # Examples
1564 ///
1565 /// ```rust
1566 /// use tracing::error;
1567 /// # fn main() {
1568 ///
1569 /// let (err_info, port) = ("No connection", 22);
1570 ///
1571 /// error!(port, error = %err_info);
1572 /// error!(target: "app_events", "App Error: {}", err_info);
1573 /// error!({ info = err_info }, "error on port: {}", port);
1574 /// # }
1575 /// ```
1576 #[macro_export]
1577 macro_rules! error {
1578      (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1579         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
1580     );
1581     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
1582         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1583     );
1584     (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1585         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1586     );
1587     (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
1588         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
1589     );
1590     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
1591         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
1592     );
1593     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
1594         $crate::event!(
1595             target: module_path!(),
1596             parent: $parent,
1597             $crate::Level::ERROR,
1598             { $($field)+ },
1599             $($arg)+
1600         )
1601     );
1602     (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
1603         $crate::event!(
1604             target: module_path!(),
1605             parent: $parent,
1606             $crate::Level::ERROR,
1607             { $($k).+ = $($field)*}
1608         )
1609     );
1610     (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
1611         $crate::event!(
1612             target: module_path!(),
1613             parent: $parent,
1614             $crate::Level::ERROR,
1615             { ?$($k).+ = $($field)*}
1616         )
1617     );
1618     (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
1619         $crate::event!(
1620             target: module_path!(),
1621             parent: $parent,
1622             $crate::Level::ERROR,
1623             { %$($k).+ = $($field)*}
1624         )
1625     );
1626     (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
1627         $crate::event!(
1628             target: module_path!(),
1629             parent: $parent,
1630             $crate::Level::ERROR,
1631             { $($k).+, $($field)*}
1632         )
1633     );
1634     (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
1635         $crate::event!(
1636             target: module_path!(),
1637             parent: $parent,
1638             $crate::Level::ERROR,
1639             { ?$($k).+, $($field)*}
1640         )
1641     );
1642     (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
1643         $crate::event!(
1644             target: module_path!(),
1645             parent: $parent,
1646             $crate::Level::ERROR,
1647             { %$($k).+, $($field)*}
1648         )
1649     );
1650     (parent: $parent:expr, $($arg:tt)+) => (
1651         $crate::event!(
1652             target: module_path!(),
1653             parent: $parent,
1654             $crate::Level::ERROR,
1655             {},
1656             $($arg)+
1657         )
1658     );
1659     (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
1660         $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
1661     );
1662     (target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
1663         $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
1664     );
1665     (target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
1666         $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
1667     );
1668     (target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
1669         $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
1670     );
1671     (target: $target:expr, $($arg:tt)+ ) => (
1672         $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
1673     );
1674     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
1675         $crate::event!(
1676             target: module_path!(),
1677             $crate::Level::ERROR,
1678             { $($field)+ },
1679             $($arg)+
1680         )
1681     );
1682     ($($k:ident).+ = $($field:tt)*) => (
1683         $crate::event!(
1684             target: module_path!(),
1685             $crate::Level::ERROR,
1686             { $($k).+ = $($field)*}
1687         )
1688     );
1689     (?$($k:ident).+ = $($field:tt)*) => (
1690         $crate::event!(
1691             target: module_path!(),
1692             $crate::Level::ERROR,
1693             { ?$($k).+ = $($field)*}
1694         )
1695     );
1696     (%$($k:ident).+ = $($field:tt)*) => (
1697         $crate::event!(
1698             target: module_path!(),
1699             $crate::Level::TRACE,
1700             { %$($k).+ = $($field)*}
1701         )
1702     );
1703     ($($k:ident).+, $($field:tt)*) => (
1704         $crate::event!(
1705             target: module_path!(),
1706             $crate::Level::ERROR,
1707             { $($k).+, $($field)*}
1708         )
1709     );
1710     (?$($k:ident).+, $($field:tt)*) => (
1711         $crate::event!(
1712             target: module_path!(),
1713             $crate::Level::ERROR,
1714             { ?$($k).+, $($field)*}
1715         )
1716     );
1717     (%$($k:ident).+, $($field:tt)*) => (
1718         $crate::event!(
1719             target: module_path!(),
1720             $crate::Level::ERROR,
1721             { %$($k).+, $($field)*}
1722         )
1723     );
1724     (?$($k:ident).+) => (
1725         $crate::event!(
1726             target: module_path!(),
1727             $crate::Level::ERROR,
1728             { ?$($k).+ }
1729         )
1730     );
1731     (%$($k:ident).+) => (
1732         $crate::event!(
1733             target: module_path!(),
1734             $crate::Level::ERROR,
1735             { %$($k).+ }
1736         )
1737     );
1738     ($($k:ident).+) => (
1739         $crate::event!(
1740             target: module_path!(),
1741             $crate::Level::ERROR,
1742             { $($k).+ }
1743         )
1744     );
1745     ($($arg:tt)+) => (
1746         $crate::event!(
1747             target: module_path!(),
1748             $crate::Level::ERROR,
1749             {},
1750             $($arg)+
1751         )
1752     );
1753 }
1754
1755 /// Constructs a new static callsite for a span or event.
1756 #[doc(hidden)]
1757 #[macro_export]
1758 macro_rules! callsite {
1759     (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{
1760         $crate::callsite! {
1761             name: $name,
1762             kind: $kind,
1763             target: module_path!(),
1764             level: $crate::Level::TRACE,
1765             fields: $($fields)*
1766         }
1767     }};
1768     (
1769         name: $name:expr,
1770         kind: $kind:expr,
1771         level: $lvl:expr,
1772         fields: $($fields:tt)*
1773     ) => {{
1774         $crate::callsite! {
1775             name: $name,
1776             kind: $kind,
1777             target: module_path!(),
1778             level: $lvl,
1779             fields: $($fields)*
1780         }
1781     }};
1782     (
1783         name: $name:expr,
1784         kind: $kind:expr,
1785         target: $target:expr,
1786         level: $lvl:expr,
1787         fields: $($fields:tt)*
1788     ) => {{
1789         use $crate::__macro_support::MacroCallsite;
1790         static META: $crate::Metadata<'static> = {
1791             $crate::metadata! {
1792                 name: $name,
1793                 target: $target,
1794                 level: $lvl,
1795                 fields: $crate::fieldset!( $($fields)* ),
1796                 callsite: &CALLSITE,
1797                 kind: $kind,
1798             }
1799         };
1800         static CALLSITE: MacroCallsite = MacroCallsite::new(&META);
1801         CALLSITE.register();
1802         &CALLSITE
1803     }};
1804 }
1805
1806 #[macro_export]
1807 // TODO: determine if this ought to be public API?`
1808 #[doc(hidden)]
1809 macro_rules! level_enabled {
1810     ($lvl:expr) => {
1811         $lvl <= $crate::level_filters::STATIC_MAX_LEVEL
1812             && $lvl <= $crate::level_filters::LevelFilter::current()
1813     };
1814 }
1815
1816 #[doc(hidden)]
1817 #[macro_export]
1818 macro_rules! valueset {
1819
1820     // === base case ===
1821     (@ { $(,)* $($val:expr),* $(,)* }, $next:expr $(,)*) => {
1822         &[ $($val),* ]
1823     };
1824
1825     // === recursive case (more tts) ===
1826
1827     // TODO(#1138): determine a new syntax for uninitialized span fields, and
1828     // re-enable this.
1829     // (@{ $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = _, $($rest:tt)*) => {
1830     //     $crate::valueset!(@ { $($out),*, (&$next, None) }, $next, $($rest)*)
1831     // };
1832     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
1833         $crate::valueset!(
1834             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
1835             $next,
1836             $($rest)*
1837         )
1838     };
1839     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
1840         $crate::valueset!(
1841             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
1842             $next,
1843             $($rest)*
1844         )
1845     };
1846     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr, $($rest:tt)*) => {
1847         $crate::valueset!(
1848             @ { $($out),*, (&$next, Some(&$val as &Value)) },
1849             $next,
1850             $($rest)*
1851         )
1852     };
1853     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+, $($rest:tt)*) => {
1854         $crate::valueset!(
1855             @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) },
1856             $next,
1857             $($rest)*
1858         )
1859     };
1860     (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+, $($rest:tt)*) => {
1861         $crate::valueset!(
1862             @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) },
1863             $next,
1864             $($rest)*
1865         )
1866     };
1867     (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+, $($rest:tt)*) => {
1868         $crate::valueset!(
1869             @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) },
1870             $next,
1871             $($rest)*
1872         )
1873     };
1874     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr) => {
1875         $crate::valueset!(
1876             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
1877             $next,
1878         )
1879     };
1880     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr) => {
1881         $crate::valueset!(
1882             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
1883             $next,
1884         )
1885     };
1886     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr) => {
1887         $crate::valueset!(
1888             @ { $($out),*, (&$next, Some(&$val as &Value)) },
1889             $next,
1890         )
1891     };
1892     (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+) => {
1893         $crate::valueset!(
1894             @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) },
1895             $next,
1896         )
1897     };
1898     (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+) => {
1899         $crate::valueset!(
1900             @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) },
1901             $next,
1902         )
1903     };
1904     (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+) => {
1905         $crate::valueset!(
1906             @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) },
1907             $next,
1908         )
1909     };
1910
1911     // Handle literal names
1912     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr, $($rest:tt)*) => {
1913         $crate::valueset!(
1914             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
1915             $next,
1916             $($rest)*
1917         )
1918     };
1919     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr, $($rest:tt)*) => {
1920         $crate::valueset!(
1921             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
1922             $next,
1923             $($rest)*
1924         )
1925     };
1926     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr, $($rest:tt)*) => {
1927         $crate::valueset!(
1928             @ { $($out),*, (&$next, Some(&$val as &Value)) },
1929             $next,
1930             $($rest)*
1931         )
1932     };
1933     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr) => {
1934         $crate::valueset!(
1935             @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) },
1936             $next,
1937         )
1938     };
1939     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr) => {
1940         $crate::valueset!(
1941             @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) },
1942             $next,
1943         )
1944     };
1945     (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr) => {
1946         $crate::valueset!(
1947             @ { $($out),*, (&$next, Some(&$val as &Value)) },
1948             $next,
1949         )
1950     };
1951
1952     // Remainder is unparseable, but exists --- must be format args!
1953     (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => {
1954         $crate::valueset!(@ { (&$next, Some(&format_args!($($rest)+) as &Value)), $($out),* }, $next, )
1955     };
1956
1957     // === entry ===
1958     ($fields:expr, $($kvs:tt)+) => {
1959         {
1960             #[allow(unused_imports)]
1961             use $crate::field::{debug, display, Value};
1962             let mut iter = $fields.iter();
1963             $fields.value_set($crate::valueset!(
1964                 @ { },
1965                 iter.next().expect("FieldSet corrupted (this is a bug)"),
1966                 $($kvs)+
1967             ))
1968         }
1969     };
1970     ($fields:expr,) => {
1971         {
1972             $fields.value_set(&[])
1973         }
1974     };
1975 }
1976
1977 #[doc(hidden)]
1978 #[macro_export]
1979 macro_rules! fieldset {
1980     // == base case ==
1981     (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => {
1982         &[ $($out),* ]
1983     };
1984
1985     // == recursive cases (more tts) ==
1986     (@ { $(,)* $($out:expr),* } $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
1987         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
1988     };
1989     (@ { $(,)* $($out:expr),* } $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
1990         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
1991     };
1992     (@ { $(,)* $($out:expr),* } $($k:ident).+ = $val:expr, $($rest:tt)*) => {
1993         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
1994     };
1995     // TODO(#1138): determine a new syntax for uninitialized span fields, and
1996     // re-enable this.
1997     // (@ { $($out:expr),* } $($k:ident).+ = _, $($rest:tt)*) => {
1998     //     $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
1999     // };
2000     (@ { $(,)* $($out:expr),* } ?$($k:ident).+, $($rest:tt)*) => {
2001         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2002     };
2003     (@ { $(,)* $($out:expr),* } %$($k:ident).+, $($rest:tt)*) => {
2004         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2005     };
2006     (@ { $(,)* $($out:expr),* } $($k:ident).+, $($rest:tt)*) => {
2007         $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*)
2008     };
2009
2010     // Handle literal names
2011     (@ { $(,)* $($out:expr),* } $k:literal = ?$val:expr, $($rest:tt)*) => {
2012         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2013     };
2014     (@ { $(,)* $($out:expr),* } $k:literal = %$val:expr, $($rest:tt)*) => {
2015         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2016     };
2017     (@ { $(,)* $($out:expr),* } $k:literal = $val:expr, $($rest:tt)*) => {
2018         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
2019     };
2020
2021     // Remainder is unparseable, but exists --- must be format args!
2022     (@ { $(,)* $($out:expr),* } $($rest:tt)+) => {
2023         $crate::fieldset!(@ { "message", $($out),*, })
2024     };
2025
2026     // == entry ==
2027     ($($args:tt)*) => {
2028         $crate::fieldset!(@ { } $($args)*,)
2029     };
2030
2031 }
2032
2033 #[cfg(feature = "log")]
2034 #[doc(hidden)]
2035 #[macro_export]
2036 macro_rules! level_to_log {
2037     ($level:expr) => {
2038         match *$level {
2039             $crate::Level::ERROR => $crate::log::Level::Error,
2040             $crate::Level::WARN => $crate::log::Level::Warn,
2041             $crate::Level::INFO => $crate::log::Level::Info,
2042             $crate::Level::DEBUG => $crate::log::Level::Debug,
2043             _ => $crate::log::Level::Trace,
2044         }
2045     };
2046 }
2047
2048 #[doc(hidden)]
2049 #[macro_export]
2050 macro_rules! __tracing_stringify {
2051     ($s:expr) => {
2052         stringify!($s)
2053     };
2054 }
2055
2056 #[cfg(not(feature = "log"))]
2057 #[doc(hidden)]
2058 #[macro_export]
2059 macro_rules! __tracing_log {
2060     (target: $target:expr, $level:expr, $($field:tt)+ ) => {};
2061 }
2062
2063 #[cfg(not(feature = "log"))]
2064 #[doc(hidden)]
2065 #[macro_export]
2066 macro_rules! __tracing_mk_span {
2067     (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
2068         {
2069             if $crate::level_enabled!($lvl) {
2070                 use $crate::__macro_support::*;
2071                 let callsite = $crate::callsite! {
2072                     name: $name,
2073                     kind: $crate::metadata::Kind::SPAN,
2074                     target: $target,
2075                     level: $lvl,
2076                     fields: $($fields)*
2077                 };
2078                 if callsite.is_enabled() {
2079                     let meta = callsite.metadata();
2080                     $crate::Span::child_of(
2081                         $parent,
2082                         meta,
2083                         &$crate::valueset!(meta.fields(), $($fields)*),
2084                     )
2085                 } else {
2086                     $crate::Span::none()
2087                 }
2088             } else {
2089                 $crate::Span::none()
2090             }
2091         }
2092     };
2093     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
2094         {
2095             if $crate::level_enabled!($lvl) {
2096                 use $crate::__macro_support::*;
2097                 let callsite = $crate::callsite! {
2098                     name: $name,
2099                     kind: $crate::metadata::Kind::SPAN,
2100                     target: $target,
2101                     level: $lvl,
2102                     fields: $($fields)*
2103                 };
2104                 if callsite.is_enabled() {
2105                     let meta = callsite.metadata();
2106                     $crate::Span::new(
2107                         meta,
2108                         &$crate::valueset!(meta.fields(), $($fields)*),
2109                     )
2110                 } else {
2111                     $crate::Span::none()
2112                 }
2113             } else {
2114                 $crate::Span::none()
2115             }
2116         }
2117     };
2118 }
2119
2120 #[cfg(feature = "log")]
2121 #[doc(hidden)]
2122 #[macro_export]
2123 macro_rules! __tracing_mk_span {
2124     (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
2125         {
2126             use $crate::callsite::Callsite;
2127             let callsite = $crate::callsite! {
2128                 name: $name,
2129                 kind: $crate::metadata::Kind::SPAN,
2130                 target: $target,
2131                 level: $lvl,
2132                 fields: $($fields)*
2133             };
2134             let meta = callsite.metadata();
2135             if $crate::level_enabled!($lvl) && callsite.is_enabled() {
2136                 $crate::Span::child_of(
2137                     $parent,
2138                     meta,
2139                     &$crate::valueset!(meta.fields(), $($fields)*),
2140                 )
2141             } else {
2142                 $crate::if_log_enabled! {{
2143                     let span = $crate::Span::new_disabled(meta);
2144                     span.record_all(&$crate::valueset!(meta.fields(), $($fields)*));
2145                     span
2146                 } else {
2147                     $crate::Span::none()
2148                 }}
2149             }
2150         }
2151     };
2152     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
2153         {
2154             use $crate::callsite::Callsite;
2155             let callsite = $crate::callsite! {
2156                 name: $name,
2157                 kind: $crate::metadata::Kind::SPAN,
2158                 target: $target,
2159                 level: $lvl,
2160                 fields: $($fields)*
2161             };
2162             let meta = callsite.metadata();
2163             if $crate::level_enabled!($lvl) && callsite.is_enabled() {
2164                 $crate::Span::new(
2165                     meta,
2166                     &$crate::valueset!(meta.fields(), $($fields)*),
2167                 )
2168             } else {
2169                 $crate::if_log_enabled! {{
2170                     let span = $crate::Span::new_disabled(meta);
2171                     span.record_all(&$crate::valueset!(meta.fields(), $($fields)*));
2172                     span
2173                 } else {
2174                     $crate::Span::none()
2175                 }}
2176             }
2177         }
2178     };
2179 }
2180
2181 #[cfg(feature = "log")]
2182 #[doc(hidden)]
2183 #[macro_export]
2184 macro_rules! __mk_format_string {
2185     // === base case ===
2186     (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => {
2187         concat!( $($out),*)
2188     };
2189
2190     // === recursive case (more tts), ===
2191     // ====== shorthand field syntax ===
2192     (@ { $(,)* $($out:expr),* }, ?$($k:ident).+, $($rest:tt)*) => {
2193         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($rest)*)
2194     };
2195     (@ { $(,)* $($out:expr),* }, %$($k:ident).+, $($rest:tt)*) => {
2196         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={} " }, $($rest)*)
2197     };
2198     (@ { $(,)* $($out:expr),* }, $($k:ident).+, $($rest:tt)*) => {
2199         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($rest)*)
2200     };
2201     // ====== kv field syntax ===
2202     (@ { $(,)* $($out:expr),* }, message = $val:expr, $($rest:tt)*) => {
2203         $crate::__mk_format_string!(@ { $($out),*, "{} " }, $($rest)*)
2204     };
2205     (@ { $(,)* $($out:expr),* }, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => {
2206         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($rest)*)
2207     };
2208     (@ { $(,)* $($out:expr),* }, $($k:ident).+ = %$val:expr, $($rest:tt)*) => {
2209         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={} " }, $($rest)*)
2210     };
2211     (@ { $(,)* $($out:expr),* }, $($k:ident).+ = $val:expr, $($rest:tt)*) => {
2212         $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($rest)*)
2213     };
2214
2215     // === rest is unparseable --- must be fmt args ===
2216     (@ { $(,)* $($out:expr),* }, $($rest:tt)+) => {
2217         $crate::__mk_format_string!(@ { "{} ", $($out),* }, )
2218     };
2219
2220     // === entry ===
2221     ($($kvs:tt)+) => {
2222         $crate::__mk_format_string!(@ { }, $($kvs)+,)
2223     };
2224     () => {
2225         ""
2226     }
2227 }
2228
2229 #[cfg(feature = "log")]
2230 #[doc(hidden)]
2231 #[macro_export]
2232 macro_rules! __mk_format_args {
2233     // === finished --- called into by base cases ===
2234     (@ { $(,)* $($out:expr),* $(,)* }, $fmt:expr, fields: $(,)*) => {
2235         format_args!($fmt, $($out),*)
2236     };
2237
2238     // === base case (no more tts) ===
2239     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = ?$val:expr $(,)*) => {
2240         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: )
2241     };
2242     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = %$val:expr $(,)*) => {
2243         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: )
2244     };
2245     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = $val:expr $(,)*) => {
2246         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: )
2247     };
2248     // ====== shorthand field syntax ===
2249     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: ?$($k:ident).+ $(,)*) => {
2250         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields:)
2251     };
2252     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: %$($k:ident).+ $(,)*) => {
2253         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: )
2254     };
2255     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ $(,)*) => {
2256         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: )
2257     };
2258
2259     // === recursive case (more tts) ===
2260     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = ?$val:expr, $($rest:tt)+) => {
2261         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: $($rest)+)
2262     };
2263     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = %$val:expr, $($rest:tt)+) => {
2264         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: $($rest)+)
2265     };
2266     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = $val:expr, $($rest:tt)+) => {
2267         $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: $($rest)+)
2268     };
2269     // ====== shorthand field syntax ===
2270     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: ?$($k:ident).+, $($rest:tt)+) => {
2271         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: $($rest)+)
2272     };
2273     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: %$($k:ident).+, $($rest:tt)+) => {
2274         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: $($rest)+)
2275     };
2276     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+, $($rest:tt)+) => {
2277         $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: $($rest)+)
2278     };
2279
2280     // === rest is unparseable --- must be fmt args ===
2281     (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($rest:tt)+) => {
2282         $crate::__mk_format_args!(@ { format_args!($($rest)+), $($out),* }, $fmt, fields: )
2283     };
2284
2285     // === entry ===
2286     ($($kv:tt)*) => {
2287         {
2288             #[allow(unused_imports)]
2289             use $crate::field::{debug, display};
2290             // use $crate::__mk_format_string;
2291             $crate::__mk_format_args!(@ { }, $crate::__mk_format_string!($($kv)*), fields: $($kv)*)
2292         }
2293     };
2294 }
2295
2296 #[cfg(feature = "log")]
2297 #[doc(hidden)]
2298 #[macro_export]
2299 macro_rules! __tracing_log {
2300     (target: $target:expr, $level:expr, $($field:tt)+ ) => {
2301         $crate::if_log_enabled! {{
2302             use $crate::log;
2303             let level = $crate::level_to_log!(&$level);
2304             if level <= log::STATIC_MAX_LEVEL && level <= log::max_level() {
2305                 let log_meta = log::Metadata::builder()
2306                     .level(level)
2307                     .target($target)
2308                     .build();
2309                 let logger = log::logger();
2310                 if logger.enabled(&log_meta) {
2311                     logger.log(&log::Record::builder()
2312                         .file(Some(file!()))
2313                         .module_path(Some(module_path!()))
2314                         .line(Some(line!()))
2315                         .metadata(log_meta)
2316                         .args($crate::__mk_format_args!($($field)+))
2317                         .build());
2318                 }
2319             }
2320         }}
2321     };
2322 }
2323
2324 #[cfg(not(feature = "log"))]
2325 #[doc(hidden)]
2326 #[macro_export]
2327 macro_rules! if_log_enabled {
2328     ($e:expr;) => {
2329         $crate::if_log_enabled! { $e }
2330     };
2331     ($if_log:block) => {
2332         $crate::if_log_enabled! { $if_log else {} }
2333     };
2334     ($if_log:block else $else_block:block) => {
2335         $else_block
2336     };
2337 }
2338
2339 #[cfg(all(feature = "log", not(feature = "log-always")))]
2340 #[doc(hidden)]
2341 #[macro_export]
2342 macro_rules! if_log_enabled {
2343     ($e:expr;) => {
2344         $crate::if_log_enabled! { $e }
2345     };
2346     ($if_log:block) => {
2347         $crate::if_log_enabled! { $if_log else {} }
2348     };
2349     ($if_log:block else $else_block:block) => {
2350         if !$crate::dispatcher::has_been_set() {
2351             $if_log
2352         } else {
2353             $else_block
2354         }
2355     };
2356 }
2357
2358 #[cfg(all(feature = "log", feature = "log-always"))]
2359 #[doc(hidden)]
2360 #[macro_export]
2361 macro_rules! if_log_enabled {
2362     ($e:expr;) => {
2363         $crate::if_log_enabled! { $e }
2364     };
2365     ($if_log:block) => {
2366         $crate::if_log_enabled! { $if_log else {} }
2367     };
2368     ($if_log:block else $else_block:block) => {
2369         #[allow(unused_braces)]
2370         $if_log
2371     };
2372 }