use std::fmt;
use std::fmt::Write as _;
use tracing::{
field::{self, Field},
Event, Subscriber,
};
use tracing_subscriber::{
field::{MakeVisitor, VisitFmt, VisitOutput},
fmt::{
format::Writer,
time::{FormatTime, SystemTime},
FmtContext, FormatEvent, FormatFields, FormattedFields,
},
registry::LookupSpan,
};
const MESSAGE_INDENT: &str = " ";
const MESSAGE_NEW_LINE_INDENT: &str = " ";
const FIELD_INDENT: &str = " ";
const FIELD_NEW_LINE_INDENT: &str = " ";
#[derive(Debug, Clone)]
pub struct Pretty<T = SystemTime> {
timer: T,
display_timestamp: bool,
display_target: bool,
display_level: bool,
display_thread_name: bool,
display_thread_id: bool,
}
impl Default for Pretty<SystemTime> {
fn default() -> Self {
Self {
timer: SystemTime,
display_timestamp: true,
display_target: true,
display_level: true,
display_thread_name: false,
display_thread_id: false,
}
}
}
impl<T> Pretty<T> {
pub fn with_timer<T2>(self, timer: T2) -> Pretty<T2> {
Pretty {
timer,
display_timestamp: self.display_timestamp,
display_target: self.display_target,
display_level: self.display_level,
display_thread_name: self.display_thread_name,
display_thread_id: self.display_thread_id,
}
}
pub fn without_time(mut self) -> Self {
self.display_timestamp = false;
self
}
pub fn with_target(mut self, display_target: bool) -> Self {
self.display_target = display_target;
self
}
pub fn with_level(mut self, display_level: bool) -> Self {
self.display_level = display_level;
self
}
pub fn with_thread_names(mut self, display_thread_name: bool) -> Self {
self.display_thread_name = display_thread_name;
self
}
pub fn with_thread_ids(mut self, display_thread_id: bool) -> Self {
self.display_thread_id = display_thread_id;
self
}
}
impl<C, N, T> FormatEvent<C, N> for Pretty<T>
where
C: Subscriber + for<'a> LookupSpan<'a>,
N: for<'a> FormatFields<'a> + 'static,
T: FormatTime,
{
fn format_event(
&self,
ctx: &FmtContext<'_, C, N>,
mut writer: Writer<'_>,
event: &Event<'_>,
) -> fmt::Result {
let meta = event.metadata();
if self.display_timestamp {
if self.timer.format_time(&mut writer).is_err() {
writer.write_str("<unknown time>")?;
}
writer.write_char(' ')?;
}
if self.display_level {
write!(writer, "{} ", meta.level())?;
}
if self.display_target {
write!(writer, "{}", meta.target())?;
}
let mut v = PrettyVisitor::new(writer.by_ref());
event.record(&mut v);
v.finish()?;
writer.write_char('\n')?;
if self.display_thread_name || self.display_thread_id {
write!(writer, "on ")?;
let thread = std::thread::current();
if self.display_thread_name {
if let Some(name) = thread.name() {
write!(writer, "{}", name)?;
if self.display_thread_id {
writer.write_char(' ')?;
}
}
}
if self.display_thread_id {
write!(writer, "{:?}", thread.id())?;
}
writer.write_char('\n')?;
}
let span = event
.parent()
.and_then(|id| ctx.span(id))
.or_else(|| ctx.lookup_current());
let scope = span.into_iter().flat_map(|span| span.scope());
for span in scope {
let meta = span.metadata();
if self.display_target {
write!(writer, " in {}::{}", meta.target(), meta.name())?;
} else {
write!(writer, " in {}", meta.name())?;
}
let ext = span.extensions();
let fields = &ext
.get::<FormattedFields<N>>()
.expect("Unable to find FormattedFields in extensions; this is a bug");
if !fields.is_empty() {
write!(writer, "{}", fields)?;
}
writer.write_char('\n')?;
}
Ok(())
}
}
#[derive(Debug, Default)]
pub struct PrettyFields;
impl<'a> MakeVisitor<Writer<'a>> for PrettyFields {
type Visitor = PrettyVisitor<'a>;
#[inline]
fn make_visitor(&self, target: Writer<'a>) -> Self::Visitor {
PrettyVisitor::new(target)
}
}
#[derive(Debug)]
pub struct PrettyVisitor<'a> {
writer: Writer<'a>,
result: fmt::Result,
}
impl<'a> PrettyVisitor<'a> {
fn new(writer: Writer<'a>) -> Self {
Self {
writer,
result: Ok(()),
}
}
fn write_padded(
&mut self,
value: &impl fmt::Debug,
first_line_indent: &'static str,
newline_indent: &'static str,
) {
self.result = self
.result
.and_then(|_| write!(self.writer, "\n{}", first_line_indent))
.and_then(|_| {
write!(
indented_skipping_first_line(&mut self.writer, newline_indent),
"{:?}",
value
)
});
}
}
impl field::Visit for PrettyVisitor<'_> {
fn record_str(&mut self, field: &Field, value: &str) {
if self.result.is_err() {
return;
}
if field.name() == "message" {
self.record_debug(field, &format_args!("{}", value))
} else {
self.record_debug(field, &value)
}
}
fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
if let Some(source) = value.source() {
self.record_debug(
field,
&format_args!("{}, {}.sources: {}", value, field, ErrorSourceList(source)),
)
} else {
self.record_debug(field, &format_args!("{}", value))
}
}
fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
if self.result.is_err() {
return;
}
match field.name() {
"message" => self.write_padded(
&format_args!("{:?}", value),
MESSAGE_INDENT,
MESSAGE_NEW_LINE_INDENT,
),
name if name.starts_with("log.") => self.result = Ok(()),
name if name.starts_with("r#") => self.write_padded(
&format_args!("{}: {:?}", &name[2..], value),
FIELD_INDENT,
FIELD_NEW_LINE_INDENT,
),
name => self.write_padded(
&format_args!("{}: {:?}", name, value),
FIELD_INDENT,
FIELD_NEW_LINE_INDENT,
),
};
}
}
impl VisitOutput<fmt::Result> for PrettyVisitor<'_> {
fn finish(self) -> fmt::Result {
self.result
}
}
impl VisitFmt for PrettyVisitor<'_> {
fn writer(&mut self) -> &mut dyn fmt::Write {
&mut self.writer
}
}
struct ErrorSourceList<'a>(&'a (dyn std::error::Error + 'static));
impl fmt::Display for ErrorSourceList<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut list = f.debug_list();
let mut curr = Some(self.0);
while let Some(curr_err) = curr {
list.entry(&format_args!("{}", curr_err));
curr = curr_err.source();
}
list.finish()
}
}
struct Indented<'a, W: ?Sized> {
inner: &'a mut W,
needs_indent: bool,
indentation: &'static str,
}
fn indented_skipping_first_line<'a, W: ?Sized>(
f: &'a mut W,
indentation: &'static str,
) -> Indented<'a, W> {
Indented {
inner: f,
needs_indent: false,
indentation,
}
}
impl<T> fmt::Write for Indented<'_, T>
where
T: fmt::Write + ?Sized,
{
fn write_str(&mut self, s: &str) -> fmt::Result {
for (ind, line) in s.split('\n').enumerate() {
if ind > 0 {
self.inner.write_char('\n')?;
self.needs_indent = true;
}
if self.needs_indent {
if line.is_empty() {
continue;
}
self.inner.write_str(self.indentation)?;
self.needs_indent = false;
}
self.inner.write_str(line)?;
}
Ok(())
}
}