chore: improve logging

src/message/mod.rs

@@ -200,7 +200,10 @@ impl Message {
         let data = &self.data[self.pointer..self.pointer + size];
         self.pointer += size;
 
-        String::from_utf8(data.to_vec()).expect("Failed to read string")
+        match String::from_utf8(data.to_vec()) {
+            Ok(s) => s,
+            Err(_) => data.iter().map(|&b| b as char).collect::<String>(),
+        }
     }
 
     pub fn read_int8(&mut self) -> u8 {
@@ -466,3 +469,26 @@ fn test_read_string_invalid_utf8() {
     let mut test_data = Message::new_with_data(data);
     test_data.read_string();
 }
+
+#[test]
+fn test_read_string_invalid_utf82() {
+    let data = [
+        128, 0, 0, 0, 103, 58, 92, 100, 105, 115, 107, 52, 92, 115, 101, 109,
+        105, 114, 97, 109, 105, 115, 92, 99, 104, 105, 108, 108, 44, 32, 100,
+        117, 98, 44, 32, 100, 111, 119, 110, 98, 101, 97, 116, 44, 32, 97, 109,
+        98, 105, 101, 110, 116, 92, 118, 97, 114, 105, 111, 117, 115, 32, 97,
+        114, 116, 105, 115, 116, 115, 92, 112, 111, 116, 116, 32, 104, 101, 97,
+        100, 122, 32, 45, 32, 100, 111, 112, 101, 32, 115, 109, 111, 107, 105,
+        110, 180, 98, 101, 97, 116, 115, 32, 107, 98, 115, 32, 49, 50, 56, 32,
+        49, 57, 57, 54, 92, 48, 53, 32, 45, 32, 98, 108, 117, 101, 32, 116,
+        114, 97, 105, 110, 46, 109, 112, 51,
+    ]
+    .to_vec();
+
+    let mut test_data = Message::new_with_data(data);
+    let str = test_data.read_string();
+    assert_eq!(
+        str,
+        r"g:\disk4\semiramis\chill, dub, downbeat, ambient\various artists\pott headz - dope smokin´beats kbs 128 1996\05 - blue train.mp3"
+    );
+}

src/message/server/message_user.rs

@@ -27,7 +27,7 @@ impl MessageHandler<ServerOperation> for MessageUser {
             new_message,
         );
 
-        info!("User message received:");
+        info!("[MessageUser] User message received:{:?}", user_message);
         user_message.print()
     }
 }

src/peer/default_peer.rs

@@ -98,9 +98,10 @@ impl DefaultPeer {
     pub fn connect(mut self) -> Result<Self, io::Error> {
         {
             let peer = self.peer.read().unwrap();
-            println!(
+            trace!(
                 "[default_peer] Connecting to {} on port {}",
-                peer.host, peer.port
+                peer.host,
+                peer.port
             );
         }
         let socket_address = {
@@ -141,10 +142,6 @@ impl DefaultPeer {
         stream: TcpStream,
         reader: Option<MessageReader>,
     ) -> Result<(), io::Error> {
-        debug!(
-            "[default_peer:{}] start_read_write_loops",
-            self.peer.read().unwrap().username
-        );
         let (peer_sender, peer_reader): (
             Sender<PeerOperation>,
             Receiver<PeerOperation>,
@@ -165,11 +162,6 @@ impl DefaultPeer {
         };
         let mut read_stream = stream;
 
-        debug!(
-            "[default_peer:{}] Streams created, spawning threads",
-            self.peer.read().unwrap().username
-        );
-
         let peer = self.peer.clone();
         let peer_clone = self.peer.clone();
         let client_channel_for_read = self.client_channel.clone();
@@ -178,10 +170,6 @@ impl DefaultPeer {
         let buffer_size = buffered_reader.buffer_len();
 
         self.read_thread = Some(thread::spawn(move || {
-            debug!(
-                "Read thread received reader with {} bytes in buffer",
-                buffer_size
-            );
             let mut handlers = Handlers::new();
             handlers.register_handler(FileSearchResponse);
             handlers.register_handler(TransferRequest);

src/utils/logger.rs

@@ -11,13 +11,13 @@ pub enum LogLevel {
 }
 
 static INIT: Once = Once::new();
-static mut LOG_LEVEL: LogLevel = LogLevel::Debug; // Default to VERBOSE (mapped to DEBUG)
+static mut LOG_LEVEL: LogLevel = LogLevel::Warn;
 
 pub fn init() {
     INIT.call_once(|| {
         let level = env::var("LOG_LEVEL")
             .or_else(|_| env::var("RUST_LOG"))
-            .unwrap_or_else(|_| "VERBOSE".to_string())
+            .unwrap_or_else(|_| "WARN".to_string())
             .to_uppercase();
 
         unsafe {
@@ -28,7 +28,7 @@ pub fn init() {
                 "DEBUG" => LogLevel::Debug,
                 "TRACE" => LogLevel::Trace,
                 "VERBOSE" => LogLevel::Debug, // Map VERBOSE to DEBUG
-                _ => LogLevel::Debug,         // Default to VERBOSE
+                _ => LogLevel::Warn,          // Default to WARN
             };
         }
     });

src/utils/thread_pool.rs

@@ -71,32 +71,32 @@ impl Worker {
     fn new(
         id: usize,
         receiver: Arc<Mutex<mpsc::Receiver<Job>>>,
-        active_threads: Arc<AtomicUsize>,
-        total_threads: usize,
+        _active_threads: Arc<AtomicUsize>,
+        _total_threads: usize,
     ) -> Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv();
             match job {
                 Ok(job) => {
-                    let active =
-                        active_threads.fetch_add(1, Ordering::SeqCst) + 1;
-                    trace!(
-                        "Thread {} started job (active: {}/{})",
-                        id,
-                        active,
-                        total_threads
-                    );
+                    // let active =
+                    //     active_threads.fetch_add(1, Ordering::SeqCst) + 1;
+                    // trace!(
+                    //     "Thread {} started job (active: {}/{})",
+                    //     id,
+                    //     active,
+                    //     total_threads
+                    // );
 
                     job();
 
-                    let active =
-                        active_threads.fetch_sub(1, Ordering::SeqCst) - 1;
-                    trace!(
-                        "Thread {} finished job (active: {}/{})",
-                        id,
-                        active,
-                        total_threads
-                    );
+                    // let active =
+                    // active_threads.fetch_sub(1, Ordering::SeqCst) - 1;
+                    // trace!(
+                    //     "Thread {} finished job (active: {}/{})",
+                    //     id,
+                    //     active,
+                    //     total_threads
+                    // );
                 }
                 Err(_) => {
                     break;