1use anyhow::Result;
4use opentelemetry::KeyValue;
5use serde::{Deserialize, Serialize};
6use tracing::Level;
7use tracing_appender::rolling::Rotation;
8use tracing_subscriber::fmt::format::FmtSpan;
9
10use super::deserialize::{
11 default, deserialize_attributes, deserialize_level_optional, deserialize_level_required,
12 deserialize_log_format, deserialize_log_format_optional, deserialize_span_events,
13};
14use super::guard::LoggerGuard;
15use super::init::init_tracing_from_logger;
16
17#[cfg(feature = "env")]
18use super::env::init_logger_from_env;
19
20#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq)]
26pub enum LogFormat {
27 #[serde(rename = "compact")]
29 #[default]
30 Compact,
31 #[serde(rename = "pretty")]
33 Pretty,
34 #[serde(rename = "json")]
36 Json,
37}
38
39#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq)]
41pub enum LogRollingRotation {
42 #[serde(rename = "minutely")]
44 Minutely,
45 #[serde(rename = "hourly")]
47 #[default]
48 Hourly,
49 #[serde(rename = "daily")]
51 Daily,
52 #[serde(rename = "never")]
54 Never,
55}
56
57#[derive(Debug, Clone, serde::Deserialize)]
63pub struct Logger {
64 #[serde(default = "default::service_name")]
67 pub service_name: String,
68
69 #[serde(
71 deserialize_with = "deserialize_log_format",
72 default = "LogFormat::default"
73 )]
74 pub format: LogFormat,
75
76 #[serde(
78 default = "default::span_events",
79 deserialize_with = "deserialize_span_events"
80 )]
81 pub span_events: FmtSpan,
82
83 #[serde(default)]
85 pub ansi: bool,
86
87 #[serde(
89 deserialize_with = "deserialize_level_required",
90 default = "default::log_level"
91 )]
92 pub level: Level,
93
94 #[serde(default, deserialize_with = "deserialize_attributes")]
96 pub attributes: Vec<KeyValue>,
97
98 #[serde(default = "default::console_enabled")]
100 pub console_enabled: bool,
101
102 #[serde(default)]
104 pub file_appender: Option<LoggerFileAppender>,
105
106 #[serde(default)]
108 pub otel_logs_enabled: bool,
109}
110
111#[derive(Debug, Clone, serde::Deserialize)]
117pub struct LoggerFileAppender {
118 pub enable: bool,
120
121 #[serde(default)]
123 pub non_blocking: bool,
124
125 #[serde(default, deserialize_with = "deserialize_level_optional")]
127 pub level: Option<Level>,
128
129 #[serde(default)]
131 pub ansi: bool,
132
133 #[serde(default, deserialize_with = "deserialize_log_format_optional")]
135 pub format: Option<LogFormat>,
136
137 #[serde(default = "default::rotation")]
139 pub rotation: LogRollingRotation,
140
141 #[serde(default)]
143 pub dir: Option<String>,
144
145 #[serde(default)]
147 pub filename_prefix: Option<String>,
148
149 #[serde(default)]
151 pub filename_suffix: Option<String>,
152
153 #[serde(default = "default::max_log_files")]
155 pub max_log_files: usize,
156}
157
158impl LoggerFileAppender {
159 pub fn merge_with_logger(&self, logger: &Logger) -> LoggerFileAppender {
161 LoggerFileAppender {
162 level: self.level.or(Some(logger.level)),
163 format: self.format.or(Some(logger.format)),
164 ..self.clone()
165 }
166 }
167
168 pub fn dir_or_default(&self) -> String {
170 self.dir.clone().unwrap_or_else(default::dir)
171 }
172
173 pub fn filename_prefix_or_default(&self) -> String {
175 self.filename_prefix
176 .clone()
177 .unwrap_or_else(default::filename_prefix)
178 }
179
180 pub fn filename_suffix_or_default(&self) -> String {
182 self.filename_suffix
183 .clone()
184 .unwrap_or_else(default::filename_suffix)
185 }
186
187 pub fn format_or_default(&self) -> LogFormat {
189 self.format.unwrap_or(LogFormat::Compact)
190 }
191
192 pub fn get_rolling_rotation(&self) -> Rotation {
194 match self.rotation {
195 LogRollingRotation::Minutely => Rotation::MINUTELY,
196 LogRollingRotation::Hourly => Rotation::HOURLY,
197 LogRollingRotation::Daily => Rotation::DAILY,
198 LogRollingRotation::Never => Rotation::NEVER,
199 }
200 }
201}
202
203impl Default for Logger {
208 fn default() -> Self {
209 Self {
210 service_name: default::service_name(),
211 format: LogFormat::default(),
212 span_events: default::span_events(),
213 ansi: true,
214 level: default::log_level(),
215 attributes: vec![],
216 console_enabled: default::console_enabled(),
217 file_appender: None,
218 otel_logs_enabled: false,
219 }
220 }
221}
222
223impl Logger {
224 pub fn new(service_name: impl Into<String>) -> Self {
226 Self {
227 service_name: service_name.into(),
228 ..Default::default()
229 }
230 }
231
232 pub fn with_service_name(mut self, service_name: impl Into<String>) -> Self {
235 self.service_name = service_name.into();
236 self
237 }
238
239 pub fn with_format(mut self, format: LogFormat) -> Self {
241 self.format = format;
242 self
243 }
244
245 pub fn with_span_events(mut self, span_events: FmtSpan) -> Self {
247 self.span_events = span_events;
248 self
249 }
250
251 pub fn with_ansi(mut self, ansi: bool) -> Self {
253 self.ansi = ansi;
254 self
255 }
256
257 pub fn with_level(mut self, level: Level) -> Self {
259 self.level = level;
260 self
261 }
262
263 pub fn with_attributes(mut self, attributes: Vec<KeyValue>) -> Self {
265 self.attributes = attributes;
266 self
267 }
268
269 pub fn with_console_enabled(mut self, enabled: bool) -> Self {
271 self.console_enabled = enabled;
272 self
273 }
274
275 pub fn with_file_appender(mut self, file_appender: Option<LoggerFileAppender>) -> Self {
277 self.file_appender = file_appender;
278 self
279 }
280
281 pub fn init(self) -> Result<LoggerGuard> {
283 init_tracing_from_logger(self)
284 }
285
286 #[cfg(feature = "env")]
288 pub fn from_env(prefix: Option<&str>) -> Result<Self> {
289 init_logger_from_env(prefix)
290 }
291}