fix: fmt

Author: mikemiles-dev

RELEASES.md

@@ -210,6 +210,13 @@
 * **`#![forbid(unsafe_code)]` enforced**
   - The crate contains zero `unsafe` blocks; this is now enforced at the crate level
 
+* **Cross-variant numeric extraction on `DataNumber` and `FieldValue`**
+  - `DataNumber::as_u8()`, `as_u16()`, `as_u64()` — try to extract a value from any numeric variant, narrowing or widening as needed (returns `None` if the value doesn't fit)
+  - `FieldValue::as_u8()` — delegates to `DataNumber` and also converts `ProtocolType` to its numeric value
+  - `FieldValue::as_u16()` — delegates to `DataNumber`
+  - `FieldValue::as_u64()` — delegates to `DataNumber` and converts `Duration` variants to milliseconds
+  - Unlike the existing `TryFrom` impls (which only match the exact variant), these methods work across all numeric widths
+
 * **Expanded root re-exports**
   - `Config`, `ConfigError`, `TtlConfig`, `EnterpriseFieldRegistry`, `CacheMetrics`, `NoTemplateInfo`, `DEFAULT_MAX_RECORDS_PER_FLOWSET`, `DEFAULT_MAX_SOURCES` — now available at crate root
   - `DataNumber`, `FieldDataType`, `FieldValue` — commonly used field/data types at crate root
@@ -382,6 +389,8 @@
   - Split `v9.rs` into `v9/{mod.rs, parser.rs, serializer.rs}`
   - Split `ipfix.rs` into `ipfix/{mod.rs, parser.rs, serializer.rs}`
   - Renamed `data_number.rs` → `field_value.rs` (deprecated re-export module preserves backward compatibility)
+  - Moved `field_types` from crate root to `variable_versions::field_types` (deprecated re-export at `crate::field_types`)
+  - Moved `template_events` from crate root to `variable_versions::template_events` (deprecated re-export at `crate::template_events`)
 
 * **Code cleanup**
   - Removed unused `enterprise_registry` field from `V9Parser` (was `#[allow(dead_code)]`)
@@ -424,6 +433,18 @@
 * **`v9_available_template_ids()` and `ipfix_available_template_ids()` now return sorted, deduplicated results**
   - Same template ID could previously appear twice (once from templates cache, once from options_templates cache)
 
+* **`clear_v9_pending_flows()` and `clear_ipfix_pending_flows()` now record dropped metrics**
+  - Previously, clearing pending flows did not update `pending_dropped` counters
+  - Now records the count of cleared entries via `record_pending_dropped_n()`
+
+* **`Data::with_template_field_lengths()` now validates field count**
+  - Panics if `template_field_lengths` length doesn't match the field count of the first record
+  - Prevents silent corrupt serialization from mismatched metadata
+
+* **IPFIX variable-length field serialization rejects zero-length fields**
+  - `to_be_bytes()` now returns an error for zero-length variable-length fields per RFC 7011 Section 7
+  - Previously wrote a `0x00` prefix which the parser would reject, breaking round-trip
+
 ## Known Limitations
 
 * **IPFIX variable-length field serialization requires `template_field_lengths`**

src/variable_versions/config.rs

@@ -1,5 +1,6 @@
 //! Parser configuration, traits, and constants for V9 and IPFIX parsers.
 
+use super::metrics::CacheMetricsInner;
 use super::pending_flows::{PendingFlowCache, PendingFlowsConfig};
 use crate::variable_versions::enterprise_registry::EnterpriseFieldRegistry;
 use crate::variable_versions::ttl::TtlConfig;
@@ -268,6 +269,7 @@ pub(crate) trait ParserFields {
     fn set_enterprise_registry(&mut self, _registry: Arc<EnterpriseFieldRegistry>) {}
     fn pending_flows(&self) -> &Option<PendingFlowCache>;
     fn pending_flows_mut(&mut self) -> &mut Option<PendingFlowCache>;
+    fn metrics_mut(&mut self) -> &mut CacheMetricsInner;
 }
 
 /// Trait for parsers that support template caching and TTL configuration
@@ -360,10 +362,19 @@ pub trait ParserConfig: ParserFields {
             .unwrap_or(0)
     }
 
-    /// Clear all pending flows.
+    /// Clear all pending flows, recording dropped metrics.
     fn clear_pending_flows(&mut self) {
+        // Count entries before clearing to record metrics.
+        let count = self
+            .pending_flows()
+            .as_ref()
+            .map(|cache| cache.count())
+            .unwrap_or(0);
         if let Some(cache) = self.pending_flows_mut() {
             cache.clear();
         }
+        if count > 0 {
+            self.metrics_mut().record_pending_dropped_n(count as u64);
+        }
     }
 }

src/variable_versions/field_value.rs

@@ -1230,4 +1230,92 @@ mod field_value_tests {
             FieldValue::Ip6Addr(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1))
         );
     }
