本站的 #[instrument]

#[cfg(feature = "accounts")]
#[cfg(feature = "server")]
#[tracing::instrument(
  name = "server::auth_callback",
  level = "info",
  skip(code, pkce_cookie),
  fields(
    provider = %provider,
    code_len = code.len(),
    state_match = received_state == pkce_cookie.state,
  ),
  err
)]
pub async fn auth_callback_internal(
  code: String,
  provider: String,
  received_state: String,
  pkce_cookie: app_core::auth::PkceCookiePayload,
) -> Result<(String, String), app_core::error::AppError> {

#[cfg_attr(
  feature = "server",
  tracing::instrument(
    name = "server::search_query",
    level = "info",
    skip(q),
    fields(q_len = q.len(), kind = ?kind, limit = ?limit, hits = tracing::field::Empty),
    err
  )
)]
#[post("/api/search/query")]
pub async fn search_query(
  q: String,
  kind: Option<String>,
  limit: Option<u32>,
) -> Result<SearchResponse, ServerFnError> {

    let mut function_on_server = function.clone();
    function_on_server
        .sig
        .inputs
        .extend(route.server_args.clone());

            // On the server, we expand the tokens and submit the function to inventory
            #[cfg(feature = "server")] {
                #function_on_server

                #[allow(clippy::unused_unit)]
                fn __inner__function__ #impl_generics(
                    // ...
                ) -> /* ... */ {
                    Box::pin(async move {
                         match (/* ... */).extract_axum(___state.0, ___request, #unpack_closure).await {
                            Ok(/* ... */) => {
                                // Call the user function
                                let res = #fn_on_server_name #ty_generics(/* ... */).await;

                                // Encode the response Into a `Result<T, E>`
                                let encoded = (&&&&&&ServerFnDecoder::<#out_ty>::new()).make_axum_response(res);
                                // ...

dioxus-logger = "=0.7.9"
dioxus-cli-config = "=0.7.9"
tracing = "=0.1.44"
tracing-subscriber = { version = "=0.3.23", features = ["env-filter", "fmt"] }
tokio = { version = "=1.54.1", features = ["rt", "macros"] }

// 把本站三处 #[tracing::instrument] 原样搬过来，函数体换成桩
use std::fmt;

#[allow(dead_code)]
#[derive(Debug)]
struct PkceCookiePayload {
  provider: String,
  state: String,
  verifier: Option<String>,
  issued_at_secs: u64,
}

#[derive(Debug)]
struct AppError(String);
impl fmt::Display for AppError {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    write!(f, "{}", self.0)
  }
}

#[tracing::instrument(
  name = "server::auth_callback",
  level = "info",
  skip(code, pkce_cookie),
  fields(
    provider = %provider,
    code_len = code.len(),
    state_match = received_state == pkce_cookie.state,
  ),
  err
)]
async fn auth_callback_internal(
  code: String,
  provider: String,
  received_state: String,
  pkce_cookie: PkceCookiePayload,
) -> Result<(String, String), AppError> {
  tracing::debug!(code_len = code.len(), "auth callback received");
  if code == "expired" {
    return Err(AppError("oauth: token exchange failed".into()));
  }
  tracing::info!(user = %"alice", "auth callback login success");
  Ok(("欢迎回来, alice!".into(), "jwt".into()))
}

#[tracing::instrument(
  name = "server::post_comment",
  level = "info",
  skip(content),
  fields(blog_id = %blog_id, content_len = content.len()),
  err
)]
async fn post_comment(blog_id: String, content: String) -> Result<Vec<String>, AppError> {
  if content.is_empty() {
    return Err(AppError("评论不能为空".into()));
  }
  tracing::warn!(user = %"bob", blog_id = %blog_id, score = 0.97, "moderation: comment BLOCKED");
  Err(AppError("评论被审核拒绝：spam".into()))
}

#[tracing::instrument(
  name = "server::search_query",
  level = "info",
  skip(q),
  fields(q_len = q.len(), kind = ?kind, limit = ?limit, hits = tracing::field::Empty),
  err
)]
async fn search_query(q: String, kind: Option<String>, limit: Option<u32>) -> Result<usize, AppError> {
  let hits = 3;
  tracing::Span::current().record("hits", hits);
  Ok(hits)
}

async fn calls() {
  let cookie = PkceCookiePayload {
    provider: "github".into(),
    state: "s3cr3t-state".into(),
    verifier: Some("v".into()),
    issued_at_secs: 0,
  };
  println!("-- auth_callback ok");
  let _ = auth_callback_internal("code-123".into(), "github".into(), "s3cr3t-state".into(), cookie).await;
  let cookie = PkceCookiePayload {
    provider: "github".into(),
    state: "s3cr3t-state".into(),
    verifier: None,
    issued_at_secs: 0,
  };
  println!("-- auth_callback err");
  let _ = auth_callback_internal("expired".into(), "github".into(), "other".into(), cookie).await;
  println!("-- post_comment blocked");
  let _ = post_comment("rust-intro".into(), "buy now".into()).await;
  println!("-- search_query ok");
  let _ = search_query("tokio 调度".into(), Some("blog".into()), None).await;
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  if std::env::args().any(|a| a == "--close") {
    // 对照：同样的过滤，再打开 span 关闭事件
    let sub = tracing_subscriber::fmt()
      .with_env_filter("info")
      .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE)
      .with_ansi(false)
      .without_time()
      .finish();
    let _g = tracing::subscriber::set_default(sub);
    calls().await;
  } else {
    // 和生产一样：只有 dioxus-logger 装的 subscriber
    dioxus_logger::initialize_default();
    calls().await;
  }
}

-- auth_callback ok
2026-10-23T20:37:24.289196Z  INFO server::auth_callback{received_state="s3cr3t-state" provider=github code_len=8 state_match=true}: instrument_site: auth callback login success user=alice
-- auth_callback err
2026-10-23T20:37:24.289213Z ERROR server::auth_callback{received_state="other" provider=github code_len=7 state_match=false}: instrument_site: error=oauth: token exchange failed
-- post_comment blocked
2026-10-23T20:37:24.289223Z  WARN server::post_comment{blog_id=rust-intro content_len=7}: instrument_site: moderation: comment BLOCKED user=bob blog_id=rust-intro score=0.97
2026-10-23T20:37:24.289230Z ERROR server::post_comment{blog_id=rust-intro content_len=7}: instrument_site: error=评论被审核拒绝：spam
-- search_query ok

    tracing::Span::current().record("hits", hits.len());

-- auth_callback ok
 INFO server::auth_callback{received_state="s3cr3t-state" provider=github code_len=8 state_match=true}: instrument_site: auth callback login success user=alice
 INFO server::auth_callback{received_state="s3cr3t-state" provider=github code_len=8 state_match=true}: instrument_site: close
-- auth_callback err
ERROR server::auth_callback{received_state="other" provider=github code_len=7 state_match=false}: instrument_site: error=oauth: token exchange failed
 INFO server::auth_callback{received_state="other" provider=github code_len=7 state_match=false}: instrument_site: close
-- post_comment blocked
 WARN server::post_comment{blog_id=rust-intro content_len=7}: instrument_site: moderation: comment BLOCKED user=bob blog_id=rust-intro score=0.97
ERROR server::post_comment{blog_id=rust-intro content_len=7}: instrument_site: error=评论被审核拒绝：spam
 INFO server::post_comment{blog_id=rust-intro content_len=7}: instrument_site: close
-- search_query ok
 INFO server::search_query{q_len=12 kind=Some("blog") limit=None hits=3}: instrument_site: close

-- search_query ok