@agentunion/kite 1.0.0

package/core/event_hub/bench_extreme.py

@@ -0,0 +1,308 @@
+"""
+Event Hub extreme tests (standalone).
+
+Usage:  python -m core.event_hub.bench_extreme
+        (from Kite root directory)
+
+Test 1: Burst ramp — step 1000 from 1000 to 50000
+Test 2: Message size ramp — 500KB to 100MB
+Test 3: Fan-out — 1 publisher, N subscribers (N=1..50)
+"""
+
+import asyncio
+import json
+import os
+import socket
+import statistics
+import sys
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+
+_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _root not in sys.path:
+    sys.path.insert(0, _root)
+
+import uvicorn
+import websockets
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from core.event_hub.hub import EventHub
+
+
+def _create_app(hub: EventHub) -> FastAPI:
+    app = FastAPI()
+
+    @app.websocket("/ws")
+    async def ws(ws: WebSocket):
+        mid = ws.query_params.get("id", f"anon_{id(ws)}")
+        await ws.accept()
+        hub.add_connection(mid, ws)
+        try:
+            while True:
+                raw = await ws.receive_text()
+                await hub.handle_message(mid, ws, raw)
+        except (WebSocketDisconnect, Exception):
+            pass
+        finally:
+            hub.remove_connection(mid)
+
+    return app
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class C:
+    def __init__(self, url: str, name: str):
+        self.url, self.name, self.ws = url, name, None
+
+    async def connect(self):
+        self.ws = await websockets.connect(
+            f"{self.url}?id={self.name}", max_size=None
+        )
+
+    async def sub(self, patterns):
+        await self.ws.send(json.dumps({"type": "subscribe", "events": patterns}))
+
+    async def pub(self, event: str, data: dict) -> str:
+        eid = str(uuid.uuid4())
+        await self.ws.send(json.dumps({
+            "type": "event", "event_id": eid, "event": event,
+            "source": self.name, "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": data,
+        }))
+        return eid
+
+    async def recv(self, timeout=5.0):
+        try:
+            return json.loads(await asyncio.wait_for(self.ws.recv(), timeout=timeout))
+        except Exception:
+            return None
+
+    async def drain(self, timeout=0.05):
+        while await self.recv(timeout=timeout) is not None:
+            pass
+
+    async def close(self):
+        if self.ws:
+            await self.ws.close()
+
+
+class BenchExtreme:
+    def __init__(self):
+        self.hub = EventHub()
+        self.port = _free_port()
+        self.ws_url = f"ws://127.0.0.1:{self.port}/ws"
+        self._server = None
+
+    def _start_server(self):
+        app = _create_app(self.hub)
+        cfg = uvicorn.Config(app, host="127.0.0.1", port=self.port, log_level="warning")
+        self._server = uvicorn.Server(cfg)
+        threading.Thread(target=self._server.run, daemon=True).start()
+        deadline = time.time() + 5
+        while time.time() < deadline:
+            if self._server.started:
+                return
+            time.sleep(0.05)
+        raise RuntimeError("Server failed to start")
+
+    async def _make_channel(self, pub_name, sub_name, pattern):
+        pub = C(self.ws_url, pub_name)
+        sub = C(self.ws_url, sub_name)
+        await pub.connect()
+        await sub.connect()
+        await sub.sub([pattern])
+        await asyncio.sleep(0.1)
+        return pub, sub
+
+    # ── Test 1: Burst ramp ──
+
+    async def test_burst_ramp(self):
+        print("=" * 60)
+        print("TEST 1: Burst ramp (step 1000, 1000→50000)")
+        print("=" * 60)
+
+        pub, sub = await self._make_channel("burst_pub", "burst_sub", "burst.*")
+
+        for size in range(1000, 50001, 1000):
+            # Snapshot hub counters before
+            q_before = self.hub._cnt_queued
+            r_before = self.hub._cnt_routed
+
+            recvd = 0
+            stop = asyncio.Event()
+
+            async def _recv():
+                nonlocal recvd
+                while not stop.is_set():
+                    msg = await sub.recv(timeout=0.3)
+                    if msg and msg.get("type") == "event":
+                        recvd += 1
+
+            task = asyncio.create_task(_recv())
+
+            start = time.time()
+            for i in range(size):
+                await pub.pub("burst.test", {"i": i})
+            send_time = time.time() - start
+            rate = size / send_time if send_time > 0 else 0
+
+            # Wait proportional to burst size
+            await asyncio.sleep(max(3, size / 1000))
+            stop.set()
+            await task
+            await pub.drain()
+            await sub.drain()
+
+            # Hub-side counters
+            hub_queued = self.hub._cnt_queued - q_before
+            hub_routed = self.hub._cnt_routed - r_before
+
+            loss = size - recvd
+            loss_pct = loss / size * 100
+            print(f"  burst={size:>6}: recv={recvd:>6}  loss={loss}({loss_pct:.1f}%)  "
+                  f"rate={rate:.0f} evt/s  send={send_time:.2f}s  "
+                  f"hub_q={hub_queued} hub_r={hub_routed}")
+
+            if loss_pct > 1:
+                print(f"  >> Loss at burst={size} — hub_queued={hub_queued} hub_routed={hub_routed} client_recv={recvd}")
+
+        await pub.close()
+        await sub.close()
+        print()
+
+    # ── Test 2: Message size ramp ──
+
+    async def test_message_size_ramp(self):
+        print("=" * 60)
+        print("TEST 2: Message size ramp (500KB→100MB)")
+        print("=" * 60)
+
+        pub, sub = await self._make_channel("size_pub", "size_sub", "size.*")
+
+        for size_kb in [500, 1024, 2048, 5120, 10240, 20480, 51200, 102400]:
+            size_label = f"{size_kb}KB" if size_kb < 1024 else f"{size_kb//1024}MB"
+            payload = "X" * (size_kb * 1024)
+            n_msgs = 3
+            latencies = []
+            ok = True
+
+            for trial in range(n_msgs):
+                try:
+                    t0 = time.time()
+                    await pub.pub("size.test", {"p": payload})
+                except Exception as e:
+                    print(f"  {size_label:>6}: SEND FAILED on msg {trial+1} ({e})")
+                    ok = False
+                    break
+
+                # Dynamic timeout based on size
+                wait = max(10, size_kb / 200)
+                msg = await sub.recv(timeout=wait)
+                elapsed = (time.time() - t0) * 1000
+
+                if msg and msg.get("type") == "event":
+                    latencies.append(elapsed)
+                await pub.drain()
+
+            if not ok:
+                break
+
+            if latencies:
+                avg = statistics.mean(latencies)
+                print(f"  {size_label:>6}: recv={len(latencies)}/{n_msgs}  "
+                      f"avg={avg:.0f}ms  min={min(latencies):.0f}ms  max={max(latencies):.0f}ms")
+            else:
+                print(f"  {size_label:>6}: recv=0/{n_msgs}  DELIVERY FAILED")
+                break
+
+        await pub.close()
+        await sub.close()
+        print()
+
+    # ── Test 3: Fan-out ──
+
+    async def test_fanout(self):
+        print("=" * 60)
+        print("TEST 3: Fan-out (1 pub, N subs, 5000 events)")
+        print("=" * 60)
+
+        n_events = 5000
+
+        for n_subs in [1, 5, 10, 20, 50]:
+            pub = C(self.ws_url, "fanout_pub")
+            await pub.connect()
+
+            subs = []
+            for i in range(n_subs):
+                s = C(self.ws_url, f"fanout_sub_{i}")
+                await s.connect()
+                await s.sub(["fanout.*"])
+                subs.append(s)
+            await asyncio.sleep(0.2)
+
+            # Receiver tasks
+            counts = [0] * n_subs
+
+            async def _recv_loop(idx, client, stop_evt):
+                while not stop_evt.is_set():
+                    msg = await client.recv(timeout=0.3)
+                    if msg and msg.get("type") == "event":
+                        counts[idx] += 1
+
+            stop = asyncio.Event()
+            tasks = [asyncio.create_task(_recv_loop(i, s, stop)) for i, s in enumerate(subs)]
+
+            start = time.time()
+            for i in range(n_events):
+                await pub.pub("fanout.test", {"i": i})
+            send_time = time.time() - start
+
+            # Wait for delivery
+            await asyncio.sleep(max(5, n_events * n_subs / 5000))
+            stop.set()
+            for t in tasks:
+                await t
+
+            await pub.drain()
+            for s in subs:
+                await s.drain()
+
+            min_recv = min(counts)
+            max_recv = max(counts)
+            avg_recv = sum(counts) / n_subs
+            rate = n_events / send_time if send_time > 0 else 0
+
+            print(f"  subs={n_subs:>3}: avg_recv={avg_recv:.0f}/{n_events}  "
+                  f"min={min_recv} max={max_recv}  "
+                  f"pub_rate={rate:.0f} evt/s  send={send_time:.2f}s")
+
+            await pub.close()
+            for s in subs:
+                await s.close()
+
+        print()
+
+    # ── Entry ──
+
+    async def run_all(self):
+        self._start_server()
+        print(f"Event Hub started on port {self.port}\n")
+        try:
+            await self.test_burst_ramp()
+            await self.test_message_size_ramp()
+            await self.test_fanout()
+            print("All extreme tests complete.")
+        finally:
+            if self._server:
+                self._server.should_exit = True
+
+
+if __name__ == "__main__":
+    asyncio.run(BenchExtreme().run_all())

