use std::collections::VecDeque;
use std::fmt::Write as _;
use std::sync::Mutex;
use tracing::field::{Field, Visit};
use tracing_subscriber::layer::Context;
use tracing_subscriber::registry::LookupSpan;
pub(crate) const MAX_ENTRIES: usize = 10_000;
#[derive(Debug, Clone)]
pub(crate) struct Entry {
pub(crate) level: tracing::Level,
pub(crate) target: String,
pub(crate) message: String,
pub(crate) fields: Option<String>,
pub(crate) request_id: Option<String>,
}
impl Entry {
pub(crate) fn line(&self) -> String {
let mut out = format!("{} {}: {}", self.level, self.target, self.message);
if let Some(fields) = &self.fields {
let _ = write!(out, " {fields}");
}
if let Some(id) = &self.request_id {
let _ = write!(out, " [request {id}]");
}
out
}
}
#[derive(Default)]
struct Buffer {
entries: VecDeque<Entry>,
dropped: u64,
}
static BUFFER: Mutex<Buffer> = Mutex::new(Buffer {
entries: VecDeque::new(),
dropped: 0,
});
fn with_buffer<R>(f: impl FnOnce(&mut Buffer) -> R) -> R {
let mut guard = BUFFER.lock().unwrap_or_else(|e| e.into_inner());
f(&mut guard)
}
pub(crate) fn clear() {
with_buffer(|b| {
b.entries.clear();
b.dropped = 0;
});
}
pub(crate) fn take() -> (Vec<Entry>, u64) {
with_buffer(|b| {
let entries = b.entries.drain(..).collect();
(entries, std::mem::take(&mut b.dropped))
})
}
pub(crate) fn snapshot() -> Vec<Entry> {
with_buffer(|b| b.entries.iter().cloned().collect())
}
fn push(entry: Entry) {
with_buffer(|b| {
if b.entries.len() >= MAX_ENTRIES {
b.entries.pop_front();
b.dropped += 1;
}
b.entries.push_back(entry);
});
}
struct RequestId(String);
#[derive(Default)]
struct Fields {
message: String,
fields: Option<String>,
id: Option<String>,
rest: Vec<(String, String)>,
}
impl Visit for Fields {
fn record_str(&mut self, field: &Field, value: &str) {
self.record(field, value.to_string());
}
fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
self.record(field, format!("{value:?}"));
}
}
impl Fields {
fn record(&mut self, field: &Field, value: String) {
match field.name() {
"message" => self.message = value,
"fields" => self.fields = Some(value),
"id" => self.id = Some(value),
name => self.rest.push((name.to_string(), value)),
}
}
}
pub(crate) struct CaptureLayer;
impl<S> tracing_subscriber::Layer<S> for CaptureLayer
where
S: tracing::Subscriber + for<'a> LookupSpan<'a>,
{
fn on_new_span(
&self,
attrs: &tracing::span::Attributes<'_>,
id: &tracing::span::Id,
ctx: Context<'_, S>,
) {
if attrs.metadata().name() != "request" {
return;
}
let mut fields = Fields::default();
attrs.record(&mut fields);
if let (Some(request_id), Some(span)) = (fields.id, ctx.span(id)) {
span.extensions_mut().insert(RequestId(request_id));
}
}
fn on_event(&self, event: &tracing::Event<'_>, ctx: Context<'_, S>) {
let mut fields = Fields::default();
event.record(&mut fields);
let request_id = ctx.event_scope(event).and_then(|scope| {
scope
.from_root()
.find_map(|span| span.extensions().get::<RequestId>().map(|id| id.0.clone()))
});
let extra = (!fields.rest.is_empty()).then(|| {
fields
.rest
.iter()
.map(|(k, v)| format!("{k}={v}"))
.collect::<Vec<_>>()
.join(" ")
});
push(Entry {
level: *event.metadata().level(),
target: event.metadata().target().to_string(),
message: fields.message,
fields: fields.fields.or(extra),
request_id,
});
}
}
#[cfg(test)]
mod tests {
use super::*;
fn entry(n: usize) -> Entry {
Entry {
level: tracing::Level::INFO,
target: "lua".into(),
message: format!("line {n}"),
fields: None,
request_id: None,
}
}
#[test]
fn the_capture_buffer_is_bounded_and_counts_what_it_dropped() {
clear();
for n in 0..MAX_ENTRIES + 5 {
push(entry(n));
}
assert_eq!(snapshot().len(), MAX_ENTRIES);
let (entries, dropped) = take();
assert_eq!(dropped, 5);
assert_eq!(entries.len(), MAX_ENTRIES);
assert_eq!(entries[0].message, "line 5", "the oldest go first");
assert!(take().0.is_empty(), "take drains");
}
}