1use std::env::{self, VarError};
37use std::fmt::{self, Display};
38use std::io::{self, IsTerminal};
39
40use tracing::dispatcher::SetGlobalDefaultError;
41use tracing_core::{Event, Subscriber};
42use tracing_subscriber::filter::{Directive, EnvFilter, LevelFilter};
43use tracing_subscriber::fmt::FmtContext;
44use tracing_subscriber::fmt::format::{self, FormatEvent, FormatFields};
45use tracing_subscriber::layer::SubscriberExt;
46use tracing_subscriber::{Layer, Registry};
47
48pub struct LoggerConfig {
51 pub filter: Result<String, VarError>,
52 pub color_logs: Result<String, VarError>,
53 pub verbose_entry_exit: Result<String, VarError>,
54 pub verbose_thread_ids: Result<String, VarError>,
55 pub backtrace: Result<String, VarError>,
56 pub wraptree: Result<String, VarError>,
57 pub lines: Result<String, VarError>,
58}
59
60impl LoggerConfig {
61 pub fn from_env(env: &str) -> Self {
62 LoggerConfig {
63 filter: env::var(env),
64 color_logs: env::var(format!("{env}_COLOR")),
65 verbose_entry_exit: env::var(format!("{env}_ENTRY_EXIT")),
66 verbose_thread_ids: env::var(format!("{env}_THREAD_IDS")),
67 backtrace: env::var(format!("{env}_BACKTRACE")),
68 wraptree: env::var(format!("{env}_WRAPTREE")),
69 lines: env::var(format!("{env}_LINES")),
70 }
71 }
72}
73
74pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
76 init_logger_with_additional_layer(cfg, || Registry::default())
77}
78
79pub trait BuildSubscriberRet:
85 tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span> + Send + Sync
86{
87}
88
89impl<
90 T: tracing::Subscriber + for<'span> tracing_subscriber::registry::LookupSpan<'span> + Send + Sync,
91> BuildSubscriberRet for T
92{
93}
94
95pub fn init_logger_with_additional_layer<F, T>(
99 cfg: LoggerConfig,
100 build_subscriber: F,
101) -> Result<(), Error>
102where
103 F: FnOnce() -> T,
104 T: BuildSubscriberRet,
105{
106 let filter = match cfg.filter {
107 Ok(env) => EnvFilter::new(env),
108 _ => EnvFilter::default().add_directive(Directive::from(LevelFilter::WARN)),
109 };
110
111 let color_logs = match cfg.color_logs {
112 Ok(value) => match value.as_ref() {
113 "always" => true,
114 "never" => false,
115 "auto" => stderr_isatty(),
116 _ => return Err(Error::InvalidColorValue(value)),
117 },
118 Err(VarError::NotPresent) => stderr_isatty(),
119 Err(VarError::NotUnicode(_value)) => return Err(Error::NonUnicodeColorValue),
120 };
121
122 let verbose_entry_exit = match cfg.verbose_entry_exit {
123 Ok(v) => &v != "0",
124 Err(_) => false,
125 };
126
127 let verbose_thread_ids = match cfg.verbose_thread_ids {
128 Ok(v) => &v == "1",
129 Err(_) => false,
130 };
131
132 let lines = match cfg.lines {
133 Ok(v) => &v == "1",
134 Err(_) => false,
135 };
136
137 let mut layer = tracing_tree::HierarchicalLayer::default()
138 .with_writer(io::stderr)
139 .with_ansi(color_logs)
140 .with_targets(true)
141 .with_verbose_exit(verbose_entry_exit)
142 .with_verbose_entry(verbose_entry_exit)
143 .with_indent_amount(2)
144 .with_indent_lines(lines)
145 .with_thread_ids(verbose_thread_ids)
146 .with_thread_names(verbose_thread_ids);
147
148 match cfg.wraptree {
149 Ok(v) => match v.parse::<usize>() {
150 Ok(v) => {
151 layer = layer.with_wraparound(v);
152 }
153 Err(_) => return Err(Error::InvalidWraptree(v)),
154 },
155 Err(_) => {} }
157
158 let subscriber = build_subscriber().with(layer.with_filter(filter));
159 match cfg.backtrace {
160 Ok(backtrace_target) => {
161 let fmt_layer = tracing_subscriber::fmt::layer()
162 .with_writer(io::stderr)
163 .without_time()
164 .event_format(BacktraceFormatter { backtrace_target });
165 let subscriber = subscriber.with(fmt_layer);
166 tracing::subscriber::set_global_default(subscriber)?;
167 }
168 Err(_) => {
169 tracing::subscriber::set_global_default(subscriber)?;
170 }
171 };
172
173 Ok(())
174}
175
176struct BacktraceFormatter {
177 backtrace_target: String,
178}
179
180impl<S, N> FormatEvent<S, N> for BacktraceFormatter
181where
182 S: Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
183 N: for<'a> FormatFields<'a> + 'static,
184{
185 fn format_event(
186 &self,
187 _ctx: &FmtContext<'_, S, N>,
188 mut writer: format::Writer<'_>,
189 event: &Event<'_>,
190 ) -> fmt::Result {
191 let target = event.metadata().target();
192 if !target.contains(&self.backtrace_target) {
193 return Ok(());
194 }
195 let backtrace = std::backtrace::Backtrace::force_capture();
198 writeln!(writer, "stack backtrace: \n{backtrace:?}")
199 }
200}
201
202pub fn stdout_isatty() -> bool {
203 io::stdout().is_terminal()
204}
205
206pub fn stderr_isatty() -> bool {
207 io::stderr().is_terminal()
208}
209
210#[derive(Debug)]
211pub enum Error {
212 InvalidColorValue(String),
213 NonUnicodeColorValue,
214 InvalidWraptree(String),
215 AlreadyInit(SetGlobalDefaultError),
216}
217
218impl std::error::Error for Error {}
219
220impl Display for Error {
221 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
222 match self {
223 Error::InvalidColorValue(value) => write!(
224 formatter,
225 "invalid log color value '{value}': expected one of always, never, or auto",
226 ),
227 Error::NonUnicodeColorValue => write!(
228 formatter,
229 "non-Unicode log color value: expected one of always, never, or auto",
230 ),
231 Error::InvalidWraptree(value) => write!(
232 formatter,
233 "invalid log WRAPTREE value '{value}': expected a non-negative integer",
234 ),
235 Error::AlreadyInit(tracing_error) => Display::fmt(tracing_error, formatter),
236 }
237 }
238}
239
240impl From<SetGlobalDefaultError> for Error {
241 fn from(tracing_error: SetGlobalDefaultError) -> Self {
242 Error::AlreadyInit(tracing_error)
243 }
244}