package/core/event_hub/bench_perf.py

@@ -0,0 +1,350 @@
+"""
+Event Hub performance benchmark — quick repeatable run.
+
+Usage:  python -m core.event_hub.bench_perf
+        (from Kite root directory)
+
+Runs in ~20s, outputs a summary table for before/after comparison.
+"""
+
+import asyncio
+import json
+import os
+import platform
+import socket
+import statistics
+import sys
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+
+_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _root not in sys.path:
+    sys.path.insert(0, _root)
+
+import uvicorn
+import websockets
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from core.event_hub.hub import EventHub
+
+
+def _create_app(hub: EventHub) -> FastAPI:
+    app = FastAPI()
+
+    @app.websocket("/ws")
+    async def ws(ws: WebSocket):
+        mid = ws.query_params.get("id", f"anon_{id(ws)}")
+        await ws.accept()
+        hub.add_connection(mid, ws)
+        try:
+            while True:
+                raw = await ws.receive_text()
+                await hub.handle_message(mid, ws, raw)
+        except (WebSocketDisconnect, Exception):
+            pass
+        finally:
+            hub.remove_connection(mid)
+
+    return app
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class Client:
+    def __init__(self, url: str, name: str):
+        self.url, self.name, self.ws = url, name, None
+
+    async def connect(self):
+        self.ws = await websockets.connect(
+            f"{self.url}?id={self.name}", max_size=None
+        )
+
+    async def sub(self, patterns):
+        await self.ws.send(json.dumps({"type": "subscribe", "events": patterns}))
+
+    async def pub(self, event: str, data: dict) -> str:
+        eid = str(uuid.uuid4())
+        await self.ws.send(json.dumps({
+            "type": "event", "event_id": eid, "event": event,
+            "source": self.name,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": data,
+        }))
+        return eid
+
+    async def recv(self, timeout=5.0):
+        try:
+            return json.loads(
+                await asyncio.wait_for(self.ws.recv(), timeout=timeout)
+            )
+        except Exception:
+            return None
+
+    async def drain(self, timeout=0.05):
+        while await self.recv(timeout=timeout) is not None:
+            pass
+
+    async def close(self):
+        if self.ws:
+            await self.ws.close()
+
+
+class PerfBench:
+    def __init__(self):
+        self.hub = EventHub()
+        self.port = _free_port()
+        self.ws_url = f"ws://127.0.0.1:{self.port}/ws"
+        self._server = None
+        self.results = {}
+
+    def _start_server(self):
+        app = _create_app(self.hub)
+        cfg = uvicorn.Config(app, host="127.0.0.1", port=self.port, log_level="warning")
+        self._server = uvicorn.Server(cfg)
+        threading.Thread(target=self._server.run, daemon=True).start()
+        deadline = time.time() + 5
+        while time.time() < deadline:
+            if self._server.started:
+                return
+            time.sleep(0.05)
+        raise RuntimeError("Server failed to start")
+
+    async def _make_pair(self, pub_name, sub_name, pattern):
+        pub = Client(self.ws_url, pub_name)
+        sub = Client(self.ws_url, sub_name)
+        await pub.connect()
+        await sub.connect()
+        await sub.sub([pattern])
+        await asyncio.sleep(0.1)
+        return pub, sub
+
+    # ── 1. Throughput: burst 10000 events, measure send+recv rate ──
+
+    async def bench_throughput(self):
+        N = 10000
+        pub, sub = await self._make_pair("tp_pub", "tp_sub", "tp.*")
+        recvd = 0
+        stop = asyncio.Event()
+
+        async def _recv():
+            nonlocal recvd
+            while not stop.is_set():
+                try:
+                    raw = await asyncio.wait_for(sub.ws.recv(), timeout=0.5)
+                    if '"event"' in raw and '"ack"' not in raw:
+                        recvd += 1
+                except Exception:
+                    pass
+
+        async def _drain_acks():
+            """Drain ACKs on publisher side to prevent server-side backpressure."""
+            while not stop.is_set():
+                try:
+                    await asyncio.wait_for(pub.ws.recv(), timeout=0.5)
+                except Exception:
+                    pass
+
+        recv_task = asyncio.create_task(_recv())
+        ack_task = asyncio.create_task(_drain_acks())
+        q_before = self.hub._cnt_queued
+        r_before = self.hub._cnt_routed
+
+        t0 = time.time()
+        for i in range(N):
+            await pub.pub("tp.test", {"i": i})
+        send_time = time.time() - t0
+
+        # Wait until hub finishes routing
+        deadline = time.time() + max(15, N / 300)
+        while recvd < N and time.time() < deadline:
+            await asyncio.sleep(0.1)
+        recv_time = time.time() - t0
+        stop.set()
+        await recv_task
+        ack_task.cancel()
+
+        hub_queued = self.hub._cnt_queued - q_before
+        hub_routed = self.hub._cnt_routed - r_before
+
+        await pub.drain()
+        await pub.close()
+        await sub.close()
+
+        self.results["throughput"] = {
+            "events": N,
+            "send_rate": round(N / send_time),
+            "client_recv": recvd,
+            "hub_queued": hub_queued,
+            "hub_routed": hub_routed,
+            "send_time": round(send_time, 2),
+            "recv_time": round(recv_time, 2),
+        }
+
+    # ── 2. Latency: 200 sequential events, measure per-event RTT ──
+
+    async def bench_latency(self):
+        N = 200
+        pub, sub = await self._make_pair("lat_pub", "lat_sub", "lat.*")
+        latencies = []
+
+        for i in range(N):
+            t0 = time.time()
+            await pub.pub("lat.test", {"i": i})
+            # Wait for ack on pub side
+            await pub.recv(timeout=2)
+            # Wait for event on sub side
+            msg = await sub.recv(timeout=2)
+            if msg and msg.get("type") == "event":
+                latencies.append((time.time() - t0) * 1000)
+
+        await pub.close()
+        await sub.close()
+
+        if latencies:
+            latencies.sort()
+            self.results["latency"] = {
+                "samples": len(latencies),
+                "avg_ms": round(statistics.mean(latencies), 2),
+                "p50_ms": round(latencies[len(latencies) // 2], 2),
+                "p95_ms": round(latencies[int(len(latencies) * 0.95)], 2),
+                "p99_ms": round(latencies[int(len(latencies) * 0.99)], 2),
+            }
+
+    # ── 3. Fan-out: 1 pub, N subs, 2000 events ──
+
+    async def bench_fanout(self):
+        N_EVENTS = 2000
+        for n_subs in [1, 10, 50]:
+            pub = Client(self.ws_url, "fo_pub")
+            await pub.connect()
+
+            subs = []
+            for i in range(n_subs):
+                s = Client(self.ws_url, f"fo_sub_{i}")
+                await s.connect()
+                await s.sub(["fo.*"])
+                subs.append(s)
+            await asyncio.sleep(0.2)
+
+            counts = [0] * n_subs
+            stop = asyncio.Event()
+
+            async def _recv(idx, client):
+                while not stop.is_set():
+                    msg = await client.recv(timeout=0.3)
+                    if msg and msg.get("type") == "event":
+                        counts[idx] += 1
+
+            tasks = [asyncio.create_task(_recv(i, s)) for i, s in enumerate(subs)]
+
+            t0 = time.time()
+            for i in range(N_EVENTS):
+                await pub.pub("fo.test", {"i": i})
+            send_time = time.time() - t0
+
+            await asyncio.sleep(max(3, N_EVENTS * n_subs / 3000))
+            stop.set()
+            for t in tasks:
+                await t
+
+            await pub.drain()
+            for s in subs:
+                await s.drain()
+                await s.close()
+            await pub.close()
+
+            avg_recv = sum(counts) / n_subs
+            self.results[f"fanout_{n_subs}"] = {
+                "subs": n_subs,
+                "events": N_EVENTS,
+                "send_rate": round(N_EVENTS / send_time),
+                "avg_recv": round(avg_recv),
+                "min_recv": min(counts),
+            }
+
+    # ── Summary ──
+
+    def _print_summary(self):
+        print("\n" + "=" * 60)
+        print("PERFORMANCE SUMMARY")
+        print("=" * 60)
+
+        tp = self.results.get("throughput", {})
+        print(f"\n  [Throughput] {tp.get('events',0)} events")
+        print(f"    send_rate:    {tp.get('send_rate',0)} evt/s")
+        print(f"    hub_queued:   {tp.get('hub_queued',0)}  hub_routed: {tp.get('hub_routed',0)}")
+        print(f"    client_recv:  {tp.get('client_recv',0)}")
+        print(f"    send: {tp.get('send_time',0)}s  recv: {tp.get('recv_time',0)}s")
+
+        lat = self.results.get("latency", {})
+        print(f"\n  [Latency] {lat.get('samples',0)} samples")
+        print(f"    avg: {lat.get('avg_ms',0)}ms  p50: {lat.get('p50_ms',0)}ms  "
+              f"p95: {lat.get('p95_ms',0)}ms  p99: {lat.get('p99_ms',0)}ms")
+
+        for n in [1, 10, 50]:
+            fo = self.results.get(f"fanout_{n}", {})
+            if fo:
+                print(f"\n  [Fan-out x{n}] {fo.get('events',0)} events")
+                print(f"    send_rate: {fo.get('send_rate',0)} evt/s  "
+                      f"avg_recv: {fo.get('avg_recv',0)}  min_recv: {fo.get('min_recv',0)}")
+
+        hub = self.hub._counters_dict()
+        print(f"\n  [Hub counters]")
+        print(f"    received: {hub['events_received']}  queued: {hub['events_queued']}  "
+              f"routed: {hub['events_routed']}  dedup: {hub['events_deduplicated']}")
+        print("=" * 60)
+
+    # ── Save ──
+
+    def _save_results(self):
+        results_dir = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "bench_results"
+        )
+        os.makedirs(results_dir, exist_ok=True)
+
+        now = datetime.now()
+        filename = now.strftime("%Y-%m-%d_%H-%M-%S") + ".json"
+        filepath = os.path.join(results_dir, filename)
+
+        data = {
+            "timestamp": now.isoformat(),
+            "env": {
+                "platform": sys.platform,
+                "python": platform.python_version(),
+            },
+            **self.results,
+            "hub_counters": self.hub._counters_dict(),
+        }
+
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        print(f"\n  Results saved: {filepath}")
+
+    # ── Entry ──
+
+    async def run(self):
+        self._start_server()
+        print(f"Event Hub perf bench on port {self.port}")
+        try:
+            print("\n  Running throughput test...")
+            await self.bench_throughput()
+            print("  Running latency test...")
+            await self.bench_latency()
+            print("  Running fan-out test...")
+            await self.bench_fanout()
+            self._print_summary()
+            self._save_results()
+        finally:
+            if self._server:
+                self._server.should_exit = True
+
+
+if __name__ == "__main__":
+    asyncio.run(PerfBench().run())

package/core/event_hub/bench_results/2026-02-28_13-26-48.json

@@ -0,0 +1,51 @@
+{
+  "timestamp": "2026-02-28T13:26:48.644977",
+  "env": {
+    "platform": "win32",
+    "python": "3.13.12"
+  },
+  "throughput": {
+    "events": 10000,
+    "send_rate": 13121,
+    "client_recv": 10000,
+    "hub_queued": 10000,
+    "hub_routed": 10000,
+    "send_time": 0.76,
+    "recv_time": 1.59
+  },
+  "latency": {
+    "samples": 200,
+    "avg_ms": 0.69,
+    "p50_ms": 0.65,
+    "p95_ms": 0.92,
+    "p99_ms": 1.27
+  },
+  "fanout_1": {
+    "subs": 1,
+    "events": 2000,
+    "send_rate": 17292,
+    "avg_recv": 2000,
+    "min_recv": 2000
+  },
+  "fanout_10": {
+    "subs": 10,
+    "events": 2000,
+    "send_rate": 18074,
+    "avg_recv": 2000,
+    "min_recv": 2000
+  },
+  "fanout_50": {
+    "subs": 50,
+    "events": 2000,
+    "send_rate": 6138,
+    "avg_recv": 2000,
+    "min_recv": 2000
+  },
+  "hub_counters": {
+    "events_received": 16200,
+    "events_routed": 132200,
+    "events_queued": 132200,
+    "events_deduplicated": 0,
+    "errors": 0
+  }
+}