use std::collections::{BTreeMap, BTreeSet};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use async_trait::async_trait;
use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
use opentelemetry_sdk::trace::{SpanData, SpanExporter};
use opentelemetry_sdk::Resource;
use crate::core::Result;
use crate::tracing::{
init_tracing_with, normalize_trace_id, DependencyLink, DependencyOptions, Span, Trace,
TraceQueryClient, TraceSearchQuery, TraceSummary, TracingConfig, TracingHandle,
};
#[derive(Debug, Default)]
struct Inner {
spans: Mutex<Vec<SpanData>>,
service_name: Mutex<String>,
fail: AtomicBool,
shutdowns: AtomicUsize,
}
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(|e| e.into_inner())
}
#[derive(Debug, Clone, Default)]
pub struct MemorySpanExporter {
inner: Arc<Inner>,
}
impl MemorySpanExporter {
pub fn new() -> Self {
Self::default()
}
pub fn init(&self, config: TracingConfig) -> Result<TracingHandle> {
let exporter = self.clone();
init_tracing_with(config, move |_| Ok(exporter))
}
pub fn span_data(&self) -> Vec<SpanData> {
lock(&self.inner.spans).clone()
}
pub fn spans(&self) -> Vec<Span> {
let service = self.service_name();
lock(&self.inner.spans)
.iter()
.map(|d| {
let mut span = Span::from_span_data(d, &service);
if let Some(name) = span.attributes.get("service.name").and_then(|v| v.as_str()) {
span.service_name = name.to_string();
}
span
})
.collect()
}
pub fn clear(&self) {
lock(&self.inner.spans).clear();
}
pub fn service_name(&self) -> String {
let name = lock(&self.inner.service_name).clone();
if name.is_empty() {
"unknown_service".to_string()
} else {
name
}
}
pub fn set_failing(&self, fail: bool) {
self.inner.fail.store(fail, Ordering::SeqCst);
}
pub fn shutdown_calls(&self) -> usize {
self.inner.shutdowns.load(Ordering::SeqCst)
}
pub fn query(&self) -> MemoryTraceQuery {
MemoryTraceQuery {
exporter: self.clone(),
}
}
fn traces(&self) -> Vec<Trace> {
let mut by_id: BTreeMap<String, Vec<Span>> = BTreeMap::new();
for s in self.spans() {
by_id.entry(s.trace_id.clone()).or_default().push(s);
}
by_id
.into_iter()
.map(|(id, spans)| Trace::new(id, spans))
.collect()
}
}
impl SpanExporter for MemorySpanExporter {
async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
if self.inner.fail.load(Ordering::SeqCst) {
return Err(OTelSdkError::InternalFailure(
"memory exporter set to fail".into(),
));
}
lock(&self.inner.spans).extend(batch);
Ok(())
}
fn shutdown_with_timeout(&mut self, _timeout: std::time::Duration) -> OTelSdkResult {
self.inner.shutdowns.fetch_add(1, Ordering::SeqCst);
Ok(())
}
fn set_resource(&mut self, resource: &Resource) {
if let Some(v) = resource.get(&opentelemetry::Key::from_static_str("service.name")) {
*lock(&self.inner.service_name) = v.to_string();
}
}
}
#[derive(Debug, Clone)]
pub struct MemoryTraceQuery {
exporter: MemorySpanExporter,
}
#[async_trait]
impl TraceQueryClient for MemoryTraceQuery {
async fn get_trace(&self, trace_id: &str) -> Result<Option<Trace>> {
let id = normalize_trace_id(trace_id)?;
Ok(self
.exporter
.traces()
.into_iter()
.find(|t| t.trace_id == id))
}
async fn search_traces(&self, query: &TraceSearchQuery) -> Result<Vec<TraceSummary>> {
let mut hits: Vec<TraceSummary> = self
.exporter
.traces()
.iter()
.filter(|t| query.matches(t))
.map(Trace::summary)
.collect();
hits.sort_by_key(|h| std::cmp::Reverse(h.start_micros));
hits.truncate(query.limit);
Ok(hits)
}
async fn list_services(&self) -> Result<Vec<String>> {
let set: BTreeSet<String> = self
.exporter
.spans()
.into_iter()
.map(|s| s.service_name)
.collect();
Ok(set.into_iter().collect())
}
async fn list_operations(&self, service: &str) -> Result<Vec<String>> {
let set: BTreeSet<String> = self
.exporter
.spans()
.into_iter()
.filter(|s| s.service_name == service)
.map(|s| s.name)
.collect();
Ok(set.into_iter().collect())
}
async fn get_dependencies(&self, _opts: DependencyOptions) -> Result<Vec<DependencyLink>> {
let spans = self.exporter.spans();
let by_id: BTreeMap<(&str, &str), &Span> = spans
.iter()
.map(|s| ((s.trace_id.as_str(), s.span_id.as_str()), s))
.collect();
let mut counts: BTreeMap<(String, String), u64> = BTreeMap::new();
for s in &spans {
let parent = s
.parent_span_id
.as_deref()
.and_then(|p| by_id.get(&(s.trace_id.as_str(), p)));
if let Some(p) = parent.filter(|p| p.service_name != s.service_name) {
*counts
.entry((p.service_name.clone(), s.service_name.clone()))
.or_default() += 1;
}
}
Ok(counts
.into_iter()
.map(|((parent, child), call_count)| DependencyLink {
parent,
child,
call_count,
})
.collect())
}
}