Add Logging

Cargo.toml

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 dotenvy = "0.15.7"
 tokio = { version = "1.52.3", features = ["full"] }
+tracing = "0.1.44"

src/ipc.rs

@@ -1,6 +1,7 @@
 use std::net::{Ipv4Addr, SocketAddrV4};
 use std::sync::Arc;
 use tokio::net::UdpSocket;
+use tracing::{error, info};
 use crate::types::{Message, Sockets};
 
 pub struct IpcFrame {
@@ -46,21 +47,26 @@ pub async fn run(host: String, port: u16, sockets: Arc<Sockets>) -> Result<(), B
         loop {
             match ipc_socket.recv_from(&mut buf).await {
                 Ok((len, _sender_addr)) => {
+                    info!("Received response from partner server");
+
                     match IpcFrame::from_bytes(&buf[..len]) {
                         Ok(ipc_frame) => {
+                            info!("Packet from partner: {:?}", ipc_frame.message);
+
                             let socket = &sockets.alt;
+                            info!("Sending partner's response to {}", ipc_frame.remote_addr);
                             let _ = socket.send_to(
                                 &ipc_frame.message.to_response_bytes(socket.clone(), ipc_frame.remote_addr).unwrap(),
                                 format!("{}:{}", ipc_frame.remote_addr.ip(), ipc_frame.remote_addr.port()),
                             ).await;
                         },
                         Err(e) => {
-                            eprintln!("Failed to decode IPC Frame: {e}")
+                            error!("Failed to decode IPC Frame: {e}")
                         }
                     }
                 },
                 Err(e) => {
-                    eprintln!("IPC Socket Error: {e}");
+                    error!("IPC Socket Error: {e}");
                     break;
                 }
             }

src/main.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use std::env;
 use dotenvy::dotenv;
 use tokio::net::UdpSocket;
+use tracing::{error, info};
 
 use crate::ipc::IpcFrame;
 use crate::types::{Message, Sockets};
@@ -11,6 +12,8 @@ pub mod types;
 mod ipc;
 
 async fn respond(socket: Arc<UdpSocket>, message: Message, remote_addr: SocketAddrV4) {
+    info!("Sending response to {remote_addr} from {}", socket.local_addr().unwrap());
+
     let _ = socket.send_to(
         &message.to_response_bytes(socket.clone(), remote_addr).unwrap(),
         remote_addr
@@ -18,6 +21,8 @@ async fn respond(socket: Arc<UdpSocket>, message: Message, remote_addr: SocketAd
 }
 
 async fn respond_from_partner(socket: Arc<UdpSocket>, message: crate::types::Message, remote_addr: SocketAddrV4, sockets: Arc<Sockets>) -> Result<(), Box<dyn std::error::Error>> {
+    info!("Sending response for {remote_addr} to partner server");
+
     let partner_addr = env::var("NNCS_PARTNER_IP")?;
 
     let ipc_sender_socket = sockets.alt.clone();
@@ -47,14 +52,17 @@ fn init_port(socket: Arc<UdpSocket>, sockets: Arc<Sockets>) {
                     let remote_port = src_addr.port();
                     let remote_addr = SocketAddrV4::new(remote_ip, remote_port);
 
+                    info!("Received packet from {remote_addr} on {}", socket.local_addr().unwrap());
+
                     match types::Message::from_bytes(&buf[..len]) {
                         Ok(packet) => {
+                            info!("Packet contents: {:?}", packet);
                             match packet.r#type {
                                 1 => respond(socket.clone(), packet, remote_addr).await, // Server responds from regular ip and regular port
 
                                 2 => match respond_from_partner(socket.clone(), packet, remote_addr, sockets.clone()).await { // Server responds from different ip and different port
                                     Ok(_) => (),
-                                    Err(e) => eprintln!("Error responding from partner: {e}"),
+                                    Err(e) => error!("Error responding from partner: {e}"),
                                 },
 
                                 3 => { // Server responds from regular ip and different port
@@ -75,17 +83,17 @@ fn init_port(socket: Arc<UdpSocket>, sockets: Arc<Sockets>) {
 
                                 103 => respond(socket.clone(), packet, remote_addr).await, // Server responds from regular ip and regular port
                                 _ => {
-                                    eprintln!("[{}] Invalid message type from {src_addr}: {}", socket.local_addr().unwrap().port(), packet.r#type)
+                                    error!("[{}] Invalid message type from {src_addr}: {}", socket.local_addr().unwrap().port(), packet.r#type)
                                 },
                             }
                         },
                         Err(e) => {
-                            eprintln!("[{}] Error parsing message from {src_addr}: {e}", socket.local_addr().unwrap().port())
+                            error!("[{}] Error parsing message from {src_addr}: {e}", socket.local_addr().unwrap().port())
                         }
                     }
                 },
                 Err(e) => {
-                    eprintln!("[{}] Socket error: {e}", socket.local_addr().unwrap().port());
+                    error!("[{}] Socket error: {e}", socket.local_addr().unwrap().port());
                     break;
                 }
             }
@@ -108,12 +116,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     init_port(sockets.primary.clone(), sockets.clone());
     init_port(sockets.secondary.clone(), sockets.clone());
 
-    println!("NNCS Running on Ports 10025 and 10125");
+    info!("NNCS Running on Ports 10025 and 10125");
 
-    let ipc_port: u16= env::var("NNCS_IPC_PORT").unwrap_or("9001".into()).parse()?;
+    let ipc_port: u16 = env::var("NNCS_IPC_PORT").unwrap_or("9001".into()).parse()?;
     ipc::run("0.0.0.0".into(), ipc_port, sockets).await?;
 
-    println!("IPC Running on Port {ipc_port}");
+    info!("IPC Running on Port {ipc_port}");
 
     std::future::pending::<()>().await;
     Ok(())

src/types.rs

@@ -10,6 +10,7 @@ pub struct Sockets {
     pub p33335: Arc<UdpSocket>,
 }
 
+#[derive(Debug)]
 pub struct Message {
     pub r#type: u32,
     pub external_port: u32,