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, { $($fields:tt)* }, $($arg:tt)+ ) => ( 688 $crate::event!( 689 target: module_path!(), 690 $lvl, 691 parent: $parent, 692 { message = format_args!($($arg)+), $($fields)* } 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, ?$($k:ident).+, $($field:tt)*) => ( 736 $crate::event!( 737 target: module_path!(), 738 parent: $parent, 739 $lvl, 740 { ?$($k).+, $($field)*} 741 ) 742 ); 743 (parent: $parent:expr, $lvl:expr, $($arg:tt)+ ) => ( 744 $crate::event!(target: module_path!(), parent: $parent, $lvl, { $($arg)+ }) 745 ); 746 ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => ( 747 $crate::event!( 748 target: module_path!(), 749 $lvl, 750 { message = format_args!($($arg)+), $($fields)* } 751 ) 752 ); 753 ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => ( 754 $crate::event!( 755 target: module_path!(), 756 $lvl, 757 { message = format_args!($($arg)+), $($fields)* } 758 ) 759 ); 760 ($lvl:expr, $($k:ident).+ = $($field:tt)*) => ( 761 $crate::event!( 762 target: module_path!(), 763 $lvl, 764 { $($k).+ = $($field)*} 765 ) 766 ); 767 ($lvl:expr, $($k:ident).+, $($field:tt)*) => ( 768 $crate::event!( 769 target: module_path!(), 770 $lvl, 771 { $($k).+, $($field)*} 772 ) 773 ); 774 ($lvl:expr, ?$($k:ident).+, $($field:tt)*) => ( 775 $crate::event!( 776 target: module_path!(), 777 $lvl, 778 { ?$($k).+, $($field)*} 779 ) 780 ); 781 ($lvl:expr, %$($k:ident).+, $($field:tt)*) => ( 782 $crate::event!( 783 target: module_path!(), 784 $lvl, 785 { %$($k).+, $($field)*} 786 ) 787 ); 788 ($lvl:expr, ?$($k:ident).+) => ( 789 $crate::event!($lvl, ?$($k).+,) 790 ); 791 ($lvl:expr, %$($k:ident).+) => ( 792 $crate::event!($lvl, %$($k).+,) 793 ); 794 ($lvl:expr, $($k:ident).+) => ( 795 $crate::event!($lvl, $($k).+,) 796 ); 797 ( $lvl:expr, $($arg:tt)+ ) => ( 798 $crate::event!(target: module_path!(), $lvl, { $($arg)+ }) 799 ); 800 } 801 802 /// Constructs an event at the trace level. 803 /// 804 /// This functions similarly to the [`event!`] macro. See [the top-level 805 /// documentation][lib] for details on the syntax accepted by 806 /// this macro. 807 /// 808 /// [`event!`]: macro.event.html 809 /// [lib]: index.html#using-the-macros 810 /// 811 /// # Examples 812 /// 813 /// ```rust 814 /// use tracing::trace; 815 /// # #[derive(Debug, Copy, Clone)] struct Position { x: f32, y: f32 } 816 /// # impl Position { 817 /// # const ORIGIN: Self = Self { x: 0.0, y: 0.0 }; 818 /// # fn dist(&self, other: Position) -> f32 { 819 /// # let x = (other.x - self.x).exp2(); let y = (self.y - other.y).exp2(); 820 /// # (x + y).sqrt() 821 /// # } 822 /// # } 823 /// # fn main() { 824 /// let pos = Position { x: 3.234, y: -1.223 }; 825 /// let origin_dist = pos.dist(Position::ORIGIN); 826 /// 827 /// trace!(position = ?pos, ?origin_dist); 828 /// trace!( 829 /// target: "app_events", 830 /// position = ?pos, 831 /// "x is {} and y is {}", 832 /// if pos.x >= 0.0 { "positive" } else { "negative" }, 833 /// if pos.y >= 0.0 { "positive" } else { "negative" } 834 /// ); 835 /// # } 836 /// ``` 837 #[macro_export] 838 macro_rules! trace { 839 (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 840 $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*) 841 ); 842 (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => ( 843 $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ }) 844 ); 845 (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => ( 846 $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ }) 847 ); 848 (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => ( 849 $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ }) 850 ); 851 (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => ( 852 $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+) 853 ); 854 (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => ( 855 $crate::event!( 856 target: module_path!(), 857 parent: $parent, 858 $crate::Level::TRACE, 859 { $($field)+ }, 860 $($arg)+ 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, %$($k:ident).+, $($field:tt)*) => ( 904 $crate::event!( 905 target: module_path!(), 906 parent: $parent, 907 $crate::Level::TRACE, 908 { %$($k).+, $($field)*} 909 ) 910 ); 911 (parent: $parent:expr, $($arg:tt)+) => ( 912 $crate::event!( 913 target: module_path!(), 914 parent: $parent, 915 $crate::Level::TRACE, 916 {}, 917 $($arg)+ 918 ) 919 ); 920 (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 921 $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*) 922 ); 923 (target: $target:expr, $($k:ident).+ $($field:tt)* ) => ( 924 $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)* }) 925 ); 926 (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => ( 927 $crate::event!(target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* }) 928 ); 929 (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => ( 930 $crate::event!(target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* }) 931 ); 932 (target: $target:expr, $($arg:tt)+ ) => ( 933 $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+) 934 ); 935 ({ $($field:tt)+ }, $($arg:tt)+ ) => ( 936 $crate::event!( 937 target: module_path!(), 938 $crate::Level::TRACE, 939 { $($field)+ }, 940 $($arg)+ 941 ) 942 ); 943 ($($k:ident).+ = $($field:tt)*) => ( 944 $crate::event!( 945 target: module_path!(), 946 $crate::Level::TRACE, 947 { $($k).+ = $($field)*} 948 ) 949 ); 950 ($($k:ident).+, $($field:tt)*) => ( 951 $crate::event!( 952 target: module_path!(), 953 $crate::Level::TRACE, 954 { $($k).+, $($field)*} 955 ) 956 ); 957 (?$($k:ident).+, $($field:tt)*) => ( 958 $crate::event!( 959 target: module_path!(), 960 $crate::Level::TRACE, 961 { ?$($k).+, $($field)*} 962 ) 963 ); 964 (%$($k:ident).+, $($field:tt)*) => ( 965 $crate::event!( 966 target: module_path!(), 967 $crate::Level::TRACE, 968 { %$($k).+, $($field)*} 969 ) 970 ); 971 (?$($k:ident).+) => ( 972 $crate::event!( 973 target: module_path!(), 974 $crate::Level::TRACE, 975 { ?$($k).+ } 976 ) 977 ); 978 (%$($k:ident).+) => ( 979 $crate::event!( 980 target: module_path!(), 981 $crate::Level::TRACE, 982 { %$($k).+ } 983 ) 984 ); 985 ($($k:ident).+) => ( 986 $crate::event!( 987 target: module_path!(), 988 $crate::Level::TRACE, 989 { $($k).+ } 990 ) 991 ); 992 ($($arg:tt)+) => ( 993 $crate::event!( 994 target: module_path!(), 995 $crate::Level::TRACE, 996 {}, 997 $($arg)+ 998 ) 999 ); 1000 } 1001 1002 /// Constructs an event at the debug level. 1003 /// 1004 /// This functions similarly to the [`event!`] macro. See [the top-level 1005 /// documentation][lib] for details on the syntax accepted by 1006 /// this macro. 1007 /// 1008 /// [`event!`]: macro.event.html 1009 /// [lib]: index.html#using-the-macros 1010 /// 1011 /// # Examples 1012 /// 1013 /// ```rust 1014 /// use tracing::debug; 1015 /// # fn main() { 1016 /// # #[derive(Debug)] struct Position { x: f32, y: f32 } 1017 /// 1018 /// let pos = Position { x: 3.234, y: -1.223 }; 1019 /// 1020 /// debug!(?pos.x, ?pos.y); 1021 /// debug!(target: "app_events", position = ?pos, "New position"); 1022 /// # } 1023 /// ``` 1024 #[macro_export] 1025 macro_rules! debug { 1026 (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1027 $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*) 1028 ); 1029 (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => ( 1030 $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ }) 1031 ); 1032 (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => ( 1033 $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ }) 1034 ); 1035 (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => ( 1036 $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ }) 1037 ); 1038 (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => ( 1039 $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+) 1040 ); 1041 (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => ( 1042 $crate::event!( 1043 target: module_path!(), 1044 parent: $parent, 1045 $crate::Level::DEBUG, 1046 { $($field)+ }, 1047 $($arg)+ 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, %$($k:ident).+, $($field:tt)*) => ( 1091 $crate::event!( 1092 target: module_path!(), 1093 parent: $parent, 1094 $crate::Level::DEBUG, 1095 { %$($k).+, $($field)*} 1096 ) 1097 ); 1098 (parent: $parent:expr, $($arg:tt)+) => ( 1099 $crate::event!( 1100 target: module_path!(), 1101 parent: $parent, 1102 $crate::Level::DEBUG, 1103 {}, 1104 $($arg)+ 1105 ) 1106 ); 1107 (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1108 $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*) 1109 ); 1110 (target: $target:expr, $($k:ident).+ $($field:tt)* ) => ( 1111 $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* }) 1112 ); 1113 (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => ( 1114 $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* }) 1115 ); 1116 (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => ( 1117 $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* }) 1118 ); 1119 (target: $target:expr, $($arg:tt)+ ) => ( 1120 $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+) 1121 ); 1122 ({ $($field:tt)+ }, $($arg:tt)+ ) => ( 1123 $crate::event!( 1124 target: module_path!(), 1125 $crate::Level::DEBUG, 1126 { $($field)+ }, 1127 $($arg)+ 1128 ) 1129 ); 1130 ($($k:ident).+ = $($field:tt)*) => ( 1131 $crate::event!( 1132 target: module_path!(), 1133 $crate::Level::DEBUG, 1134 { $($k).+ = $($field)*} 1135 ) 1136 ); 1137 (?$($k:ident).+ = $($field:tt)*) => ( 1138 $crate::event!( 1139 target: module_path!(), 1140 $crate::Level::DEBUG, 1141 { ?$($k).+ = $($field)*} 1142 ) 1143 ); 1144 (%$($k:ident).+ = $($field:tt)*) => ( 1145 $crate::event!( 1146 target: module_path!(), 1147 $crate::Level::DEBUG, 1148 { %$($k).+ = $($field)*} 1149 ) 1150 ); 1151 ($($k:ident).+, $($field:tt)*) => ( 1152 $crate::event!( 1153 target: module_path!(), 1154 $crate::Level::DEBUG, 1155 { $($k).+, $($field)*} 1156 ) 1157 ); 1158 (?$($k:ident).+, $($field:tt)*) => ( 1159 $crate::event!( 1160 target: module_path!(), 1161 $crate::Level::DEBUG, 1162 { ?$($k).+, $($field)*} 1163 ) 1164 ); 1165 (%$($k:ident).+, $($field:tt)*) => ( 1166 $crate::event!( 1167 target: module_path!(), 1168 $crate::Level::DEBUG, 1169 { %$($k).+, $($field)*} 1170 ) 1171 ); 1172 (?$($k:ident).+) => ( 1173 $crate::event!( 1174 target: module_path!(), 1175 $crate::Level::DEBUG, 1176 { ?$($k).+ } 1177 ) 1178 ); 1179 (%$($k:ident).+) => ( 1180 $crate::event!( 1181 target: module_path!(), 1182 $crate::Level::DEBUG, 1183 { %$($k).+ } 1184 ) 1185 ); 1186 ($($k:ident).+) => ( 1187 $crate::event!( 1188 target: module_path!(), 1189 $crate::Level::DEBUG, 1190 { $($k).+ } 1191 ) 1192 ); 1193 ($($arg:tt)+) => ( 1194 $crate::event!( 1195 target: module_path!(), 1196 $crate::Level::DEBUG, 1197 {}, 1198 $($arg)+ 1199 ) 1200 ); 1201 } 1202 1203 /// Constructs an event at the info level. 1204 /// 1205 /// This functions similarly to the [`event!`] macro. See [the top-level 1206 /// documentation][lib] for details on the syntax accepted by 1207 /// this macro. 1208 /// 1209 /// [`event!`]: macro.event.html 1210 /// [lib]: index.html#using-the-macros 1211 /// 1212 /// # Examples 1213 /// 1214 /// ```rust 1215 /// use tracing::info; 1216 /// # // this is so the test will still work in no-std mode 1217 /// # #[derive(Debug)] 1218 /// # pub struct Ipv4Addr; 1219 /// # impl Ipv4Addr { fn new(o1: u8, o2: u8, o3: u8, o4: u8) -> Self { Self } } 1220 /// # fn main() { 1221 /// # struct Connection { port: u32, speed: f32 } 1222 /// use tracing::field; 1223 /// 1224 /// let addr = Ipv4Addr::new(127, 0, 0, 1); 1225 /// let conn = Connection { port: 40, speed: 3.20 }; 1226 /// 1227 /// info!(conn.port, "connected to {:?}", addr); 1228 /// info!( 1229 /// target: "connection_events", 1230 /// ip = ?addr, 1231 /// conn.port, 1232 /// ?conn.speed, 1233 /// ); 1234 /// # } 1235 /// ``` 1236 #[macro_export] 1237 macro_rules! info { 1238 (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1239 $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*) 1240 ); 1241 (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => ( 1242 $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ }) 1243 ); 1244 (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => ( 1245 $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ }) 1246 ); 1247 (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => ( 1248 $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ }) 1249 ); 1250 (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => ( 1251 $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+) 1252 ); 1253 (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => ( 1254 $crate::event!( 1255 target: module_path!(), 1256 parent: $parent, 1257 $crate::Level::INFO, 1258 { $($field)+ }, 1259 $($arg)+ 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, %$($k:ident).+, $($field:tt)*) => ( 1303 $crate::event!( 1304 target: module_path!(), 1305 parent: $parent, 1306 $crate::Level::INFO, 1307 { %$($k).+, $($field)*} 1308 ) 1309 ); 1310 (parent: $parent:expr, $($arg:tt)+) => ( 1311 $crate::event!( 1312 target: module_path!(), 1313 parent: $parent, 1314 $crate::Level::INFO, 1315 {}, 1316 $($arg)+ 1317 ) 1318 ); 1319 (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1320 $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*) 1321 ); 1322 (target: $target:expr, $($k:ident).+ $($field:tt)* ) => ( 1323 $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* }) 1324 ); 1325 (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => ( 1326 $crate::event!(target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* }) 1327 ); 1328 (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => ( 1329 $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* }) 1330 ); 1331 (target: $target:expr, $($arg:tt)+ ) => ( 1332 $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+) 1333 ); 1334 ({ $($field:tt)+ }, $($arg:tt)+ ) => ( 1335 $crate::event!( 1336 target: module_path!(), 1337 $crate::Level::INFO, 1338 { $($field)+ }, 1339 $($arg)+ 1340 ) 1341 ); 1342 ($($k:ident).+ = $($field:tt)*) => ( 1343 $crate::event!( 1344 target: module_path!(), 1345 $crate::Level::INFO, 1346 { $($k).+ = $($field)*} 1347 ) 1348 ); 1349 (?$($k:ident).+ = $($field:tt)*) => ( 1350 $crate::event!( 1351 target: module_path!(), 1352 $crate::Level::INFO, 1353 { ?$($k).+ = $($field)*} 1354 ) 1355 ); 1356 (%$($k:ident).+ = $($field:tt)*) => ( 1357 $crate::event!( 1358 target: module_path!(), 1359 $crate::Level::INFO, 1360 { %$($k).+ = $($field)*} 1361 ) 1362 ); 1363 ($($k:ident).+, $($field:tt)*) => ( 1364 $crate::event!( 1365 target: module_path!(), 1366 $crate::Level::INFO, 1367 { $($k).+, $($field)*} 1368 ) 1369 ); 1370 (?$($k:ident).+, $($field:tt)*) => ( 1371 $crate::event!( 1372 target: module_path!(), 1373 $crate::Level::INFO, 1374 { ?$($k).+, $($field)*} 1375 ) 1376 ); 1377 (%$($k:ident).+, $($field:tt)*) => ( 1378 $crate::event!( 1379 target: module_path!(), 1380 $crate::Level::INFO, 1381 { %$($k).+, $($field)*} 1382 ) 1383 ); 1384 (?$($k:ident).+) => ( 1385 $crate::event!( 1386 target: module_path!(), 1387 $crate::Level::INFO, 1388 { ?$($k).+ } 1389 ) 1390 ); 1391 (%$($k:ident).+) => ( 1392 $crate::event!( 1393 target: module_path!(), 1394 $crate::Level::INFO, 1395 { %$($k).+ } 1396 ) 1397 ); 1398 ($($k:ident).+) => ( 1399 $crate::event!( 1400 target: module_path!(), 1401 $crate::Level::INFO, 1402 { $($k).+ } 1403 ) 1404 ); 1405 ($($arg:tt)+) => ( 1406 $crate::event!( 1407 target: module_path!(), 1408 $crate::Level::INFO, 1409 {}, 1410 $($arg)+ 1411 ) 1412 ); 1413 } 1414 1415 /// Constructs an event at the warn level. 1416 /// 1417 /// This functions similarly to the [`event!`] macro. See [the top-level 1418 /// documentation][lib] for details on the syntax accepted by 1419 /// this macro. 1420 /// 1421 /// [`event!`]: macro.event.html 1422 /// [lib]: index.html#using-the-macros 1423 /// 1424 /// # Examples 1425 /// 1426 /// ```rust 1427 /// use tracing::warn; 1428 /// # fn main() { 1429 /// 1430 /// let warn_description = "Invalid Input"; 1431 /// let input = &[0x27, 0x45]; 1432 /// 1433 /// warn!(?input, warning = warn_description); 1434 /// warn!( 1435 /// target: "input_events", 1436 /// warning = warn_description, 1437 /// "Received warning for input: {:?}", input, 1438 /// ); 1439 /// # } 1440 /// ``` 1441 #[macro_export] 1442 macro_rules! warn { 1443 (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1444 $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*) 1445 ); 1446 (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => ( 1447 $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ }) 1448 ); 1449 (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => ( 1450 $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ }) 1451 ); 1452 (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => ( 1453 $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ }) 1454 ); 1455 (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => ( 1456 $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+) 1457 ); 1458 (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => ( 1459 $crate::event!( 1460 target: module_path!(), 1461 parent: $parent, 1462 $crate::Level::WARN, 1463 { $($field)+ }, 1464 $($arg)+ 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, %$($k:ident).+, $($field:tt)*) => ( 1508 $crate::event!( 1509 target: module_path!(), 1510 parent: $parent, 1511 $crate::Level::WARN, 1512 { %$($k).+, $($field)*} 1513 ) 1514 ); 1515 (parent: $parent:expr, $($arg:tt)+) => ( 1516 $crate::event!( 1517 target: module_path!(), 1518 parent: $parent, 1519 $crate::Level::WARN, 1520 {}, 1521 $($arg)+ 1522 ) 1523 ); 1524 (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1525 $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*) 1526 ); 1527 (target: $target:expr, $($k:ident).+ $($field:tt)* ) => ( 1528 $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)* }) 1529 ); 1530 (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => ( 1531 $crate::event!(target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* }) 1532 ); 1533 (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => ( 1534 $crate::event!(target: $target, $crate::Level::WARN, { %$($k).+ $($field)* }) 1535 ); 1536 (target: $target:expr, $($arg:tt)+ ) => ( 1537 $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+) 1538 ); 1539 ({ $($field:tt)+ }, $($arg:tt)+ ) => ( 1540 $crate::event!( 1541 target: module_path!(), 1542 $crate::Level::WARN, 1543 { $($field)+ }, 1544 $($arg)+ 1545 ) 1546 ); 1547 ($($k:ident).+ = $($field:tt)*) => ( 1548 $crate::event!( 1549 target: module_path!(), 1550 $crate::Level::WARN, 1551 { $($k).+ = $($field)*} 1552 ) 1553 ); 1554 (?$($k:ident).+ = $($field:tt)*) => ( 1555 $crate::event!( 1556 target: module_path!(), 1557 $crate::Level::WARN, 1558 { ?$($k).+ = $($field)*} 1559 ) 1560 ); 1561 (%$($k:ident).+ = $($field:tt)*) => ( 1562 $crate::event!( 1563 target: module_path!(), 1564 $crate::Level::TRACE, 1565 { %$($k).+ = $($field)*} 1566 ) 1567 ); 1568 ($($k:ident).+, $($field:tt)*) => ( 1569 $crate::event!( 1570 target: module_path!(), 1571 $crate::Level::WARN, 1572 { $($k).+, $($field)*} 1573 ) 1574 ); 1575 (?$($k:ident).+, $($field:tt)*) => ( 1576 $crate::event!( 1577 target: module_path!(), 1578 $crate::Level::WARN, 1579 { ?$($k).+, $($field)*} 1580 ) 1581 ); 1582 (%$($k:ident).+, $($field:tt)*) => ( 1583 $crate::event!( 1584 target: module_path!(), 1585 $crate::Level::WARN, 1586 { %$($k).+, $($field)*} 1587 ) 1588 ); 1589 (?$($k:ident).+) => ( 1590 $crate::event!( 1591 target: module_path!(), 1592 $crate::Level::WARN, 1593 { ?$($k).+ } 1594 ) 1595 ); 1596 (%$($k:ident).+) => ( 1597 $crate::event!( 1598 target: module_path!(), 1599 $crate::Level::WARN, 1600 { %$($k).+ } 1601 ) 1602 ); 1603 ($($k:ident).+) => ( 1604 $crate::event!( 1605 target: module_path!(), 1606 $crate::Level::WARN, 1607 { $($k).+ } 1608 ) 1609 ); 1610 ($($arg:tt)+) => ( 1611 $crate::event!( 1612 target: module_path!(), 1613 $crate::Level::WARN, 1614 {}, 1615 $($arg)+ 1616 ) 1617 ); 1618 } 1619 1620 /// Constructs an event at the error level. 1621 /// 1622 /// This functions similarly to the [`event!`] macro. See [the top-level 1623 /// documentation][lib] for details on the syntax accepted by 1624 /// this macro. 1625 /// 1626 /// [`event!`]: macro.event.html 1627 /// [lib]: index.html#using-the-macros 1628 /// 1629 /// # Examples 1630 /// 1631 /// ```rust 1632 /// use tracing::error; 1633 /// # fn main() { 1634 /// 1635 /// let (err_info, port) = ("No connection", 22); 1636 /// 1637 /// error!(port, error = %err_info); 1638 /// error!(target: "app_events", "App Error: {}", err_info); 1639 /// error!({ info = err_info }, "error on port: {}", port); 1640 /// # } 1641 /// ``` 1642 #[macro_export] 1643 macro_rules! error { 1644 (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1645 $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*) 1646 ); 1647 (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => ( 1648 $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ }) 1649 ); 1650 (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => ( 1651 $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ }) 1652 ); 1653 (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => ( 1654 $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ }) 1655 ); 1656 (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => ( 1657 $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+) 1658 ); 1659 (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => ( 1660 $crate::event!( 1661 target: module_path!(), 1662 parent: $parent, 1663 $crate::Level::ERROR, 1664 { $($field)+ }, 1665 $($arg)+ 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, %$($k:ident).+, $($field:tt)*) => ( 1709 $crate::event!( 1710 target: module_path!(), 1711 parent: $parent, 1712 $crate::Level::ERROR, 1713 { %$($k).+, $($field)*} 1714 ) 1715 ); 1716 (parent: $parent:expr, $($arg:tt)+) => ( 1717 $crate::event!( 1718 target: module_path!(), 1719 parent: $parent, 1720 $crate::Level::ERROR, 1721 {}, 1722 $($arg)+ 1723 ) 1724 ); 1725 (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => ( 1726 $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*) 1727 ); 1728 (target: $target:expr, $($k:ident).+ $($field:tt)* ) => ( 1729 $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)* }) 1730 ); 1731 (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => ( 1732 $crate::event!(target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* }) 1733 ); 1734 (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => ( 1735 $crate::event!(target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* }) 1736 ); 1737 (target: $target:expr, $($arg:tt)+ ) => ( 1738 $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+) 1739 ); 1740 ({ $($field:tt)+ }, $($arg:tt)+ ) => ( 1741 $crate::event!( 1742 target: module_path!(), 1743 $crate::Level::ERROR, 1744 { $($field)+ }, 1745 $($arg)+ 1746 ) 1747 ); 1748 ($($k:ident).+ = $($field:tt)*) => ( 1749 $crate::event!( 1750 target: module_path!(), 1751 $crate::Level::ERROR, 1752 { $($k).+ = $($field)*} 1753 ) 1754 ); 1755 (?$($k:ident).+ = $($field:tt)*) => ( 1756 $crate::event!( 1757 target: module_path!(), 1758 $crate::Level::ERROR, 1759 { ?$($k).+ = $($field)*} 1760 ) 1761 ); 1762 (%$($k:ident).+ = $($field:tt)*) => ( 1763 $crate::event!( 1764 target: module_path!(), 1765 $crate::Level::ERROR, 1766 { %$($k).+ = $($field)*} 1767 ) 1768 ); 1769 ($($k:ident).+, $($field:tt)*) => ( 1770 $crate::event!( 1771 target: module_path!(), 1772 $crate::Level::ERROR, 1773 { $($k).+, $($field)*} 1774 ) 1775 ); 1776 (?$($k:ident).+, $($field:tt)*) => ( 1777 $crate::event!( 1778 target: module_path!(), 1779 $crate::Level::ERROR, 1780 { ?$($k).+, $($field)*} 1781 ) 1782 ); 1783 (%$($k:ident).+, $($field:tt)*) => ( 1784 $crate::event!( 1785 target: module_path!(), 1786 $crate::Level::ERROR, 1787 { %$($k).+, $($field)*} 1788 ) 1789 ); 1790 (?$($k:ident).+) => ( 1791 $crate::event!( 1792 target: module_path!(), 1793 $crate::Level::ERROR, 1794 { ?$($k).+ } 1795 ) 1796 ); 1797 (%$($k:ident).+) => ( 1798 $crate::event!( 1799 target: module_path!(), 1800 $crate::Level::ERROR, 1801 { %$($k).+ } 1802 ) 1803 ); 1804 ($($k:ident).+) => ( 1805 $crate::event!( 1806 target: module_path!(), 1807 $crate::Level::ERROR, 1808 { $($k).+ } 1809 ) 1810 ); 1811 ($($arg:tt)+) => ( 1812 $crate::event!( 1813 target: module_path!(), 1814 $crate::Level::ERROR, 1815 {}, 1816 $($arg)+ 1817 ) 1818 ); 1819 } 1820 1821 /// Constructs a new static callsite for a span or event. 1822 #[doc(hidden)] 1823 #[macro_export] 1824 macro_rules! callsite { 1825 (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{ 1826 $crate::callsite! { 1827 name: $name, 1828 kind: $kind, 1829 target: module_path!(), 1830 level: $crate::Level::TRACE, 1831 fields: $($fields)* 1832 } 1833 }}; 1834 ( 1835 name: $name:expr, 1836 kind: $kind:expr, 1837 level: $lvl:expr, 1838 fields: $($fields:tt)* 1839 ) => {{ 1840 $crate::callsite! { 1841 name: $name, 1842 kind: $kind, 1843 target: module_path!(), 1844 level: $lvl, 1845 fields: $($fields)* 1846 } 1847 }}; 1848 ( 1849 name: $name:expr, 1850 kind: $kind:expr, 1851 target: $target:expr, 1852 level: $lvl:expr, 1853 fields: $($fields:tt)* 1854 ) => {{ 1855 use $crate::__macro_support::MacroCallsite; 1856 static META: $crate::Metadata<'static> = { 1857 $crate::metadata! { 1858 name: $name, 1859 target: $target, 1860 level: $lvl, 1861 fields: $crate::fieldset!( $($fields)* ), 1862 callsite: &CALLSITE, 1863 kind: $kind, 1864 } 1865 }; 1866 static CALLSITE: MacroCallsite = MacroCallsite::new(&META); 1867 CALLSITE.register(); 1868 &CALLSITE 1869 }}; 1870 } 1871 1872 /// Constructs a new static callsite for a span or event. 1873 #[doc(hidden)] 1874 #[macro_export] 1875 macro_rules! callsite2 { 1876 (name: $name:expr, kind: $kind:expr, fields: $($fields:tt)*) => {{ 1877 $crate::callsite2! { 1878 name: $name, 1879 kind: $kind, 1880 target: module_path!(), 1881 level: $crate::Level::TRACE, 1882 fields: $($fields)* 1883 } 1884 }}; 1885 ( 1886 name: $name:expr, 1887 kind: $kind:expr, 1888 level: $lvl:expr, 1889 fields: $($fields:tt)* 1890 ) => {{ 1891 $crate::callsite2! { 1892 name: $name, 1893 kind: $kind, 1894 target: module_path!(), 1895 level: $lvl, 1896 fields: $($fields)* 1897 } 1898 }}; 1899 ( 1900 name: $name:expr, 1901 kind: $kind:expr, 1902 target: $target:expr, 1903 level: $lvl:expr, 1904 fields: $($fields:tt)* 1905 ) => {{ 1906 use $crate::__macro_support::MacroCallsite; 1907 static META: $crate::Metadata<'static> = { 1908 $crate::metadata! { 1909 name: $name, 1910 target: $target, 1911 level: $lvl, 1912 fields: $crate::fieldset!( $($fields)* ), 1913 callsite: &CALLSITE, 1914 kind: $kind, 1915 } 1916 }; 1917 MacroCallsite::new(&META) 1918 }}; 1919 } 1920 1921 #[macro_export] 1922 // TODO: determine if this ought to be public API?` 1923 #[doc(hidden)] 1924 macro_rules! level_enabled { 1925 ($lvl:expr) => { 1926 $lvl <= $crate::level_filters::STATIC_MAX_LEVEL 1927 && $lvl <= $crate::level_filters::LevelFilter::current() 1928 }; 1929 } 1930 1931 #[doc(hidden)] 1932 #[macro_export] 1933 macro_rules! valueset { 1934 1935 // === base case === 1936 (@ { $(,)* $($val:expr),* $(,)* }, $next:expr $(,)*) => { 1937 &[ $($val),* ] 1938 }; 1939 1940 // === recursive case (more tts) === 1941 1942 // TODO(#1138): determine a new syntax for uninitialized span fields, and 1943 // re-enable this. 1944 // (@{ $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = _, $($rest:tt)*) => { 1945 // $crate::valueset!(@ { $($out),*, (&$next, None) }, $next, $($rest)*) 1946 // }; 1947 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => { 1948 $crate::valueset!( 1949 @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) }, 1950 $next, 1951 $($rest)* 1952 ) 1953 }; 1954 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr, $($rest:tt)*) => { 1955 $crate::valueset!( 1956 @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) }, 1957 $next, 1958 $($rest)* 1959 ) 1960 }; 1961 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr, $($rest:tt)*) => { 1962 $crate::valueset!( 1963 @ { $($out),*, (&$next, Some(&$val as &Value)) }, 1964 $next, 1965 $($rest)* 1966 ) 1967 }; 1968 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+, $($rest:tt)*) => { 1969 $crate::valueset!( 1970 @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) }, 1971 $next, 1972 $($rest)* 1973 ) 1974 }; 1975 (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+, $($rest:tt)*) => { 1976 $crate::valueset!( 1977 @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) }, 1978 $next, 1979 $($rest)* 1980 ) 1981 }; 1982 (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+, $($rest:tt)*) => { 1983 $crate::valueset!( 1984 @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) }, 1985 $next, 1986 $($rest)* 1987 ) 1988 }; 1989 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr) => { 1990 $crate::valueset!( 1991 @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) }, 1992 $next, 1993 ) 1994 }; 1995 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr) => { 1996 $crate::valueset!( 1997 @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) }, 1998 $next, 1999 ) 2000 }; 2001 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr) => { 2002 $crate::valueset!( 2003 @ { $($out),*, (&$next, Some(&$val as &Value)) }, 2004 $next, 2005 ) 2006 }; 2007 (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+) => { 2008 $crate::valueset!( 2009 @ { $($out),*, (&$next, Some(&$($k).+ as &Value)) }, 2010 $next, 2011 ) 2012 }; 2013 (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+) => { 2014 $crate::valueset!( 2015 @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &Value)) }, 2016 $next, 2017 ) 2018 }; 2019 (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+) => { 2020 $crate::valueset!( 2021 @ { $($out),*, (&$next, Some(&display(&$($k).+) as &Value)) }, 2022 $next, 2023 ) 2024 }; 2025 2026 // Handle literal names 2027 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr, $($rest:tt)*) => { 2028 $crate::valueset!( 2029 @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) }, 2030 $next, 2031 $($rest)* 2032 ) 2033 }; 2034 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr, $($rest:tt)*) => { 2035 $crate::valueset!( 2036 @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) }, 2037 $next, 2038 $($rest)* 2039 ) 2040 }; 2041 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr, $($rest:tt)*) => { 2042 $crate::valueset!( 2043 @ { $($out),*, (&$next, Some(&$val as &Value)) }, 2044 $next, 2045 $($rest)* 2046 ) 2047 }; 2048 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr) => { 2049 $crate::valueset!( 2050 @ { $($out),*, (&$next, Some(&debug(&$val) as &Value)) }, 2051 $next, 2052 ) 2053 }; 2054 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr) => { 2055 $crate::valueset!( 2056 @ { $($out),*, (&$next, Some(&display(&$val) as &Value)) }, 2057 $next, 2058 ) 2059 }; 2060 (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr) => { 2061 $crate::valueset!( 2062 @ { $($out),*, (&$next, Some(&$val as &Value)) }, 2063 $next, 2064 ) 2065 }; 2066 2067 // Remainder is unparseable, but exists --- must be format args! 2068 (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => { 2069 $crate::valueset!(@ { (&$next, Some(&format_args!($($rest)+) as &Value)), $($out),* }, $next, ) 2070 }; 2071 2072 // === entry === 2073 ($fields:expr, $($kvs:tt)+) => { 2074 { 2075 #[allow(unused_imports)] 2076 use $crate::field::{debug, display, Value}; 2077 let mut iter = $fields.iter(); 2078 $fields.value_set($crate::valueset!( 2079 @ { }, 2080 iter.next().expect("FieldSet corrupted (this is a bug)"), 2081 $($kvs)+ 2082 )) 2083 } 2084 }; 2085 ($fields:expr,) => { 2086 { 2087 $fields.value_set(&[]) 2088 } 2089 }; 2090 } 2091 2092 #[doc(hidden)] 2093 #[macro_export] 2094 macro_rules! fieldset { 2095 // == base case == 2096 (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => { 2097 &[ $($out),* ] 2098 }; 2099 2100 // == recursive cases (more tts) == 2101 (@ { $(,)* $($out:expr),* } $($k:ident).+ = ?$val:expr, $($rest:tt)*) => { 2102 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2103 }; 2104 (@ { $(,)* $($out:expr),* } $($k:ident).+ = %$val:expr, $($rest:tt)*) => { 2105 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2106 }; 2107 (@ { $(,)* $($out:expr),* } $($k:ident).+ = $val:expr, $($rest:tt)*) => { 2108 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2109 }; 2110 // TODO(#1138): determine a new syntax for uninitialized span fields, and 2111 // re-enable this. 2112 // (@ { $($out:expr),* } $($k:ident).+ = _, $($rest:tt)*) => { 2113 // $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2114 // }; 2115 (@ { $(,)* $($out:expr),* } ?$($k:ident).+, $($rest:tt)*) => { 2116 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2117 }; 2118 (@ { $(,)* $($out:expr),* } %$($k:ident).+, $($rest:tt)*) => { 2119 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2120 }; 2121 (@ { $(,)* $($out:expr),* } $($k:ident).+, $($rest:tt)*) => { 2122 $crate::fieldset!(@ { $($out),*, $crate::__tracing_stringify!($($k).+) } $($rest)*) 2123 }; 2124 2125 // Handle literal names 2126 (@ { $(,)* $($out:expr),* } $k:literal = ?$val:expr, $($rest:tt)*) => { 2127 $crate::fieldset!(@ { $($out),*, $k } $($rest)*) 2128 }; 2129 (@ { $(,)* $($out:expr),* } $k:literal = %$val:expr, $($rest:tt)*) => { 2130 $crate::fieldset!(@ { $($out),*, $k } $($rest)*) 2131 }; 2132 (@ { $(,)* $($out:expr),* } $k:literal = $val:expr, $($rest:tt)*) => { 2133 $crate::fieldset!(@ { $($out),*, $k } $($rest)*) 2134 }; 2135 2136 // Remainder is unparseable, but exists --- must be format args! 2137 (@ { $(,)* $($out:expr),* } $($rest:tt)+) => { 2138 $crate::fieldset!(@ { "message", $($out),*, }) 2139 }; 2140 2141 // == entry == 2142 ($($args:tt)*) => { 2143 $crate::fieldset!(@ { } $($args)*,) 2144 }; 2145 2146 } 2147 2148 #[cfg(feature = "log")] 2149 #[doc(hidden)] 2150 #[macro_export] 2151 macro_rules! level_to_log { 2152 ($level:expr) => { 2153 match $level { 2154 $crate::Level::ERROR => $crate::log::Level::Error, 2155 $crate::Level::WARN => $crate::log::Level::Warn, 2156 $crate::Level::INFO => $crate::log::Level::Info, 2157 $crate::Level::DEBUG => $crate::log::Level::Debug, 2158 _ => $crate::log::Level::Trace, 2159 } 2160 }; 2161 } 2162 2163 #[doc(hidden)] 2164 #[macro_export] 2165 macro_rules! __tracing_stringify { 2166 ($s:expr) => { 2167 stringify!($s) 2168 }; 2169 } 2170 2171 #[cfg(not(feature = "log"))] 2172 #[doc(hidden)] 2173 #[macro_export] 2174 macro_rules! __tracing_log { 2175 (target: $target:expr, $level:expr, $($field:tt)+ ) => {}; 2176 } 2177 2178 #[cfg(feature = "log")] 2179 #[doc(hidden)] 2180 #[macro_export] 2181 macro_rules! __mk_format_string { 2182 // === base case === 2183 (@ { $(,)* $($out:expr),* $(,)* } $(,)*) => { 2184 concat!( $($out),*) 2185 }; 2186 2187 // === recursive case (more tts), === 2188 // ====== shorthand field syntax === 2189 (@ { $(,)* $($out:expr),* }, ?$($k:ident).+, $($rest:tt)*) => { 2190 $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($rest)*) 2191 }; 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 // ====== kv field syntax === 2199 (@ { $(,)* $($out:expr),* }, message = $val:expr, $($rest:tt)*) => { 2200 $crate::__mk_format_string!(@ { $($out),*, "{} " }, $($rest)*) 2201 }; 2202 (@ { $(,)* $($out:expr),* }, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => { 2203 $crate::__mk_format_string!(@ { $($out),*, $crate::__tracing_stringify!($($k).+), "={:?} " }, $($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 2212 // === rest is unparseable --- must be fmt args === 2213 (@ { $(,)* $($out:expr),* }, $($rest:tt)+) => { 2214 $crate::__mk_format_string!(@ { "{} ", $($out),* }, ) 2215 }; 2216 2217 // === entry === 2218 ($($kvs:tt)+) => { 2219 $crate::__mk_format_string!(@ { }, $($kvs)+,) 2220 }; 2221 () => { 2222 "" 2223 } 2224 } 2225 2226 #[cfg(feature = "log")] 2227 #[doc(hidden)] 2228 #[macro_export] 2229 macro_rules! __mk_format_args { 2230 // === finished --- called into by base cases === 2231 (@ { $(,)* $($out:expr),* $(,)* }, $fmt:expr, fields: $(,)*) => { 2232 format_args!($fmt, $($out),*) 2233 }; 2234 2235 // === base case (no more tts) === 2236 (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = ?$val:expr $(,)*) => { 2237 $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: ) 2238 }; 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 // ====== shorthand field syntax === 2246 (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: ?$($k:ident).+ $(,)*) => { 2247 $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields:) 2248 }; 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 2256 // === recursive case (more tts) === 2257 (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($k:ident).+ = ?$val:expr, $($rest:tt)+) => { 2258 $crate::__mk_format_args!(@ { $($out),*, $val }, $fmt, fields: $($rest)+) 2259 }; 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 // ====== shorthand field syntax === 2267 (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: ?$($k:ident).+, $($rest:tt)+) => { 2268 $crate::__mk_format_args!(@ { $($out),*, &$($k).+ }, $fmt, fields: $($rest)+) 2269 }; 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 2277 // === rest is unparseable --- must be fmt args === 2278 (@ { $(,)* $($out:expr),* }, $fmt:expr, fields: $($rest:tt)+) => { 2279 $crate::__mk_format_args!(@ { format_args!($($rest)+), $($out),* }, $fmt, fields: ) 2280 }; 2281 2282 // === entry === 2283 ($($kv:tt)*) => { 2284 { 2285 #[allow(unused_imports)] 2286 use $crate::field::{debug, display}; 2287 // use $crate::__mk_format_string; 2288 $crate::__mk_format_args!(@ { }, $crate::__mk_format_string!($($kv)*), fields: $($kv)*) 2289 } 2290 }; 2291 } 2292 2293 #[cfg(feature = "log")] 2294 #[doc(hidden)] 2295 #[macro_export] 2296 macro_rules! __tracing_log { 2297 (target: $target:expr, $level:expr, $($field:tt)+ ) => { 2298 $crate::if_log_enabled! { $level, { 2299 use $crate::log; 2300 let level = $crate::level_to_log!($level); 2301 if level <= log::max_level() { 2302 let log_meta = log::Metadata::builder() 2303 .level(level) 2304 .target($target) 2305 .build(); 2306 let logger = log::logger(); 2307 if logger.enabled(&log_meta) { 2308 logger.log(&log::Record::builder() 2309 .file(Some(file!())) 2310 .module_path(Some(module_path!())) 2311 .line(Some(line!())) 2312 .metadata(log_meta) 2313 .args($crate::__mk_format_args!($($field)+)) 2314 .build()); 2315 } 2316 } 2317 }} 2318 }; 2319 } 2320 2321 #[cfg(not(feature = "log"))] 2322 #[doc(hidden)] 2323 #[macro_export] 2324 macro_rules! if_log_enabled { 2325 ($lvl:expr, $e:expr;) => { 2326 $crate::if_log_enabled! { $lvl, $e } 2327 }; 2328 ($lvl:expr, $if_log:block) => { 2329 $crate::if_log_enabled! { $lvl, $if_log else {} } 2330 }; 2331 ($lvl:expr, $if_log:block else $else_block:block) => { 2332 $else_block 2333 }; 2334 } 2335 2336 #[cfg(all(feature = "log", not(feature = "log-always")))] 2337 #[doc(hidden)] 2338 #[macro_export] 2339 macro_rules! if_log_enabled { 2340 ($lvl:expr, $e:expr;) => { 2341 $crate::if_log_enabled! { $lvl, $e } 2342 }; 2343 ($lvl:expr, $if_log:block) => { 2344 $crate::if_log_enabled! { $lvl, $if_log else {} } 2345 }; 2346 ($lvl:expr, $if_log:block else $else_block:block) => { 2347 if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL { 2348 if !$crate::dispatcher::has_been_set() { 2349 $if_log 2350 } else { 2351 $else_block 2352 } 2353 } else { 2354 $else_block 2355 } 2356 }; 2357 } 2358 2359 #[cfg(all(feature = "log", feature = "log-always"))] 2360 #[doc(hidden)] 2361 #[macro_export] 2362 macro_rules! if_log_enabled { 2363 ($lvl:expr, $e:expr;) => { 2364 $crate::if_log_enabled! { $lvl, $e } 2365 }; 2366 ($lvl:expr, $if_log:block) => { 2367 $crate::if_log_enabled! { $lvl, $if_log else {} } 2368 }; 2369 ($lvl:expr, $if_log:block else $else_block:block) => { 2370 if $crate::level_to_log!($lvl) <= $crate::log::STATIC_MAX_LEVEL { 2371 #[allow(unused_braces)] 2372 $if_log 2373 } else { 2374 $else_block 2375 } 2376 }; 2377 } 2378