Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.3 KB
Raw Blame
use tracing::field::{Field, Visit};
use tracing_subscriber::{
    Layer,
    layer::Context as LayerContext,
    registry::{LookupSpan, Registry},
};

use super::exporter::{buffer_log, buffer_span};
use super::model::{
    ClosedLog, ClosedSpan, ClosedSpanEvent, LiveSpan, now_unix_nanos, random_span_id,
    random_trace_id,
};
use super::trace_context::{parse_span_id, parse_trace_id, sampled_traceparent};
use super::{REMOTE_PARENT_FIELD, REMOTE_TRACE_ID_FIELD};

#[derive(Default)]
struct FieldVisitor {
    remote_trace_id: Option<[u8; 16]>,
    remote_parent: Option<[u8; 8]>,
    fields: Vec<(String, String)>,
}

impl FieldVisitor {
    fn record(&mut self, field: &Field, value: String) {
        match field.name() {
            REMOTE_TRACE_ID_FIELD => self.remote_trace_id = parse_trace_id(&value),
            REMOTE_PARENT_FIELD => self.remote_parent = parse_span_id(&value),
            name => self.fields.push((name.to_string(), value)),
        }
    }
}

macro_rules! string_visit {
    ($ty:ty) => {
        impl Visit for $ty {
            fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
                self.record(field, format!("{value:?}"));
            }

            fn record_str(&mut self, field: &Field, value: &str) {
                self.record(field, value.to_string());
            }
        }
    };
}

string_visit!(FieldVisitor);

#[derive(Default)]
struct EventVisitor {
    message: Option<String>,
    fields: Vec<(String, String)>,
}

impl EventVisitor {
    fn record(&mut self, field: &Field, value: String) {
        if field.name() == "message" {
            self.message = Some(value);
        } else {
            self.fields.push((field.name().to_string(), value));
        }
    }
}

string_visit!(EventVisitor);

/// A tracing-subscriber layer that exports closed spans through OTLP/HTTP.
pub struct OtelLayer {
    service_name: &'static str,
}

impl OtelLayer {
    /// Create a layer that identifies exported resources as `service_name`.
    pub const fn new(service_name: &'static str) -> Self {
        Self { service_name }
    }
}

/// Build a sampled W3C `traceparent` value for a span managed by this layer.
pub fn traceparent_for_span(span: &tracing::Span) -> Option<String> {
    span.with_subscriber(|(id, dispatch)| {
        let registry = dispatch.downcast_ref::<Registry>()?;
        let span = registry.span(id)?;
        let extensions = span.extensions();
        let data = extensions.get::<LiveSpan>()?;
        sampled_traceparent(data.trace_id, data.span_id)
    })
    .flatten()
}

impl<S> Layer<S> for OtelLayer
where
    S: tracing::Subscriber + for<'a> LookupSpan<'a>,
{
    fn on_new_span(
        &self,
        attrs: &tracing::span::Attributes<'_>,
        id: &tracing::span::Id,
        ctx: LayerContext<'_, S>,
    ) {
        let Some(span) = ctx.span(id) else { return };

        let mut visitor = FieldVisitor::default();
        attrs.record(&mut visitor);

        let parent = span.parent().and_then(|p| {
            let ext = p.extensions();
            ext.get::<LiveSpan>().map(|d| (d.trace_id, d.span_id))
        });

        let (trace_id, parent_span_id, local_root) = match parent {
            Some((trace_id, parent_span_id)) => (trace_id, Some(parent_span_id), false),
            None => match visitor.remote_trace_id {
                Some(remote_trace_id) => (remote_trace_id, visitor.remote_parent, true),
                None => (random_trace_id(), None, true),
            },
        };

        span.extensions_mut().insert(LiveSpan {
            trace_id,
            span_id: random_span_id(),
            parent_span_id,
            local_root,
            start_ns: now_unix_nanos(),
            attrs: visitor.fields,
            events: Vec::new(),
            error_message: None,
        });
    }

    fn on_event(&self, event: &tracing::Event<'_>, ctx: LayerContext<'_, S>) {
        if *event.metadata().level() > tracing::Level::INFO {
            return;
        }
        let mut visitor = EventVisitor::default();
        event.record(&mut visitor);
        let meta = event.metadata();
        let level = *meta.level();
        let name = visitor.message.unwrap_or_else(|| meta.name().to_string());
        let mut attrs = visitor.fields;
        attrs.push(("level".to_string(), level.as_str().to_string()));
        let time_ns = now_unix_nanos();
        let trace_context = ctx.event_span(event).and_then(|span| {
            let mut extensions = span.extensions_mut();
            let data = extensions.get_mut::<LiveSpan>()?;
            if level == tracing::Level::ERROR && data.error_message.is_none() {
                data.error_message = Some(name.clone());
            }
            data.events.push(ClosedSpanEvent {
                name: name.clone(),
                time_ns,
                attrs: attrs.clone(),
            });
            Some((data.trace_id, data.span_id))
        });
        let (trace_id, span_id) = trace_context
            .map(|(trace_id, span_id)| (Some(trace_id), Some(span_id)))
            .unwrap_or_default();
        buffer_log(ClosedLog {
            service_name: self.service_name,
            time_ns,
            level,
            body: name,
            attrs,
            target: meta.target(),
            file: meta.file(),
            line: meta.line(),
            trace_id,
            span_id,
        });
    }

    fn on_record(
        &self,
        id: &tracing::span::Id,
        values: &tracing::span::Record<'_>,
        ctx: LayerContext<'_, S>,
    ) {
        let Some(span) = ctx.span(id) else { return };
        let mut visitor = FieldVisitor::default();
        values.record(&mut visitor);
        if let Some(data) = span.extensions_mut().get_mut::<LiveSpan>() {
            data.attrs.append(&mut visitor.fields);
        }
    }

    fn on_close(&self, id: tracing::span::Id, ctx: LayerContext<'_, S>) {
        let Some(span) = ctx.span(&id) else { return };
        let Some(data) = span.extensions_mut().remove::<LiveSpan>() else {
            return;
        };
        let meta = span.metadata();
        buffer_span(ClosedSpan {
            data,
            service_name: self.service_name,
            name: meta.name(),
            level: meta.level().as_str(),
            file: meta.file(),
            line: meta.line(),
            end_ns: now_unix_nanos(),
        });
    }
}

#[cfg(test)]
mod test;