xithead 1.5.1 → 1.5.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin/xithead.js +486 -226
- package/index.d.ts +57 -0
- package/index.js +139 -0
- package/package.json +44 -63
- package/postinstall.js +43 -0
- package/LICENSE +0 -190
- package/README.md +0 -108
- package/app/api/config/route.ts +0 -22
- package/app/api/export/route.ts +0 -83
- package/app/api/models/route.ts +0 -12
- package/app/api/stats/route.ts +0 -46
- package/app/dashboard/page.tsx +0 -445
- package/app/globals.css +0 -35
- package/app/installation/page.tsx +0 -293
- package/app/layout.tsx +0 -35
- package/app/master-design-system.css +0 -2076
- package/app/master-design-system.source.css +0 -8
- package/app/page.tsx +0 -187
- package/app/rechtliches/agb/page.tsx +0 -165
- package/app/rechtliches/datenschutz/page.tsx +0 -128
- package/app/rechtliches/impressum/page.tsx +0 -122
- package/app/rechtliches/widerruf/page.tsx +0 -185
- package/components/layout/AppShell.tsx +0 -25
- package/components/layout/Footer.tsx +0 -120
- package/components/layout/Header.tsx +0 -145
- package/components/marketing/LegalHighlights.tsx +0 -45
- package/components/marketing/LegalPageShell.tsx +0 -49
- package/components/marketing/LegalPanel.tsx +0 -41
- package/components/marketing/index.ts +0 -3
- package/design-system/README.md +0 -80
- package/design-system/base.css +0 -127
- package/design-system/components.css +0 -1943
- package/design-system/fonts.css +0 -17
- package/design-system/tailwind-preset.js +0 -95
- package/design-system/tokens.css +0 -48
- package/design-system/utilities.css +0 -53
- package/lib/config/index.ts +0 -12
- package/lib/hooks/index.ts +0 -4
- package/lib/hooks/use-mounted.ts +0 -13
- package/lib/hooks/use-session.ts +0 -34
- package/lib/hooks/use-settings.ts +0 -49
- package/lib/utils/index.ts +0 -1
- package/lib/utils/settings.ts +0 -162
- package/lib/utils/utils.ts +0 -6
- package/middleware.ts +0 -26
- package/next-env.d.ts +0 -7
- package/next.config.ts +0 -12
- package/postcss.config.mjs +0 -7
- package/public/apple-touch-icon.png +0 -0
- package/public/logo-transparent.png +0 -0
- package/public/xithead.ps1 +0 -937
- package/scripts/README.md +0 -77
- package/scripts/audit_wheel_glibc_symbols.py +0 -217
- package/scripts/build-master-design-system.cjs +0 -33
- package/scripts/build_rust_extension.sh +0 -58
- package/scripts/changelog-gen.py +0 -203
- package/scripts/eval_output_shaper.py +0 -235
- package/scripts/export_kompress_v2_onnx.py +0 -267
- package/scripts/fixtures/anthropic_replay_body.json +0 -133
- package/scripts/fixtures/codex_response_create_frame.json +0 -52
- package/scripts/install-git-hooks.sh +0 -104
- package/scripts/install.ps1 +0 -1809
- package/scripts/install.sh +0 -1673
- package/scripts/pr-governance.py +0 -297
- package/scripts/record_fixtures.py +0 -59
- package/scripts/refresh_model_limits.sh +0 -48
- package/scripts/replay_codex_ws_load.py +0 -445
- package/scripts/repro_codex_replay.py +0 -699
- package/scripts/smoke_issue_327.py +0 -233
- package/scripts/sync-plugin-versions.py +0 -116
- package/scripts/tests/test_changelog_gen.py +0 -302
- package/scripts/tests/test_pr_governance.py +0 -163
- package/scripts/tests/test_pr_health_labels.py +0 -94
- package/scripts/tests/test_pr_health_workflow.py +0 -14
- package/scripts/tests/test_sync_plugin_versions.py +0 -131
- package/scripts/tests/test_version_sync.py +0 -291
- package/scripts/validate-workflows.sh +0 -39
- package/scripts/verify-versions.py +0 -106
- package/scripts/version-sync.py +0 -207
- package/tailwind.config.js +0 -31
- package/tailwind.master.config.cjs +0 -47
- package/tsconfig.json +0 -84
- package/types/api.ts +0 -12
- package/types/config.ts +0 -9
- package/types/index.ts +0 -2
|
@@ -1,445 +0,0 @@
|
|
|
1
|
-
#!/usr/bin/env python3
|
|
2
|
-
"""Tier-3 replay: reproduce Codex /v1/responses compression load.
|
|
3
|
-
|
|
4
|
-
Parses a production proxy log to extract per-session frame-size scenarios,
|
|
5
|
-
generates synthetic payloads matching those sizes/shapes, and concurrently
|
|
6
|
-
drives the proxy's _compress_openai_responses_payload entry point. Reports
|
|
7
|
-
per-frame latency percentiles, timeout count, and total wall time so a
|
|
8
|
-
before/after comparison proves the P2 scheduler fix.
|
|
9
|
-
|
|
10
|
-
Why this lives in scripts/ (not tests/):
|
|
11
|
-
- It is a measurement tool, not a correctness test.
|
|
12
|
-
- It needs to run against multiple branches (main baseline vs fix
|
|
13
|
-
branch) and report comparable numbers.
|
|
14
|
-
- It exercises the *real* compression dispatch by booting a proxy
|
|
15
|
-
instance via create_app() and calling the handler method directly —
|
|
16
|
-
no HTTP/WS layer, because the bug is in the dispatch, not the wire.
|
|
17
|
-
|
|
18
|
-
Usage:
|
|
19
|
-
.venv/bin/python scripts/replay_codex_ws_load.py \\
|
|
20
|
-
--log "/Users/tchopra/Downloads/proxy (1).log" \\
|
|
21
|
-
--concurrency 10 \\
|
|
22
|
-
--frames-per-session 20
|
|
23
|
-
"""
|
|
24
|
-
|
|
25
|
-
from __future__ import annotations
|
|
26
|
-
|
|
27
|
-
import argparse
|
|
28
|
-
import concurrent.futures
|
|
29
|
-
import json
|
|
30
|
-
import os
|
|
31
|
-
import statistics
|
|
32
|
-
import sys
|
|
33
|
-
import time
|
|
34
|
-
from dataclasses import dataclass, field
|
|
35
|
-
from pathlib import Path
|
|
36
|
-
|
|
37
|
-
REPO_ROOT = Path(__file__).resolve().parent.parent
|
|
38
|
-
sys.path.insert(0, str(REPO_ROOT))
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
# Telemetry off so we don't pollute the user's metrics during replay.
|
|
42
|
-
os.environ.setdefault("HEADROOM_DISABLE_TELEMETRY", "true")
|
|
43
|
-
os.environ.setdefault("HEADROOM_REQUIRE_RUST_CORE", "false")
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
@dataclass
|
|
47
|
-
class Frame:
|
|
48
|
-
bytes_estimate: int
|
|
49
|
-
text_shape: str # plain_text_like | code_fence | traceback | jsonl_like
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
@dataclass
|
|
53
|
-
class Scenario:
|
|
54
|
-
request_id: str
|
|
55
|
-
frames: list[Frame] = field(default_factory=list)
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
# ── Log parser ─────────────────────────────────────────────────────────
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
# Marker columns. We are not using regex here per the design constraints —
|
|
62
|
-
# the log shape is a single deterministic format set by code we own. If
|
|
63
|
-
# the format changes the parser fails loud, not silently.
|
|
64
|
-
_FRAME_TOKEN = " WS /v1/responses "
|
|
65
|
-
_REQID_OPEN = "["
|
|
66
|
-
_REQID_CLOSE = "]"
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
def _parse_kv(text: str) -> dict[str, str]:
|
|
70
|
-
"""Parse ``key=value`` pairs out of a slow-unit log tail. Stops at the
|
|
71
|
-
first unquoted space after a value. Quoted values not supported because
|
|
72
|
-
the log never emits them; if it ever does, this raises.
|
|
73
|
-
"""
|
|
74
|
-
out: dict[str, str] = {}
|
|
75
|
-
for token in text.split():
|
|
76
|
-
if "=" not in token:
|
|
77
|
-
continue
|
|
78
|
-
k, _, v = token.partition("=")
|
|
79
|
-
out[k] = v
|
|
80
|
-
return out
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
def parse_log(log_path: Path) -> dict[str, Scenario]:
|
|
84
|
-
"""Group ``WS /v1/responses slow compression unit`` entries by request_id.
|
|
85
|
-
|
|
86
|
-
Each ``slow compression unit`` line carries the per-unit byte count and
|
|
87
|
-
text_shape — exactly what we need to reconstruct a payload of similar
|
|
88
|
-
compression cost. We deliberately ignore the ``compressed`` / ``frame
|
|
89
|
-
compressed`` lines because they report POST-compression bytes, not the
|
|
90
|
-
pre-compression input the dispatcher sees.
|
|
91
|
-
|
|
92
|
-
Format:
|
|
93
|
-
... [hr_..._...] WS /v1/responses slow compression unit elapsed_ms=N
|
|
94
|
-
strategy=X category=Y modified=Z content_type=T text_shape=S
|
|
95
|
-
bytes=B min_bytes=N tokens_before=T tokens_after=T tokens_saved=S
|
|
96
|
-
strategy_chain=[...]
|
|
97
|
-
"""
|
|
98
|
-
scenarios: dict[str, Scenario] = {}
|
|
99
|
-
with log_path.open("r", encoding="utf-8", errors="replace") as fh:
|
|
100
|
-
for line in fh:
|
|
101
|
-
if "slow compression unit" not in line:
|
|
102
|
-
continue
|
|
103
|
-
if _FRAME_TOKEN not in line:
|
|
104
|
-
continue
|
|
105
|
-
req_open = line.find(_REQID_OPEN)
|
|
106
|
-
req_close = line.find(_REQID_CLOSE, req_open + 1)
|
|
107
|
-
if req_open < 0 or req_close < 0:
|
|
108
|
-
continue
|
|
109
|
-
request_id = line[req_open + 1 : req_close]
|
|
110
|
-
tail = line[req_close + 1 :]
|
|
111
|
-
kv = _parse_kv(tail)
|
|
112
|
-
try:
|
|
113
|
-
size = int(kv["bytes"])
|
|
114
|
-
except (KeyError, ValueError):
|
|
115
|
-
continue
|
|
116
|
-
shape = kv.get("text_shape", "plain_text_like")
|
|
117
|
-
scen = scenarios.setdefault(request_id, Scenario(request_id=request_id))
|
|
118
|
-
scen.frames.append(Frame(bytes_estimate=size, text_shape=shape))
|
|
119
|
-
return scenarios
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
# ── Payload synthesizer ────────────────────────────────────────────────
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
_LOREM = (
|
|
126
|
-
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
|
|
127
|
-
"Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
|
|
128
|
-
)
|
|
129
|
-
_CODE_LINE = "def compute_metric_{i}(value: int) -> int:\n return value * {i}\n\n"
|
|
130
|
-
_TRACEBACK_LINE = (
|
|
131
|
-
' File "/app/handler.py", line {i}, in process_request\n raise RuntimeError(f"oops {i}")\n'
|
|
132
|
-
)
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
def _text_for_shape(shape: str, target_bytes: int) -> str:
|
|
136
|
-
"""Generate a string roughly ``target_bytes`` long, shaped like the
|
|
137
|
-
production observation. No randomness — same input produces same output
|
|
138
|
-
so the replay is reproducible.
|
|
139
|
-
"""
|
|
140
|
-
if target_bytes < 64:
|
|
141
|
-
# Below size_floor — generator just returns a short token.
|
|
142
|
-
return "ok"
|
|
143
|
-
if shape == "code_fence":
|
|
144
|
-
body_target = max(target_bytes - 12, 0) # "```python\n" + closing
|
|
145
|
-
repeats = max(body_target // 50, 1)
|
|
146
|
-
body = "".join(_CODE_LINE.format(i=i) for i in range(repeats))
|
|
147
|
-
return "```python\n" + body[:body_target] + "\n```"
|
|
148
|
-
if shape == "traceback":
|
|
149
|
-
header = "Traceback (most recent call last):\n"
|
|
150
|
-
body_target = max(target_bytes - len(header), 0)
|
|
151
|
-
repeats = max(body_target // 65, 1)
|
|
152
|
-
body = "".join(_TRACEBACK_LINE.format(i=i) for i in range(repeats))
|
|
153
|
-
return header + body[:body_target]
|
|
154
|
-
# plain_text_like / unknown / jsonl_like → lorem ipsum is fine as a
|
|
155
|
-
# neutral payload; we are measuring scheduler contention, not compressor
|
|
156
|
-
# quality, so the content shape just needs to traverse the same router.
|
|
157
|
-
repeats = max(target_bytes // len(_LOREM), 1)
|
|
158
|
-
raw = _LOREM * repeats
|
|
159
|
-
return raw[:target_bytes]
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
def synthesize_payload(frame: Frame, turn_no: int) -> dict:
|
|
163
|
-
"""Build the *inner* Responses payload (no `response.create` envelope)
|
|
164
|
-
with one function_call_output of the target byte size.
|
|
165
|
-
|
|
166
|
-
``_compress_openai_responses_payload`` is envelope-agnostic but routes
|
|
167
|
-
by inspecting ``input``/``messages`` at the top level. The WS handler
|
|
168
|
-
extracts ``payload["response"]`` and passes that downstream — we pass
|
|
169
|
-
the same shape directly so the router actually sees compressible
|
|
170
|
-
candidates instead of a single opaque ``response`` key.
|
|
171
|
-
"""
|
|
172
|
-
output_text = _text_for_shape(frame.text_shape, frame.bytes_estimate)
|
|
173
|
-
return {
|
|
174
|
-
"model": "gpt-4o-mini",
|
|
175
|
-
"input": [
|
|
176
|
-
{
|
|
177
|
-
"type": "message",
|
|
178
|
-
"role": "user",
|
|
179
|
-
"content": [
|
|
180
|
-
{
|
|
181
|
-
"type": "input_text",
|
|
182
|
-
"text": f"Turn {turn_no} — please summarize.",
|
|
183
|
-
}
|
|
184
|
-
],
|
|
185
|
-
},
|
|
186
|
-
{
|
|
187
|
-
"type": "function_call",
|
|
188
|
-
"call_id": f"call_replay_{turn_no}",
|
|
189
|
-
"name": "shell",
|
|
190
|
-
"arguments": '{"command": "build"}',
|
|
191
|
-
},
|
|
192
|
-
{
|
|
193
|
-
"type": "function_call_output",
|
|
194
|
-
"call_id": f"call_replay_{turn_no}",
|
|
195
|
-
"output": output_text,
|
|
196
|
-
},
|
|
197
|
-
],
|
|
198
|
-
"instructions": "Be brief.",
|
|
199
|
-
"max_output_tokens": 30,
|
|
200
|
-
}
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
# ── Proxy bring-up ─────────────────────────────────────────────────────
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
def boot_proxy():
|
|
207
|
-
"""Build a HeadroomProxy instance with optimize=True so the compression
|
|
208
|
-
dispatch is actually exercised.
|
|
209
|
-
|
|
210
|
-
This deliberately does NOT start the FastAPI server. We only need the
|
|
211
|
-
in-process handler methods. Lifecycle hooks (background tasks, model
|
|
212
|
-
pre-loading) that fire on startup are not required for the dispatch
|
|
213
|
-
method we exercise — Kompress will lazy-load on first use, which we
|
|
214
|
-
explicitly warm up below.
|
|
215
|
-
"""
|
|
216
|
-
from headroom.proxy.server import ProxyConfig, create_app
|
|
217
|
-
|
|
218
|
-
config = ProxyConfig(
|
|
219
|
-
optimize=True,
|
|
220
|
-
cache_enabled=False,
|
|
221
|
-
rate_limit_enabled=False,
|
|
222
|
-
)
|
|
223
|
-
app = create_app(config)
|
|
224
|
-
return app.state.proxy
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
def warmup(proxy, model: str = "gpt-4o-mini") -> float:
|
|
228
|
-
"""Issue one small compression call so model weights are loaded.
|
|
229
|
-
|
|
230
|
-
Returns the warmup wall time so the caller can sanity-check the
|
|
231
|
-
measurements (warmup time is NOT counted toward replay metrics).
|
|
232
|
-
"""
|
|
233
|
-
payload = synthesize_payload(
|
|
234
|
-
Frame(bytes_estimate=4096, text_shape="plain_text_like"), turn_no=0
|
|
235
|
-
)
|
|
236
|
-
started = time.perf_counter()
|
|
237
|
-
proxy._compress_openai_responses_payload(payload, model=model, request_id="replay-warmup")
|
|
238
|
-
return (time.perf_counter() - started) * 1000.0
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
# ── Replay driver ──────────────────────────────────────────────────────
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
@dataclass
|
|
245
|
-
class FrameResult:
|
|
246
|
-
request_id: str
|
|
247
|
-
frame_index: int
|
|
248
|
-
bytes_in: int
|
|
249
|
-
elapsed_ms: float
|
|
250
|
-
error: str | None = None
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
def replay_session(proxy, scenario: Scenario, model: str) -> list[FrameResult]:
|
|
254
|
-
out: list[FrameResult] = []
|
|
255
|
-
for idx, frame in enumerate(scenario.frames):
|
|
256
|
-
payload = synthesize_payload(frame, turn_no=idx + 1)
|
|
257
|
-
started = time.perf_counter()
|
|
258
|
-
err: str | None = None
|
|
259
|
-
try:
|
|
260
|
-
proxy._compress_openai_responses_payload(
|
|
261
|
-
payload, model=model, request_id=scenario.request_id
|
|
262
|
-
)
|
|
263
|
-
except Exception as e: # noqa: BLE001 — surface ALL failure modes
|
|
264
|
-
err = f"{type(e).__name__}: {e}"
|
|
265
|
-
elapsed_ms = (time.perf_counter() - started) * 1000.0
|
|
266
|
-
out.append(
|
|
267
|
-
FrameResult(
|
|
268
|
-
request_id=scenario.request_id,
|
|
269
|
-
frame_index=idx,
|
|
270
|
-
bytes_in=frame.bytes_estimate,
|
|
271
|
-
elapsed_ms=elapsed_ms,
|
|
272
|
-
error=err,
|
|
273
|
-
)
|
|
274
|
-
)
|
|
275
|
-
return out
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
def _percentile(values: list[float], pct: float) -> float:
|
|
279
|
-
if not values:
|
|
280
|
-
return 0.0
|
|
281
|
-
s = sorted(values)
|
|
282
|
-
k = max(0, min(len(s) - 1, int(round(pct / 100.0 * (len(s) - 1)))))
|
|
283
|
-
return s[k]
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
# ── Reporting ──────────────────────────────────────────────────────────
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
def print_report(
|
|
290
|
-
results: list[FrameResult],
|
|
291
|
-
wall_time_s: float,
|
|
292
|
-
concurrency: int,
|
|
293
|
-
warmup_ms: float,
|
|
294
|
-
out_json: Path | None,
|
|
295
|
-
) -> None:
|
|
296
|
-
elapsed = [r.elapsed_ms for r in results]
|
|
297
|
-
errors = [r for r in results if r.error]
|
|
298
|
-
total_bytes = sum(r.bytes_in for r in results)
|
|
299
|
-
by_session: dict[str, list[float]] = {}
|
|
300
|
-
for r in results:
|
|
301
|
-
by_session.setdefault(r.request_id, []).append(r.elapsed_ms)
|
|
302
|
-
session_totals = [sum(v) for v in by_session.values()]
|
|
303
|
-
|
|
304
|
-
summary = {
|
|
305
|
-
"concurrency": concurrency,
|
|
306
|
-
"warmup_ms": round(warmup_ms, 1),
|
|
307
|
-
"frames_total": len(results),
|
|
308
|
-
"sessions": len(by_session),
|
|
309
|
-
"wall_time_s": round(wall_time_s, 2),
|
|
310
|
-
"errors": len(errors),
|
|
311
|
-
"error_classes": sorted({type(e.error).__name__: 1 for e in errors if e.error}.keys()),
|
|
312
|
-
"input_bytes_total": total_bytes,
|
|
313
|
-
"per_frame_elapsed_ms": {
|
|
314
|
-
"p50": round(_percentile(elapsed, 50), 1),
|
|
315
|
-
"p90": round(_percentile(elapsed, 90), 1),
|
|
316
|
-
"p99": round(_percentile(elapsed, 99), 1),
|
|
317
|
-
"max": round(max(elapsed) if elapsed else 0.0, 1),
|
|
318
|
-
"mean": round(statistics.mean(elapsed) if elapsed else 0.0, 1),
|
|
319
|
-
},
|
|
320
|
-
"per_session_total_ms": {
|
|
321
|
-
"p50": round(_percentile(session_totals, 50), 1),
|
|
322
|
-
"p90": round(_percentile(session_totals, 90), 1),
|
|
323
|
-
"max": round(max(session_totals) if session_totals else 0.0, 1),
|
|
324
|
-
},
|
|
325
|
-
}
|
|
326
|
-
|
|
327
|
-
print("─── Codex compression replay summary ───")
|
|
328
|
-
print(f"Concurrency: {summary['concurrency']}")
|
|
329
|
-
print(f"Sessions replayed: {summary['sessions']}")
|
|
330
|
-
print(f"Frames replayed: {summary['frames_total']}")
|
|
331
|
-
print(f"Wall time: {summary['wall_time_s']}s")
|
|
332
|
-
print(f"Warmup wall time: {summary['warmup_ms']}ms (NOT counted in metrics)")
|
|
333
|
-
print(f"Failures: {summary['errors']}")
|
|
334
|
-
print(f"Input bytes total: {summary['input_bytes_total']:,}")
|
|
335
|
-
print("Per-frame elapsed_ms:")
|
|
336
|
-
for k, v in summary["per_frame_elapsed_ms"].items():
|
|
337
|
-
print(f" {k:5} {v}")
|
|
338
|
-
print("Per-session total_ms:")
|
|
339
|
-
for k, v in summary["per_session_total_ms"].items():
|
|
340
|
-
print(f" {k:5} {v}")
|
|
341
|
-
if errors:
|
|
342
|
-
print("\nFirst 5 errors:")
|
|
343
|
-
for e in errors[:5]:
|
|
344
|
-
print(f" [{e.request_id}] frame {e.frame_index}: {e.error}")
|
|
345
|
-
|
|
346
|
-
if out_json:
|
|
347
|
-
out_json.write_text(json.dumps(summary, indent=2))
|
|
348
|
-
print(f"\nWrote machine-readable summary to {out_json}")
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
# ── Main ───────────────────────────────────────────────────────────────
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
def main() -> int:
|
|
355
|
-
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
|
356
|
-
parser.add_argument(
|
|
357
|
-
"--log",
|
|
358
|
-
type=Path,
|
|
359
|
-
required=True,
|
|
360
|
-
help="Path to production proxy log; per-session frame sizes are extracted from "
|
|
361
|
-
"`slow compression unit` lines.",
|
|
362
|
-
)
|
|
363
|
-
parser.add_argument(
|
|
364
|
-
"--concurrency",
|
|
365
|
-
type=int,
|
|
366
|
-
default=10,
|
|
367
|
-
help="Number of concurrent sessions to replay (default: 10).",
|
|
368
|
-
)
|
|
369
|
-
parser.add_argument(
|
|
370
|
-
"--frames-per-session",
|
|
371
|
-
type=int,
|
|
372
|
-
default=20,
|
|
373
|
-
help="Cap frames per session for bounded run-time (default: 20). "
|
|
374
|
-
"Sessions with more frames are truncated; with fewer are padded.",
|
|
375
|
-
)
|
|
376
|
-
parser.add_argument(
|
|
377
|
-
"--model",
|
|
378
|
-
default="gpt-4o-mini",
|
|
379
|
-
help="Model name passed through the dispatcher (default: gpt-4o-mini).",
|
|
380
|
-
)
|
|
381
|
-
parser.add_argument(
|
|
382
|
-
"--out-json",
|
|
383
|
-
type=Path,
|
|
384
|
-
help="Write machine-readable summary JSON here for before/after comparison.",
|
|
385
|
-
)
|
|
386
|
-
args = parser.parse_args()
|
|
387
|
-
|
|
388
|
-
if not args.log.exists():
|
|
389
|
-
print(f"error: log file not found: {args.log}", file=sys.stderr)
|
|
390
|
-
return 2
|
|
391
|
-
|
|
392
|
-
print(f"[replay] parsing {args.log} ...", flush=True)
|
|
393
|
-
scenarios = parse_log(args.log)
|
|
394
|
-
if not scenarios:
|
|
395
|
-
print(
|
|
396
|
-
"error: no scenarios extracted from log (no `slow compression unit` lines)",
|
|
397
|
-
file=sys.stderr,
|
|
398
|
-
)
|
|
399
|
-
return 2
|
|
400
|
-
|
|
401
|
-
# Pick the top-N sessions by frame count — those exercised the bug
|
|
402
|
-
# hardest in production and give the most representative replay.
|
|
403
|
-
ranked = sorted(scenarios.values(), key=lambda s: -len(s.frames))
|
|
404
|
-
picked = ranked[: args.concurrency]
|
|
405
|
-
# Cap each scenario's frame count for bounded runtime.
|
|
406
|
-
for s in picked:
|
|
407
|
-
s.frames = s.frames[: args.frames_per_session]
|
|
408
|
-
print(
|
|
409
|
-
f"[replay] picked {len(picked)} scenarios "
|
|
410
|
-
f"(total frames: {sum(len(s.frames) for s in picked)})",
|
|
411
|
-
flush=True,
|
|
412
|
-
)
|
|
413
|
-
|
|
414
|
-
print("[replay] booting proxy in-process ...", flush=True)
|
|
415
|
-
proxy = boot_proxy()
|
|
416
|
-
|
|
417
|
-
print("[replay] warming up Kompress + router ...", flush=True)
|
|
418
|
-
warmup_ms = warmup(proxy, model=args.model)
|
|
419
|
-
print(f"[replay] warmup done in {warmup_ms:.1f}ms", flush=True)
|
|
420
|
-
|
|
421
|
-
print(
|
|
422
|
-
f"[replay] starting replay: {len(picked)} concurrent sessions x "
|
|
423
|
-
f"{args.frames_per_session} frames",
|
|
424
|
-
flush=True,
|
|
425
|
-
)
|
|
426
|
-
results: list[FrameResult] = []
|
|
427
|
-
wall_started = time.perf_counter()
|
|
428
|
-
with concurrent.futures.ThreadPoolExecutor(max_workers=args.concurrency) as pool:
|
|
429
|
-
futures = [pool.submit(replay_session, proxy, s, args.model) for s in picked]
|
|
430
|
-
for fut in concurrent.futures.as_completed(futures):
|
|
431
|
-
results.extend(fut.result())
|
|
432
|
-
wall_time_s = time.perf_counter() - wall_started
|
|
433
|
-
|
|
434
|
-
print_report(
|
|
435
|
-
results,
|
|
436
|
-
wall_time_s=wall_time_s,
|
|
437
|
-
concurrency=args.concurrency,
|
|
438
|
-
warmup_ms=warmup_ms,
|
|
439
|
-
out_json=args.out_json,
|
|
440
|
-
)
|
|
441
|
-
return 0 if all(r.error is None for r in results) else 1
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
if __name__ == "__main__":
|
|
445
|
-
raise SystemExit(main())
|