#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]
use std::time::Instant;
use tide::{Middleware, Next, Request};
use tracing::{error, error_span, field, info, info_span, warn, warn_span};
use tracing_futures::Instrument;
#[cfg(feature = "request_id")]
use uuid::Uuid;
#[derive(Debug, Default, Clone)]
pub struct TraceMiddleware;
impl TraceMiddleware {
#[must_use]
pub const fn new() -> Self {
Self
}
async fn log<'a, State: Clone + Send + Sync + 'static>(
&'a self,
ctx: Request<State>,
next: Next<'a, State>,
) -> tide::Result {
let path = ctx.url().path().to_owned();
let method = ctx.method();
Ok(async {
info!("received");
let start = Instant::now();
let response = next.run(ctx).await;
let duration = start.elapsed();
let status = response.status();
info_span!("Response", http.status_code = status as u16, http.duration = ?duration)
.in_scope(|| {
if status.is_server_error() {
let span = error_span!(
"Internal error",
detail = field::Empty,
error = field::Empty
);
if let Some(error) = response.error() {
span.record("error", &field::display(error));
span.record("detail", &field::debug(error));
}
span.in_scope(|| error!("sent"));
} else if status.is_client_error() {
warn_span!("Client error").in_scope(|| warn!("sent"));
} else {
info!("sent")
}
});
response
}
.instrument({
let span = info_span!(
"Request",
http.method = %method,
http.target = %path,
request_id = field::Empty,
);
#[cfg(feature = "request_id")]
span.record("request_id", Uuid::new_v4().to_string());
span
})
.await)
}
}
#[async_trait::async_trait]
impl<State: Clone + Send + Sync + 'static> Middleware<State> for TraceMiddleware {
async fn handle(&self, req: Request<State>, next: Next<'_, State>) -> tide::Result {
self.log(req, next).await
}
}