Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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"]);
}