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.

14.4 KB
Raw Blame
use super::*;

use opentelemetry::trace::TraceContextExt as _;
use opentelemetry::trace::{SpanId, TraceId};
use opentelemetry_sdk::trace::InMemorySpanExporter;
use std::io;
use std::sync::{Arc, Mutex, Once};
use tracing_opentelemetry::OpenTelemetrySpanExt as _;
use tracing_subscriber::fmt::MakeWriter;

#[derive(Clone, Default)]
struct SharedWriter(Arc<Mutex<Vec<u8>>>);

impl SharedWriter {
    fn contents(&self) -> String {
        String::from_utf8(self.0.lock().unwrap().clone()).unwrap()
    }
}

impl io::Write for SharedWriter {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.0.lock().unwrap().extend_from_slice(buf);
        Ok(buf.len())
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl<'a> MakeWriter<'a> for SharedWriter {
    type Writer = SharedWriter;

    fn make_writer(&'a self) -> Self::Writer {
        self.clone()
    }
}

fn test_tracer_provider() -> (InMemorySpanExporter, SdkTracerProvider) {
    let exporter = InMemorySpanExporter::default();
    let provider = SdkTracerProvider::builder()
        .with_simple_exporter(exporter.clone())
        .build();
    (exporter, provider)
}

#[tokio::test]
async fn force_flush_exports_short_invocations_and_preserves_warm_provider() {
    use opentelemetry::trace::Tracer as _;

    let exporter = InMemorySpanExporter::default();
    let provider = SdkTracerProvider::builder()
        .with_batch_exporter(exporter.clone())
        .build();
    let tracer = provider.tracer("retention-test");
    let entrypoint = InitializedEntrypoint {
        tracer_provider: Some(provider),
        logger_provider: None,
    };

    tracer.in_span("first-invocation", |_| {});
    entrypoint
        .force_flush()
        .await
        .expect("first flush succeeds");
    let spans = exporter.get_finished_spans().expect("exported spans");
    assert_eq!(spans.len(), 1);
    assert_eq!(spans[0].name, "first-invocation");

    tracer.in_span("warm-invocation", |_| {});
    entrypoint.force_flush().await.expect("warm flush succeeds");
    let spans = exporter.get_finished_spans().expect("exported spans");
    assert_eq!(spans.len(), 2);
    assert_eq!(spans[1].name, "warm-invocation");
    entrypoint.shutdown();
}

#[tokio::test]
async fn force_flush_reports_export_failure_instead_of_success() {
    use opentelemetry::trace::Tracer as _;
    use opentelemetry_sdk::{
        error::{OTelSdkError, OTelSdkResult},
        trace::{BatchConfigBuilder, BatchSpanProcessor, SpanData, SpanExporter},
    };

    #[derive(Debug)]
    struct FailingExporter;
    impl SpanExporter for FailingExporter {
        async fn export(&self, _batch: Vec<SpanData>) -> OTelSdkResult {
            Err(OTelSdkError::InternalFailure(
                "test export failure".to_owned(),
            ))
        }
    }
    let processor = BatchSpanProcessor::builder(FailingExporter)
        .with_batch_config(
            BatchConfigBuilder::default()
                .with_scheduled_delay(std::time::Duration::from_secs(3600))
                .build(),
        )
        .build();
    let provider = SdkTracerProvider::builder()
        .with_span_processor(processor)
        .build();
    provider
        .tracer("test")
        .in_span("completed-invocation", |_| {});
    let entrypoint = InitializedEntrypoint {
        tracer_provider: Some(provider),
        logger_provider: None,
    };
    assert!(matches!(
        entrypoint.force_flush().await,
        Err(TelemetryFlushError::Traces(_))
    ));
    entrypoint.shutdown();
}

#[tokio::test]
async fn force_flush_without_exporters_is_a_noop() {
    InitializedEntrypoint {
        tracer_provider: None,
        logger_provider: None,
    }
    .force_flush()
    .await
    .expect("no exporter needs flushing");
}

#[test]
fn rootcause_tracing_subscriber_captures_span_chain() {
    static INSTALL_ROOTCAUSE_HOOKS: Once = Once::new();
    INSTALL_ROOTCAUSE_HOOKS.call_once(install_rootcause_hooks);

    let subscriber = Registry::default().with(RootcauseLayer.with_filter(EnvFilter::new("info")));
    let output = tracing::subscriber::with_default(subscriber, || {
        let request = tracing::info_span!("handle_request", request_id = "req-123");
        let _request_guard = request.enter();
        let document = tracing::info_span!("load_document", document_id = 42);
        let _document_guard = document.enter();

        rootcause::report!("document load failed").to_string()
    });

    assert!(output.contains("document load failed"));
    assert!(output.contains("Tracing spans"));

    let document_span = "load_document{document_id=42}";
    let request_span = "handle_request{request_id=\"req-123\"}";
    assert!(output.contains(document_span), "{output}");
    assert!(output.contains(request_span), "{output}");
    assert!(
        output.find(document_span) < output.find(request_span),
        "span chain should be ordered from the innermost span outward: {output}"
    );
    assert!(!output.contains("Span values missing"), "{output}");
}

#[test]
fn rust_log_warn_does_not_drop_info_spans() {
    let (exporter, provider) = test_tracer_provider();
    let tracer = provider.tracer("test");

    let rust_log_filter = EnvFilter::new("warn");
    let otel_filter = otel_trace_filter(None);
    let rootcause_filter = rust_log_filter.clone().or(otel_filter.clone());
    let otel_layer = tracing_opentelemetry::layer()
        .with_tracer(tracer)
        .with_filter(otel_filter);

    let json_format = tracing_subscriber::fmt::format::Format::default()
        .json()
        .with_current_span(true)
        .with_span_list(false)
        .flatten_event(true);

    let logs = SharedWriter::default();
    let fmt_layer = tracing_subscriber::fmt::layer()
        .with_ansi(false)
        .fmt_fields(tracing_subscriber::fmt::format::JsonFields::new())
        .event_format(datadog_fmt::DatadogFormat { inner: json_format })
        .with_writer(logs.clone())
        .with_filter(rust_log_filter);

    let subscriber = Registry::default()
        .with(RootcauseLayer.with_filter(rootcause_filter))
        .with(fmt_layer)
        .with(otel_layer);

    // The span context DatadogFormat reads via Span::current() is only observable here
    // outside event dispatch: under a scoped test dispatcher, tracing's re-entrancy guard
    // hands Dispatch::none() to Span::current() inside format_event. Prod installs a global
    // dispatcher, which get_default resolves without the guard.
    let mut current_ids: Option<(TraceId, SpanId)> = None;
    tracing::subscriber::with_default(subscriber, || {
        assert!(tracing::enabled!(tracing::Level::INFO));
        assert!(!tracing::enabled!(tracing::Level::DEBUG));

        tracing::debug_span!("filtered_debug_op").in_scope(|| {});
        tracing::info_span!("instrumented_op").in_scope(|| {
            let cx = tracing::Span::current().context();
            let span_cx = cx.span().span_context().clone();
            assert!(span_cx.is_valid());
            current_ids = Some((span_cx.trace_id(), span_cx.span_id()));

            tracing::warn!("warn inside info span");
            tracing::info!("info event is filtered from logs");
        });
    });

    let spans = exporter.get_finished_spans().unwrap();
    assert_eq!(spans.len(), 1);
    assert_eq!(spans[0].name, "instrumented_op");

    let (trace_id, span_id) = current_ids.unwrap();
    assert_eq!(spans[0].span_context.trace_id(), trace_id);
    assert_eq!(spans[0].span_context.span_id(), span_id);

    let output = logs.contents();
    let line = output
        .lines()
        .find(|l| l.contains("warn inside info span"))
        .expect("warn event should be logged");
    assert!(serde_json::from_str::<serde_json::Value>(line).is_ok());
    assert!(!output.contains("info event is filtered from logs"));
}

#[test]
fn rust_log_target_directive_includes_info_span_fields_in_warn_log() {
    let json_format = tracing_subscriber::fmt::format::Format::default()
        .json()
        .with_current_span(true)
        .with_span_list(false)
        .flatten_event(true);

    let logs = SharedWriter::default();
    let fmt_layer = tracing_subscriber::fmt::layer()
        .with_ansi(false)
        .fmt_fields(tracing_subscriber::fmt::format::JsonFields::new())
        .event_format(datadog_fmt::DatadogFormat { inner: json_format })
        .with_writer(logs.clone())
        .with_filter(EnvFilter::new("warn,macro_http_request=info"));
    let subscriber = Registry::default().with(fmt_layer);

    tracing::subscriber::with_default(subscriber, || {
        tracing::info_span!(
            target: "macro_http_request",
            "http.request",
            "http.request.method" = "POST",
            "url.path" = "/documents",
            "request.id" = "req-123",
        )
        .in_scope(|| {
            tracing::warn!("slow http request");
            tracing::info!(target: "other_target", "filtered info event");
        });
    });

    let output = logs.contents();
    let line = output
        .lines()
        .find(|line| line.contains("slow http request"))
        .expect("warn event should be logged");
    let json = serde_json::from_str::<serde_json::Value>(line).unwrap();
    assert_eq!(json["span"]["name"], "http.request", "{output}");
    assert_eq!(json["span"]["http.request.method"], "POST");
    assert_eq!(json["span"]["url.path"], "/documents");
    assert_eq!(json["span"]["request.id"], "req-123");
    assert!(!output.contains("filtered info event"));
}

#[test]
fn global_warn_filter_drops_info_spans() {
    let (exporter, provider) = test_tracer_provider();
    let tracer = provider.tracer("test");

    let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);

