Add optional file logging, and add logging for heartbeat disconnects

Cargo.toml

@@ -27,8 +27,10 @@ serde = { version = "1.0.136", features = ["derive"] }
 serde_json = "1.0.79"
 sha2 = "0.10.2"
 tokio = { version = "1.17.0", features = ["rt-multi-thread", "io-util", "macros", "net", "time"] }
+time = "0.3.35"
 tokio-util = { version = "0.7.1", features = ["codec"] }
 tracing = "0.1.32"
+tracing-appender = "0.2.3"
 tracing-subscriber = "0.3.18"
 uuid = { version = "1.2.1", features = ["serde", "v4"] }
 

src/main.rs

@@ -3,12 +3,15 @@ use std::net::IpAddr;
 use anyhow::Result;
 use bore_cli::{client::Client, server::Server};
 use clap::{error::ErrorKind, CommandFactory, Parser, Subcommand};
+use tracing;
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about)]
 struct Args {
     #[clap(subcommand)]
     command: Command,
+    #[arg(long)]
+    log_path: Option<String>,
 }
 
 #[derive(Subcommand, Debug)]
@@ -96,7 +99,33 @@ async fn run(command: Command) -> Result<()> {
     Ok(())
 }
 
+fn setup_logging(log_path: Option<&String>) -> Result<tracing_appender::non_blocking::WorkerGuard> {
+    match log_path {
+        Some(x) => {
+            let file_appender = tracing_appender::rolling::daily(x, "bore_server.log");
+            let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+            let subscriber = tracing_subscriber::fmt()
+                .with_writer(non_blocking)
+                .with_ansi(false)
+                .finish();
+            tracing::subscriber::set_global_default(subscriber)
+                .expect("setting up trace logging failed");
+            Ok(guard)
+        }
+        None => {
+            let (non_blocking, guard) = tracing_appender::non_blocking(std::io::stdout());
+            let subscriber = tracing_subscriber::fmt()
+                .with_writer(non_blocking)
+                .finish();
+            tracing::subscriber::set_global_default(subscriber)
+                .expect("setting up trace logging failed");
+            Ok(guard)
+        }
+    }
+}
+
 fn main() -> Result<()> {
-    tracing_subscriber::fmt::init();
+    // _ to persist the global logger guard
+    let _guard = setup_logging(Args::parse().log_path.as_ref());
     run(Args::parse().command)
 }

src/server.rs

@@ -116,6 +116,7 @@ impl Server {
     }
 
     async fn handle_connection(&self, stream: TcpStream) -> Result<()> {
+        let peer_addr = stream.peer_addr().unwrap().to_string();
         let mut stream = Delimited::new(stream);
         if let Some(auth) = &self.auth {
             if let Err(err) = auth.server_handshake(&mut stream).await {
@@ -146,6 +147,7 @@ impl Server {
                 loop {
                     if stream.send(ServerMessage::Heartbeat).await.is_err() {
                         // Assume that the TCP connection has been dropped.
+                        info!(peer_addr, "connection dropped after heartbeat timeout");
                         return Ok(());
                     }
                     const TIMEOUT: Duration = Duration::from_millis(500);