一个请求穿过三个时刻

    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
        let encoding = Encoding::from_headers(req.headers(), self.accept);

        ResponseFuture {
            inner: self.inner.call(req),
            encoding,
            // ...
        }
    }

tower-http = { version = "=0.7.1", features = ["cors", "trace", "compression-gzip", "timeout"] }
tower = { version = "=0.5.3", features = ["util"] }
axum = { version = "=0.8.9", default-features = false }
tokio = { version = "=1.54.1", features = ["macros", "rt", "time", "test-util"] }
http = "1"
http-body-util = "0.1"
bytes = "1"
tracing = "0.1"

use axum::{body::Body, routing::get, Router};
use bytes::Bytes;
use http::{header, HeaderValue, Method, Request, Response, StatusCode};
use http_body_util::BodyExt;
use std::time::Duration;
use tower::ServiceExt;
use tower_http::{
  classify::ServerErrorsFailureClass, compression::CompressionLayer, cors::CorsLayer,
  timeout::TimeoutLayer, trace::TraceLayer,
};
use tracing::Span;

struct Dropped(&'static str);
impl Drop for Dropped {
  fn drop(&mut self) {
    println!("    handler future for {} dropped", self.0);
  }
}

async fn fast() -> String {
  println!("    handler /");
  let _guard = Dropped("/");
  "tower-http ".repeat(100)
}

async fn slow() -> String {
  println!("    handler /slow");
  let _guard = Dropped("/slow");
  tokio::time::sleep(Duration::from_secs(1)).await;
  "never".into()
}

#[tokio::main(flavor = "current_thread", start_paused = true)]
async fn main() {
  // Router::layer：后写的在外层。从外到里：Cors → Trace → Compression → Timeout → handler
  let app = Router::new()
    .route("/", get(fast))
    .route("/slow", get(slow))
    .layer(TimeoutLayer::with_status_code(StatusCode::SERVICE_UNAVAILABLE, Duration::from_millis(100)))
    .layer(CompressionLayer::new())
    .layer(
      TraceLayer::new_for_http()
        .on_request(|_: &Request<Body>, _: &Span| println!("  trace: on_request"))
        .on_response(|r: &Response<_>, _: Duration, _: &Span| println!("  trace: on_response {}", r.status()))
        .on_body_chunk(|c: &Bytes, _: Duration, _: &Span| println!("  trace: on_body_chunk {} bytes", c.len()))
        .on_eos(|_: Option<&http::HeaderMap>, _: Duration, _: &Span| println!("  trace: on_eos"))
        .on_failure(|c: ServerErrorsFailureClass, _: Duration, _: &Span| println!("  trace: on_failure {c}")),
    )
    .layer(CorsLayer::new().allow_origin(HeaderValue::from_static("https://a.example")).allow_methods([Method::GET]));

  let cases = [
    ("OPTIONS / (preflight)", Request::options("/").header(header::ORIGIN, "https://a.example").header(header::ACCESS_CONTROL_REQUEST_METHOD, "GET")),
    ("GET /", Request::get("/").header(header::ORIGIN, "https://a.example").header(header::ACCEPT_ENCODING, "gzip")),
    ("GET /slow", Request::get("/slow").header(header::ORIGIN, "https://a.example").header(header::ACCEPT_ENCODING, "gzip")),
  ];
  for (name, req) in cases {
    println!("{name}");
    let res = app.clone().oneshot(req.body(Body::empty()).unwrap()).await.unwrap();
    let mut names: Vec<_> = res.headers().keys().map(|k| k.as_str()).collect();
    names.sort();
    println!("  client: {} {:?}", res.status(), names);
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("  client: body {} bytes", body.len());
  }
}

OPTIONS / (preflight)
  client: 200 OK ["access-control-allow-methods", "access-control-allow-origin", "allow", "content-length"]
  client: body 0 bytes
GET /
  trace: on_request
    handler /
    handler future for / dropped
  trace: on_response 200 OK
  client: 200 OK ["access-control-allow-origin", "content-encoding", "content-type", "vary"]
  trace: on_body_chunk 51 bytes
  trace: on_eos
  client: body 51 bytes
GET /slow
  trace: on_request
    handler /slow
    handler future for /slow dropped
  trace: on_response 503 Service Unavailable
  trace: on_failure Status code: 503 Service Unavailable
  client: 503 Service Unavailable ["access-control-allow-origin", "content-length"]
  trace: on_eos
  client: body 0 bytes