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