grow-apache-skywalking 0.2.0

Rust SDK for Apache SkyWalking by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! In-memory span exporter and trace query client for tests.

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())
}

/// OpenTelemetry [`SpanExporter`] that keeps finished spans in memory; clones share the store.
/// The `service.name` comes from the provider's resource.
#[derive(Debug, Clone, Default)]
pub struct MemorySpanExporter {
    inner: Arc<Inner>,
}

impl MemorySpanExporter {
    /// Empty exporter.
    pub fn new() -> Self {
        Self::default()
    }

    /// Starts tracing with this exporter (see [`init_tracing_with`]).
    pub fn init(&self, config: TracingConfig) -> Result<TracingHandle> {
        let exporter = self.clone();
        init_tracing_with(config, move |_| Ok(exporter))
    }

    /// Raw SDK span data in export order.
    pub fn span_data(&self) -> Vec<SpanData> {
        lock(&self.inner.spans).clone()
    }

    /// Finished spans converted to the query model. A span attribute `service.name` overrides
    /// the resource's service name (to simulate several services in one test).
    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()
    }

    /// Removes every stored span.
    pub fn clear(&self) {
        lock(&self.inner.spans).clear();
    }

    /// `service.name` reported by the provider (`unknown_service` before it is known).
    pub fn service_name(&self) -> String {
        let name = lock(&self.inner.service_name).clone();
        if name.is_empty() {
            "unknown_service".to_string()
        } else {
            name
        }
    }

    /// Makes every export fail (`true`) or succeed again (`false`).
    pub fn set_failing(&self, fail: bool) {
        self.inner.fail.store(fail, Ordering::SeqCst);
    }

    /// Number of `shutdown` calls.
    pub fn shutdown_calls(&self) -> usize {
        self.inner.shutdowns.load(Ordering::SeqCst)
    }

    /// Query client over the stored spans.
    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();
        }
    }
}

/// [`TraceQueryClient`] over a [`MemorySpanExporter`] (dependencies are derived from
/// parent/child spans of different services).
#[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())
    }
}