switched to log4rs

server/Cargo.toml

@@ -18,6 +18,8 @@ hilbert_index = "0.2.0"
 hyper = "1.0.1"
 hyper-util = "0.1.1"
 indoc = "2.0.4"
+log = "0.4.20"
+log4rs = "1.2.0"
 nalgebra = { version = "0.32.3", features = ["serde-serialize"] }
 parking_lot = { version = "0.11", features = ["serde"] }
 pathfinding = "4.6.0"

server/src/main.rs

@@ -11,6 +11,7 @@ use axum::{
 };
 use blocks::{World, Position, Vec3};
 use indoc::formatdoc;
+use log::info;
 use mine::TurtleMineJob;
 use rstar::{self, AABB, RTree};
 
@@ -90,6 +91,8 @@ async fn main() -> Result<(), Error> {
         None => "save".into(),
     })?;
 
+    log4rs::init_file(SAVE.get().unwrap().join("log.yml"), Default::default())?;
+
     let state = read_from_disk().await?;
 
     let state = LiveState::from_save(state);
@@ -115,7 +118,7 @@ async fn main() -> Result<(), Error> {
 
     let server = safe_kill::serve(server, listener).await;
 
-    println!("writing");
+    info!("writing");
     write_to_disk(state.read().await.save().await).await?;
 
     server.closed().await;
@@ -180,7 +183,7 @@ async fn create_turtle(
     state.tasks.push(VecDeque::new());
     
 
-    println!("new turtle: {id}");
+    info!("new turtle: {id}");
 
     Json(turtle::TurtleResponse {
         name: Name::from_num(id).to_str(),

server/src/mine.rs

@@ -1,4 +1,5 @@
 use hilbert_index::FromHilbertIndex;
+use log::{info, warn};
 use nalgebra::SimdValue;
 use serde::{Deserialize, Serialize};
 use rstar::{self, AABB};
@@ -152,9 +153,10 @@ pub async fn mine(turtle: TurtleCommander, pos: Vec3, fuel: Position, storage: P
 
     async fn refuel_needed(turtle: &TurtleCommander, volume: i32, fuel: Position) -> Option<()> {
         Some(if (turtle.fuel().await as f64) < (2 * volume + (fuel.pos-turtle.pos().await.pos).abs().sum()) as f64 * 1.8 {
-            println!("refueling");
+            let name = turtle.name().await.to_str();
+            info!("{name}: refueling");
             turtle.goto(fuel).await?;
-            println!("docked");
+            info!("{name}: docked");
             refuel(turtle.clone()).await;
         })
     }
@@ -179,7 +181,7 @@ pub async fn mine(turtle: TurtleCommander, pos: Vec3, fuel: Position, storage: P
         }
 
         if dump_filter(turtle.clone(), |i| USELESS.iter().any(|u| **u == i.name)).await > 12 {
-            println!("storage rtb");
+            info!("storage rtb");
             turtle.goto(storage).await?;
             dump(turtle.clone()).await;
             // while we're here
@@ -225,7 +227,7 @@ async fn refuel(turtle: TurtleCommander) {
         let re = turtle.execute(Refuel).await;
         if let TurtleCommandResponse::Failure = re.ret {
             // partial refuel, good enough
-            println!("only received {} fuel", turtle.fuel().await);
+            warn!("only received {} fuel", turtle.fuel().await);
             if turtle.fuel().await > 5000 {
                 break;
             } else {

server/src/safe_kill.rs

@@ -1,3 +1,4 @@
+use log::{error, info};
 use tokio::net::TcpListener;
 use tokio::signal;
 
@@ -28,7 +29,7 @@ pub(crate) async fn serve(server: Router, listener: TcpListener) -> Sender<()> {
                 result.unwrap()
             }
             _ = shutdown_signal() => {
-                println!("cancelled connection");
+                info!("cancelled connection");
                 break;
             }
         };
@@ -52,12 +53,12 @@ pub(crate) async fn serve(server: Router, listener: TcpListener) -> Sender<()> {
                 tokio::select! {
                     result = conn.as_mut() => {
                         if result.is_err() {
-                            println!("req failed");
+                            error!("req failed");
                         }
                         break;
                     }
                     _ = shutdown_signal() => {
-                        println!("starting shutdown");
+                        info!("starting shutdown");
                         conn.as_mut().graceful_shutdown();
                     }
                 }

server/src/turtle.rs

@@ -14,6 +14,10 @@ use anyhow::Ok;
 
 use anyhow;
 use anyhow::Context;
+use log::trace;
+use log::warn;
+use log::info;
+use tokio::sync::OnceCell;
 use tokio::sync::RwLock;
 use tokio::sync::mpsc;
 use tokio::sync::oneshot;
@@ -151,7 +155,7 @@ pub struct TurtleCommander {
     pos: Arc<RwLock<Position>>,
     fuel: Arc<AtomicUsize>,
     max_fuel: Arc<AtomicUsize>,
-    
+    name: Arc<OnceCell<Name>>,
 }
 
 impl TurtleCommander {
@@ -164,6 +168,7 @@ impl TurtleCommander {
             pos: Arc::new(RwLock::new(turtle.position)),
             fuel: Arc::new(AtomicUsize::new(turtle.fuel)),
             max_fuel: Arc::new(AtomicUsize::new(turtle.fuel_limit)),
+            name: Arc::new(OnceCell::new_with(Some(turtle.name))),
         })
     }
 
@@ -179,6 +184,10 @@ impl TurtleCommander {
         resp
     }
 
+    pub async fn name(&self) -> Name {
+        self.name.get().unwrap().clone()
+    }
+
     pub async fn pos(&self) -> Position {
         self.pos.read().await.clone()
     }
@@ -336,6 +345,10 @@ pub(crate) async fn process_turtle_update(
 
     let info = TurtleInfo::from_update(update, turtle.name.clone(), turtle.position.clone());
 
+    if let TurtleCommandResponse::Failure = info.ret {
+        warn!("{} command failure", turtle.name.to_str());
+    }
+
     if let Some(send) = turtle.callback.take() {
         send.send(info).unwrap();
     }
@@ -351,12 +364,12 @@ pub(crate) async fn process_turtle_update(
                 _ => {}
             }
             turtle.queued_movement = cmd.unit(turtle.position.dir);
-            println!("{}: {cmd:?}", turtle.name.to_str());
+            info!("{}: {cmd:?}", turtle.name.to_str());
             return Ok(cmd);
         }
     }
 
-    println!("{} idle, connected", turtle.name.to_str());
+    trace!("{} idle, connected", turtle.name.to_str());
     Ok(TurtleCommand::Wait(IDLE_TIME))
 }