feat: switch to rolling logs

Remove cli args and output to stdout. Wasn't readable anyway

Author: c-git

Cargo.lock

@@ -61,6 +61,7 @@ tokio = { version = "1.42.0", default-features = false }
 tokio-util = "0.7.13"
 tracing = "0.1.41"
 tracing-actix-web = "0.7.11"
+tracing-appender = "0.2.3"
 tracing-bunyan-formatter = "0.3.10"
 tracing-log = "0.2.0"
 tracing-subscriber = { version = "0.3", features = ["fmt", "json"] }

Cargo.toml

@@ -7,7 +7,6 @@ description = "egui Client for the Demo Chat App"
 
 [dependencies]
 anyhow.workspace = true
-clap = { workspace = true, features = ["derive"] }
 eframe = { workspace = true, features = [ # put all features on their own line
   "accesskit", # Make egui compatible with screen readers. NOTE: adds a lot of dependencies.
   "default_fonts", # Embed the default egui fonts.
@@ -30,10 +29,9 @@ wykies-time.workspace = true
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-clap.workspace = true
 ewebsock = { workspace = true, features = ["tls", "tokio"] }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
-tracing-subscriber.workspace = true
+tracing-appender.workspace = true
 
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]

crates/chat-app-client/Cargo.toml

@@ -9,7 +9,6 @@ mod suppress_wasm_warnings {
 
 mod app;
 pub mod background_worker;
-pub mod cli;
 mod lockout;
 mod pages;
 mod shortcuts;

crates/chat-app-client/src/cli.rs

@@ -4,12 +4,13 @@
 // When compiling natively:
 #[cfg(not(target_arch = "wasm32"))]
 fn main() -> eframe::Result<()> {
-    use clap::Parser;
-    let args = chat_app_client::cli::Cli::parse();
-
-    if let Err(e) = chat_app_client::tracing::init(&args) {
-        eprintln!("Failed to start tracing: {e}");
-    }
+    let _guard = match chat_app_client::tracing::init() {
+        Ok(guard) => guard,
+        Err(err_msg) => {
+            eprintln!("Failed to start tracing: {err_msg:?}");
+            std::process::exit(84);
+        }
+    };
 
     let rt = chat_app_client::background_worker::create_runtime();
     let _enter = rt.enter(); // This Guard must be held to call `tokio::spawn` anywhere in the program

crates/chat-app-client/src/lib.rs

@@ -1,46 +1,22 @@
 #[cfg(not(target_arch = "wasm32"))]
-pub fn init(cli: &super::cli::Cli) -> anyhow::Result<()> {
+pub fn init() -> anyhow::Result<tracing_appender::non_blocking::WorkerGuard> {
     use anyhow::{bail, Context};
     use wykies_shared::telemetry;
 
-    fn init_to_file() -> anyhow::Result<()> {
-        let (file, filename) = telemetry::create_trace_file("chat_app_client")?;
-        let subscriber =
-            telemetry::get_subscriber("chat_app_client".into(), "zbus=warn,info", file);
+    let (writer, path, guard) = telemetry::setup_tracing_writer("chat_app_client")?;
+    let subscriber = telemetry::get_subscriber("chat_app_client".into(), "zbus=warn,info", writer);
 
-        // Start logging to file
-        match telemetry::init_subscriber(subscriber) {
-            Ok(_) => {
-                println!(
-                    "Traces being written to: {:?}",
-                    filename
-                        .canonicalize()
-                        .context("trace file canonicalization failed")?
-                );
-                Ok(())
-            }
-            Err(e) => {
-                bail!("Failed to start tracing to file. Error: {e}");
-            }
+    match telemetry::init_subscriber(subscriber) {
+        Ok(()) => {
+            println!(
+                "Traces being written to: {:?}",
+                path.canonicalize()
+                    .context("trace file canonicalization failed")?
+            );
+            Ok(guard)
         }
-    }
-
-    if !cli.is_to_std_out {
-        // Log to file
-        match init_to_file() {
-            Ok(_) => return Ok(()),
-            Err(e) => {
-                // Print error and fall though to logging to stdout
-                eprintln!("Failed to start logging to file: {e}");
-            }
-        }
-    }
-
-    // Log to stdout
-    match tracing_subscriber::fmt().try_init() {
-        Ok(_) => Ok(()),
         Err(e) => {
-            bail!("Failed to start tracing. Error: {e}");
+            bail!("Failed to start tracing to file. Error: {e}");
         }
     }
 }

crates/chat-app-client/src/main.rs

@@ -38,9 +38,9 @@ async fn main(
 async fn main() -> anyhow::Result<()> {
     use shuttle_runtime::Service as _;
 
-    let (file, path) = wykies_shared::telemetry::create_trace_file("chat-app-server")
-        .context("failed to create file for traces")?;
-    initialize_tracing("chat_app_server", "info", file);
+    let (writer, path, _guard) = wykies_shared::telemetry::setup_tracing_writer("chat-app-server")
+        .context("failed to setup traces")?;
+    initialize_tracing("chat_app_server", "info", writer);
     println!(
         "Traces being written to: {:?}",
         path.canonicalize()

crates/chat-app-client/src/tracing.rs

@@ -25,8 +25,9 @@ wykies-time.workspace = true
 # For native compilation only
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 actix-web.workspace = true
-tracing-bunyan-formatter.workspace = true
 ewebsock = { workspace = true, features = ["tls", "tokio"] }
+tracing-appender.workspace = true
+tracing-bunyan-formatter.workspace = true
 tracing-log.workspace = true
 tracing-subscriber = { workspace = true, features = ["registry", "env-filter"] }
 

crates/chat-app-server/src/main.rs

@@ -1,11 +1,9 @@
 use actix_web::rt::task::JoinHandle;
 use anyhow::Context;
-use std::{
-    fs::{create_dir_all, File},
-    path::PathBuf,
-};
+use std::{fs::create_dir_all, path::PathBuf};
 use tracing::subscriber::set_global_default;
 use tracing::Subscriber;
+use tracing_appender::non_blocking::{NonBlocking, WorkerGuard};
 use tracing_bunyan_formatter::{BunyanFormattingLayer, JsonStorageLayer};
 use tracing_log::LogTracer;
 use tracing_subscriber::fmt::MakeWriter;
@@ -55,23 +53,16 @@ where
     actix_web::rt::task::spawn_blocking(move || current_span.in_scope(f))
 }
 
-fn gen_log_filename(app_name: &str) -> String {
-    format!(
-        "{}_{app_name}.log",
-        chrono::Local::now().format("%Y-%m-%dT%H-%M-%S")
-    )
-}
-
 /// Returns a handle to the file created and the file path
-pub fn create_trace_file(app_name: &str) -> anyhow::Result<(File, PathBuf)> {
+pub fn setup_tracing_writer(app_name: &str) -> anyhow::Result<(NonBlocking, PathBuf, WorkerGuard)> {
     // Create logging folder
-    let log_folder = PathBuf::from("traces");
+    let mut log_folder = PathBuf::from("traces");
+    log_folder.push(app_name);
     create_dir_all(&log_folder).context("Failed to create logging folder")?;
 
-    // Create file to log to
-    let filename = gen_log_filename(app_name);
-    let file_path = log_folder.join(&filename);
-    let file = File::create(&file_path)
-        .with_context(|| format!("Failed to create log file: {filename:?}"))?;
-    Ok((file, file_path))
+    // Start non blocking logger wrapping a rolling logger
+    let file_appender = tracing_appender::rolling::daily(&log_folder, app_name);
+    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+
+    Ok((non_blocking, log_folder, guard))
 }