Json structured logs

bin/reth/src/args/log_args.rs

@@ -1,26 +1,28 @@
 //! clap [Args](clap::Args) for logging configuration.
 
 use crate::dirs::{LogsDir, PlatformPath};
-use clap::{Args, ValueEnum};
+use clap::{ArgAction, Args, ValueEnum};
 use reth_tracing::{
-    tracing_subscriber::{registry::LookupSpan, EnvFilter},
-    BoxedLayer, FileWorkerGuard,
+    tracing_subscriber::filter::Directive, FileInfo, FileWorkerGuard, LayerInfo, LogFormat,
+    RethTracer, Tracer,
 };
 use std::{fmt, fmt::Display};
-use tracing::Subscriber;
-
-/// Default [directives](reth_tracing::tracing_subscriber::filter::Directive) for [EnvFilter] which
-/// disables high-frequency debug logs from `hyper` and `trust-dns`
-const DEFAULT_ENV_FILTER_DIRECTIVES: [&str; 3] =
-    ["hyper::proto::h1=off", "trust_dns_proto=off", "atrust_dns_resolver=off"];
-
+use tracing::{level_filters::LevelFilter, Level};
 /// Constant to convert megabytes to bytes
 const MB_TO_BYTES: u64 = 1024 * 1024;
 
 /// The log configuration.
 #[derive(Debug, Args)]
 #[command(next_help_heading = "Logging")]
 pub struct LogArgs {
+    /// The format to use for logs written to std.
+    #[arg(long = "log.std.format", value_name = "FORMAT", global = true, default_value_t = LogFormat::Terminal)]
+    pub log_std_format: LogFormat,
+
+    /// The format to use for logs written to the log file.
+    #[arg(long = "log.file.format", value_name = "FORMAT", global = true, default_value_t = LogFormat::Terminal)]
+    pub log_file_format: LogFormat,
+
     /// The path to put log files in.
     #[arg(long = "log.file.directory", value_name = "PATH", global = true, default_value_t)]
     pub log_file_directory: PlatformPath<LogsDir>,
@@ -60,55 +62,50 @@ pub struct LogArgs {
         default_value_t = ColorMode::Always
     )]
     pub color: ColorMode,
+    /// The verbosity settings for the tracer.
+    #[clap(flatten)]
+    pub verbosity: Verbosity,
 }
 
 impl LogArgs {
-    /// Builds tracing layers from the current log options.
-    pub fn layers<S>(&self) -> eyre::Result<(Vec<BoxedLayer<S>>, Option<FileWorkerGuard>)>
-    where
-        S: Subscriber,
-        for<'a> S: LookupSpan<'a>,
-    {
-        let mut layers = Vec::new();
-
-        // Function to create a new EnvFilter with environment (from `RUST_LOG` env var), default
-        // (from `DEFAULT_DIRECTIVES`) and additional directives.
-        let create_env_filter = |additional_directives: &str| -> eyre::Result<EnvFilter> {
-            let env_filter = EnvFilter::builder().from_env_lossy();
-
-            DEFAULT_ENV_FILTER_DIRECTIVES
-                .into_iter()
-                .chain(additional_directives.split(','))
-                .try_fold(env_filter, |env_filter, directive| {
-                    Ok(env_filter.add_directive(directive.parse()?))
-                })
-        };
-
-        // Create and add the journald layer if enabled
+    /// Creates a LayerInfo instance.
+    fn layer(&self, format: LogFormat, use_color: bool) -> LayerInfo {
+        LayerInfo::new(
+            format,
+            self.log_file_filter.clone(),
+            self.verbosity.directive(),
+            if use_color { Some(self.color.to_string()) } else { None },
+        )
+    }
+
+    /// File info from the current log options.
+    fn file_info(&self) -> FileInfo {
+        FileInfo::new(
+            self.log_file_directory.clone().into(),
+            self.log_file_max_size * MB_TO_BYTES,
+            self.log_file_max_files,
+        )
+    }
+
+    /// Initializes tracing with the configured options from cli args.
+    pub fn init_tracing(&self) -> eyre::Result<Option<FileWorkerGuard>> {
+        let mut tracer = RethTracer::new();
+
+        let stdout = self.layer(self.log_std_format, true);
+        tracer = tracer.with_stdout(stdout);
+
         if self.journald {
-            let journald_filter = create_env_filter(&self.journald_filter)?;
-            layers.push(
-                reth_tracing::journald(journald_filter).expect("Could not connect to journald"),
-            );
+            tracer = tracer.with_journald(self.journald_filter.clone());
         }
 
-        // Create and add the file logging layer if enabled
-        let file_guard = if self.log_file_max_files > 0 {
-            let file_filter = create_env_filter(&self.log_file_filter)?;
-            let (layer, guard) = reth_tracing::file(
-                file_filter,
-                &self.log_file_directory,
-                "reth.log",
-                self.log_file_max_size * MB_TO_BYTES,
-                self.log_file_max_files,
-            );
-            layers.push(layer);
-            Some(guard)
-        } else {
-            None
-        };
+        if self.log_file_max_files > 0 {
+            let info = self.file_info();
+            let file = self.layer(self.log_file_format, false);
+            tracer = tracer.with_file(file, info);
+        }
 
-        Ok((layers, file_guard))
+        let guard = tracer.init()?;
+        Ok(guard)
     }
 }
 
@@ -132,3 +129,42 @@ impl Display for ColorMode {
         }
     }
 }
