use std::{error::Error, io};
use tracing_appender::non_blocking::{ErrorCounter, NonBlockingBuilder, WorkerGuard};
use tracing_subscriber::{
EnvFilter, Layer,
fmt::{MakeWriter, format::JsonFields},
layer::SubscriberExt,
util::SubscriberInitExt,
};
#[cfg(any(feature = "connection-mysql", feature = "connection-postgres"))]
use super::SqlxQueryLayer;
use super::StructuredJsonFormatter;
pub type InitTracingError = Box<dyn Error + Send + Sync + 'static>;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LogOverflowPolicy {
DropAndCount,
Block,
}
#[must_use = "必须在应用生命周期内保留日志守卫"]
pub struct JsonTracingGuard {
error_counter: ErrorCounter,
_worker_guard: WorkerGuard,
}
impl JsonTracingGuard {
#[must_use]
pub fn dropped_lines(&self) -> usize {
self.error_counter.dropped_lines()
}
}
#[derive(Clone, Debug)]
#[must_use = "需要调用 init_stdout 或 init_with_writer 初始化日志"]
pub struct JsonTracingBuilder {
default_filter: String,
queue_capacity: usize,
overflow_policy: LogOverflowPolicy,
worker_thread_name: String,
}
impl JsonTracingBuilder {
pub fn new(default_filter: impl Into<String>) -> Self {
Self {
default_filter: default_filter.into(),
queue_capacity: 8_192,
overflow_policy: LogOverflowPolicy::DropAndCount,
worker_thread_name: "loveyu-kit-log-writer".into(),
}
}
pub const fn queue_capacity(mut self, capacity: usize) -> Self {
self.queue_capacity = capacity;
self
}
pub const fn overflow_policy(mut self, policy: LogOverflowPolicy) -> Self {
self.overflow_policy = policy;
self
}
pub fn worker_thread_name(mut self, name: impl Into<String>) -> Self {
self.worker_thread_name = name.into();
self
}
pub fn init_stdout(self) -> Result<JsonTracingGuard, InitTracingError> {
self.init_with_writer(std::io::stdout())
}
pub fn init_with_writer<W>(self, writer: W) -> Result<JsonTracingGuard, InitTracingError>
where
W: io::Write + Send + 'static,
{
if self.queue_capacity == 0 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"非阻塞日志队列容量必须大于 0",
)
.into());
}
if self.worker_thread_name.trim().is_empty() {
return Err(
io::Error::new(io::ErrorKind::InvalidInput, "日志写入线程名称不能为空").into(),
);
}
let (writer, worker_guard) = NonBlockingBuilder::default()
.buffered_lines_limit(self.queue_capacity)
.lossy(self.overflow_policy == LogOverflowPolicy::DropAndCount)
.thread_name(&self.worker_thread_name)
.finish(writer);
let error_counter = writer.error_counter();
init_json_tracing_with_writer(&self.default_filter, writer)?;
Ok(JsonTracingGuard {
error_counter,
_worker_guard: worker_guard,
})
}
}
pub fn init_default_json_tracing() -> Result<(), InitTracingError> {
init_json_tracing("info")
}
pub fn init_json_tracing(default_filter: &str) -> Result<(), InitTracingError> {
init_json_tracing_with_writer(default_filter, std::io::stdout)
}
pub fn init_json_tracing_with_writer<W>(
default_filter: &str,
writer: W,
) -> Result<(), InitTracingError>
where
W: for<'writer> MakeWriter<'writer> + Send + Sync + 'static,
{
let filter = match EnvFilter::try_from_default_env() {
Ok(filter) => filter,
Err(_) => EnvFilter::try_new(default_filter)?,
}
.add_directive("sqlx::query=off".parse()?);
let format_layer = tracing_subscriber::fmt::layer()
.fmt_fields(JsonFields::new())
.event_format(StructuredJsonFormatter::new())
.with_writer(writer)
.with_filter(filter);
#[cfg(any(feature = "connection-mysql", feature = "connection-postgres"))]
tracing_subscriber::registry()
.with(SqlxQueryLayer::new().with_capture_filter())
.with(format_layer)
.try_init()?;
#[cfg(not(any(feature = "connection-mysql", feature = "connection-postgres")))]
tracing_subscriber::registry()
.with(format_layer)
.try_init()?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn non_blocking_builder_rejects_zero_capacity_before_initializing_subscriber() {
let result = JsonTracingBuilder::new("info")
.queue_capacity(0)
.init_with_writer(std::io::sink());
assert!(result.is_err());
}
}