windhover 0.14.0__tar.gz → 0.14.2__tar.gz

{windhover-0.14.0 → windhover-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windhover
-Version: 0.14.0
+Version: 0.14.2
 Summary: Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view.
 Project-URL: Repository, https://github.com/justfeltlikerunning/windhover
 Author: justfeltlikerunning

{windhover-0.14.0 → windhover-0.14.2}/docs/GUIDE.md

@@ -60,9 +60,10 @@ Projects with a **`langgraph.json`** (the LangGraph Studio/CLI convention) need
 run `windhover` in the project directory and every graph the file defines is served.
 
 **Multiple graphs**: `WINDHOVER_GRAPH="checkout=app.flows:checkout,support=app.flows:support"`
-puts a graph selector in the top bar. The selector scopes the canvas, New run, node source,
-and Memory; the Runs page gets an extra graph filter; human-in-the-loop actions always follow
-the graph the run belongs to.
+puts a graph selector in the top bar. The selector scopes **everything** — canvas, New run,
+node source, Memory, Runs, Sessions, Stats (so per-node latency and model usage never mix
+graphs). The Runs page keeps an "All graphs" override in its own filter; human-in-the-loop
+actions always follow the graph the run belongs to.
 
 - The canvas always reflects **current-on-disk** topology (a subprocess re-extracts on
   file change). Runs, however, execute the graph **imported at startup** — restart the

{windhover-0.14.0 → windhover-0.14.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "windhover"
-version = "0.14.0"
+version = "0.14.2"
 description = "Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view."
 readme = "README.md"
 requires-python = ">=3.10"

{windhover-0.14.0 → windhover-0.14.2}/tests/test_smoke.py

@@ -587,6 +587,31 @@ def test_env_multi_graph_parsing():
     print("env multi-graph parsing OK")
 
 
+def test_graph_scoped_stats_and_sessions():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    now = int(time.time() * 1000)
+    for i, g in enumerate(("alpha", "alpha", "beta")):
+        rid = f"g{i}"
+        s.open_run({"id": rid, "graph": g, "session": f"sess-{g}", "started_ms": now - i})
+        s.add_span({"id": f"s{i}", "run_id": rid, "type": "node", "name": "shared_name",
+                    "seq": 0, "dur_ms": 100 * (i + 1)})
+        s.add_span({"id": f"l{i}", "run_id": rid, "type": "llm", "name": "m", "seq": 1,
+                    "model": f"model-{g}", "dur_ms": 5, "prompt_tokens": 10,
+                    "completion_tokens": 1})
+        s.close_run(rid, "done", now + 10)
+    st_a = s.stats(graph="alpha")
+    assert st_a["totals"]["runs"] == 2
+    assert st_a["per_node"][0]["n"] == 2            # only alpha's spans, not beta's
+    assert [m["model"] for m in st_a["models"]] == ["model-alpha"]
+    st_all = s.stats()
+    assert st_all["totals"]["runs"] == 3 and st_all["per_node"][0]["n"] == 3
+    ses_b = s.sessions(graph="beta")
+    assert [x["session"] for x in ses_b] == ["sess-beta"]
+    assert len(s.sessions()) == 2
+    print("graph-scoped stats/sessions OK")
+
+
 def test_nonblocking_sink_and_webhook_hook():
     # sink to an unreachable host must return instantly and never raise
     from windhover.tracer import http_sink
@@ -607,6 +632,63 @@ def test_nonblocking_sink_and_webhook_hook():
     print("non-blocking sink + webhook hook OK")
 
 
+def test_fork_not_marked_interrupted():
+    """Pending-next check must query by thread only — a config carrying
+    checkpoint_id reads the historical checkpoint and falsely flags forks."""
+    os.environ.setdefault("WINDHOVER_DB", tempfile.mktemp(suffix=".db"))
+    from windhover.server import _pending_next
+    from typing import TypedDict
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.checkpoint.memory import MemorySaver
+
+    class St(TypedDict):
+        x: int
+    g = StateGraph(St)
+    g.add_node("inc", lambda st: {"x": st["x"] + 1})
+    g.add_node("mul", lambda st: {"x": st["x"] * 10})
+    g.add_edge(START, "inc"); g.add_edge("inc", "mul"); g.add_edge("mul", END)
+    app = g.compile(checkpointer=MemorySaver())
+    cfgc = {"configurable": {"thread_id": "fork-t"}}
+    app.invoke({"x": 1}, config=cfgc)                       # completes
+    hist = list(app.get_state_history(cfgc))
+    early = next(s for s in hist if s.next)                 # historical, pending
+    cid = early.config["configurable"]["checkpoint_id"]
+    fork_cfg = {"configurable": {"thread_id": "fork-t", "checkpoint_id": cid}}
+    assert app.get_state(fork_cfg).next, "sanity: historical checkpoint has next"
+    assert _pending_next(app, fork_cfg) == [], "must ignore checkpoint_id"
+    print("fork-not-interrupted OK")
+
+
+def test_score_rejects_nonfinite():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    s.open_run({"id": "sf1", "graph": "g", "started_ms": 1})
+    s.close_run("sf1", "done", 2)
+    assert s.add_score("sf1", "ok", 0.5) is not None
+    assert s.add_score("sf1", "bad", float("inf")) is None
+    assert s.add_score("sf1", "bad", float("nan")) is None
+    # the runs API payload must stay JSON-parseable
+    import json as _json
+    _json.loads(_json.dumps(s.runs()["runs"][0], allow_nan=False))
+    print("non-finite score rejection OK")
+
+
+def test_tracer_cleanup_no_leak():
+    p = tempfile.mktemp(suffix=".db")
+    s = Store(p)
+    tr = SpanBuilder(db_sink(s), run_name="leak")
+    for i in range(20):
+        tr.on_chain_start({}, {"i": i}, run_id=f"r{i}", parent_run_id=None)
+        tr.on_chain_start({}, {}, run_id=f"n{i}", parent_run_id=f"r{i}",
+                          metadata={"langgraph_node": "w"})
+        tr.on_chain_end({}, run_id=f"n{i}")
+        tr.on_chain_end({}, run_id=f"r{i}")
+    assert s.runs(limit=100)["total"] == 20
+    assert not tr._runs and not tr._root_of and not tr._span_of and not tr._open, (
+        len(tr._runs), len(tr._root_of), len(tr._span_of), len(tr._open))
+    print("tracer cleanup (no leak) OK")
+
+
 if __name__ == "__main__":
     test_cost(); print("cost OK")
     test_store_roundtrip()
@@ -633,5 +715,9 @@ if __name__ == "__main__":
     test_message_serialization()
     test_langgraph_json_discovery()
     test_env_multi_graph_parsing()
+    test_graph_scoped_stats_and_sessions()
     test_nonblocking_sink_and_webhook_hook()
+    test_fork_not_marked_interrupted()
+    test_score_rejects_nonfinite()
+    test_tracer_cleanup_no_leak()
     print("ALL SMOKE TESTS PASSED")

{windhover-0.14.0 → windhover-0.14.2}/windhover/server.py

@@ -230,6 +230,20 @@ def _sse(ev: str, data: dict) -> str:
     return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
 
 
+def _pending_next(gr, config) -> list:
+    """Nodes still pending on the LATEST checkpoint of this thread. Must query
+    by thread only — carrying a checkpoint_id (fork/resume-from) would read the
+    HISTORICAL checkpoint, whose next-nodes are always non-empty."""
+    try:
+        thread_id = (config.get("configurable") or {}).get("thread_id")
+        if not thread_id:
+            return []
+        st = gr.get_state({"configurable": {"thread_id": thread_id}})
+        return list(st.next or [])
+    except Exception:
+        return []
+
+
 def _stream_execution(gr, graph_input, config, tracer, stream_kwargs=None):
     """Shared SSE executor for /api/run and /api/threads/…/resume. Detects both
     dynamic interrupts (__interrupt__ updates) and static breakpoints (stream
@@ -272,17 +286,17 @@ def _stream_execution(gr, graph_input, config, tracer, stream_kwargs=None):
                         seq_extra[0] += 1
                     q.put(("node", {"node": node, "cached": cached or None}))
             if not interrupted and getattr(gr, "checkpointer", None) is not None:
-                try:  # static breakpoint: stream ended but nodes are pending
-                    st = gr.get_state(config)
-                    if st.next:
-                        interrupted = True
-                        q.put(("interrupt", {"run_id": run_id,
-                                             "next": list(st.next)}))
-                except Exception:
-                    pass
+                nxt = _pending_next(gr, config)
+                if nxt:
+                    interrupted = True
+                    q.put(("interrupt", {"run_id": run_id, "next": nxt}))
             if interrupted:
-                # tracer closed the run as done on root end; correct it
-                store.close_run(run_id, "interrupted", int(time.time() * 1000))
+                # correct the status ONLY if the tracer didn't already mark it
+                # (dynamic interrupts close as interrupted themselves — a second
+                # close here would double-fire the webhook)
+                row = store.run_detail(run_id)
+                if row and row.get("status") != "interrupted":
+                    store.close_run(run_id, "interrupted", int(time.time() * 1000))
             q.put(("interrupted" if interrupted else "done", {"run_id": run_id}))
         except Exception as e:
             # tracer already recorded the error span/close; surface to the client too
@@ -307,6 +321,17 @@ async def api_run(request: Request):
         payload = await request.json()
     except Exception:
         payload = {}
+    if not isinstance(payload, dict):
+        # non-dict graph inputs (e.g. functional-API entrypoints taking a
+        # scalar) carry no _directives — run them as-is on the default graph
+        gr = _graph_for(_default_name())
+        if gr is None:
+            return JSONResponse({"error": "no local graph"}, 400)
+        tracer = SpanBuilder(db_sink(store), run_name=_default_name())
+        config = {"callbacks": [tracer]}
+        if getattr(gr, "checkpointer", None) is not None:
+            config["configurable"] = {"thread_id": tracer.run_id}
+        return _stream_execution(gr, payload, config, tracer)
     gname = payload.pop("_graph", None) or _default_name()
     gr = _graph_for(gname)
     if gr is None:
@@ -414,8 +439,8 @@ def api_runs(limit: int = 50, offset: int = 0, q: str = None, status: str = None
 
 
 @app.get("/api/sessions")
-def api_sessions(limit: int = 100):
-    return JSONResponse(store.sessions(limit=limit))
+def api_sessions(limit: int = 100, graph: str = None):
+    return JSONResponse(store.sessions(limit=limit, graph=graph or None))
 
 
 @app.get("/api/runs/{run_id}")
@@ -441,8 +466,10 @@ async def api_score_add(request: Request, run_id: str):
         name, value = str(body["name"]).strip(), float(body["value"])
     except (KeyError, TypeError, ValueError):
         return JSONResponse({"error": "requires name (str) and value (number)"}, 400)
-    if not name:
-        return JSONResponse({"error": "name must be non-empty"}, 400)
+    import math
+    if not name or not math.isfinite(value):
+        return JSONResponse({"error": "name must be non-empty and value finite "
+                            "(NaN/Infinity would corrupt API JSON)"}, 400)
     sc = store.add_score(run_id, name, value, comment=body.get("comment"),
                          source=body.get("source", "api"))
     return JSONResponse(sc) if sc else JSONResponse({"error": "run not found"}, 404)
@@ -622,8 +649,8 @@ def api_dataset_run(ds_id: str, graph: str = None):
 
 
 @app.get("/api/stats")
-def api_stats(days: int = 30):
-    return JSONResponse(store.stats(days=max(1, min(days, 365))))
+def api_stats(days: int = 30, graph: str = None):
+    return JSONResponse(store.stats(days=max(1, min(days, 365)), graph=graph or None))
 
 
 @app.get("/api/events")

{windhover-0.14.0 → windhover-0.14.2}/windhover/static/index.html

@@ -184,6 +184,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
+  clearTimeout(window.__liveT);
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history?'+rgparam());
     d=await r.json(); if(!r.ok) return toast(d.error||'history unavailable'); }catch(e){ return toast('history unavailable'); }
   const steps=d.steps||[];
@@ -218,6 +219,7 @@ window.showHistory=async(tid)=>{
 window.pickDiff=async(id)=>{
   if(!window.__diffA||window.__diffA===id){ window.__diffA=id; toast('Compare: pick a second run (open it, hit compare)'); return; }
   const a=window.__diffA; window.__diffA=null;
+  clearTimeout(window.__liveT);
   const [ra,rb]=await Promise.all([fetch('/api/runs/'+a).then(r=>r.json()),
                                    fetch('/api/runs/'+id).then(r=>r.json())]);
   const tops=r=>r.spans.filter(s=>!s.parent_id&&s.type==='node');
@@ -526,7 +528,7 @@ th{font-family:var(--mono);letter-spacing:.11em;font-size:10.5px}
       </div>
       <div id="view-stats" style="display:none">
         <div class="page">
-          <div class="page-head"><h1>Stats</h1><span class="sub">all recorded runs</span></div>
+          <div class="page-head"><h1>Stats</h1><span class="sub" id="stats-sub">all recorded runs</span></div>
           <div id="stats-body"></div>
         </div>
       </div>
@@ -642,14 +644,22 @@ async function loadGraphList(){
       sel.style.display=''; $('#gname').style.display='none';
       sel.innerHTML=window.__graphList.map(g=>`<option ${g===GSEL?'selected':''}>${esc(g)}</option>`).join('');
       sel.onchange=()=>{ GSEL=sel.value; localStorage.setItem('wh-graph',GSEL);
-        loadGraph(true); probeMemory(); if(VIEW==='memory') loadMemory(); };
+        RF.graph=GSEL; const rg=$('#rgraph'); if(rg) rg.value=GSEL;
+        loadGraph(true); probeMemory();
+        if(VIEW==='memory') loadMemory();
+        if(VIEW==='runs') loadRuns();
+        if(VIEW==='sessions') loadSessions();
+        if(VIEW==='stats'){ loadStats(); loadDatasets(); } };
       const rg=$('#rgraph');
       if(rg){ rg.style.display='';
         rg.innerHTML='<option value="">All graphs</option>'+window.__graphList.map(g=>`<option>${esc(g)}</option>`).join('');
+        RF.graph=GSEL; rg.value=GSEL;
         rg.onchange=e=>{RF.graph=e.target.value;RF.offset=0;loadRuns();}; }
     }
   }catch(e){}
 }
+function multiGraph(){ return (window.__graphList||[]).length>1; }
+function gscope(){ return multiGraph()&&GSEL?'graph='+encodeURIComponent(GSEL):''; }
 function gparam(pfx){ return GSEL?pfx+'graph='+encodeURIComponent(GSEL):''; }
 function rgparam(){ const g=(window.__run||{}).graph||GSEL; return g?'graph='+encodeURIComponent(g):''; }
 let XRAY=false;
@@ -719,6 +729,7 @@ function codeBlock(src,hi){ const lines=src.code.replace(/\n$/,'').split('\n');
 
 /* ---------- node pane (tap a node on the graph) ---------- */
 async function openNode(name){
+  clearTimeout(window.__liveT); window.__run=null;
   let d={}; try{ d=await(await fetch('/api/nodes/'+encodeURIComponent(name))).json(); }catch(e){}
   let src=null; try{ const rs=await fetch('/api/nodes/'+encodeURIComponent(name)+'/source?'+gparam(''));
     if(rs.ok) src=await rs.json(); }catch(e){}
@@ -889,7 +900,7 @@ $('#rbook').onclick=()=>{RF.bookmarked=!RF.bookmarked;$('#rbook').classList.togg
 
 /* ---------- sessions ---------- */
 async function loadSessions(){
-  const ss=await(await fetch('/api/sessions')).json();
+  const ss=await(await fetch('/api/sessions?'+gscope())).json();
   $('#sess-sub').textContent=ss.length?`${ss.length} session${ss.length===1?'':'s'}`:'';
   if(!ss.length){ $('#sess-wrap').innerHTML='<div class="empty"><div class="t">No sessions yet</div>Pass <span class="mono">session=</span> to <span class="mono">WindhoverTracer</span>, or <span class="mono">config={"metadata": {"windhover_session": …}}</span> in any LangChain/LangGraph app.</div>'; return; }
   $('#sess-wrap').innerHTML=`<div style="overflow:auto"><table>
@@ -1098,6 +1109,7 @@ window.editState=async(tid,cid,valuesJson)=>{
 
 /* ---------- time-travel (checkpoint history) ---------- */
 window.showHistory=async(tid)=>{
+  clearTimeout(window.__liveT);
   let d=null; try{ const r=await fetch('/api/threads/'+encodeURIComponent(tid)+'/history?'+rgparam());
     d=await r.json(); if(!r.ok) return toast(d.error||'history unavailable'); }catch(e){ return toast('history unavailable'); }
   const steps=d.steps||[];
@@ -1132,6 +1144,7 @@ window.showHistory=async(tid)=>{
 window.pickDiff=async(id)=>{
   if(!window.__diffA||window.__diffA===id){ window.__diffA=id; toast('Compare: pick a second run (open it, hit compare)'); return; }
   const a=window.__diffA; window.__diffA=null;
+  clearTimeout(window.__liveT);
   const [ra,rb]=await Promise.all([fetch('/api/runs/'+a).then(r=>r.json()),
                                    fetch('/api/runs/'+id).then(r=>r.json())]);
   const tops=r=>r.spans.filter(s=>!s.parent_id&&s.type==='node');
@@ -1178,11 +1191,13 @@ function chartCard(title,daily,val,errKey){
     <div class="clabels"><span>${daily[0]?.day||''}</span><span>${daily[daily.length-1]?.day||''}</span></div></div></div>`;
 }
 async function loadStats(){
-  const s=await(await fetch('/api/stats?days=30')).json(); const t=s.totals||{};
+  const s=await(await fetch('/api/stats?days=30&'+gscope())).json(); const t=s.totals||{};
   const errRate=t.runs?Math.round((t.errors||0)/t.runs*100):0;
   const max=Math.max(1,...(s.per_node||[]).map(n=>n.avg_ms||0));
   const daily=s.daily||[], models=s.models||[];
   const db=t.db_bytes!=null?(t.db_bytes/1048576).toFixed(1)+' MB db':'';
+  const ssub=document.getElementById('stats-sub');
+  if(ssub) ssub.textContent=(multiGraph()&&GSEL)?('graph: '+GSEL):'all recorded runs';
   $('#stats-body').innerHTML=`
     <div class="metrics">
       <div class="metric"><div class="v num">${t.runs||0}</div><div class="l">Total runs</div></div>
@@ -1215,7 +1230,7 @@ async function loadStats(){
 }
 
 /* ---------- misc ---------- */
-function closeAll(){ $('#scrim').classList.remove('on'); $('#drawer').classList.remove('on'); $('#modal').classList.remove('on'); }
+function closeAll(){ clearTimeout(window.__liveT); $('#scrim').classList.remove('on'); $('#drawer').classList.remove('on'); $('#modal').classList.remove('on'); }
 function esc(s){ return String(s).replace(/[&<>]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;'}[c])); }
 function fmtms(ms){ return ms<1000?ms+' ms':(ms/1000).toFixed(1)+' s'; }
 function fmtk(n){ return n<1000?String(n):(n/1000).toFixed(1)+'k'; }

{windhover-0.14.0 → windhover-0.14.2}/windhover/store.py

@@ -195,6 +195,9 @@ class Store:
 
     def add_score(self, run_id: str, name: str, value: float,
                   comment: Optional[str] = None, source: str = "api") -> Optional[dict]:
+        import math
+        if not math.isfinite(float(value)):
+            return None  # NaN/Infinity would render the runs API unparseable
         with _lock, self._conn() as c:
             if not c.execute("SELECT 1 FROM runs WHERE id=?", (run_id,)).fetchone():
                 return None
@@ -310,14 +313,18 @@ class Store:
                     r["scores"] = sc.get(r["id"]) or None
         return {"runs": rows, "total": total, "limit": limit, "offset": offset}
 
-    def sessions(self, limit: int = 100) -> list[dict]:
+    def sessions(self, limit: int = 100, graph: Optional[str] = None) -> list[dict]:
+        cond, args = "", []
+        if graph:
+            cond = " AND graph=?"; args.append(graph)
         with _lock, self._conn() as c:
-            return [dict(r) for r in c.execute("""SELECT session,
+            return [dict(r) for r in c.execute(f"""SELECT session,
                 COUNT(*) runs, COUNT(*) FILTER (WHERE status='error') errors,
                 MIN(started_ms) first_ms, MAX(started_ms) last_ms,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost, SUM(duration_ms) duration_ms
-                FROM runs WHERE session IS NOT NULL AND session!=''
-                GROUP BY session ORDER BY last_ms DESC LIMIT ?""", (limit,)).fetchall()]
+                FROM runs WHERE session IS NOT NULL AND session!=''{cond}
+                GROUP BY session ORDER BY last_ms DESC LIMIT ?""",
+                (*args, limit)).fetchall()]
 
     def run_detail(self, run_id: str) -> Optional[dict]:
         with _lock, self._conn() as c:
@@ -366,27 +373,36 @@ class Store:
                     s[f] = json.loads(s[f]) if s.get(f) else None
         return {"name": name, "summary": dict(agg), "recent": rows}
 
-    def stats(self, days: int = 30) -> dict:
+    def stats(self, days: int = 30, graph: Optional[str] = None) -> dict:
         cutoff = int((time.time() - days * 86400) * 1000)
+        rcond, rargs = ("", [])
+        scond, sargs = ("", [])
+        if graph:
+            rcond = " WHERE graph=?"; rargs = [graph]
+            scond = " AND runs.graph=?"; sargs = [graph]
         with _lock, self._conn() as c:
-            tot = c.execute("""SELECT COUNT(*) runs,
+            tot = c.execute(f"""SELECT COUNT(*) runs,
                 COUNT(*) FILTER (WHERE status='error') errors,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost,
-                SUM(llm_calls) llm_calls FROM runs""").fetchone()
-            per_node = c.execute("""SELECT name, COUNT(*) n, AVG(dur_ms) avg_ms,
-                SUM(cost_usd) cost FROM spans WHERE type='node'
-                GROUP BY name ORDER BY avg_ms DESC LIMIT 20""").fetchall()
-            models = c.execute("""SELECT model, COUNT(*) calls,
-                SUM(prompt_tokens) prompt_tokens, SUM(completion_tokens) completion_tokens,
-                SUM(cost_usd) cost, AVG(dur_ms) avg_ms
-                FROM spans WHERE type='llm' AND model IS NOT NULL
-                GROUP BY model ORDER BY calls DESC LIMIT 20""").fetchall()
-            daily = c.execute("""SELECT
+                SUM(llm_calls) llm_calls FROM runs{rcond}""", rargs).fetchone()
+            per_node = c.execute(f"""SELECT spans.name, COUNT(*) n,
+                AVG(spans.dur_ms) avg_ms, SUM(spans.cost_usd) cost
+                FROM spans JOIN runs ON runs.id = spans.run_id
+                WHERE spans.type='node'{scond}
+                GROUP BY spans.name ORDER BY avg_ms DESC LIMIT 20""", sargs).fetchall()
+            models = c.execute(f"""SELECT spans.model, COUNT(*) calls,
+                SUM(spans.prompt_tokens) prompt_tokens,
+                SUM(spans.completion_tokens) completion_tokens,
+                SUM(spans.cost_usd) cost, AVG(spans.dur_ms) avg_ms
+                FROM spans JOIN runs ON runs.id = spans.run_id
+                WHERE spans.type='llm' AND spans.model IS NOT NULL{scond}
+                GROUP BY spans.model ORDER BY calls DESC LIMIT 20""", sargs).fetchall()
+            daily = c.execute(f"""SELECT
                 strftime('%Y-%m-%d', started_ms/1000, 'unixepoch') day,
                 COUNT(*) runs, COUNT(*) FILTER (WHERE status='error') errors,
                 SUM(total_tokens) tokens, SUM(cost_usd) cost
-                FROM runs WHERE started_ms >= ?
-                GROUP BY day ORDER BY day""", (cutoff,)).fetchall()
+                FROM runs WHERE started_ms >= ?{' AND graph=?' if graph else ''}
+                GROUP BY day ORDER BY day""", (cutoff, *rargs)).fetchall()
         try:
             db_bytes = os.path.getsize(self.path)
         except OSError:
@@ -395,4 +411,4 @@ class Store:
                 "per_node": [dict(r) for r in per_node],
                 "models": [dict(r) for r in models],
                 "daily": [dict(r) for r in daily],
-                "days": days}
+                "days": days, "graph": graph}

{windhover-0.14.0 → windhover-0.14.2}/windhover/tracer.py

@@ -151,6 +151,7 @@ class SpanBuilder(BaseCallbackHandler):
         self.session = session
         self.tags = tags
         self.run_id = uuid.uuid4().hex[:12]     # id of the FIRST run this tracer opens
+        self._closed = 0                         # runs completed (cleanup bookkeeping)
         self._runs: dict = {}                    # lc root id -> run ctx
         self._root_of: dict = {}                 # lc run id -> lc root id
         self._open: dict = {}                    # lc run id -> pending span info
@@ -171,7 +172,10 @@ class SpanBuilder(BaseCallbackHandler):
         if root is None:
             root = self._root_of.get(run_id) or (run_id if parent_run_id is None else parent_run_id)
         self._root_of[run_id] = root
-        return root, self._runs.get(root)
+        ctx = self._runs.get(root)
+        if ctx is not None:
+            ctx["members"].add(run_id)
+        return root, ctx
 
     def _open_ctx(self, root, inputs, metadata=None, lc_tags=None):
         md = metadata or {}
@@ -181,8 +185,8 @@ class SpanBuilder(BaseCallbackHandler):
                      if not str(t).startswith(self._INTERNAL_TAG_PREFIXES)]
         extra = md.get("windhover_tags") or []
         tags = list(dict.fromkeys([*(self.tags or []), *map(str, extra), *map(str, user_tags)])) or None
-        ctx = {"id": self.run_id if not self._runs else uuid.uuid4().hex[:12],
-               "t0": time.time(), "seq": 0, "interrupted": False}
+        ctx = {"id": self.run_id if not self._closed and not self._runs else uuid.uuid4().hex[:12],
+               "t0": time.time(), "seq": 0, "interrupted": False, "members": {root}}
         self._runs[root] = ctx
         self._emit({"kind": "run_open", "run_id": ctx["id"], "graph": name,
                     "input": _trunc(inputs), "started_ms": int(ctx["t0"] * 1000),
@@ -229,11 +233,17 @@ class SpanBuilder(BaseCallbackHandler):
         ctx["seq"] += 1
 
     def _close_ctx(self, root, status, error=None):
-        ctx = self._runs.get(root)
+        ctx = self._runs.pop(root, None)
         if ctx is None:
             return
         self._emit({"kind": "run_close", "run_id": ctx["id"], "status": status,
                     "ended_ms": int(time.time() * 1000), "error": error})
+        # long-lived tracers (production apps) must not grow without bound
+        self._closed += 1
+        for m in ctx.get("members", ()):
+            self._root_of.pop(m, None)
+            self._span_of.pop(m, None)
+            self._open.pop(m, None)
 
     # -- chains / nodes --------------------------------------------------------
     def on_chain_start(self, serialized, inputs, *, run_id=None, parent_run_id=None,