+
+/// The verbosity settings for the cli.
+#[derive(Debug, Copy, Clone, Args)]
+#[command(next_help_heading = "Display")]
+pub struct Verbosity {
+    /// Set the minimum log level.
+    ///
+    /// -v      Errors
+    /// -vv     Warnings
+    /// -vvv    Info
+    /// -vvvv   Debug
+    /// -vvvvv  Traces (warning: very verbose!)
+    #[clap(short, long, action = ArgAction::Count, global = true, default_value_t = 3, verbatim_doc_comment, help_heading = "Display")]
+    verbosity: u8,
+
+    /// Silence all log output.
+    #[clap(long, alias = "silent", short = 'q', global = true, help_heading = "Display")]
+    quiet: bool,
+}
+
+impl Verbosity {
+    /// Get the corresponding [Directive] for the given verbosity, or none if the verbosity
+    /// corresponds to silent.
+    pub fn directive(&self) -> Directive {
+        if self.quiet {
+            LevelFilter::OFF.into()
+        } else {
+            let level = match self.verbosity - 1 {
+                0 => Level::ERROR,
+                1 => Level::WARN,
+                2 => Level::INFO,
+                3 => Level::DEBUG,
+                _ => Level::TRACE,
+            };
+
+            format!("{level}").parse().unwrap()
+        }
+    }
+}

bin/reth/src/cli/mod.rs

@@ -12,13 +12,9 @@ use crate::{
     runner::CliRunner,
     version::{LONG_VERSION, SHORT_VERSION},
 };
-use clap::{value_parser, ArgAction, Args, Parser, Subcommand};
+use clap::{value_parser, Parser, Subcommand};
 use reth_primitives::ChainSpec;
-use reth_tracing::{
-    tracing::{metadata::LevelFilter, Level},
-    tracing_subscriber::filter::Directive,
-    FileWorkerGuard,
-};
+use reth_tracing::FileWorkerGuard;
 use std::sync::Arc;
 
 pub mod components;
@@ -67,9 +63,6 @@ pub struct Cli<Ext: RethCliExt = ()> {
 
     #[clap(flatten)]
     logs: LogArgs,
-
-    #[clap(flatten)]
-    verbosity: Verbosity,
 }
 
 impl<Ext: RethCliExt> Cli<Ext> {
@@ -101,13 +94,7 @@ impl<Ext: RethCliExt> Cli<Ext> {
     /// If file logging is enabled, this function returns a guard that must be kept alive to ensure
     /// that all logs are flushed to disk.
     pub fn init_tracing(&self) -> eyre::Result<Option<FileWorkerGuard>> {
-        let mut layers =
-            vec![reth_tracing::stdout(self.verbosity.directive(), &self.logs.color.to_string())];
-
-        let (additional_layers, guard) = self.logs.layers()?;
-        layers.extend(additional_layers);
-
-        reth_tracing::init(layers);
+        let guard = self.logs.init_tracing()?;
         Ok(guard)
     }
 
@@ -173,45 +160,6 @@ impl<Ext: RethCliExt> Commands<Ext> {
     }
 }
 
-/// The verbosity settings for the cli.
-#[derive(Debug, Copy, Clone, Args)]
-#[command(next_help_heading = "Display")]
-pub struct Verbosity {
-    /// Set the minimum log level.
-    ///
-    /// -v      Errors
-    /// -vv     Warnings
-    /// -vvv    Info
-    /// -vvvv   Debug
-    /// -vvvvv  Traces (warning: very verbose!)
-    #[clap(short, long, action = ArgAction::Count, global = true, default_value_t = 3, verbatim_doc_comment, help_heading = "Display")]
-    verbosity: u8,
-
-    /// Silence all log output.
-    #[clap(long, alias = "silent", short = 'q', global = true, help_heading = "Display")]
-    quiet: bool,
-}
-
-impl Verbosity {
-    /// Get the corresponding [Directive] for the given verbosity, or none if the verbosity
-    /// corresponds to silent.
-    pub fn directive(&self) -> Directive {
-        if self.quiet {
-            LevelFilter::OFF.into()
-        } else {
-            let level = match self.verbosity - 1 {
-                0 => Level::ERROR,
-                1 => Level::WARN,
-                2 => Level::INFO,
-                3 => Level::DEBUG,
-                _ => Level::TRACE,
-            };
-
-            format!("{level}").parse().unwrap()
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use clap::CommandFactory;

crates/tracing/Cargo.toml

@@ -10,7 +10,10 @@ description = "tracing helpers"
 
 [dependencies]
 tracing.workspace = true
-tracing-subscriber = { version = "0.3", default-features = false, features = ["env-filter", "fmt"] }
+tracing-subscriber = { version = "0.3", default-features = false, features = ["env-filter", "fmt", "json"] }
 tracing-appender.workspace = true
 tracing-journald = "0.3"
+tracing-logfmt = "0.3.3"
 rolling-file = "0.2.0"
+eyre.workspace = true
+clap = { workspace = true, features = ["derive"] }