ro11y 0.1.0

Lightweight Rust observability. Hand-rolled OTLP protobuf over HTTP, built on tracing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use std::task::{Context, Poll};

use http::Request;
use tower::{Layer, Service};

use crate::trace_id::hex_encode;

/// Tower Layer that injects W3C `traceparent` header into outgoing requests.
///
/// Reads trace_id and span_id from the current span's extensions (set by OtlpLayer)
/// and formats them as `traceparent: 00-{trace_id}-{span_id}-01`.
#[derive(Clone, Debug)]
pub struct PropagationLayer;

#[derive(Clone, Debug)]
pub struct PropagationService<S> {
    inner: S,
}

impl<S> Layer<S> for PropagationLayer {
    type Service = PropagationService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        PropagationService { inner }
    }
}

impl<S, ReqBody> Service<Request<ReqBody>> for PropagationService<S>
where
    S: Service<Request<ReqBody>>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
        // Read trace_id/span_id from the OtlpLayer's SpanFields extension.
        // This walks the subscriber's span registry to find our extension data.
        let mut trace_id_hex = None;
        let mut span_id_hex = None;

        tracing::Span::current().with_subscriber(|(id, dispatch)| {
            use tracing_subscriber::registry::LookupSpan;
            if let Some(registry) = dispatch.downcast_ref::<tracing_subscriber::Registry>() {
                if let Some(span_ref) = registry.span(id) {
                    // Walk up the span tree to find the nearest span with SpanFields.
                    let ext = span_ref.extensions();
                    if let Some(fields) = ext.get::<crate::otlp_layer::SpanFields>() {
                        trace_id_hex = Some(hex_encode(&fields.trace_id));
                        span_id_hex = Some(hex_encode(&fields.span_id));
                    } else {
                        // Check parent spans
                        for ancestor in span_ref.scope().skip(1) {
                            let ext = ancestor.extensions();
                            if let Some(fields) = ext.get::<crate::otlp_layer::SpanFields>() {
                                trace_id_hex = Some(hex_encode(&fields.trace_id));
                                span_id_hex = Some(hex_encode(&fields.span_id));
                                break;
                            }
                        }
                    }
                }
            }
        });

        if let (Some(tid), Some(sid)) = (trace_id_hex, span_id_hex) {
            let traceparent = format!("00-{}-{}-01", tid, sid);
            if let Ok(val) = http::HeaderValue::from_str(&traceparent) {
                req.headers_mut().insert("traceparent", val);
            }
        }

        self.inner.call(req)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn propagation_layer_constructs() {
        let _layer = PropagationLayer;
    }

    #[test]
    fn traceparent_format() {
        let trace_id = [1u8; 16];
        let span_id = [2u8; 8];
        let tp = format!(
            "00-{}-{}-01",
            hex_encode(&trace_id),
            hex_encode(&span_id)
        );
        assert_eq!(
            tp,
            "00-01010101010101010101010101010101-0202020202020202-01"
        );
    }
}