fix: relay command startup (#310)

* Make `log_output_path` optional

* Avoid multiple `pluto_tracing` initializations

* Move `pluto_tracing::init` to main

* Simplify `pluto_tracing::init`

* Simplify `relay::run`

* Simplify main

- Allow bubbling up errors
- Remove `ExitResult` indirection

Author: emlautarom1

crates/cli/src/commands/relay.rs

@@ -266,10 +266,9 @@ pub struct RelayLogFlags {
     #[arg(
         long = "log-output-path",
         env = "PLUTO_LOG_OUTPUT_PATH",
-        default_value = "",
         help = "Path in which to write on-disk logs."
     )]
-    pub log_output_path: PathBuf,
+    pub log_output_path: Option<PathBuf>,
 }
 
 #[derive(clap::ValueEnum, Clone, Default)]
@@ -299,19 +298,7 @@ pub struct RelayLokiArgs {
     pub loki_service: String,
 }
 
-pub async fn run(args: RelayArgs, ct: CancellationToken) -> Result<(), CliError> {
-    let config: pluto_relay_server::config::Config = args.try_into()?;
-
-    let log_config = config
-        .log_config
-        .as_ref()
-        .expect("Log config is always configured");
-    pluto_tracing::init(log_config).expect("Failed to initialize tracing");
-
-    run_with_config(config, ct).await
-}
-
-async fn run_with_config(
+pub async fn run(
     config: pluto_relay_server::config::Config,
     ct: CancellationToken,
 ) -> Result<(), CliError> {
@@ -350,7 +337,7 @@ async fn run_with_config(
 #[cfg(test)]
 mod tests {
     use backon::{BackoffBuilder, Retryable};
-    use std::{path::PathBuf, str::FromStr, time};
+    use std::{str::FromStr, time};
     use tokio::net;
     use tokio_util::sync::CancellationToken;
 
@@ -547,7 +534,7 @@ mod tests {
                 format: "console".into(),
                 level: "error".into(),
                 color: super::ConsoleColor::Disable,
-                log_output_path: PathBuf::new(),
+                log_output_path: None,
             },
             loki: super::RelayLokiArgs {
                 loki_addresses: vec![],
@@ -559,7 +546,7 @@ mod tests {
         let cfg: pluto_relay_server::config::Config = args.clone().try_into().unwrap();
         let ct = CancellationToken::new();
 
-        let relay = tokio::spawn(super::run_with_config(cfg.clone(), ct.child_token()));
+        let relay = tokio::spawn(super::run(cfg.clone(), ct.child_token()));
 
         test_fn(cfg.clone()).await;
 

crates/cli/src/error.rs

@@ -1,31 +1,12 @@
 //! Error types for the Pluto CLI.
 
-use std::{
-    path::PathBuf,
-    process::{ExitCode, Termination},
-};
-
-use thiserror::Error;
+use std::path::PathBuf;
 
 /// Result type for CLI operations.
 pub type Result<T> = std::result::Result<T, CliError>;
 
-pub struct ExitResult(pub Result<()>);
-
-impl Termination for ExitResult {
-    fn report(self) -> ExitCode {
-        match self.0 {
-            Ok(()) => ExitCode::SUCCESS,
-            Err(err) => {
-                eprintln!("Error: {}", err);
-                ExitCode::FAILURE
-            }
-        }
-    }
-}
-
 /// Errors that can occur in the Pluto CLI.
-#[derive(Error, Debug)]
+#[derive(thiserror::Error, Debug)]
 pub enum CliError {
     /// Private key file not found.
     #[error(
@@ -87,11 +68,15 @@ pub enum CliError {
     #[error("test case not supported")]
     _TestCaseNotSupported,
 
-    /// Generic error with message.
-    #[error("{0}")]
-    Other(String),
-
     /// Relay P2P error.
     #[error("Relay P2P error: {0}")]
     RelayP2PError(#[from] pluto_relay_server::error::RelayP2PError),
+
+    /// Command parsing error.
+    #[error("Command parsing error: {0}")]
+    CommandParsingError(#[from] clap::Error),
+
+    /// Generic error with message.
+    #[error("{0}")]
+    Other(String),
 }

crates/cli/src/main.rs

@@ -4,32 +4,33 @@
 //! This crate provides the CLI tools and commands for managing and operating
 //! Pluto validator nodes.
 
+use crate::error::CliError;
 use clap::{CommandFactory, FromArgMatches};
+use cli::{AlphaCommands, Cli, Commands, CreateCommands, TestCommands};
+use std::process::ExitCode;
+use tokio_util::sync::CancellationToken;
 
 mod ascii;
 mod cli;
 mod commands;
 mod duration;
 mod error;
 
-use cli::{AlphaCommands, Cli, Commands, CreateCommands, TestCommands};
-
-use crate::error::ExitResult;
-use tokio_util::sync::CancellationToken;
-
 #[tokio::main]
-async fn main() -> ExitResult {
-    let config = pluto_tracing::TracingConfig::builder()
-        .with_default_console()
-        .build();
-    let _ = pluto_tracing::init(&config);
+async fn main() -> ExitCode {
+    match run().await {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("Error: {}", err);
+            ExitCode::FAILURE
+        }
+    }
+}
 
+async fn run() -> std::result::Result<(), CliError> {
     let cmd = commands::test::update_test_cases_help(Cli::command());
     let matches = cmd.get_matches();
-    let cli = match Cli::from_arg_matches(&matches) {
-        Ok(cli) => cli,
-        Err(e) => return ExitResult(Err(error::CliError::Other(e.to_string()))),
-    };
+    let cli = Cli::from_arg_matches(&matches)?;
 
     // Top level cancellation token for graceful shutdown on Ctrl+C
     let ct = CancellationToken::new();
@@ -41,13 +42,17 @@ async fn main() -> ExitResult {
         }
     });
 
-    let result = match cli.command {
+    match cli.command {
         Commands::Create(args) => match args.command {
             CreateCommands::Enr(args) => commands::create_enr::run(args),
         },
         Commands::Enr(args) => commands::enr::run(args),
         Commands::Version(args) => commands::version::run(args),
-        Commands::Relay(args) => commands::relay::run(*args, ct.clone()).await,
+        Commands::Relay(args) => {
+            let config: pluto_relay_server::config::Config = (*args).clone().try_into()?;
+            pluto_tracing::init(&config.log_config).expect("Failed to initialize tracing");
+            commands::relay::run(config, ct.clone()).await
+        }
         Commands::Alpha(args) => match args.command {
             AlphaCommands::Test(args) => {
                 let mut stdout = std::io::stdout();
@@ -56,6 +61,8 @@ async fn main() -> ExitResult {
                         .await
                         .map(|_| ()),
                     TestCommands::Beacon(args) => {
+                        pluto_tracing::init(&pluto_tracing::TracingConfig::default())
+                            .expect("Failed to initialize tracing");
                         commands::test::beacon::run(args, &mut stdout, ct.clone())
                             .await
                             .map(|_| ())
@@ -75,7 +82,5 @@ async fn main() -> ExitResult {
                 }
             }
         },
-    };
-
-    ExitResult(result)
+    }
 }

crates/relay-server/src/config.rs

@@ -29,7 +29,8 @@ pub struct Config {
     /// The P2P configuration.
     pub p2p_config: P2PConfig,
     /// The logging configuration.
-    pub log_config: Option<TracingConfig>,
+    #[builder(default)]
+    pub log_config: TracingConfig,
     /// Whether to automatically generate a P2P key.
     #[builder(default = false)]
     pub auto_p2p_key: bool,