uhg_custom_appollo_roouter/plugins/telemetry/tracing/
reload.rs

1use std::borrow::Cow;
2use std::sync::Arc;
3use std::sync::RwLock;
4
5use opentelemetry::trace::SpanBuilder;
6use opentelemetry::trace::Tracer;
7
8use crate::plugins::telemetry::otel::OtelData;
9use crate::plugins::telemetry::otel::PreSampledTracer;
10
11#[derive(Clone)]
12pub(crate) struct ReloadTracer<S> {
13    parent: Arc<RwLock<S>>,
14}
15
16impl<S: PreSampledTracer> PreSampledTracer for ReloadTracer<S> {
17    fn sampled_context(&self, data: &mut OtelData) -> opentelemetry::Context {
18        self.parent
19            .read()
20            .expect("parent tracer must be available")
21            .sampled_context(data)
22    }
23
24    fn new_trace_id(&self) -> opentelemetry::trace::TraceId {
25        self.parent
26            .read()
27            .expect("parent tracer must be available")
28            .new_trace_id()
29    }
30
31    fn new_span_id(&self) -> opentelemetry::trace::SpanId {
32        self.parent
33            .read()
34            .expect("parent tracer must be available")
35            .new_span_id()
36    }
37}
38
39impl<S: Tracer> Tracer for ReloadTracer<S> {
40    type Span = S::Span;
41
42    fn start<T>(&self, name: T) -> Self::Span
43    where
44        T: Into<Cow<'static, str>>,
45    {
46        self.parent
47            .read()
48            .expect("parent tracer must be available")
49            .start(name)
50    }
51
52    fn start_with_context<T>(&self, name: T, parent_cx: &opentelemetry::Context) -> Self::Span
53    where
54        T: Into<Cow<'static, str>>,
55    {
56        self.parent
57            .read()
58            .expect("parent tracer must be available")
59            .start_with_context(name, parent_cx)
60    }
61
62    fn span_builder<T>(&self, name: T) -> SpanBuilder
63    where
64        T: Into<Cow<'static, str>>,
65    {
66        self.parent
67            .read()
68            .expect("parent tracer must be available")
69            .span_builder(name)
70    }
71
72    fn build(&self, builder: SpanBuilder) -> Self::Span {
73        self.parent
74            .read()
75            .expect("parent tracer must be available")
76            .build(builder)
77    }
78
79    fn build_with_context(
80        &self,
81        builder: SpanBuilder,
82        parent_cx: &opentelemetry::Context,
83    ) -> Self::Span {
84        self.parent
85            .read()
86            .expect("parent tracer must be available")
87            .build_with_context(builder, parent_cx)
88    }
89
90    fn in_span<T, F, N>(&self, name: N, f: F) -> T
91    where
92        F: FnOnce(opentelemetry::Context) -> T,
93        N: Into<Cow<'static, str>>,
94        Self::Span: Send + Sync + 'static,
95    {
96        self.parent
97            .read()
98            .expect("parent tracer must be available")
99            .in_span(name, f)
100    }
101}
102
103impl<S> ReloadTracer<S> {
104    pub(crate) fn new(parent: S) -> Self {
105        Self {
106            parent: Arc::new(RwLock::new(parent)),
107        }
108    }
109
110    pub(crate) fn reload(&self, new: S) {
111        *self
112            .parent
113            .write()
114            .expect("parent tracer must be available") = new;
115    }
116}