use opentelemetry::KeyValue;
use serde::{Deserialize, de::IntoDeserializer};
use tracing::Level;
use tracing_subscriber::fmt::format::FmtSpan;
use super::config::{LogFormat, LogRollingRotation};
pub fn deserialize_log_format<'de, D>(deserializer: D) -> Result<LogFormat, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
LogFormat::deserialize(s.to_lowercase().trim().into_deserializer())
}
pub fn deserialize_log_format_optional<'de, D>(
deserializer: D,
) -> Result<Option<LogFormat>, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if s.trim().is_empty() {
return Ok(None);
}
deserialize_log_format(s.into_deserializer()).map(Some)
}
pub fn deserialize_level_required<'de, D>(deserializer: D) -> Result<Level, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
s.parse().map_err(serde::de::Error::custom)
}
pub fn deserialize_level_optional<'de, D>(deserializer: D) -> Result<Option<Level>, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if s.trim().is_empty() {
return Ok(None);
}
s.parse().map(Some).map_err(serde::de::Error::custom)
}
pub fn deserialize_attributes<'de, D>(deserializer: D) -> Result<Vec<KeyValue>, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if s.is_empty() {
return Ok(Vec::new());
}
s.split(',')
.filter(|s| !s.trim().is_empty())
.map(|s| {
let s = s.trim();
let (key, value) = s
.split_once('=')
.ok_or_else(|| serde::de::Error::custom(format!("Invalid attribute: '{s}'")))?;
let key = key.trim();
let value = value.trim();
if key.is_empty() || value.is_empty() {
return Err(serde::de::Error::custom(format!(
"Empty key or value: '{s}'"
)));
}
Ok(KeyValue::new(key.to_string(), value.to_string()))
})
.collect()
}
pub fn deserialize_span_events<'de, D>(deserializer: D) -> Result<FmtSpan, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let s = s.trim();
if s.is_empty() {
return Ok(FmtSpan::NONE);
}
let mut result = FmtSpan::NONE;
for part in s.split('|').map(|p| p.trim()) {
let span = match part {
"FMT::NEW" | "FmtSpan::NEW" => FmtSpan::NEW,
"FMT::ENTER" | "FmtSpan::ENTER" => FmtSpan::ENTER,
"FMT::EXIT" | "FmtSpan::EXIT" => FmtSpan::EXIT,
"FMT::CLOSE" | "FmtSpan::CLOSE" => FmtSpan::CLOSE,
"FMT::NONE" | "FmtSpan::NONE" => FmtSpan::NONE,
"FMT::ACTIVE" | "FmtSpan::ACTIVE" => FmtSpan::ACTIVE,
"FMT::FULL" | "FmtSpan::FULL" => return Ok(FmtSpan::FULL),
_ => {
return Err(serde::de::Error::custom(format!(
"Invalid span events: '{part}'. Valid options: FMT::NEW, FMT::ENTER, FMT::EXIT, FMT::CLOSE, FMT::NONE, FMT::ACTIVE, FMT::FULL"
)));
}
};
result |= span;
}
Ok(result)
}
pub mod default {
use super::LogRollingRotation;
use tracing::Level;
use tracing_subscriber::fmt::format::FmtSpan;
pub fn service_name() -> String {
env!("CARGO_CRATE_NAME").to_string()
}
pub fn max_log_files() -> usize {
5
}
pub fn log_level() -> Level {
Level::INFO
}
pub fn dir() -> String {
"./logs".to_string()
}
pub fn filename_prefix() -> String {
"combine".to_string()
}
pub fn filename_suffix() -> String {
"log".to_string()
}
pub fn span_events() -> FmtSpan {
FmtSpan::NEW | FmtSpan::CLOSE
}
pub fn rotation() -> LogRollingRotation {
LogRollingRotation::Hourly
}
pub fn console_enabled() -> bool {
true
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde::de::IntoDeserializer;
type StrDeserializer<'a> = serde::de::value::StrDeserializer<'a, serde::de::value::Error>;
#[test]
fn test_parse_log_format() {
assert_eq!(
deserialize_log_format::<StrDeserializer>("compact".into_deserializer()).unwrap(),
LogFormat::Compact
);
assert_eq!(
deserialize_log_format::<StrDeserializer>("pretty".into_deserializer()).unwrap(),
LogFormat::Pretty
);
assert_eq!(
deserialize_log_format::<StrDeserializer>("json".into_deserializer()).unwrap(),
LogFormat::Json
);
}
#[test]
fn test_log_format_compatibility() {
for (input, expected) in [
(" COMPACT ", LogFormat::Compact),
("Pretty", LogFormat::Pretty),
("\tJSON\n", LogFormat::Json),
] {
assert_eq!(
deserialize_log_format::<StrDeserializer>(input.into_deserializer()).unwrap(),
expected,
);
assert_eq!(
deserialize_log_format_optional::<StrDeserializer>(input.into_deserializer())
.unwrap(),
Some(expected),
);
}
assert_eq!(
deserialize_log_format_optional::<StrDeserializer>(" ".into_deserializer()).unwrap(),
None,
);
for input in ["", "invalid"] {
assert!(deserialize_log_format::<StrDeserializer>(input.into_deserializer()).is_err());
}
assert!(
deserialize_log_format_optional::<StrDeserializer>("invalid".into_deserializer())
.is_err(),
);
}
#[test]
fn test_parse_attributes() {
assert_eq!(
deserialize_attributes::<StrDeserializer>("".into_deserializer()).unwrap(),
vec![]
);
let attrs = deserialize_attributes::<StrDeserializer>(
"key1=value1,key2=value2".into_deserializer(),
)
.unwrap();
assert_eq!(attrs.len(), 2);
}
}