use std::fmt;
use std::io::Write;
use std::sync::{Arc, Mutex, PoisonError};
use futures::future::BoxFuture;
use crate::otlp;
use crate::span::Span;
pub trait SpanExporter: Send + Sync + fmt::Debug {
fn export(&self, span: Span);
fn flush(&self) -> BoxFuture<'_, ()> {
Box::pin(futures::future::ready(()))
}
}
#[derive(Debug, Default, Clone)]
pub struct InMemoryExporter {
spans: Arc<Mutex<Vec<Span>>>,
}
impl InMemoryExporter {
pub fn new() -> Self {
Self::default()
}
pub fn spans(&self) -> Vec<Span> {
self.spans.lock().unwrap_or_else(PoisonError::into_inner).clone()
}
pub fn take(&self) -> Vec<Span> {
std::mem::take(&mut *self.spans.lock().unwrap_or_else(PoisonError::into_inner))
}
}
impl SpanExporter for InMemoryExporter {
fn export(&self, span: Span) {
self.spans.lock().unwrap_or_else(PoisonError::into_inner).push(span);
}
}
pub struct WriterExporter {
out: Mutex<Box<dyn Write + Send>>,
}
pub type StdoutExporter = WriterExporter;
impl fmt::Debug for WriterExporter {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("WriterExporter")
}
}
impl WriterExporter {
pub fn new(out: Box<dyn Write + Send>) -> Self {
Self { out: Mutex::new(out) }
}
pub fn stdout() -> Self {
Self::new(Box::new(std::io::stdout()))
}
pub fn stderr() -> Self {
Self::new(Box::new(std::io::stderr()))
}
}
impl SpanExporter for WriterExporter {
fn export(&self, span: Span) {
let line = otlp::span(&span).to_string();
let mut out = self.out.lock().unwrap_or_else(PoisonError::into_inner);
let _ignored = writeln!(out, "{line}");
}
fn flush(&self) -> BoxFuture<'_, ()> {
let _ignored = self.out.lock().unwrap_or_else(PoisonError::into_inner).flush();
Box::pin(futures::future::ready(()))
}
}
#[derive(Debug, Default, Clone)]
pub struct MultiExporter {
exporters: Vec<Arc<dyn SpanExporter>>,
}
impl MultiExporter {
pub fn new() -> Self {
Self::default()
}
pub fn with(mut self, exporter: Arc<dyn SpanExporter>) -> Self {
self.exporters.push(exporter);
self
}
pub fn is_empty(&self) -> bool {
self.exporters.is_empty()
}
}
impl SpanExporter for MultiExporter {
fn export(&self, span: Span) {
if let Some((last, rest)) = self.exporters.split_last() {
for e in rest {
e.export(span.clone());
}
last.export(span);
}
}
fn flush(&self) -> BoxFuture<'_, ()> {
Box::pin(async move {
for e in &self.exporters {
e.flush().await;
}
})
}
}