    let subscriber = Registry::default()
        .with(EnvFilter::new("warn"))
        .with(otel_layer);

    tracing::subscriber::with_default(subscriber, || {
        tracing::info_span!("instrumented_op").in_scope(|| {
            tracing::warn!("warn inside info span");
        });
    });

    assert!(exporter.get_finished_spans().unwrap().is_empty());
}

#[test]
fn otel_trace_filter_defaults_to_info() {
    let (exporter, provider) = test_tracer_provider();
    let tracer = provider.tracer("test");

    let otel_layer = tracing_opentelemetry::layer()
        .with_tracer(tracer)
        .with_filter(otel_trace_filter(None));

    let subscriber = Registry::default().with(otel_layer);

    tracing::subscriber::with_default(subscriber, || {
        tracing::info_span!("info_op").in_scope(|| {});
        tracing::debug_span!("debug_op").in_scope(|| {});
    });

    let names: Vec<_> = exporter
        .get_finished_spans()
        .unwrap()
        .into_iter()
        .map(|s| s.name)
        .collect();
    assert_eq!(names, vec!["info_op"]);
}

#[test]
fn otel_trace_filter_invalid_value_falls_back_to_info() {
    let (exporter, provider) = test_tracer_provider();
    let tracer = provider.tracer("test");

    let otel_layer = tracing_opentelemetry::layer()
        .with_tracer(tracer)
        .with_filter(otel_trace_filter(Some("foo=notalevel")));

    let subscriber = Registry::default().with(otel_layer);

    tracing::subscriber::with_default(subscriber, || {
        tracing::info_span!("info_op").in_scope(|| {});
    });

    assert_eq!(exporter.get_finished_spans().unwrap().len(), 1);
}

