@agentunion/kite 1.0.7 → 1.3.0

package/extensions/event_hub_bench/entry.py

@@ -1,379 +1,624 @@
-"""
-Event Hub Benchmark module entry point.
-Discovers hub via Registry, runs benchmarks, saves results, exits.
-"""
-
-import asyncio
-import json
-import os
-import platform
-import sys
-import time
-from datetime import datetime, timezone
-
-import statistics
-import uuid
-
-import httpx
-import websockets
-
-_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-if _project_root not in sys.path:
-    sys.path.insert(0, _project_root)
-
-# Results go to KITE_MODULE_DATA (set by Launcher per module)
-# Fallback to source tree for standalone runs
-RESULTS_DIR = os.environ.get("KITE_MODULE_DATA") or os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "core", "event_hub", "bench_results",
-)
-TAG = "[event_hub_bench]"
-
-
-def _discover_hub(registry_url: str, token: str, timeout: float = 30) -> str | None:
-    """Poll registry until event_hub is found. Returns ws:// URL or None."""
-    headers = {"Authorization": f"Bearer {token}"}
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        try:
-            resp = httpx.get(
-                f"{registry_url}/get/event_hub",
-                headers=headers, timeout=5,
-            )
-            if resp.status_code == 200:
-                info = resp.json()
-                ws_url = (info.get("metadata") or {}).get("ws_endpoint")
-                if ws_url:
-                    return ws_url
-        except Exception:
-            pass
-        time.sleep(1)
-    return None
-
-
-def _get_hub_stats(ws_url: str) -> dict:
-    """Fetch hub /stats via HTTP (derive from ws:// URL)."""
-    http_url = ws_url.replace("ws://", "http://").rsplit("/ws", 1)[0]
-    try:
-        resp = httpx.get(f"{http_url}/stats", timeout=5)
-        if resp.status_code == 200:
-            return resp.json()
-    except Exception:
-        pass
-    return {}
-
-
-def _sample_hub_resources(ws_url: str) -> dict:
-    """Sample hub process CPU/memory via psutil. Returns {} if unavailable."""
-    try:
-        import psutil
-    except ImportError:
-        return {"error": "psutil not installed"}
-    http_url = ws_url.replace("ws://", "http://").rsplit("/ws", 1)[0]
-    port = int(http_url.rsplit(":", 1)[1].split("/")[0])
-    for conn in psutil.net_connections(kind="tcp"):
-        if conn.laddr.port == port and conn.status == "LISTEN":
-            try:
-                p = psutil.Process(conn.pid)
-                mem = p.memory_info()
-                return {
-                    "pid": conn.pid,
-                    "cpu_percent": p.cpu_percent(interval=1),
-                    "rss_mb": round(mem.rss / 1048576, 1),
-                    "vms_mb": round(mem.vms / 1048576, 1),
-                    "threads": p.num_threads(),
-                }
-            except Exception:
-                pass
-    return {"error": "hub process not found"}
-
-
-# ── WebSocket client ──
-
-class WsClient:
-    """Lightweight async WebSocket client for hub benchmarks."""
-
-    def __init__(self, ws_url: str, token: str, client_id: str):
-        self.url = f"{ws_url}?token={token}&id={client_id}"
-        self.id = client_id
-        self.ws = None
-
-    async def connect(self):
-        self.ws = await websockets.connect(self.url, max_size=None)
-
-    async def subscribe(self, patterns: list[str]):
-        await self.ws.send(json.dumps({"type": "subscribe", "events": patterns}))
-
-    async def publish(self, event_type: str, data: dict) -> str:
-        eid = str(uuid.uuid4())
-        await self.ws.send(json.dumps({
-            "type": "event", "event_id": eid, "event": event_type,
-            "source": self.id,
-            "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 close(self):
-        if self.ws:
-            await self.ws.close()
-
-
-# ── Benchmark runner ──
-
-class BenchRunner:
-    def __init__(self, ws_url: str, token: str):
-        self.ws_url = ws_url
-        self.token = token
-        self.results = {}
-
-    async def _make_client(self, name: str) -> WsClient:
-        c = WsClient(self.ws_url, self.token, name)
-        await c.connect()
-        return c
-
-    # ── Throughput: burst N events, measure hub processing rate ──
-
-    async def bench_throughput(self, n: int = 10000):
-        print(f"{TAG} Throughput test: {n} events...")
-        pub = await self._make_client("bench_tp_pub")
-        sub = await self._make_client("bench_tp_sub")
-        await sub.subscribe(["bench.tp.*"])
-        await asyncio.sleep(0.2)
-
-        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():
-            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())
-
-        hub_before = (_get_hub_stats(self.ws_url).get("counters") or {})
-
-        t0 = time.time()
-        for i in range(n):
-            await pub.publish("bench.tp.test", {"i": i})
-        send_time = time.time() - t0
-
-        deadline = time.time() + max(15, n / 300)
-        while recvd < n and time.time() < deadline:
-            await asyncio.sleep(0.1)
-        total_time = time.time() - t0
-
-        stop.set()
-        await recv_task
-        ack_task.cancel()
-
-        hub_after = (_get_hub_stats(self.ws_url).get("counters") or {})
-
-        await pub.close()
-        await sub.close()
-
-        self.results["throughput"] = {
-            "events": n,
-            "send_rate": round(n / send_time),
-            "recv_rate": round(recvd / total_time) if total_time > 0 else 0,
-            "client_recv": recvd,
-            "hub_queued": hub_after.get("events_queued", 0) - hub_before.get("events_queued", 0),
-            "hub_routed": hub_after.get("events_routed", 0) - hub_before.get("events_routed", 0),
-            "send_time_s": round(send_time, 2),
-            "total_time_s": round(total_time, 2),
-        }
-        print(f"{TAG}   send_rate={self.results['throughput']['send_rate']} evt/s, "
-              f"recv={recvd}/{n}, time={round(total_time, 1)}s")
-
-    # ── Latency: sequential pub→recv round-trip ──
-
-    async def bench_latency(self, n: int = 200):
-        print(f"{TAG} Latency test: {n} samples...")
-        pub = await self._make_client("bench_lat_pub")
-        sub = await self._make_client("bench_lat_sub")
-        await sub.subscribe(["bench.lat.*"])
-        await asyncio.sleep(0.2)
-
-        latencies = []
-        for i in range(n):
-            t0 = time.time()
-            await pub.publish("bench.lat.test", {"i": i})
-            await pub.recv(timeout=2)  # ack
-            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),
-            }
-            print(f"{TAG}   avg={self.results['latency']['avg_ms']}ms, "
-                  f"p50={self.results['latency']['p50_ms']}ms, "
-                  f"p99={self.results['latency']['p99_ms']}ms")
-
-    # ── Fan-out: 1 pub, N subs ──
-
-    async def bench_fanout(self, n_events: int = 2000):
-        for n_subs in [1, 5, 10, 50]:
-            print(f"{TAG} Fan-out x{n_subs}: {n_events} events...")
-            pub = await self._make_client("bench_fo_pub")
-            subs = []
-            for i in range(n_subs):
-                s = await self._make_client(f"bench_fo_sub_{i}")
-                await s.subscribe(["bench.fo.*"])
-                subs.append(s)
-            await asyncio.sleep(0.3)
-
-            counts = [0] * n_subs
-            stop = asyncio.Event()
-
-            async def _recv(idx, client):
-                while not stop.is_set():
-                    try:
-                        raw = await asyncio.wait_for(client.ws.recv(), timeout=0.5)
-                        if '"event"' in raw and '"ack"' not in raw:
-                            counts[idx] += 1
-                    except Exception:
-                        pass
-
-            tasks = [asyncio.create_task(_recv(i, s)) for i, s in enumerate(subs)]
-            ack_stop = asyncio.Event()
-
-            async def _drain():
-                while not ack_stop.is_set():
-                    try:
-                        await asyncio.wait_for(pub.ws.recv(), timeout=0.5)
-                    except Exception:
-                        pass
-
-            ack_task = asyncio.create_task(_drain())
-
-            t0 = time.time()
-            for i in range(n_events):
-                await pub.publish("bench.fo.test", {"i": i})
-            send_time = time.time() - t0
-
-            await asyncio.sleep(max(3, n_events * n_subs / 3000))
-            stop.set()
-            ack_stop.set()
-            for t in tasks:
-                await t
-            ack_task.cancel()
-
-            await pub.close()
-            for s in subs:
-                await s.close()
-
-            avg_recv = sum(counts) / n_subs if n_subs else 0
-            self.results[f"fanout_{n_subs}"] = {
-                "subs": n_subs,
-                "events": n_events,
-                "send_rate": round(n_events / send_time) if send_time > 0 else 0,
-                "avg_recv": round(avg_recv),
-                "min_recv": min(counts),
-            }
-            print(f"{TAG}   subs={n_subs}, avg_recv={round(avg_recv)}/{n_events}, "
-                  f"min={min(counts)}")
-
-    # ── Save results ──
-
-    def save(self, ws_url: str):
-        os.makedirs(RESULTS_DIR, exist_ok=True)
-        now = datetime.now()
-        filepath = os.path.join(RESULTS_DIR, now.strftime("%Y-%m-%d_%H-%M-%S") + ".json")
-
-        hub_stats = _get_hub_stats(ws_url)
-        resources = _sample_hub_resources(ws_url)
-
-        data = {
-            "timestamp": now.isoformat(),
-            "env": {
-                "platform": sys.platform,
-                "python": platform.python_version(),
-            },
-            "hub_resources": resources,
-            "hub_counters": hub_stats.get("counters", {}),
-            **self.results,
-        }
-        with open(filepath, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=2, ensure_ascii=False)
-        print(f"{TAG} Results saved: {filepath}")
-
-
-# ── Entry point ──
-
-async def _run(ws_url: str, token: str):
-    bench = BenchRunner(ws_url, token)
-    await bench.bench_throughput()
-    await bench.bench_latency()
-    await bench.bench_fanout()
-    bench.save(ws_url)
-
-
-def main():
-    # Read boot_info from stdin (only token)
-    token = ""
-    try:
-        line = sys.stdin.readline().strip()
-        if line:
-            boot = json.loads(line)
-            token = boot.get("token", "")
-    except Exception:
-        pass
-
-    # Read registry_port from environment variable
-    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
-
-    if not token or not registry_port:
-        print(f"{TAG} ERROR: Missing token or KITE_REGISTRY_PORT")
-        sys.exit(1)
-
-    if os.environ.get("KITE_DEBUG") != "1":
-        print(f"{TAG} ERROR: Benchmark requires KITE_DEBUG=1 (multiple clients share one token)")
-        sys.exit(1)
-
-    registry_url = f"http://127.0.0.1:{registry_port}"
-    print(f"{TAG} Discovering event_hub via registry...")
-
-    ws_url = _discover_hub(registry_url, token)
-    if not ws_url:
-        print(f"{TAG} ERROR: event_hub not found")
-        sys.exit(1)
-
-    print(f"{TAG} Hub found: {ws_url}")
-    print(f"{TAG} Starting benchmarks...")
-
-    asyncio.run(_run(ws_url, token))
-
-    print(f"{TAG} Benchmarks complete, exiting.")
-
-
-if __name__ == "__main__":
-    main()
+"""
+Event Hub Benchmark module entry point.
+Connects to Kernel via WebSocket JSON-RPC 2.0, runs benchmarks, saves results, exits.
+"""
+
+import asyncio
+import builtins
+import json
+import os
+import platform
+import re
+import sys
+import threading
+import time
+import traceback
+from datetime import datetime, timezone
+
+import statistics
+import uuid
+
+import httpx
+import websockets
+
+_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+# Results go to KITE_MODULE_DATA (set by Launcher per module)
+# Fallback to source tree for standalone runs
+RESULTS_DIR = os.environ.get("KITE_MODULE_DATA") or os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "core", "event_hub", "bench_results",
+)
+TAG = "[event_hub_bench]"
+
+
+# ── Module configuration ──
+MODULE_NAME = "event_hub_bench"
+
+
+# ── Timestamped print + log file writer ──
+_builtin_print = builtins.print
+_start_ts = time.monotonic()
+_last_ts = time.monotonic()
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_log_lock = threading.Lock()
+_log_latest_path = None
+_log_daily_path = None
+_log_daily_date = ""
+_log_dir = None
+_crash_log_path = None
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+def _resolve_daily_log_path():
+    global _log_daily_path, _log_daily_date
+    if not _log_dir:
+        return
+    today = datetime.now().strftime("%Y-%m-%d")
+    if today == _log_daily_date and _log_daily_path:
+        return
+    month_dir = os.path.join(_log_dir, today[:7])
+    os.makedirs(month_dir, exist_ok=True)
+    _log_daily_path = os.path.join(month_dir, f"{today}.log")
+    _log_daily_date = today
+
+def _write_log(plain_line: str):
+    with _log_lock:
+        if _log_latest_path:
+            try:
+                with open(_log_latest_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+        _resolve_daily_log_path()
+        if _log_daily_path:
+            try:
+                with open(_log_daily_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+
+def _write_crash(exc_type, exc_value, exc_tb, thread_name=None, severity="critical", handled=False):
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "module": MODULE_NAME,
+        "thread": thread_name or threading.current_thread().name,
+        "exception_type": exc_type.__name__ if exc_type else "Unknown",
+        "exception_message": str(exc_value),
+        "traceback": "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
+        "severity": severity,
+        "handled": handled,
+        "process_id": os.getpid(),
+        "platform": sys.platform,
+        "runtime_version": f"Python {sys.version.split()[0]}",
+    }
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            record["context"] = {
+                "function": last.name,
+                "file": os.path.basename(last.filename),
+                "line": last.lineno,
+            }
+
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+
+    if _crash_log_path:
+        try:
+            with open(_crash_log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+    if _log_dir:
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+            archive_dir = os.path.join(_log_dir, "crashes", today[:7])
+            os.makedirs(archive_dir, exist_ok=True)
+            archive_path = os.path.join(archive_dir, f"{today}.jsonl")
+            with open(archive_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+def _print_crash_summary(exc_type, exc_tb, thread_name=None):
+    RED = "\033[91m"
+    RESET = "\033[0m"
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            location = f"{os.path.basename(last.filename)}:{last.lineno}"
+        else:
+            location = "unknown"
+    else:
+        location = "unknown"
+
+    prefix = f"[{MODULE_NAME}]"
+    if thread_name:
+        _builtin_print(f"{prefix} {RED}线程 {thread_name} 崩溃: "
+                       f"{exc_type.__name__} in {location}{RESET}")
+    else:
+        _builtin_print(f"{prefix} {RED}崩溃: {exc_type.__name__} in {location}{RESET}")
+    if _crash_log_path:
+        _builtin_print(f"{prefix} 崩溃日志: {_crash_log_path}")
+
+def _setup_exception_hooks():
+    _orig_excepthook = sys.excepthook
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
+        _print_crash_summary(exc_type, exc_tb)
+        _orig_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+    if hasattr(threading, "excepthook"):
+        def _thread_excepthook(args):
+            _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
+                        thread_name=args.thread.name if args.thread else "unknown",
+                        severity="error", handled=False)
+            _print_crash_summary(args.exc_type, args.exc_traceback,
+                                thread_name=args.thread.name if args.thread else None)
+
+        threading.excepthook = _thread_excepthook
+
+def _tprint(*args, **kwargs):
+    global _last_ts
+    now = time.monotonic()
+    elapsed = now - _start_ts
+    delta = now - _last_ts
+    _last_ts = now
+
+    if elapsed < 1:
+        elapsed_str = f"{elapsed * 1000:.0f}ms"
+    elif elapsed < 100:
+        elapsed_str = f"{elapsed:.1f}s"
+    else:
+        elapsed_str = f"{elapsed:.0f}s"
+
+    if delta < 0.001:
+        delta_str = ""
+    elif delta < 1:
+        delta_str = f"+{delta * 1000:.0f}ms"
+    elif delta < 100:
+        delta_str = f"+{delta:.1f}s"
+    else:
+        delta_str = f"+{delta:.0f}s"
+
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    _builtin_print(*args, **kwargs)
+
+    if _log_latest_path or _log_daily_path:
+        sep = kwargs.get("sep", " ")
+        end = kwargs.get("end", "\n")
+        text = sep.join(str(a) for a in args)
+        prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _write_log(prefix + _strip_ansi(text) + end)
+
+builtins.print = _tprint
+
+# Initialize log files
+module_data = os.environ.get("KITE_MODULE_DATA")
+if module_data:
+    _log_dir = os.path.join(module_data, "log")
+    os.makedirs(_log_dir, exist_ok=True)
+    suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+
+    _log_latest_path = os.path.join(_log_dir, f"latest{suffix}.log")
+    try:
+        with open(_log_latest_path, "w", encoding="utf-8") as f:
+            pass
+    except Exception:
+        _log_latest_path = None
+
+    _crash_log_path = os.path.join(_log_dir, f"crashes{suffix}.jsonl")
+    try:
+        with open(_crash_log_path, "w", encoding="utf-8") as f:
+            pass
+    except Exception:
+        _crash_log_path = None
+
+    _resolve_daily_log_path()
+
+_setup_exception_hooks()
+
+
+def _get_kernel_stats(kernel_port: int) -> dict:
+    """Fetch Kernel /stats via HTTP."""
+    try:
+        resp = httpx.get(f"http://127.0.0.1:{kernel_port}/stats", timeout=5)
+        if resp.status_code == 200:
+            return resp.json()
+    except Exception:
+        pass
+    return {}
+
+
+def _sample_kernel_resources(kernel_port: int) -> dict:
+    """Sample Kernel process CPU/memory via psutil. Returns {} if unavailable."""
+    try:
+        import psutil
+    except ImportError:
+        return {"error": "psutil not installed"}
+    for conn in psutil.net_connections(kind="tcp"):
+        if conn.laddr.port == kernel_port and conn.status == "LISTEN":
+            try:
+                p = psutil.Process(conn.pid)
+                mem = p.memory_info()
+                return {
+                    "pid": conn.pid,
+                    "cpu_percent": p.cpu_percent(interval=1),
+                    "rss_mb": round(mem.rss / 1048576, 1),
+                    "vms_mb": round(mem.vms / 1048576, 1),
+                    "threads": p.num_threads(),
+                }
+            except Exception:
+                pass
+    return {"error": "kernel process not found"}
+
+
+# ── WebSocket client ──
+
+class WsClient:
+    """Lightweight async WebSocket client for Kernel benchmarks (JSON-RPC 2.0)."""
+
+    def __init__(self, ws_url: str, token: str, client_id: str):
+        self.url = f"{ws_url}?token={token}&id={client_id}"
+        self.id = client_id
+        self.ws = None
+
+    async def connect(self):
+        self.ws = await websockets.connect(self.url, max_size=None)
+
+    async def subscribe(self, patterns: list[str]):
+        msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": "event.subscribe", "params": {"events": patterns}}
+        await self.ws.send(json.dumps(msg))
+
+    async def publish(self, event_type: str, data: dict) -> str:
+        eid = str(uuid.uuid4())
+        msg = {
+            "jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": "event.publish",
+            "params": {
+                "event_id": eid, "event": event_type, "data": data,
+            },
+        }
+        await self.ws.send(json.dumps(msg))
+        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 close(self):
+        if self.ws:
+            await self.ws.close()
+
+
+# ── Benchmark runner ──
+
+class BenchRunner:
+    def __init__(self, ws_url: str, token: str, kernel_port: int):
+        self.ws_url = ws_url
+        self.token = token
+        self.kernel_port = kernel_port
+        self.results = {}
+
+    async def _make_client(self, name: str) -> WsClient:
+        c = WsClient(self.ws_url, self.token, name)
+        await c.connect()
+        return c
+
+    # ── Throughput: burst N events, measure hub processing rate ──
+
+    async def bench_throughput(self, n: int = 10000):
+        print(f"{TAG} Throughput test: {n} events...")
+        pub = await self._make_client("bench_tp_pub")
+        sub = await self._make_client("bench_tp_sub")
+        await sub.subscribe(["bench.tp.*"])
+        await asyncio.sleep(0.2)
+
+        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)
+                    msg = json.loads(raw)
+                    # JSON-RPC Notification (event): has method, no id
+                    if "method" in msg and "id" not in msg:
+                        recvd += 1
+                except Exception:
+                    pass
+
+        async def _drain_acks():
+            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())
+
+        hub_before = (_get_kernel_stats(self.kernel_port).get("counters") or {})
+
+        t0 = time.time()
+        for i in range(n):
+            await pub.publish("bench.tp.test", {"i": i})
+        send_time = time.time() - t0
+
+        deadline = time.time() + max(15, n / 300)
+        while recvd < n and time.time() < deadline:
+            await asyncio.sleep(0.1)
+        total_time = time.time() - t0
+
+        stop.set()
+        await recv_task
+        ack_task.cancel()
+
+        hub_after = (_get_kernel_stats(self.kernel_port).get("counters") or {})
+
+        await pub.close()
+        await sub.close()
+
+        self.results["throughput"] = {
+            "events": n,
+            "send_rate": round(n / send_time),
+            "recv_rate": round(recvd / total_time) if total_time > 0 else 0,
+            "client_recv": recvd,
+            "hub_queued": hub_after.get("events_queued", 0) - hub_before.get("events_queued", 0),
+            "hub_routed": hub_after.get("events_routed", 0) - hub_before.get("events_routed", 0),
+            "send_time_s": round(send_time, 2),
+            "total_time_s": round(total_time, 2),
+        }
+        print(f"{TAG}   send_rate={self.results['throughput']['send_rate']} evt/s, "
+              f"recv={recvd}/{n}, time={round(total_time, 1)}s")
+
+    # ── Latency: sequential pub→recv round-trip ──
+
+    async def bench_latency(self, n: int = 200):
+        print(f"{TAG} Latency test: {n} samples...")
+        pub = await self._make_client("bench_lat_pub")
+        sub = await self._make_client("bench_lat_sub")
+        await sub.subscribe(["bench.lat.*"])
+        await asyncio.sleep(0.2)
+
+        latencies = []
+        for i in range(n):
+            t0 = time.time()
+            await pub.publish("bench.lat.test", {"i": i})
+            await pub.recv(timeout=2)  # RPC response
+            msg = await sub.recv(timeout=2)
+            if msg and "method" in msg and "id" not in msg:
+                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),
+            }
+            print(f"{TAG}   avg={self.results['latency']['avg_ms']}ms, "
+                  f"p50={self.results['latency']['p50_ms']}ms, "
+                  f"p99={self.results['latency']['p99_ms']}ms")
+
+    # ── Fan-out: 1 pub, N subs ──
+
+    async def bench_fanout(self, n_events: int = 2000):
+        for n_subs in [1, 5, 10, 50]:
+            print(f"{TAG} Fan-out x{n_subs}: {n_events} events...")
+            pub = await self._make_client("bench_fo_pub")
+            subs = []
+            for i in range(n_subs):
+                s = await self._make_client(f"bench_fo_sub_{i}")
+                await s.subscribe(["bench.fo.*"])
+                subs.append(s)
+            await asyncio.sleep(0.3)
+
+            counts = [0] * n_subs
+            stop = asyncio.Event()
+
+            async def _recv(idx, client):
+                while not stop.is_set():
+                    try:
+                        raw = await asyncio.wait_for(client.ws.recv(), timeout=0.5)
+                        msg = json.loads(raw)
+                        if "method" in msg and "id" not in msg:
+                            counts[idx] += 1
+                    except Exception:
+                        pass
+
+            tasks = [asyncio.create_task(_recv(i, s)) for i, s in enumerate(subs)]
+            ack_stop = asyncio.Event()
+
+            async def _drain():
+                while not ack_stop.is_set():
+                    try:
+                        await asyncio.wait_for(pub.ws.recv(), timeout=0.5)
+                    except Exception:
+                        pass
+
+            ack_task = asyncio.create_task(_drain())
+
+            t0 = time.time()
+            for i in range(n_events):
+                await pub.publish("bench.fo.test", {"i": i})
+            send_time = time.time() - t0
+
+            await asyncio.sleep(max(3, n_events * n_subs / 3000))
+            stop.set()
+            ack_stop.set()
+            for t in tasks:
+                await t
+            ack_task.cancel()
+
+            await pub.close()
+            for s in subs:
+                await s.close()
+
+            avg_recv = sum(counts) / n_subs if n_subs else 0
+            self.results[f"fanout_{n_subs}"] = {
+                "subs": n_subs,
+                "events": n_events,
+                "send_rate": round(n_events / send_time) if send_time > 0 else 0,
+                "avg_recv": round(avg_recv),
+                "min_recv": min(counts),
+            }
+            print(f"{TAG}   subs={n_subs}, avg_recv={round(avg_recv)}/{n_events}, "
+                  f"min={min(counts)}")
+
+    # ── Save results ──
+
+    def save(self):
+        os.makedirs(RESULTS_DIR, exist_ok=True)
+        now = datetime.now()
+        filepath = os.path.join(RESULTS_DIR, now.strftime("%Y-%m-%d_%H-%M-%S") + ".json")
+
+        kernel_stats = _get_kernel_stats(self.kernel_port)
+        resources = _sample_kernel_resources(self.kernel_port)
+
+        data = {
+            "timestamp": now.isoformat(),
+            "env": {
+                "platform": sys.platform,
+                "python": platform.python_version(),
+            },
+            "hub_resources": resources,
+            "hub_counters": kernel_stats.get("counters", {}),
+            **self.results,
+        }
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        print(f"{TAG} Results saved: {filepath}")
+
+
+def _send_ready_event(ws_url: str, token: str):
+    """Send module.ready to Kernel via JSON-RPC 2.0. Startup phase complete."""
+    try:
+        import websockets.sync.client as ws_sync
+        url = f"{ws_url}?token={token}&id=event_hub_bench"
+        with ws_sync.connect(url, close_timeout=3) as ws:
+            # Subscribe (先订阅)
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.subscribe", "params": {"events": []},
+            }))
+            # Register (再注册)
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "registry.register",
+                "params": {
+                    "module_id": "event_hub_bench",
+                    "module_type": "tool",
+                    "name": "Event Hub Benchmark",
+                },
+            }))
+            # Publish ready
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.publish",
+                "params": {
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.ready",
+                    "data": {"module_id": "event_hub_bench"},
+                },
+            }))
+            time.sleep(0.1)
+    except Exception as e:
+        print(f"{TAG} WARNING: Could not send module.ready: {e}")
+
+
+def _send_exiting_event(ws_url: str, token: str, reason: str):
+    """Send module.exiting event to Kernel via JSON-RPC 2.0 before exit."""
+    try:
+        import websockets.sync.client as ws_sync
+        url = f"{ws_url}?token={token}&id=event_hub_bench"
+        with ws_sync.connect(url, close_timeout=3) as ws:
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": str(uuid.uuid4()),
+                "method": "event.publish",
+                "params": {
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.exiting",
+                    "data": {
+                        "module_id": "event_hub_bench",
+                        "reason": reason,
+                        "action": "none",
+                    },
+                },
+            }))
+            time.sleep(0.3)
+    except Exception as e:
+        print(f"{TAG} WARNING: Could not send module.exiting: {e}")
+
+
+# ── Entry point ──
+
+async def _run(ws_url: str, token: str, kernel_port: int):
+    bench = BenchRunner(ws_url, token, kernel_port)
+    await bench.bench_throughput()
+    await bench.bench_latency()
+    await bench.bench_fanout()
+    bench.save()
+
+
+def main():
+    # Read boot_info from stdin (only token)
+    token = ""
+    try:
+        line = sys.stdin.readline().strip()
+        if line:
+            boot = json.loads(line)
+            token = boot.get("token", "")
+    except Exception:
+        pass
+
+    # Read registry_port from environment variable
+    kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
+
+    if not token or not kernel_port:
+        print(f"{TAG} ERROR: Missing token or KITE_KERNEL_PORT")
+        sys.exit(1)
+
+    ws_url = f"ws://127.0.0.1:{kernel_port}/ws"
+    print(f"{TAG} Kernel at port {kernel_port}")
+
+    # Debug mode required: multiple benchmark clients share one token
+    if os.environ.get("KITE_DEBUG") != "1":
+        print(f"{TAG} 需要调试模式才能运行 (启动时加 --debug)")
+        _send_exiting_event(ws_url, token, "requires KITE_DEBUG=1")
+        sys.exit(0)
+
+    # ── Startup complete — notify Launcher ──
+    _send_ready_event(ws_url, token)
+
+    # ── Business logic: run benchmarks ──
+    print(f"{TAG} Starting benchmarks...")
+
+    asyncio.run(_run(ws_url, token, kernel_port))
+
+    print(f"{TAG} Benchmarks complete, sending exit intent...")
+    _send_exiting_event(ws_url, token, "benchmarks complete")
+    print(f"{TAG} Exiting.")
+
+
+if __name__ == "__main__":
+    main()