use tracing_subscriber::Layer;
use tracing_subscriber::filter::LevelFilter;
use tracing_subscriber::layer::SubscriberExt as _;
use tracing_subscriber::util::SubscriberInitExt as _;
#[must_use]
pub fn level_from_env() -> LevelFilter {
let rust_log = std::env::var("RUST_LOG")
.ok()
.and_then(|value| value.parse().ok());
let lambda = || {
std::env::var("AWS_LAMBDA_LOG_LEVEL")
.ok()
.and_then(|value| match value.trim() {
fatal if fatal.eq_ignore_ascii_case("fatal") => Some(LevelFilter::ERROR),
"" => None,
level => level.parse().ok(),
})
};
rust_log.or_else(lambda).unwrap_or(LevelFilter::INFO)
}
#[must_use]
pub fn runtime_span_filter<S>() -> impl Layer<S>
where
S: tracing::Subscriber,
{
tracing_subscriber::filter::filter_fn(|metadata| {
!(metadata.is_span() && metadata.target() == "lambda_runtime::layers::trace")
})
}
pub fn init() -> Result<(), crate::RuntimeError> {
tracing_subscriber::registry()
.with(level_from_env())
.with(runtime_span_filter())
.with(text_layer())
.try_init()
.map_err(|error| crate::RuntimeError::other("installing the log subscriber", error))
}
pub async fn timed_init<T, E>(
component: &'static str,
work: impl std::future::Future<Output = Result<T, E>>,
) -> Result<T, E> {
let started = std::time::Instant::now();
let result = work.await;
let init_ms = started.elapsed().as_millis() as u64;
let success = result.is_ok();
tracing::info!(component, init_ms, success, "initialized");
result
}
pub fn invocation_span(operation: &'static str, invocation: &crate::Invocation) -> tracing::Span {
let span = tracing::info_span!("lambda.invocation", operation,
request_id = %invocation.request_id, "otel.kind" = tracing::field::Empty);
#[cfg(feature = "otel")]
super::join_trace(&span, invocation.trace_id.as_deref());
span
}
pub fn text_layer<S>() -> impl Layer<S>
where
S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
{
tracing_subscriber::fmt::layer()
.with_ansi(false)
.without_time()
}