use std::collections::BTreeMap;
use tracing::field::Visit;
use tracing::Subscriber;
use tracing_subscriber::layer::Context;
use tracing_subscriber::registry::LookupSpan;
use tracing_subscriber::Layer;
#[derive(Debug, Default, Clone)]
pub struct SpanFieldStore {
fields: BTreeMap<String, String>,
}
impl SpanFieldStore {
pub fn get(&self, key: &str) -> Option<&str> {
self.fields.get(key).map(String::as_str)
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
self.fields.iter().map(|(k, v)| (k.as_str(), v.as_str()))
}
fn record(&mut self, name: &str, value: String) {
self.fields.insert(name.to_string(), value);
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct SpanFieldsLayer;
impl<S> Layer<S> for SpanFieldsLayer
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
fn on_new_span(
&self,
attrs: &tracing::span::Attributes<'_>,
id: &tracing::span::Id,
ctx: Context<'_, S>,
) {
let span = match ctx.span(id) {
Some(s) => s,
None => return,
};
let mut extensions = span.extensions_mut();
let mut store = SpanFieldStore::default();
let mut visitor = FieldRecorder { store: &mut store };
attrs.record(&mut visitor);
extensions.insert(store);
}
fn on_record(
&self,
id: &tracing::span::Id,
values: &tracing::span::Record<'_>,
ctx: Context<'_, S>,
) {
let span = match ctx.span(id) {
Some(s) => s,
None => return,
};
let mut extensions = span.extensions_mut();
if let Some(store) = extensions.get_mut::<SpanFieldStore>() {
let mut visitor = FieldRecorder { store };
values.record(&mut visitor);
}
}
}
struct FieldRecorder<'a> {
store: &'a mut SpanFieldStore,
}
impl<'a> Visit for FieldRecorder<'a> {
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
self.store.record(field.name(), format!("{:?}", value));
}
fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
self.store.record(field.name(), value.to_string());
}
fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
self.store.record(field.name(), value.to_string());
}
fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
self.store.record(field.name(), value.to_string());
}
fn record_i128(&mut self, field: &tracing::field::Field, value: i128) {
self.store.record(field.name(), value.to_string());
}
fn record_u128(&mut self, field: &tracing::field::Field, value: u128) {
self.store.record(field.name(), value.to_string());
}
fn record_bool(&mut self, field: &tracing::field::Field, value: bool) {
self.store.record(field.name(), value.to_string());
}
fn record_f64(&mut self, field: &tracing::field::Field, value: f64) {
self.store.record(field.name(), value.to_string());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn store_get_and_iter() {
let mut s = SpanFieldStore::default();
s.record("user_id", "42".into());
s.record("trace", "abc".into());
assert_eq!(s.get("user_id"), Some("42"));
assert_eq!(s.get("missing"), None);
let collected: Vec<_> = s.iter().collect();
assert_eq!(collected, vec![("trace", "abc"), ("user_id", "42")]);
}
}