#![deny(missing_docs)]
use std::io::Write as IoWrite;
use std::path::Path;
use tracing_appender::rolling::RollingFileAppender;
use tracing_subscriber::fmt::writer::MakeWriter;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::EnvFilter;
use crate::config::{AppenderConfig, Config};
use crate::error::ConfigError;
use crate::formatter::build_formatter;
use crate::sampling::SamplingWriter;
use crate::span_fields::SpanFieldsLayer;
pub mod appender;
pub mod config;
pub mod error;
pub mod formatter;
pub mod sampling;
pub mod span_fields;
pub mod windows;
#[cfg(feature = "opentelemetry")]
pub mod otel;
#[cfg(feature = "hot-reload")]
pub mod hot_reload;
include!(concat!(env!("OUT_DIR"), "/version.rs"));
#[cfg(feature = "hot-reload")]
pub use hot_reload::ReloadHandle;
#[cfg(feature = "opentelemetry")]
use otel::build_otel_layer;
pub fn init() -> Result<(), ConfigError> {
let config = Config::from_default_file()?;
init_with_config(config)
}
pub fn init_from_file(path: impl AsRef<Path>) -> Result<(), ConfigError> {
let config = Config::from_file(path)?;
init_with_config(config)
}
pub fn init_from_str(content: &str) -> Result<(), ConfigError> {
let config: Config = toml::from_str(content)?;
init_with_config(config)
}
pub fn parse(content: &str) -> Result<Config, ConfigError> {
let config: Config = toml::from_str(content)?;
Ok(config)
}
#[deprecated(
note = "Use init_from_str instead — both functions silently skip if already initialized"
)]
pub fn try_init_from_str(content: &str) -> Result<(), ConfigError> {
let config: Config = toml::from_str(content)?;
init_with_config(config)
}
fn init_with_config(config: Config) -> Result<(), ConfigError> {
if tracing::dispatcher::has_been_set() {
return Ok(());
}
let _ = windows::enable_ansi_escapes();
let env_filter = build_env_filter(&config)?;
let enabled: Vec<&AppenderConfig> = config.appenders.iter().filter(|a| a.enabled).collect();
let rate = if config.sampling.enabled {
config.sampling.rate_per_second
} else {
0
};
#[cfg(feature = "opentelemetry")]
let otel_guard = {
if config.opentelemetry.enabled {
Some(build_otel_layer(&config.opentelemetry)?)
} else {
None
}
};
if enabled.is_empty() {
#[cfg(feature = "opentelemetry")]
if let Some(guard) = otel_guard {
let provider: &'static _ = Box::leak(Box::new(guard.provider));
let _ = provider;
tracing_subscriber::registry()
.with(guard.layer)
.with(env_filter)
.with(SpanFieldsLayer)
.with(tracing_subscriber::fmt::layer())
.try_init()
.ok();
return Ok(());
}
tracing_subscriber::registry()
.with(env_filter)
.with(SpanFieldsLayer)
.with(tracing_subscriber::fmt::layer())
.try_init()
.ok();
return Ok(());
}
let mut make_writer = MultiMakeWriter::default();
let mut first_formatter_cfg: Option<&crate::config::FormatterConfig> = None;
for appender_cfg in &enabled {
let factory = build_factory(appender_cfg, rate)?;
make_writer.push(factory);
if first_formatter_cfg.is_none() {
first_formatter_cfg = Some(&appender_cfg.formatter);
}
}
let formatter_cfg = first_formatter_cfg
.ok_or_else(|| ConfigError::InvalidConfig("no enabled appenders".into()))?;
let formatter = build_formatter(formatter_cfg)?;
#[cfg(feature = "opentelemetry")]
if let Some(guard) = otel_guard {
let provider: &'static _ = Box::leak(Box::new(guard.provider));
let _ = provider;
tracing_subscriber::registry()
.with(guard.layer)
.with(env_filter)
.with(SpanFieldsLayer)
.with(
tracing_subscriber::fmt::layer()
.with_writer(make_writer)
.event_format(formatter),
)
.try_init()
.ok();
return Ok(());
}
tracing_subscriber::registry()
.with(env_filter)
.with(SpanFieldsLayer)
.with(
tracing_subscriber::fmt::layer()
.with_writer(make_writer)
.event_format(formatter),
)
.try_init()
.ok();
Ok(())
}
fn build_factory(
appender_cfg: &AppenderConfig,
global_rate: u64,
) -> Result<WriterFactory, ConfigError> {
let rate = if appender_sampling_enabled(appender_cfg) {
global_rate
} else {
0
};
let factory: WriterFactory = match appender_cfg.kind.as_str() {
"stdout" => make_sampler_factory(SamplingWriter::new(std::io::stdout, rate)),
"stderr" => make_sampler_factory(SamplingWriter::new(std::io::stderr, rate)),
"file" => {
let path = appender_cfg.path.as_ref().ok_or_else(|| {
ConfigError::InvalidConfig("file appender requires 'path'".into())
})?;
let file = std::fs::OpenOptions::new()
.create(true)
.write(true)
.append(appender_cfg.append)
.open(path)?;
make_sampler_factory(SamplingWriter::new(file, rate))
}
"rolling_file" => {
let dir = appender_cfg
.dir
.as_ref()
.ok_or(ConfigError::RollingMissingDir)?;
let rotation = appender_cfg.rotation.as_deref().unwrap_or("daily");
let rot = match rotation {
"daily" => tracing_appender::rolling::Rotation::DAILY,
"hourly" => tracing_appender::rolling::Rotation::HOURLY,
"never" => tracing_appender::rolling::Rotation::NEVER,
_ => {
return Err(ConfigError::InvalidConfig(format!(
"unknown rotation '{}'",
rotation
)));
}
};
let prefix = appender_cfg.prefix.as_deref().unwrap_or("app");
let suffix = appender_cfg.suffix.as_deref().unwrap_or("log");
let appender = RollingFileAppender::new(rot, dir, format!("{}.{}", prefix, suffix));
make_sampler_factory(SamplingWriter::new(appender, rate))
}
other => {
return Err(ConfigError::UnknownAppenderKind {
kind: other.to_string(),
});
}
};
Ok(factory)
}
fn appender_sampling_enabled(_appender_cfg: &AppenderConfig) -> bool {
true
}
type WriterFactory = Box<dyn Fn() -> Box<dyn IoWrite> + Send + Sync>;
fn make_sampler_factory<W>(sampler: SamplingWriter<W>) -> WriterFactory
where
W: MakeWriter<'static> + Send + Sync + 'static,
W::Writer: IoWrite,
{
let sampler: &'static SamplingWriter<W> = Box::leak(Box::new(sampler));
Box::new(move || {
let guard = sampler.make_writer();
Box::new(guard) as Box<dyn IoWrite>
})
}
fn build_env_filter(config: &Config) -> Result<EnvFilter, ConfigError> {
let default_lvl = if config.filter.default_level.is_empty() {
config.global.level.clone()
} else {
config.filter.default_level.clone()
};
let mut directives = Vec::new();
if !default_lvl.is_empty() {
directives.push(default_lvl);
}
for d in &config.filter.directives {
directives.push(d.clone());
}
for appender in &config.appenders {
if appender.enabled {
if let Some(lvl) = &appender.level {
directives.push(format!("{}={}", appender.name, lvl));
}
}
}
let filter_str = directives.join(",");
if filter_str.is_empty() {
return EnvFilter::try_new("info").map_err(|e| ConfigError::InvalidConfig(e.to_string()));
}
EnvFilter::try_new(&filter_str).map_err(|e| ConfigError::InvalidConfig(e.to_string()))
}
#[derive(Default)]
struct MultiMakeWriter {
factories: Vec<WriterFactory>,
}
impl MultiMakeWriter {
fn push(&mut self, f: WriterFactory) {
self.factories.push(f);
}
}
impl<'a> MakeWriter<'a> for MultiMakeWriter {
type Writer = MultiWriter;
fn make_writer(&'a self) -> Self::Writer {
let writers: Vec<Box<dyn IoWrite>> = self.factories.iter().map(|f| f()).collect();
MultiWriter { writers }
}
}
struct MultiWriter {
writers: Vec<Box<dyn IoWrite>>,
}
impl IoWrite for MultiWriter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
for w in self.writers.iter_mut() {
let _ = w.write_all(buf);
}
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
for w in self.writers.iter_mut() {
let _ = w.flush();
}
Ok(())
}
}