use std::sync::Once;
#[cfg(feature = "otlp")]
use std::sync::OnceLock;
use tracing_subscriber::{fmt, prelude::*, EnvFilter};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum LogLevel {
Auto,
Error,
Warn,
Info,
Debug,
Trace,
}
impl LogLevel {
fn as_directive(self) -> Option<&'static str> {
match self {
LogLevel::Auto => None,
LogLevel::Error => Some("error"),
LogLevel::Warn => Some("warn"),
LogLevel::Info => Some("info"),
LogLevel::Debug => Some("debug"),
LogLevel::Trace => Some("trace"),
}
}
}
static INIT: Once = Once::new();
#[cfg(feature = "otlp")]
static INIT_OTLP: Once = Once::new();
#[cfg(feature = "otlp")]
static INIT_OTLP_RESULT: OnceLock<Result<(), OtlpInitError>> = OnceLock::new();
pub fn init(level: LogLevel, json: bool) -> bool {
let mut try_init_succeeded = false;
INIT.call_once(|| {
let filter = build_filter(level);
let registry = tracing_subscriber::registry().with(filter);
let try_init_result = if json {
let json_layer = fmt::layer()
.json()
.with_target(true)
.with_current_span(true)
.with_span_list(false);
registry.with(json_layer).try_init()
} else {
let pretty_layer = fmt::layer().with_target(true).with_ansi(true).compact();
registry.with(pretty_layer).try_init()
};
try_init_succeeded = try_init_result.is_ok();
});
try_init_succeeded
}
fn build_filter(level: LogLevel) -> EnvFilter {
match level.as_directive() {
Some(directive) => filter_from_directive(directive),
None => {
if let Ok(v) = std::env::var("TENSOR_WASM_LOG") {
filter_from_directive(&v)
} else {
EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"))
}
}
}
}
fn filter_from_directive(directive: &str) -> EnvFilter {
EnvFilter::try_new(directive).unwrap_or_else(|_| EnvFilter::new("info"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn init_is_idempotent() {
let first = init(LogLevel::Info, false);
let second = init(LogLevel::Debug, true);
assert!(!(first && second), "init reported success twice");
let third = init(LogLevel::Info, false);
assert!(!third, "init succeeded after at least one prior call");
}
#[test]
fn log_level_directives() {
assert_eq!(LogLevel::Error.as_directive(), Some("error"));
assert_eq!(LogLevel::Warn.as_directive(), Some("warn"));
assert_eq!(LogLevel::Info.as_directive(), Some("info"));
assert_eq!(LogLevel::Debug.as_directive(), Some("debug"));
assert_eq!(LogLevel::Trace.as_directive(), Some("trace"));
assert_eq!(LogLevel::Auto.as_directive(), None);
}
#[test]
fn log_levels_are_distinct() {
assert_ne!(LogLevel::Info, LogLevel::Debug);
assert_ne!(LogLevel::Trace, LogLevel::Auto);
}
#[test]
fn build_filter_falls_back_to_info_on_malformed_env() {
temp_env::with_vars(
[
("TENSOR_WASM_LOG", Some("twasm=notalevel")),
("RUST_LOG", None::<&str>),
],
|| {
let filter = build_filter(LogLevel::Auto);
let rendered = format!("{filter}");
assert!(
rendered.contains("info"),
"expected `info` fallback for malformed env directive, got: {rendered}",
);
},
);
}
#[test]
fn build_filter_uses_default_when_env_unset() {
temp_env::with_vars(
[
("TENSOR_WASM_LOG", None::<&str>),
("RUST_LOG", None::<&str>),
],
|| {
let filter = build_filter(LogLevel::Auto);
let rendered = format!("{filter}");
assert!(
rendered.contains("info"),
"expected `info` default with both env vars unset, got: {rendered}",
);
},
);
}
#[test]
fn filter_from_directive_falls_back_to_info_on_malformed() {
let filter = filter_from_directive("twasm=notalevel");
let rendered = format!("{filter}");
assert!(
rendered.contains("info"),
"expected `info` fallback for malformed explicit directive, got: {rendered}",
);
}
#[test]
fn filter_from_directive_preserves_valid_directive() {
let filter = filter_from_directive("debug");
let rendered = format!("{filter}");
assert!(
rendered.contains("debug"),
"expected valid `debug` directive to be preserved, got: {rendered}",
);
}
#[test]
fn build_filter_explicit_level_is_honoured() {
let filter = build_filter(LogLevel::Warn);
let rendered = format!("{filter}");
assert!(
rendered.contains("warn"),
"expected explicit `Warn` level to yield a `warn` filter, got: {rendered}",
);
}
}
#[cfg(feature = "otlp")]
#[cfg_attr(docsrs, doc(cfg(feature = "otlp")))]
pub fn init_with_otlp(
level: LogLevel,
json: bool,
otlp_env_var: &str,
) -> Result<bool, OtlpInitError> {
if INIT.is_completed() {
return Err(OtlpInitError::AlreadyInitialized);
}
let mut performed = false;
INIT_OTLP.call_once(|| {
let outcome = run_otlp_init(level, json, otlp_env_var);
performed = outcome.is_ok();
let _ = INIT_OTLP_RESULT.set(outcome);
});
if performed {
return Ok(true);
}
match INIT_OTLP_RESULT.get() {
Some(Ok(())) => Ok(false),
Some(Err(e)) => Err(e.clone()),
None => Ok(false),
}
}
#[cfg(feature = "otlp")]
fn resolve_otlp_endpoint(primary: &str, lookup: impl Fn(&str) -> Option<String>) -> String {
lookup(primary)
.or_else(|| lookup("OTEL_EXPORTER_OTLP_ENDPOINT"))
.unwrap_or_else(|| "http://localhost:4317".to_string())
}
#[cfg(feature = "otlp")]
fn map_exporter_error<E: std::fmt::Debug>(e: E) -> OtlpInitError {
OtlpInitError::Exporter(format!("{e:?}"))
}
#[cfg(feature = "otlp")]
fn run_otlp_init(level: LogLevel, json: bool, otlp_env_var: &str) -> Result<(), OtlpInitError> {
use opentelemetry::trace::TracerProvider as _;
use opentelemetry_otlp::WithExportConfig;
use tracing_subscriber::{fmt, prelude::*};
let endpoint = resolve_otlp_endpoint(otlp_env_var, |name| std::env::var(name).ok());
let exporter = opentelemetry_otlp::SpanExporter::builder()
.with_tonic()
.with_endpoint(&endpoint)
.build()
.map_err(map_exporter_error)?;
let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
.with_batch_exporter(exporter)
.with_resource(
opentelemetry_sdk::Resource::builder()
.with_service_name("tensor-wasm")
.build(),
)
.build();
let tracer = provider.tracer("tensor-wasm");
let filter = build_filter(level);
let otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);
let registry = tracing_subscriber::registry().with(filter).with(otel_layer);
let try_init_result = if json {
registry.with(fmt::layer().json()).try_init()
} else {
registry.with(fmt::layer().compact()).try_init()
};
if try_init_result.is_err() {
drop(provider);
return Err(OtlpInitError::AlreadyInitialized);
}
opentelemetry::global::set_tracer_provider(provider);
opentelemetry::global::set_text_map_propagator(
opentelemetry_sdk::propagation::TraceContextPropagator::new(),
);
Ok(())
}
#[cfg(feature = "otlp")]
#[cfg_attr(docsrs, doc(cfg(feature = "otlp")))]
#[derive(Debug, Clone, thiserror::Error)]
#[non_exhaustive]
pub enum OtlpInitError {
#[error("OTLP exporter build failed: {0}")]
Exporter(String),
#[error("a global tracing subscriber has already been installed")]
AlreadyInitialized,
}
#[cfg(all(test, feature = "otlp"))]
mod otlp_tests {
use super::*;
#[test]
fn init_with_otlp_does_not_panic() {
let _ = init_with_otlp(LogLevel::Info, false, "TENSOR_WASM_TEST_OTLP_ENDPOINT");
}
#[test]
fn already_initialized_variant_displays() {
let e = OtlpInitError::AlreadyInitialized;
let s = format!("{e}");
assert!(
s.to_lowercase().contains("already"),
"AlreadyInitialized message should mention 'already', got: {s}",
);
}
#[test]
fn already_initialized_when_init_ran_first() {
let _ = init(LogLevel::Info, false);
assert!(INIT.is_completed());
let err = init_with_otlp(LogLevel::Info, false, "TENSOR_WASM_TEST_OTLP_ENDPOINT_2")
.expect_err("init_with_otlp must fail once plain init has run");
assert!(matches!(err, OtlpInitError::AlreadyInitialized));
}
#[test]
fn resolve_endpoint_prefers_primary_var() {
let endpoint = resolve_otlp_endpoint("PRIMARY", |name| match name {
"PRIMARY" => Some("http://primary:4317".to_string()),
"OTEL_EXPORTER_OTLP_ENDPOINT" => Some("http://standard:4317".to_string()),
_ => None,
});
assert_eq!(endpoint, "http://primary:4317");
}
#[test]
fn resolve_endpoint_falls_back_to_standard_var() {
let endpoint = resolve_otlp_endpoint("PRIMARY", |name| match name {
"OTEL_EXPORTER_OTLP_ENDPOINT" => Some("http://standard:4317".to_string()),
_ => None,
});
assert_eq!(endpoint, "http://standard:4317");
}
#[test]
fn resolve_endpoint_falls_back_to_default() {
let endpoint = resolve_otlp_endpoint("PRIMARY", |_| None);
assert_eq!(endpoint, "http://localhost:4317");
}
#[test]
fn map_exporter_error_produces_exporter_variant() {
#[derive(Debug)]
struct SyntheticErr;
let mapped = map_exporter_error(SyntheticErr);
match mapped {
OtlpInitError::Exporter(msg) => {
assert!(
msg.contains("SyntheticErr"),
"expected the Debug rendering of the source error, got: {msg}",
);
}
other => panic!("expected OtlpInitError::Exporter, got: {other:?}"),
}
}
#[test]
fn map_exporter_error_preserves_debug_rendering() {
#[derive(Debug)]
struct DetailedErr {
#[allow(dead_code)]
code: u32,
}
let mapped = map_exporter_error(DetailedErr { code: 7 });
let rendered = format!("{mapped}");
assert!(
rendered.contains("code: 7"),
"expected Debug fields preserved through the mapping, got: {rendered}",
);
}
}