vendor/tracing-subscriber/src/fmt/format/pretty.rs

   1 use super::*;
   2 use crate::{
   3     field::{VisitFmt, VisitOutput},
   4     fmt::fmt_layer::{FmtContext, FormattedFields},
   5     registry::LookupSpan,
   6 };
   7
   8 use std::{
   9     fmt::{self, Write},
  10     iter,
  11 };
  12 use tracing_core::{
  13     field::{self, Field},
  14     Event, Level, Subscriber,
  15 };
  16
  17 #[cfg(feature = "tracing-log")]
  18 use tracing_log::NormalizeEvent;
  19
  20 use ansi_term::{Colour, Style};
  21
  22 /// An excessively pretty, human-readable event formatter.
  23 #[derive(Debug, Clone, Eq, PartialEq)]
  24 pub struct Pretty {
  25     display_location: bool,
  26 }
  27
  28 /// The [visitor] produced by [`Pretty`]'s [`MakeVisitor`] implementation.
  29 ///
  30 /// [visitor]: ../../field/trait.Visit.html
  31 /// [`DefaultFields`]: struct.DefaultFields.html
  32 /// [`MakeVisitor`]: ../../field/trait.MakeVisitor.html
  33 pub struct PrettyVisitor<'a> {
  34     writer: &'a mut dyn Write,
  35     is_empty: bool,
  36     ansi: bool,
  37     style: Style,
  38     result: fmt::Result,
  39 }
  40
  41 /// An excessively pretty, human-readable [`MakeVisitor`] implementation.
  42 ///
  43 /// [`MakeVisitor`]: crate::field::MakeVisitor
  44 #[derive(Debug)]
  45 pub struct PrettyFields {
  46     ansi: bool,
  47 }
  48
  49 // === impl Pretty ===
  50
  51 impl Default for Pretty {
  52     fn default() -> Self {
  53         Self {
  54             display_location: true,
  55         }
  56     }
  57 }
  58
  59 impl Pretty {
  60     fn style_for(level: &Level) -> Style {
  61         match *level {
  62             Level::TRACE => Style::new().fg(Colour::Purple),
  63             Level::DEBUG => Style::new().fg(Colour::Blue),
  64             Level::INFO => Style::new().fg(Colour::Green),
  65             Level::WARN => Style::new().fg(Colour::Yellow),
  66             Level::ERROR => Style::new().fg(Colour::Red),
  67         }
  68     }
  69
  70     /// Sets whether the event's source code location is displayed.
  71     ///
  72     /// This defaults to `true`.
  73     pub fn with_source_location(self, display_location: bool) -> Self {
  74         Self {
  75             display_location,
  76             ..self
  77         }
  78     }
  79 }
  80
  81 impl<T> Format<Pretty, T> {
  82     /// Sets whether or not the source code location from which an event
  83     /// originated is displayed.
  84     ///
  85     /// This defaults to `true`.
  86     pub fn with_source_location(mut self, display_location: bool) -> Self {
  87         self.format = self.format.with_source_location(display_location);
  88         self
  89     }
  90 }
  91
  92 impl<C, N, T> FormatEvent<C, N> for Format<Pretty, T>
  93 where
  94     C: Subscriber + for<'a> LookupSpan<'a>,
  95     N: for<'a> FormatFields<'a> + 'static,
  96     T: FormatTime,
  97 {
  98     fn format_event(
  99         &self,
 100         ctx: &FmtContext<'_, C, N>,
 101         writer: &mut dyn fmt::Write,
 102         event: &Event<'_>,
 103     ) -> fmt::Result {
 104         #[cfg(feature = "tracing-log")]
 105         let normalized_meta = event.normalized_metadata();
 106         #[cfg(feature = "tracing-log")]
 107         let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
 108         #[cfg(not(feature = "tracing-log"))]
 109         let meta = event.metadata();
 110         write!(writer, "  ")?;
 111         time::write(&self.timer, writer, self.ansi)?;
 112
 113         let style = if self.display_level && self.ansi {
 114             Pretty::style_for(meta.level())
 115         } else {
 116             Style::new()
 117         };
 118
 119         if self.display_level {
 120             write!(writer, "{}", super::FmtLevel::new(meta.level(), self.ansi))?;
 121         }
 122
 123         if self.display_target {
 124             let target_style = if self.ansi { style.bold() } else { style };
 125             write!(
 126                 writer,
 127                 "{}{}{}: ",
 128                 target_style.prefix(),
 129                 meta.target(),
 130                 target_style.infix(style)
 131             )?;
 132         }
 133         let mut v = PrettyVisitor::new(writer, true)
 134             .with_style(style)
 135             .with_ansi(self.ansi);
 136         event.record(&mut v);
 137         v.finish()?;
 138         writer.write_char('\n')?;
 139
 140         let dimmed = if self.ansi {
 141             Style::new().dimmed().italic()
 142         } else {
 143             Style::new()
 144         };
 145         let thread = self.display_thread_name || self.display_thread_id;
 146         if let (true, Some(file), Some(line)) =
 147             (self.format.display_location, meta.file(), meta.line())
 148         {
 149             write!(
 150                 writer,
 151                 "    {} {}:{}{}",
 152                 dimmed.paint("at"),
 153                 file,
 154                 line,
 155                 dimmed.paint(if thread { " " } else { "\n" })
 156             )?;
 157         } else if thread {
 158             write!(writer, "    ")?;
 159         }
 160
 161         if thread {
 162             write!(writer, "{} ", dimmed.paint("on"))?;
 163             let thread = std::thread::current();
 164             if self.display_thread_name {
 165                 if let Some(name) = thread.name() {
 166                     write!(writer, "{}", name)?;
 167                     if self.display_thread_id {
 168                         write!(writer, " ({:?})", thread.id())?;
 169                     }
 170                 } else if !self.display_thread_id {
 171                     write!(writer, " {:?}", thread.id())?;
 172                 }
 173             } else if self.display_thread_id {
 174                 write!(writer, " {:?}", thread.id())?;
 175             }
 176             writer.write_char('\n')?;
 177         }
 178
 179         let bold = if self.ansi {
 180             Style::new().bold()
 181         } else {
 182             Style::new()
 183         };
 184         let span = event
 185             .parent()
 186             .and_then(|id| ctx.span(&id))
 187             .or_else(|| ctx.lookup_current());
 188
 189         let scope = span.into_iter().flat_map(|span| {
 190             let parents = span.parents();
 191             iter::once(span).chain(parents)
 192         });
 193
 194         for span in scope {
 195             let meta = span.metadata();
 196             if self.display_target {
 197                 write!(
 198                     writer,
 199                     "    {} {}::{}",
 200                     dimmed.paint("in"),
 201                     meta.target(),
 202                     bold.paint(meta.name()),
 203                 )?;
 204             } else {
 205                 write!(
 206                     writer,
 207                     "    {} {}",
 208                     dimmed.paint("in"),
 209                     bold.paint(meta.name()),
 210                 )?;
 211             }
 212
 213             let ext = span.extensions();
 214             let fields = &ext
 215                 .get::<FormattedFields<N>>()
 216                 .expect("Unable to find FormattedFields in extensions; this is a bug");
 217             if !fields.is_empty() {
 218                 write!(writer, " {} {}", dimmed.paint("with"), fields)?;
 219             }
 220             writer.write_char('\n')?;
 221         }
 222
 223         writer.write_char('\n')
 224     }
 225 }
 226
 227 impl<'writer> FormatFields<'writer> for Pretty {
 228     fn format_fields<R: RecordFields>(
 229         &self,
 230         writer: &'writer mut dyn fmt::Write,
 231         fields: R,
 232     ) -> fmt::Result {
 233         let mut v = PrettyVisitor::new(writer, true);
 234         fields.record(&mut v);
 235         v.finish()
 236     }
 237
 238     fn add_fields(&self, current: &'writer mut String, fields: &span::Record<'_>) -> fmt::Result {
 239         let empty = current.is_empty();
 240         let mut v = PrettyVisitor::new(current, empty);
 241         fields.record(&mut v);
 242         v.finish()
 243     }
 244 }
 245
 246 // === impl PrettyFields ===
 247
 248 impl Default for PrettyFields {
 249     fn default() -> Self {
 250         Self::new()
 251     }
 252 }
 253
 254 impl PrettyFields {
 255     /// Returns a new default [`PrettyFields`] implementation.
 256     pub fn new() -> Self {
 257         Self { ansi: true }
 258     }
 259
 260     /// Enable ANSI encoding for formatted fields.
 261     pub fn with_ansi(self, ansi: bool) -> Self {
 262         Self { ansi, ..self }
 263     }
 264 }
 265
 266 impl<'a> MakeVisitor<&'a mut dyn Write> for PrettyFields {
 267     type Visitor = PrettyVisitor<'a>;
 268
 269     #[inline]
 270     fn make_visitor(&self, target: &'a mut dyn Write) -> Self::Visitor {
 271         PrettyVisitor::new(target, true).with_ansi(self.ansi)
 272     }
 273 }
 274
 275 // === impl PrettyVisitor ===
 276
 277 impl<'a> PrettyVisitor<'a> {
 278     /// Returns a new default visitor that formats to the provided `writer`.
 279     ///
 280     /// # Arguments
 281     /// - `writer`: the writer to format to.
 282     /// - `is_empty`: whether or not any fields have been previously written to
 283     ///   that writer.
 284     pub fn new(writer: &'a mut dyn Write, is_empty: bool) -> Self {
 285         Self {
 286             writer,
 287             is_empty,
 288             ansi: true,
 289             style: Style::default(),
 290             result: Ok(()),
 291         }
 292     }
 293
 294     pub(crate) fn with_style(self, style: Style) -> Self {
 295         Self { style, ..self }
 296     }
 297
 298     pub(crate) fn with_ansi(self, ansi: bool) -> Self {
 299         Self { ansi, ..self }
 300     }
 301
 302     fn write_padded(&mut self, value: &impl fmt::Debug) {
 303         let padding = if self.is_empty {
 304             self.is_empty = false;
 305             ""
 306         } else {
 307             ", "
 308         };
 309         self.result = write!(self.writer, "{}{:?}", padding, value);
 310     }
 311
 312     fn bold(&self) -> Style {
 313         if self.ansi {
 314             self.style.bold()
 315         } else {
 316             Style::new()
 317         }
 318     }
 319 }
 320
 321 impl<'a> field::Visit for PrettyVisitor<'a> {
 322     fn record_str(&mut self, field: &Field, value: &str) {
 323         if self.result.is_err() {
 324             return;
 325         }
 326
 327         if field.name() == "message" {
 328             self.record_debug(field, &format_args!("{}", value))
 329         } else {
 330             self.record_debug(field, &value)
 331         }
 332     }
 333
 334     fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
 335         if let Some(source) = value.source() {
 336             let bold = self.bold();
 337             self.record_debug(
 338                 field,
 339                 &format_args!(
 340                     "{}, {}{}.source{}: {}",
 341                     value,
 342                     bold.prefix(),
 343                     field,
 344                     bold.infix(self.style),
 345                     source,
 346                 ),
 347             )
 348         } else {
 349             self.record_debug(field, &format_args!("{}", value))
 350         }
 351     }
 352
 353     fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
 354         if self.result.is_err() {
 355             return;
 356         }
 357         let bold = self.bold();
 358         match field.name() {
 359             "message" => self.write_padded(&format_args!("{}{:?}", self.style.prefix(), value,)),
 360             // Skip fields that are actually log metadata that have already been handled
 361             #[cfg(feature = "tracing-log")]
 362             name if name.starts_with("log.") => self.result = Ok(()),
 363             name if name.starts_with("r#") => self.write_padded(&format_args!(
 364                 "{}{}{}: {:?}",
 365                 bold.prefix(),
 366                 &name[2..],
 367                 bold.infix(self.style),
 368                 value
 369             )),
 370             name => self.write_padded(&format_args!(
 371                 "{}{}{}: {:?}",
 372                 bold.prefix(),
 373                 name,
 374                 bold.infix(self.style),
 375                 value
 376             )),
 377         };
 378     }
 379 }
 380
 381 impl<'a> VisitOutput<fmt::Result> for PrettyVisitor<'a> {
 382     fn finish(self) -> fmt::Result {
 383         write!(self.writer, "{}", self.style.suffix())?;
 384         self.result
 385     }
 386 }
 387
 388 impl<'a> VisitFmt for PrettyVisitor<'a> {
 389     fn writer(&mut self) -> &mut dyn fmt::Write {
 390         self.writer
 391     }
 392 }
 393
 394 impl<'a> fmt::Debug for PrettyVisitor<'a> {
 395     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 396         f.debug_struct("PrettyVisitor")
 397             .field("writer", &format_args!("<dyn fmt::Write>"))
 398             .field("is_empty", &self.is_empty)
 399             .field("result", &self.result)
 400             .field("style", &self.style)
 401             .field("ansi", &self.ansi)
 402             .finish()
 403     }
 404 }