#[test]
fn absent_rust_log_still_logs_info() {
    // A builder with no default directive and an empty value parses to zero
    // directives, which logs nothing at all - the failure mode this floor
    // exists to prevent. A service deployed without `RUST_LOG` must still
    // emit its INFO lines, because those are what carry the decisions worth
    // reconstructing after the fact.
    for value in [None, Some("")] {
        let logs = SharedWriter::default();
        let subscriber = Registry::default().with(
            tracing_subscriber::fmt::layer()
                .with_ansi(false)
                .with_writer(logs.clone())
                .with_filter(rust_log_filter(value)),
        );

        tracing::subscriber::with_default(subscriber, || {
            tracing::info!("info survives an unset RUST_LOG");
            tracing::debug!("debug is still filtered");
        });

        let output = logs.contents();
        assert!(
            output.contains("info survives an unset RUST_LOG"),
            "RUST_LOG={value:?} should keep INFO: {output:?}"
        );
        assert!(
            !output.contains("debug is still filtered"),
            "RUST_LOG={value:?} should not raise the floor to DEBUG: {output:?}"
        );
    }
}

#[test]
fn explicit_rust_log_still_wins_over_the_floor() {
    let logs = SharedWriter::default();
    let subscriber = Registry::default().with(
        tracing_subscriber::fmt::layer()
            .with_ansi(false)
            .with_writer(logs.clone())
            .with_filter(rust_log_filter(Some("warn"))),
    );

    tracing::subscriber::with_default(subscriber, || {
        tracing::warn!("warn is kept");
        tracing::info!("info is filtered by an explicit directive");
    });

    let output = logs.contents();
    assert!(output.contains("warn is kept"), "{output:?}");
    assert!(
        !output.contains("info is filtered by an explicit directive"),
        "an explicit RUST_LOG must override the default floor: {output:?}"
    );
}

#[test]
fn dependency_suppression_overrides_enabled_logs_without_hiding_service_logs() {
    let output = SharedWriter::default();
    let subscriber = Registry::default()
        .with(tracing_subscriber::filter::filter_fn(|metadata| {
            dependency_logs_allowed(&["russh", "rmcp"], metadata.target())
        }))
        .with(
            tracing_subscriber::fmt::layer()
                .with_ansi(false)
                .with_writer(output.clone())
                .with_filter(EnvFilter::new("info")),
        );
    tracing::subscriber::with_default(subscriber, || {
        tracing::info!(target: "russh::server", username = "test-only-token", "authentication");
        tracing::info!(target: "rmcp::service", "script containing test-only-token");
        tracing::info!(target: "preview_gateway", "gateway ready");
        tracing::info!(target: "russh_unrelated", "unrelated target");
    });
    let text = output.contents();
    assert!(!text.contains("test-only-token"));
    assert!(text.contains("gateway ready"));
    assert!(text.contains("unrelated target"));
    let entrypoint = MacroEntrypoint::default()
        .suppress_dependency_logs(&["russh"])
        .local()
        .build();
    assert_eq!(entrypoint.suppressed_targets, &["russh"]);
}