Skip to main content

graphrt_otel/
exporter.rs

1//! Span exporters: the [`SpanExporter`] contract plus in-memory, writer (stdout /
2//! stderr) and fan-out implementations.
3
4use std::fmt;
5use std::io::Write;
6use std::sync::{Arc, Mutex, PoisonError};
7
8use futures::future::BoxFuture;
9
10use crate::otlp;
11use crate::span::Span;
12
13/// Receives finished spans. `export` must never block the run: implementations
14/// queue or write quickly and drop data when overloaded.
15pub trait SpanExporter: Send + Sync + fmt::Debug {
16    fn export(&self, span: Span);
17
18    /// Deliver everything queued so far (and current metrics, when supported).
19    fn flush(&self) -> BoxFuture<'_, ()> {
20        Box::pin(futures::future::ready(()))
21    }
22}
23
24/// Keeps spans in memory. For tests and embedding hosts that ship spans themselves.
25#[derive(Debug, Default, Clone)]
26pub struct InMemoryExporter {
27    spans: Arc<Mutex<Vec<Span>>>,
28}
29
30impl InMemoryExporter {
31    pub fn new() -> Self {
32        Self::default()
33    }
34
35    /// Spans exported so far, in export order.
36    pub fn spans(&self) -> Vec<Span> {
37        self.spans.lock().unwrap_or_else(PoisonError::into_inner).clone()
38    }
39
40    /// Remove and return the exported spans.
41    pub fn take(&self) -> Vec<Span> {
42        std::mem::take(&mut *self.spans.lock().unwrap_or_else(PoisonError::into_inner))
43    }
44}
45
46impl SpanExporter for InMemoryExporter {
47    fn export(&self, span: Span) {
48        self.spans.lock().unwrap_or_else(PoisonError::into_inner).push(span);
49    }
50}
51
52/// Writes each span as one OTLP-JSON line to a writer (stdout / stderr by default).
53pub struct WriterExporter {
54    out: Mutex<Box<dyn Write + Send>>,
55}
56
57/// Alias kept for discoverability: the debugging exporter.
58pub type StdoutExporter = WriterExporter;
59
60impl fmt::Debug for WriterExporter {
61    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
62        f.write_str("WriterExporter")
63    }
64}
65
66impl WriterExporter {
67    pub fn new(out: Box<dyn Write + Send>) -> Self {
68        Self { out: Mutex::new(out) }
69    }
70
71    pub fn stdout() -> Self {
72        Self::new(Box::new(std::io::stdout()))
73    }
74
75    /// Stderr, so span lines never mix with a run's answer on stdout.
76    pub fn stderr() -> Self {
77        Self::new(Box::new(std::io::stderr()))
78    }
79}
80
81impl SpanExporter for WriterExporter {
82    fn export(&self, span: Span) {
83        let line = otlp::span(&span).to_string();
84        let mut out = self.out.lock().unwrap_or_else(PoisonError::into_inner);
85        // Debug output: a failed write is not worth failing the run over.
86        let _ignored = writeln!(out, "{line}");
87    }
88
89    fn flush(&self) -> BoxFuture<'_, ()> {
90        let _ignored = self.out.lock().unwrap_or_else(PoisonError::into_inner).flush();
91        Box::pin(futures::future::ready(()))
92    }
93}
94
95/// Sends every span to several exporters.
96#[derive(Debug, Default, Clone)]
97pub struct MultiExporter {
98    exporters: Vec<Arc<dyn SpanExporter>>,
99}
100
101impl MultiExporter {
102    pub fn new() -> Self {
103        Self::default()
104    }
105
106    pub fn with(mut self, exporter: Arc<dyn SpanExporter>) -> Self {
107        self.exporters.push(exporter);
108        self
109    }
110
111    pub fn is_empty(&self) -> bool {
112        self.exporters.is_empty()
113    }
114}
115
116impl SpanExporter for MultiExporter {
117    fn export(&self, span: Span) {
118        if let Some((last, rest)) = self.exporters.split_last() {
119            for e in rest {
120                e.export(span.clone());
121            }
122            last.export(span);
123        }
124    }
125
126    fn flush(&self) -> BoxFuture<'_, ()> {
127        Box::pin(async move {
128            for e in &self.exporters {
129                e.flush().await;
130            }
131        })
132    }
133}