1use 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
13pub trait SpanExporter: Send + Sync + fmt::Debug {
16 fn export(&self, span: Span);
17
18 fn flush(&self) -> BoxFuture<'_, ()> {
20 Box::pin(futures::future::ready(()))
21 }
22}
23
24#[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 pub fn spans(&self) -> Vec<Span> {
37 self.spans.lock().unwrap_or_else(PoisonError::into_inner).clone()
38 }
39
40 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
52pub struct WriterExporter {
54 out: Mutex<Box<dyn Write + Send>>,
55}
56
57pub 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 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 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#[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}