poc4 wit rust

2026-08-16 15:34:53 +02:00
parent e5d344622e
commit 40474cdc59
29 changed files with 2692 additions and 159 deletions
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import threading
+import time
+import unittest
+
+from app.state import RuntimeStats
+from app.tzsp_rust import RustTZSPReceiver
+
+
+class RustTZSPReceiverTelemetryTests(unittest.TestCase):
+    def _receiver(self, sink=None):
+        return RustTZSPReceiver(
+            binary="/does/not/start-in-unit-tests",
+            telemetry_socket="/tmp/unused-tzsp-test.sock",
+            stats=RuntimeStats(),
+            stop_event=threading.Event(),
+            throughput_sink=sink,
+        )
+
+    def test_telemetry_sample_drives_live_rate_without_packet_bytes_in_python(self):
+        written = []
+        receiver = self._receiver(written.append)
+        now_ms = int(time.time() * 1000)
+        receiver._ingest(
+            {
+                "type": "tzsp_sample",
+                "engine": "rust",
+                "ready": True,
+                "ts_ms": now_ms,
+                "interval_ms": 1000,
+                "last_packet_ms": now_ms,
+                "bytes_total": 125_000_000,
+                "bytes_in": 100_000_000,
+                "bytes_out": 25_000_000,
+                "packets_total": 80_000,
+                "traffic_counters": {"bytes_total": 125_000_000, "packets_total": 80_000},
+                "kernel_udp_drops": 3,
+                "kernel_udp_drops_interval": 0,
+                "queue_dropped_datagrams": 0,
+                "queue_drops_interval": 0,
+                "truncated_datagrams": 0,
+                "truncated_interval": 0,
+                "queue_depth_batches": 1,
+                "queue_capacity_batches": 24,
+                "queue_capacity_bytes": 64 * 1024 * 1024,
+                "capture_efficiency_pct": 100.0,
+                "rx_datagrams_interval": 80_000,
+                "rx_bytes_interval": 126_000_000,
+                "rx_thread_alive": True,
+                "worker_thread_alive": True,
+                "rcvbuf_bytes": 425_984,
+                "batch_size": 256,
+                "datagram_bytes": 12_288,
+            }
+        )
+        current = receiver.current_throughput(3600)
+        self.assertEqual(current["current_bps"], 1_000_000_000)
+        self.assertEqual(current["current_in_bps"], 800_000_000)
+        self.assertEqual(current["current_out_bps"], 200_000_000)
+        self.assertEqual(current["current_pps"], 80_000)
+        self.assertEqual(current["kernel_udp_drops"], 3)
+        self.assertEqual(current["current_ingress_bps"], 1_008_000_000)
+        self.assertEqual(current["capture_efficiency_pct"], 100.0)
+        self.assertEqual(current["queue_fill_pct"], 4.2)
+        self.assertEqual(current["loss_pps"], 0)
+        self.assertTrue(current["rx_thread_alive"])
+        self.assertTrue(current["worker_thread_alive"])
+        self.assertEqual(current["receiver_engine"], "rust")
+        self.assertEqual(len(written), 1)
+        self.assertEqual(written[0]["bytes_total"], 125_000_000)
+
+    def test_ingress_and_inspection_are_reported_separately_when_pipeline_is_behind(self):
+        receiver = self._receiver()
+        now_ms = int(time.time() * 1000)
+        receiver._last = {
+            "ts_ms": now_ms,
+            "interval_ms": 1000,
+            "bytes_total": 31_250_000,
+            "packets_total": 24_000,
+            "rx_bytes_interval": 125_000_000,
+            "rx_datagrams_interval": 80_000,
+            "kernel_udp_drops_interval": 10,
+            "queue_drops_interval": 90,
+            "truncated_interval": 0,
+            "queue_depth_batches": 20,
+            "queue_capacity_batches": 22,
+            "capture_efficiency_pct": 99.875,
+        }
+        current = receiver.current_throughput(900)
+        self.assertEqual(current["current_bps"], 250_000_000)
+        self.assertEqual(current["current_ingress_bps"], 1_000_000_000)
+        self.assertEqual(current["inspection_ratio_pct"], 25.0)
+        self.assertEqual(current["queue_fill_pct"], 90.9)
+        self.assertEqual(current["loss_pps"], 100.0)
+
+    def test_stale_sample_reports_zero_current_rate(self):
+        receiver = self._receiver()
+        receiver._last = {
+            "ts_ms": int(time.time() * 1000) - 10_000,
+            "interval_ms": 1000,
+            "bytes_total": 125_000_000,
+            "packets_total": 80_000,
+        }
+        current = receiver.current_throughput(900)
+        self.assertFalse(current["current_sample_fresh"])
+        self.assertEqual(current["current_bps"], 0)
+        self.assertEqual(current["current_pps"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()