use std::fmt;
use async_trait::async_trait;
use opentelemetry::trace::{FutureExt as _, SpanKind, Status, TraceContextExt};
use opentelemetry::KeyValue;
use opentelemetry_sdk::trace::SdkTracer;
use reqwest_middleware::{Middleware, Next};
use super::{helpers::mark_error_on, inject_headers_context, start_span, SpanOptions};
#[derive(Clone, Default)]
pub struct TracingMiddleware {
tracer: Option<SdkTracer>,
}
impl fmt::Debug for TracingMiddleware {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TracingMiddleware").finish_non_exhaustive()
}
}
impl TracingMiddleware {
pub fn new() -> Self {
Self::default()
}
pub fn with_tracer(mut self, tracer: SdkTracer) -> Self {
self.tracer = Some(tracer);
self
}
}
#[async_trait]
impl Middleware for TracingMiddleware {
async fn handle(
&self,
mut req: reqwest::Request,
extensions: &mut http::Extensions,
next: Next<'_>,
) -> reqwest_middleware::Result<reqwest::Response> {
let url = req.url();
let mut opts = SpanOptions::default()
.kind(SpanKind::Client)
.attribute(KeyValue::new(
"http.request.method",
req.method().as_str().to_string(),
))
.attribute(KeyValue::new(
"url.full",
crate::core::redact::redact_url(url.as_str()),
));
if let Some(host) = url.host_str() {
opts = opts.attribute(KeyValue::new("server.address", host.to_string()));
}
if let Some(port) = url.port_or_known_default() {
opts = opts.attribute(KeyValue::new("server.port", i64::from(port)));
}
if let Some(tracer) = &self.tracer {
opts = opts.tracer(tracer.clone());
}
let cx = start_span(req.method().as_str().to_string(), opts);
inject_headers_context(&cx, req.headers_mut());
let result = next.run(req, extensions).with_context(cx.clone()).await;
let span = cx.span();
match &result {
Ok(resp) => {
let code = resp.status().as_u16();
span.set_attribute(KeyValue::new("http.response.status_code", i64::from(code)));
if code >= 400 {
span.set_status(Status::error(format!("HTTP {code}")));
}
}
Err(e) => mark_error_on(&span, "reqwest_middleware::Error", e),
}
span.end();
result
}
}