add more error telemetry

veilid-tools/src/assembly_buffer.rs

@@ -234,23 +234,39 @@ impl AssemblyBuffer {
 
     /// Receive a packet chunk and add to the message assembly
     /// if a message has been completely, return it
-    pub fn insert_frame(&self, frame: &[u8], remote_addr: SocketAddr) -> Option<Vec<u8>> {
+    pub fn insert_frame(
+        &self,
+        frame: &[u8],
+        remote_addr: SocketAddr,
+    ) -> NetworkResult<Option<Vec<u8>>> {
         // If we receive a zero length frame, send it
         if frame.len() == 0 {
-            return Some(frame.to_vec());
+            return NetworkResult::value(Some(frame.to_vec()));
         }
 
         // If we receive a frame smaller than or equal to the length of the header, drop it
         // or if this frame is larger than our max message length, then drop it
         if frame.len() <= HEADER_LEN || frame.len() > MAX_LEN {
-            return None;
+            #[cfg(feature = "network-result-extra")]
+            return NetworkResult::invalid_message(format!(
+                "invalid header length: frame.len={}",
+                frame.len()
+            ));
+            #[cfg(not(feature = "network-result-extra"))]
+            return NetworkResult::invalid_message("invalid header length");
         }
 
         // --- Decode the header
 
         // Drop versions we don't understand
         if frame[0] != VERSION_1 {
-            return None;
+            #[cfg(feature = "network-result-extra")]
+            return NetworkResult::invalid_message(format!(
+                "invalid frame version: frame[0]={}",
+                frame[0]
+            ));
+            #[cfg(not(feature = "network-result-extra"))]
+            return NetworkResult::invalid_message("invalid frame version");
         }
         // Version 1 header
         let seq = SequenceType::from_be_bytes(frame[2..4].try_into().unwrap());
@@ -260,16 +276,30 @@ impl AssemblyBuffer {
 
         // See if we have a whole message and not a fragment
         if off == 0 && len as usize == chunk.len() {
-            return Some(chunk.to_vec());
+            return NetworkResult::value(Some(chunk.to_vec()));
         }
 
         // Drop fragments with offsets greater than or equal to the message length
         if off >= len {
-            return None;
+            #[cfg(feature = "network-result-extra")]
+            return NetworkResult::invalid_message(format!(
+                "offset greater than length: off={} >= len={}",
+                off, len
+            ));
+            #[cfg(not(feature = "network-result-extra"))]
+            return NetworkResult::invalid_message("offset greater than length");
         }
         // Drop fragments where the chunk would be applied beyond the message length
         if off as usize + chunk.len() > len as usize {
-            return None;
+            #[cfg(feature = "network-result-extra")]
+            return NetworkResult::invalid_message(format!(
+                "chunk applied beyond message length: off={} + chunk.len={} > len={}",
+                off,
+                chunk.len(),
+                len
+            ));
+            #[cfg(not(feature = "network-result-extra"))]
+            return NetworkResult::invalid_message("chunk applied beyond message length");
         }
 
         // Get or create the peer message assemblies
@@ -291,19 +321,18 @@ impl AssemblyBuffer {
                         e.remove();
                     }
                 }
-
-                out
+                NetworkResult::value(out)
             }
             std::collections::hash_map::Entry::Vacant(v) => {
                 // See if we have room for one more
                 if peer_count == MAX_CONCURRENT_HOSTS {
-                    return None;
+                    return NetworkResult::value(None);
                 }
                 // Add the peer
                 let peer_messages = v.insert(PeerMessages::new());
 
                 // Insert the fragment and see what comes out
-                peer_messages.insert_fragment(seq, off, len, chunk)
+                NetworkResult::value(peer_messages.insert_fragment(seq, off, len, chunk))
             }
         }
     }