grow-apache-skywalking 0.2.0

Rust SDK for Apache SkyWalking by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! `reqwest-middleware` middleware: a client span per request plus trace-context injection.

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};

/// Creates a `client` span named after the method with `http.request.method`, `url.full`
/// (query values redacted), `server.address`, `server.port` and `http.response.status_code`,
/// injects the span context into the request headers, and marks 4xx/5xx responses and
/// transport errors as `ERROR`.
///
/// ```no_run
/// # use grow_apache_skywalking::tracing::TracingMiddleware;
/// let client = reqwest_middleware::ClientBuilder::new(reqwest::Client::new())
///     .with(TracingMiddleware::new())
///     .build();
/// ```
#[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 {
    /// Middleware using the global tracer.
    pub fn new() -> Self {
        Self::default()
    }
    /// Uses this tracer instead of the global one.
    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
    }
}