参数

tracing = "=0.1.44"
tracing-subscriber = { version = "=0.3.23", default-features = false, features = ["fmt", "registry", "std"] }

pub(crate) struct InstrumentArgs {
    level: Option<Level>,
    pub(crate) name: Option<LitStrOrIdent>,
    target: Option<LitStrOrIdent>,
    pub(crate) parent: Option<Expr>,
    pub(crate) follows_from: Option<Expr>,
    pub(crate) skips: HashSet<Ident>,
    pub(crate) skip_all: bool,
    pub(crate) fields: Option<Fields>,
    pub(crate) err_args: Option<EventArgs>,
    pub(crate) ret_args: Option<EventArgs>,
    /// Errors describing any unrecognized parse inputs that we skipped.
    parse_warnings: Vec<syn::Error>,
}

            } else if lookahead.peek(kw::parent) {
                if args.target.is_some() {
                    return Err(input.error("expected only a single `parent` argument"));
                }

use tracing::instrument;

#[instrument(target = "app", parent = None)]
fn detached() {}

fn main() {}

error: expected only a single `parent` argument
 --> src/bin/err_target_parent.rs:3:30
  |
3 | #[instrument(target = "app", parent = None)]
  |                              ^^^^^^

#[instrument(skip(pasword))]
fn login(user: &str, password: &str) {}

error: attempting to skip non-existent parameter
 --> src/bin/err_skip_missing.rs:3:19
  |
3 | #[instrument(skip(pasword))]
  |                   ^^^^^^^

use tracing::instrument;

struct Conn; // 没有 Debug

#[instrument]
fn query(conn: &Conn, sql: &str) {}

fn main() {}

error[E0277]: `Conn` doesn't implement `Debug`
   --> src/bin/err_no_debug.rs:5:1
    |
  5 | #[instrument]
    | ^^^^^^^^^^^^^ the trait `Debug` is not implemented for `Conn`
    |
    = note: required for `&Conn` to implement `Debug`
    = note: 1 redundant requirement hidden
    = note: required for `&&Conn` to implement `Debug`
note: required by a bound in `debug`
   --> ~/.cargo/registry/.../tracing-core-0.1.36/src/field.rs:379:8
    |
377 | pub fn debug<T>(t: T) -> DebugValue<T>
    |        ----- required by a bound in this function
378 | where
379 |     T: fmt::Debug,
    |        ^^^^^^^^^^ required by this bound in `debug`
    = note: this error originates in the attribute macro `instrument` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Conn` with `#[derive(Debug)]`
    |
  3 + #[derive(Debug)]
  4 | struct Conn; // 没有 Debug
    |

error[E0277]: `Conn` doesn't implement `Debug`
   --> src/bin/err_no_debug.rs:5:1
    |
  5 | #[instrument]
    | ^^^^^^^^^^^^^ the trait `Debug` is not implemented for `Conn`
    |
help: the trait `Value` is conditionally implemented for `DebugValue<T>`
   --> ~/.cargo/registry/.../tracing-core-0.1.36/src/field.rs:744:1
    |
744 | / impl<T> Value for DebugValue<T>
745 | | where
746 | |     T: fmt::Debug,
    | |________----------^
    |          |
    |          unsatisfied requirement introduced here: `&&Conn: Debug`
    = note: required for `&Conn` to implement `Debug`
    = note: 1 redundant requirement hidden
    = note: required for `&&Conn` to implement `Debug`
    = note: required for `DebugValue<&&Conn>` to implement `Value`
    = note: required for the cast from `&DebugValue<&&Conn>` to `&dyn Value`
    = note: this error originates in the macro `$crate::valueset_all` which comes from the expansion of the attribute macro `instrument` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Conn` with `#[derive(Debug)]`
    |
  3 + #[derive(Debug)]
  4 | struct Conn; // 没有 Debug
    |

use tracing::{info, instrument};

const KEY: &str = "http.method";
const SPAN: &str = "handle_request";
const TARGET: &str = "app::http";

#[instrument(name = SPAN, target = TARGET, fields({ KEY } = method, empty))]
fn handle(method: &str) {
  info!("inside");
}

fn main() {
  tracing_subscriber::fmt().with_ansi(false).without_time().with_target(true).init();
  handle("GET");
}

 INFO handle_request{method="GET" http.method="GET"}: const_name: inside

#[instrument(err(Pretty))]
fn work() -> Result<(), std::io::Error> {
  Ok(())
}

error: unknown event formatting mode, expected either `Debug` or `Display`
 --> src/bin/err_mode.rs:3:18
  |
3 | #[instrument(err(Pretty))]
  |                  ^^^^^^

    let target = args.target();

    let err_event = match args.err_args {
        Some(event_args) => {
            let level_tokens = event_args.level(Level::Error);
            match event_args.mode {
                FormatMode::Default | FormatMode::Display => Some(quote!(
                    ::tracing::event!(target: #target, #level_tokens, error = %e)
                )),
                FormatMode::Debug => Some(quote!(
                    ::tracing::event!(target: #target, #level_tokens, error = ?e)
                )),
            }
        }
        _ => None,
    };

    let ret_event = match args.ret_args {
        Some(event_args) => {
            let level_tokens = event_args.level(args_level);
            match event_args.mode {
                FormatMode::Display => Some(quote!(
                    ::tracing::event!(target: #target, #level_tokens, return = %x)
                )),
                FormatMode::Default | FormatMode::Debug => Some(quote!(
                    ::tracing::event!(target: #target, #level_tokens, return = ?x)
                )),
            }
        }
        _ => None,
    };

    #[allow(clippy::redundant_closure_call)]
    match (move || {
        // ... 假返回
        { s.parse() }
    })() {
        #[allow(clippy::unit_arg)]
        Ok(x) => {
            {
                // ... event!：名字 "event src/bin/expand_err.rs:4"，INFO，字段 return
            };
            Ok(x)
        }
        Err(e) => {
            {
                // ... event!：同名，ERROR，值 ::tracing::field::display(&e)
            };
            Err(e)
        }
    }

use tracing::instrument;

#[derive(Debug)]
struct MyError; // 只有 Debug，没有 Display

#[instrument(err)]
fn work() -> Result<(), MyError> {
  Err(MyError)
}

fn main() {}

error[E0277]: `MyError` doesn't implement `std::fmt::Display`
   --> src/bin/err_no_display.rs:6:1
    |
  6 | #[instrument(err)]
    | ^^^^^^^^^^^^^^^^^^
    | |
    | unsatisfied trait bound
    | required by a bound introduced by this call
    |
help: the trait `std::fmt::Display` is not implemented for `MyError`
   --> src/bin/err_no_display.rs:4:1
    |
  4 | struct MyError; // 只有 Debug，没有 Display
    | ^^^^^^^^^^^^^^
    = note: required for `&MyError` to implement `std::fmt::Display`
note: required by a bound in `display`
   --> ~/.cargo/registry/.../tracing-core-0.1.36/src/field.rs:370:8
    |
368 | pub fn display<T>(t: T) -> DisplayValue<T>
    |        ------- required by a bound in this function
369 | where
370 |     T: fmt::Display,
    |        ^^^^^^^^^^^^ required by this bound in `display`
    = note: this error originates in the macro `$crate::valueset_all` which comes from the expansion of the attribute macro `instrument` (in Nightly builds, run with -Z macro-backtrace for more info)

use std::fmt::Write;
use std::num::ParseIntError;
use tracing::field::{Field, Visit};
use tracing::span::{Attributes, Id, Record};
use tracing::{Event, Span, Subscriber, info, info_span, instrument};
use tracing_subscriber::layer::{Context, Layer, SubscriberExt};
use tracing_subscriber::registry::{LookupSpan, Registry};

struct Fields(String);
impl Visit for Fields {
  fn record_debug(&mut self, f: &Field, v: &dyn std::fmt::Debug) {
    let _ = write!(self.0, " {}={:?}", f.name(), v);
  }
}

struct Print;
impl<S: Subscriber + for<'a> LookupSpan<'a>> Layer<S> for Print {
  fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, cx: Context<'_, S>) {
    let mut f = Fields(String::new());
    attrs.record(&mut f);
    let m = attrs.metadata();
    let parent = cx.span(id).and_then(|s| s.parent()).map(|p| p.name()).unwrap_or("-");
    println!("span  {} {} {} parent={}{}", m.level(), m.target(), m.name(), parent, f.0);
  }
  fn on_record(&self, id: &Id, rec: &Record<'_>, cx: Context<'_, S>) {
    let mut f = Fields(String::new());
    rec.record(&mut f);
    println!("record {}{}", cx.span(id).unwrap().name(), f.0);
  }
  fn on_follows_from(&self, id: &Id, cause: &Id, cx: Context<'_, S>) {
    println!("follows_from {} <- {}", cx.span(id).unwrap().name(), cx.span(cause).unwrap().name());
  }
  fn on_event(&self, ev: &Event<'_>, cx: Context<'_, S>) {
    let mut f = Fields(String::new());
    ev.record(&mut f);
    let m = ev.metadata();
    let cur = cx.lookup_current().map(|s| s.name()).unwrap_or("-");
    println!("event {} {} in={}{}", m.level(), m.target(), cur, f.0);
  }
}

struct Secret; // 没有 Debug

#[instrument(skip(password), fields(user_len = user.len()))]
fn login(user: &str, password: &str) {
  let _ = password;
}

#[instrument(skip_all, fields(n = items.len()))]
fn batch(items: Vec<Secret>) {}

#[instrument(fields(status = tracing::field::Empty))]
fn handle(path: &str) {
  Span::current().record("status", 200);
}

#[instrument(level = "debug", name = "load_cfg", target = "app::cfg")]
fn load() {}

#[instrument]
fn attached() {}

#[instrument(parent = None)]
fn detached() {}

#[instrument(fields(path = %path.to_uppercase()))]
fn shout(path: &str) {}

#[instrument(skip(cause), follows_from = [cause])]
fn later(cause: &Span) {}

#[instrument(err, ret)]
fn parse(s: &str) -> Result<u32, ParseIntError> {
  s.parse()
}

#[instrument(level = "debug", ret(Display), err(level = "warn", Debug))]
fn parse_custom(s: &str) -> Result<u32, ParseIntError> {
  s.parse()
}

fn main() {
  tracing::subscriber::set_global_default(Registry::default().with(Print)).unwrap();
  login("ann", "hunter2");
  batch(vec![Secret, Secret]);
  handle("/a");
  load();
  info_span!("outer").in_scope(|| {
    attached();
    detached();
  });
  shout("/a");
  let cause = info_span!("cause");
  later(&cause);
  println!("--");
  let _ = parse("42");
  let _ = parse("x");
  let _ = parse_custom("7");
  let _ = parse_custom("y");
  info!("done");
}

span  INFO args_demo login parent=- user="ann" user_len=3
span  INFO args_demo batch parent=- n=2
span  INFO args_demo handle parent=- path="/a"
record handle status=200
span  DEBUG app::cfg load_cfg parent=-
span  INFO args_demo outer parent=-
span  INFO args_demo attached parent=outer
span  INFO args_demo detached parent=-
span  INFO args_demo shout parent=- path=/A
span  INFO args_demo cause parent=-
span  INFO args_demo later parent=-
follows_from later <- cause
--
span  INFO args_demo parse parent=- s="42"
event INFO args_demo in=parse return=42
span  INFO args_demo parse parent=- s="x"
event ERROR args_demo in=parse error=invalid digit found in string
span  DEBUG args_demo parse_custom parent=- s="7"
event DEBUG args_demo in=parse_custom return=7
span  DEBUG args_demo parse_custom parent=- s="y"
event WARN args_demo in=parse_custom error=ParseIntError { kind: InvalidDigit }
event INFO args_demo in=- message=done

new_span parse Id(1) s="x"
enter    Id(1)
event    in parse: return=Err(ParseIntError { kind: InvalidDigit })
exit     Id(1)
close    Id(1)