+
+    #[test]
+    fn test_data_number_as_u8() {
+        assert_eq!(DataNumber::U8(42).as_u8(), Some(42));
+        assert_eq!(DataNumber::U16(255).as_u8(), Some(255));
+        assert_eq!(DataNumber::U16(256).as_u8(), None);
+        assert_eq!(DataNumber::U32(100).as_u8(), Some(100));
+        assert_eq!(DataNumber::U64(300).as_u8(), None);
+        assert_eq!(DataNumber::I8(-1).as_u8(), None);
+        assert_eq!(DataNumber::I8(127).as_u8(), Some(127));
+        assert_eq!(DataNumber::I16(-1).as_u8(), None);
+        assert_eq!(DataNumber::I32(200).as_u8(), Some(200));
+        assert_eq!(DataNumber::U128(255).as_u8(), Some(255));
+        assert_eq!(DataNumber::U128(256).as_u8(), None);
+        assert_eq!(DataNumber::Vec(vec![1, 2]).as_u8(), None);
+    }
+
+    #[test]
+    fn test_data_number_as_u16() {
+        assert_eq!(DataNumber::U8(42).as_u16(), Some(42));
+        assert_eq!(DataNumber::U16(65535).as_u16(), Some(65535));
+        assert_eq!(DataNumber::U32(65536).as_u16(), None);
+        assert_eq!(DataNumber::U32(1000).as_u16(), Some(1000));
+        assert_eq!(DataNumber::I8(-1).as_u16(), None);
+        assert_eq!(DataNumber::I16(32000).as_u16(), Some(32000));
+        assert_eq!(DataNumber::I16(-1).as_u16(), None);
+        assert_eq!(DataNumber::U64(70000).as_u16(), None);
+        assert_eq!(DataNumber::Vec(vec![1]).as_u16(), None);
+    }
+
+    #[test]
+    fn test_data_number_as_u64() {
+        assert_eq!(DataNumber::U8(42).as_u64(), Some(42));
+        assert_eq!(DataNumber::U16(1000).as_u64(), Some(1000));
+        assert_eq!(DataNumber::U32(100_000).as_u64(), Some(100_000));
+        assert_eq!(DataNumber::U64(u64::MAX).as_u64(), Some(u64::MAX));
+        assert_eq!(DataNumber::I8(-1).as_u64(), None);
+        assert_eq!(DataNumber::I64(1_000_000).as_u64(), Some(1_000_000));
+        assert_eq!(DataNumber::I64(-1).as_u64(), None);
+        assert_eq!(DataNumber::U128(u64::MAX as u128).as_u64(), Some(u64::MAX));
+        assert_eq!(DataNumber::U128(u64::MAX as u128 + 1).as_u64(), None);
+        assert_eq!(DataNumber::Vec(vec![1]).as_u64(), None);
+    }
+
+    #[test]
+    fn test_field_value_as_u8() {
+        assert_eq!(FieldValue::DataNumber(DataNumber::U8(6)).as_u8(), Some(6));
+        assert_eq!(
+            FieldValue::ProtocolType(ProtocolTypes::Tcp).as_u8(),
+            Some(6)
+        );
+        assert_eq!(FieldValue::Float64(1.0).as_u8(), None);
+        assert_eq!(FieldValue::Ip4Addr(Ipv4Addr::LOCALHOST).as_u8(), None);
+    }
+
+    #[test]
+    fn test_field_value_as_u16() {
+        assert_eq!(
+            FieldValue::DataNumber(DataNumber::U16(80)).as_u16(),
+            Some(80)
+        );
+        assert_eq!(FieldValue::Float64(1.0).as_u16(), None);
+    }
+
+    #[test]
+    fn test_field_value_as_u64() {
+        assert_eq!(
+            FieldValue::DataNumber(DataNumber::U32(1000)).as_u64(),
+            Some(1000)
+        );
+        assert_eq!(
+            FieldValue::Duration(DurationValue::Millis {
+                value: 5000,
+                width: 4
+            })
+            .as_u64(),
+            Some(5000)
+        );
+        assert_eq!(
+            FieldValue::Duration(DurationValue::Seconds {
+                value: 10,
+                width: 4
+            })
+            .as_u64(),
+            Some(10_000)
+        );
+        assert_eq!(FieldValue::Float64(1.0).as_u64(), None);
+    }
 }

src/variable_versions/ipfix/parser.rs

@@ -124,6 +124,9 @@ impl ParserFields for IPFixParser {
     fn pending_flows_mut(&mut self) -> &mut Option<PendingFlowCache> {
         &mut self.pending_flows
     }
+    fn metrics_mut(&mut self) -> &mut CacheMetricsInner {
+        &mut self.metrics
+    }
 }
 
 impl ParserConfig for IPFixParser {

src/variable_versions/ipfix/serializer.rs

@@ -15,6 +15,11 @@ fn write_varlen_prefix(
     buf: &mut Vec<u8>,
     value_len: usize,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if value_len == 0 {
+        return Err(
+            "IPFIX variable-length field cannot have zero length (RFC 7011 Section 7)".into(),
+        );
+    }
     if value_len < 255 {
         buf.push(value_len as u8);
     } else {

src/variable_versions/pending_flows.rs

@@ -156,7 +156,10 @@ impl PendingFlowCache {
             return Err(ConfigError::InvalidEntrySize(config.max_entry_size_bytes));
         }
         if config.max_total_bytes == 0 {
-            return Err(ConfigError::InvalidPendingCacheSize(0));
+            return Err(ConfigError::InvalidPendingTotalBytes {
+                max_total_bytes: 0,
+                max_entry_size_bytes: config.max_entry_size_bytes,
+            });
         }
         if config.max_total_bytes < config.max_entry_size_bytes {
             return Err(ConfigError::InvalidPendingTotalBytes {
@@ -410,6 +413,9 @@ impl PendingFlowCache {
     }
 
     /// Clear all pending flows.
+    ///
+    /// Callers are responsible for recording dropped metrics via
+    /// `metrics.record_pending_dropped_n(cache.count())` before calling this.
     pub(crate) fn clear(&mut self) {
         self.cache.clear();
         self.total_bytes = 0;

src/variable_versions/v9/parser.rs

@@ -130,6 +130,9 @@ impl ParserFields for V9Parser {
     fn pending_flows_mut(&mut self) -> &mut Option<PendingFlowCache> {
         &mut self.pending_flows
     }
+    fn metrics_mut(&mut self) -> &mut CacheMetricsInner {
+        &mut self.metrics
+    }
 }
 
 impl ParserConfig for V9Parser {