Logging!

Cargo.toml

@@ -10,7 +10,9 @@ codegen-units = 1
 [dependencies]
 clap = { version = "4.5.20", features = ["derive"] }
 csv = "1.3.1"
+env_logger = "0.11.5"
 jiff = "0.1.14"
+log = "0.4.22"
 pid = "4.0.0"
 rand = "0.8.5"
 rumqttc = "0.24.0"

src/commands/run.rs

@@ -1,4 +1,7 @@
 use clap::Parser;
+use log::debug;
+use log::error;
+use log::info;
 use pid::Pid;
 use rumqttc::{AsyncClient, MqttOptions, QoS};
 use std::time::Duration;
@@ -29,7 +32,8 @@ impl RunArgs {
 
         let (client, mut eventloop) = AsyncClient::new(mqttoptions, 10);
         if let Err(e) = client.subscribe(self.input_topic, QoS::AtMostOnce).await {
-            panic!("Failed to subscribe to MQTT topic: {}", e);
+            error!("Failed to subscribe to MQTT topic: {}", e);
+            return Err(Box::new(e));
         }
 
         let (tx, mut rx) = watch::channel(0);
@@ -53,6 +57,7 @@ impl RunArgs {
                         .round() as u8;
 
                     if last_output_value != output {
+                        debug!("Emitting new output value: {}", output);
                         last_output_value = output;
                         if let Err(e) = client
                             .publish(
@@ -63,28 +68,31 @@ impl RunArgs {
                             )
                             .await
                         {
-                            eprintln!("Failed to publish to MQTT topic: {}", e);
+                            error!("Failed to publish to MQTT topic: {}", e);
                         }
                     }
                 }
             });
         }
 
+        info!("Topic subscribed; waiting for events.");
+
         loop {
             let notification = eventloop.poll().await;
             match notification {
                 Ok(rumqttc::Event::Incoming(rumqttc::Packet::Publish(publish))) => {
                     if let Ok(payload) = std::str::from_utf8(&publish.payload) {
                         if let Ok(value) = payload.parse::<u16>() {
+                            debug!("Received new input value: {}", value);
                             if let Err(e) = tx.send(value) {
-                                eprintln!("Failed to send via channel: {}", e);
+                                error!("Failed to send via channel: {}", e);
                             }
                         }
                     }
                 }
                 Ok(_) => {}
                 Err(e) => {
-                    eprintln!("MQTT error: {:?}", e);
+                    error!("MQTT error: {:?}", e);
                 }
             }
         }

src/main.rs

@@ -32,6 +32,8 @@ enum Commands {
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 2)]
 async fn main() {
+    env_logger::init();
+
     let args = Args::parse();
     let mut pid = Pid::<f64>::new(args.setpoint, 100.0);
     pid.p(args.kp, 100.0);