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