pub mod log4j;
pub mod logback;
pub use log4j::{Keyword as Log4jKeyword, Log4jFormatter, Token as Log4jToken};
pub use logback::{scan, Keyword, LogbackFormatter, Token};
use std::fmt;
use tracing::Subscriber;
use tracing_subscriber::fmt::format::Format;
use tracing_subscriber::fmt::format::Full;
use tracing_subscriber::fmt::format::Writer;
use tracing_subscriber::fmt::time::SystemTime;
use tracing_subscriber::fmt::FmtContext;
use tracing_subscriber::fmt::FormatEvent;
use tracing_subscriber::registry::LookupSpan;
use crate::config::FormatterConfig;
use crate::error::ConfigError;
pub enum FormatterKind {
Default(Format<Full, SystemTime>),
Logback(LogbackFormatter),
Log4j(Log4jFormatter),
}
impl<S, N> FormatEvent<S, N> for FormatterKind
where
S: Subscriber + for<'a> LookupSpan<'a>,
N: for<'a> tracing_subscriber::fmt::FormatFields<'a> + 'static,
{
fn format_event(
&self,
ctx: &FmtContext<'_, S, N>,
writer: Writer<'_>,
event: &tracing::Event<'_>,
) -> fmt::Result {
match self {
FormatterKind::Default(f) => f.format_event(ctx, writer, event),
FormatterKind::Logback(f) => f.format_event(ctx, writer, event),
FormatterKind::Log4j(f) => f.format_event(ctx, writer, event),
}
}
}
pub fn build_formatter(config: &FormatterConfig) -> Result<FormatterKind, ConfigError> {
match config.typ.as_str() {
"default" => Ok(FormatterKind::Default(tracing_subscriber::fmt::format())),
"logback" => {
let pattern = config.pattern.as_ref().ok_or_else(|| {
ConfigError::InvalidConfig("logback formatter requires 'pattern'".into())
})?;
let tokens = scan(pattern).map_err(|e| ConfigError::InvalidConfig(e.to_string()))?;
Ok(FormatterKind::Logback(LogbackFormatter::new(tokens)))
}
"pattern" => {
let pattern = config.pattern.as_ref().ok_or_else(|| {
ConfigError::InvalidConfig("pattern formatter requires 'pattern'".into())
})?;
let tokens = scan(pattern).map_err(|e| ConfigError::InvalidConfig(e.to_string()))?;
Ok(FormatterKind::Logback(LogbackFormatter::new(tokens)))
}
"log4j" => {
let pattern = config.pattern.as_ref().ok_or_else(|| {
ConfigError::InvalidConfig("log4j formatter requires 'pattern'".into())
})?;
let tokens =
log4j::scan(pattern).map_err(|e| ConfigError::InvalidConfig(e.to_string()))?;
Ok(FormatterKind::Log4j(Log4jFormatter::new(tokens)))
}
_ => Err(ConfigError::UnknownFormatterType {
typ: config.typ.clone(),
}),
}
}