Implement robust logging with flexi_logger and update CI to verify logs

src/main.rs

@@ -2,6 +2,8 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+use flexi_logger::writers::FileLogWriter;
+use flexi_logger::{Cleanup, Criterion, Duplicate, FileSpec, Logger, Naming, WriteMode};
 use russh::keys::ssh_key::rand_core::OsRng;
 use russh::server::Server as _;
 use tokio::net::TcpListener;
@@ -18,12 +20,12 @@ const DEFAULT_DB_PATH: &str = "./mudserver.db";
 
 #[tokio::main]
 async fn main() {
-    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
-
     let mut port = DEFAULT_PORT;
     let mut jsonrpc_port = 2223;
     let mut world_dir = PathBuf::from(DEFAULT_WORLD_DIR);
     let mut db_path = PathBuf::from(DEFAULT_DB_PATH);
+    let mut log_dir = "logs".to_string();
+    let mut log_level = "info".to_string();
 
     let args: Vec<String> = std::env::args().collect();
     let mut i = 1;
@@ -51,12 +53,22 @@ async fn main() {
                 i += 1;
                 db_path = PathBuf::from(args.get(i).expect("--db requires a path"));
             }
+            "--log-dir" => {
+                i += 1;
+                log_dir = args.get(i).expect("--log-dir requires a path").to_string();
+            }
+            "--log-level" => {
+                i += 1;
+                log_level = args.get(i).expect("--log-level requires a level").to_string();
+            }
             "--help" => {
                 eprintln!("Usage: mudserver [OPTIONS]");
                 eprintln!("  --port, -p      SSH listen port (default: {DEFAULT_PORT})");
                 eprintln!("  --rpc-port      JSON-RPC listen port (default: 2223)");
                 eprintln!("  --world, -w     World directory (default: {DEFAULT_WORLD_DIR})");
                 eprintln!("  --db, -d        Database path (default: {DEFAULT_DB_PATH})");
+                eprintln!("  --log-dir       Directory for log files (default: logs)");
+                eprintln!("  --log-level     Logging level (default: info)");
                 std::process::exit(0);
             }
             other => {
@@ -67,6 +79,42 @@ async fn main() {
         i += 1;
     }
 
+    // Ensure log directory exists
+    std::fs::create_dir_all(&log_dir).unwrap_or_else(|e| {
+        eprintln!("Failed to create log directory: {e}");
+        std::process::exit(1);
+    });
+
+    // Initialize logger
+    let combat_writer = FileLogWriter::builder(FileSpec::default().directory(&log_dir).basename("combat"))
+        .rotate(
+            Criterion::Size(10_000_000), // 10 MB
+            Naming::Numbers,
+            Cleanup::KeepLogFiles(7),
+        )
+        .append()
+        .write_mode(WriteMode::Direct)
+        .try_build()
+        .unwrap();
+
+    Logger::try_with_str(&log_level)
+        .unwrap()
+        .log_to_file(FileSpec::default().directory(&log_dir).basename("mudserver"))
+        .append()
+        .duplicate_to_stderr(Duplicate::All)
+        .rotate(
+            Criterion::Size(10_000_000), // 10 MB
+            Naming::Numbers,
+            Cleanup::KeepLogFiles(7),
+        )
+        .write_mode(WriteMode::Direct)
+        .add_writer("combat", Box::new(combat_writer))
+        .start()
+        .unwrap_or_else(|e| {
+            eprintln!("Failed to initialize logger: {e}");
+            std::process::exit(1);
+        });
+
     log::info!("Loading world from: {}", world_dir.display());
     let loaded_world = world::World::load(&world_dir).unwrap_or_else(|e| {
         eprintln!("Failed to load world: {e}");