use anyhow::Result;
use opentelemetry::KeyValue;
use serde::{Deserialize, Serialize};
use tracing::Level;
use tracing_appender::rolling::Rotation;
use tracing_subscriber::fmt::format::FmtSpan;
use super::deserialize::{
default, deserialize_attributes, deserialize_level_optional, deserialize_level_required,
deserialize_log_format, deserialize_log_format_optional, deserialize_span_events,
};
use super::guard::LoggerGuard;
use super::init::init_tracing_from_logger;
#[cfg(feature = "env")]
use super::env::init_logger_from_env;
#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq)]
pub enum LogFormat {
#[serde(rename = "compact")]
#[default]
Compact,
#[serde(rename = "pretty")]
Pretty,
#[serde(rename = "json")]
Json,
}
#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq)]
pub enum LogRollingRotation {
#[serde(rename = "minutely")]
Minutely,
#[serde(rename = "hourly")]
#[default]
Hourly,
#[serde(rename = "daily")]
Daily,
#[serde(rename = "never")]
Never,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct Logger {
#[serde(default = "default::service_name")]
pub service_name: String,
#[serde(
deserialize_with = "deserialize_log_format",
default = "LogFormat::default"
)]
pub format: LogFormat,
#[serde(
default = "default::span_events",
deserialize_with = "deserialize_span_events"
)]
pub span_events: FmtSpan,
#[serde(default)]
pub ansi: bool,
#[serde(
deserialize_with = "deserialize_level_required",
default = "default::log_level"
)]
pub level: Level,
#[serde(default, deserialize_with = "deserialize_attributes")]
pub attributes: Vec<KeyValue>,
#[serde(default = "default::console_enabled")]
pub console_enabled: bool,
#[serde(default)]
pub file_appender: Option<LoggerFileAppender>,
#[serde(default)]
pub otel_logs_enabled: bool,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct LoggerFileAppender {
pub enable: bool,
#[serde(default)]
pub non_blocking: bool,
#[serde(default, deserialize_with = "deserialize_level_optional")]
pub level: Option<Level>,
#[serde(default)]
pub ansi: bool,
#[serde(default, deserialize_with = "deserialize_log_format_optional")]
pub format: Option<LogFormat>,
#[serde(default = "default::rotation")]
pub rotation: LogRollingRotation,
#[serde(default)]
pub dir: Option<String>,
#[serde(default)]
pub filename_prefix: Option<String>,
#[serde(default)]
pub filename_suffix: Option<String>,
#[serde(default = "default::max_log_files")]
pub max_log_files: usize,
}
impl LoggerFileAppender {
pub fn merge_with_logger(&self, logger: &Logger) -> LoggerFileAppender {
LoggerFileAppender {
level: self.level.or(Some(logger.level)),
format: self.format.or(Some(logger.format)),
..self.clone()
}
}
pub fn dir_or_default(&self) -> String {
self.dir.clone().unwrap_or_else(default::dir)
}
pub fn filename_prefix_or_default(&self) -> String {
self.filename_prefix
.clone()
.unwrap_or_else(default::filename_prefix)
}
pub fn filename_suffix_or_default(&self) -> String {
self.filename_suffix
.clone()
.unwrap_or_else(default::filename_suffix)
}
pub fn format_or_default(&self) -> LogFormat {
self.format.unwrap_or(LogFormat::Compact)
}
pub fn get_rolling_rotation(&self) -> Rotation {
match self.rotation {
LogRollingRotation::Minutely => Rotation::MINUTELY,
LogRollingRotation::Hourly => Rotation::HOURLY,
LogRollingRotation::Daily => Rotation::DAILY,
LogRollingRotation::Never => Rotation::NEVER,
}
}
}
impl Default for Logger {
fn default() -> Self {
Self {
service_name: default::service_name(),
format: LogFormat::default(),
span_events: default::span_events(),
ansi: true,
level: default::log_level(),
attributes: vec![],
console_enabled: default::console_enabled(),
file_appender: None,
otel_logs_enabled: false,
}
}
}
impl Logger {
pub fn new(service_name: impl Into<String>) -> Self {
Self {
service_name: service_name.into(),
..Default::default()
}
}
pub fn with_service_name(mut self, service_name: impl Into<String>) -> Self {
self.service_name = service_name.into();
self
}
pub fn with_format(mut self, format: LogFormat) -> Self {
self.format = format;
self
}
pub fn with_span_events(mut self, span_events: FmtSpan) -> Self {
self.span_events = span_events;
self
}
pub fn with_ansi(mut self, ansi: bool) -> Self {
self.ansi = ansi;
self
}
pub fn with_level(mut self, level: Level) -> Self {
self.level = level;
self
}
pub fn with_attributes(mut self, attributes: Vec<KeyValue>) -> Self {
self.attributes = attributes;
self
}
pub fn with_console_enabled(mut self, enabled: bool) -> Self {
self.console_enabled = enabled;
self
}
pub fn with_file_appender(mut self, file_appender: Option<LoggerFileAppender>) -> Self {
self.file_appender = file_appender;
self
}
pub fn init(self) -> Result<LoggerGuard> {
init_tracing_from_logger(self)
}
#[cfg(feature = "env")]
pub fn from_env(prefix: Option<&str>) -> Result<Self> {
init_logger_from_env(prefix)
}
}