#!/usr/bin/env python3
"""Tracing overhead bench (see ../PREREGISTRATION.md).
usage: bench.py MODE PASS OUTDIR   MODE in baseline-phx|phoenix|baseline-mlf|mlflow|micro-phoenix|micro-mlflow"""
import json, os, sys, time, datetime, statistics, pathlib
MODE, PASS, OUT = sys.argv[1], int(sys.argv[2]), pathlib.Path(sys.argv[3]); OUT.mkdir(parents=True, exist_ok=True)
PHX = "http://localhost:6006"; MLF = "http://localhost:5055"
def now(): return datetime.datetime.now().isoformat(timespec="seconds")
def say(*a): print(*a, flush=True)

if MODE.startswith("micro"):
    N = 2000
    def noop(x): return x + 1
    if MODE == "micro-phoenix":
        from phoenix.otel import register
        tp = register(project_name="micro-bench", endpoint=PHX + "/v1/traces", verbose=False)
        tr = tp.get_tracer("micro")
        def traced(x):
            with tr.start_as_current_span("noop"): return x + 1
    else:
        import mlflow
        mlflow.set_tracking_uri(MLF); mlflow.set_experiment("micro-bench")
        traced = mlflow.trace(noop)
    for f, label in ((noop, "untraced"), (traced, "traced")):
        for i in range(50): f(i)   # warm-up
        ts = []
        for i in range(N):
            t = time.perf_counter(); f(i); ts.append((time.perf_counter() - t) * 1e6)
        med = statistics.median(ts)
        json.dump({"mode": MODE, "label": label, "n": N, "median_us": med, "p95_us": sorted(ts)[int(0.95 * N) - 1], "ts": now()},
                  open(OUT / f"{MODE}-{label}.json", "w"))
        say(f"{MODE:<14} {label:<9} {N} calls  median {med:8.1f} us per call")
    if MODE == "micro-phoenix": tp.force_flush()
    sys.exit(0)

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")   # placeholder string; Ollama ignores it
if MODE == "phoenix":
    from phoenix.otel import register
    from openinference.instrumentation.openai import OpenAIInstrumentor
    tp = register(project_name="tracing-bench", endpoint=PHX + "/v1/traces", verbose=False)
    OpenAIInstrumentor().instrument(tracer_provider=tp)
elif MODE == "mlflow":
    import mlflow
    mlflow.set_tracking_uri(MLF); mlflow.set_experiment("tracing-bench"); mlflow.openai.autolog()
def call():
    t = time.perf_counter()
    r = client.chat.completions.create(model="qwen2.5:3b", temperature=0, max_tokens=5,
                                       messages=[{"role": "user", "content": "Reply with the single word OK."}])
    return (time.perf_counter() - t) * 1000, r.choices[0].message.content
for i in range(10): call()
lat = []
say(f"pass {PASS} {MODE}: 10 warm-up calls done, measuring 100")
for i in range(100):
    ms, txt = call(); lat.append(ms)
    if (i + 1) % 10 == 0:
        say(f"  {MODE:<13} call {i+1:>3}/100  last {ms:6.0f} ms  median so far {statistics.median(lat):6.0f} ms")
t_end = time.time()
res = {"mode": MODE, "pass": PASS, "latencies_ms": lat, "median_ms": statistics.median(lat), "p95_ms": sorted(lat)[94], "ts": now()}
# trace visibility: time until the server reports at least the expected number of traces for this process
exp_total = None
if MODE == "phoenix":
    from phoenix.client import Client
    c = Client(base_url=PHX); want = res["expected_cumulative"] = int(os.environ["EXPECTED"])
    while True:
        n = len(c.spans.get_spans(project_identifier="tracing-bench", limit=5000, timeout=30))
        if n >= want or time.time() - t_end > 120: break
        time.sleep(0.2)
    res["visible_after_s"] = round(time.time() - t_end, 2); res["server_count"] = n
elif MODE == "mlflow":
    from mlflow import MlflowClient
    c = MlflowClient(MLF); exp = mlflow.get_experiment_by_name("tracing-bench").experiment_id
    want = res["expected_cumulative"] = int(os.environ["EXPECTED"])
    while True:
        n, tok = 0, None
        while True:
            pl = c.search_traces(locations=[exp], max_results=500, include_spans=False, page_token=tok)
            n += len(pl); tok = pl.token
            if not tok: break
        if n >= want or time.time() - t_end > 120: break
        time.sleep(0.2)
    res["visible_after_s"] = round(time.time() - t_end, 2); res["server_count"] = n
json.dump(res, open(OUT / f"pass{PASS}-{MODE}.json", "w"))
say(f"pass {PASS} {MODE}: median {res['median_ms']:.0f} ms, p95 {res['p95_ms']:.0f} ms" +
    (f", all {res['server_count']} traces visible {res['visible_after_s']} s after the last call" if "visible_after_s" in res else ""))
