reactifact 0.6.0__py3-none-any.whl

reactifact/tracing/store.py

@@ -0,0 +1,254 @@
+"""Trace sinks: what accepts a finished `RunTrace`.
+
+`TraceStore` is the SQLite sink (`runs`/`spans` tables), `PostgresStore` the
+Postgres one. Both expose an async interface (`export`/`query`/`get`) — SQLite
+keeps its sync `sqlite3` core and bridges it with `asyncio.to_thread`, so the
+whole tracing surface is uniform `async` (this is what makes a web dashboard
+over Postgres possible). Langfuse is a separate `Tracer` subclass.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sqlite3
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Protocol
+
+from .models import AgentSpan, ArtifactRef, LLMCall, RelationRef, RunTrace
+
+
+class TraceSink(Protocol):
+    """Async interface for trace sinks (SQLite, Postgres, Langfuse…)."""
+
+    async def export(self, trace: RunTrace) -> None: ...
+
+
+class TraceReader(Protocol):
+    """Async read interface used by the web dashboard (§54)."""
+
+    async def query(
+        self,
+        *,
+        session_id: str | None = None,
+        outcome: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]: ...
+
+    async def get(self, trace_id: str) -> RunTrace | None: ...
+
+
+class TraceStore:
+    """SQLite trace sink: writes `RunTrace` and can serve them back.
+
+    The `sqlite3` connection is used from a single worker thread: public
+    methods are async and delegate to sync implementations via
+    `asyncio.to_thread`. Pass `bridge=None` only inside tests that drive the
+    sync core directly.
+    """
+
+    def __init__(
+        self,
+        path: str = "traces.db",
+        *,
+        timeout: float = 10.0,
+        max_runs: int | None = 200,
+    ):
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        self.max_runs = max_runs
+        self._conn = sqlite3.connect(path, check_same_thread=False, timeout=timeout)
+        self._create_schema()
+        self._migrate()
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def _create_schema(self) -> None:
+        self._conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS runs (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL DEFAULT '',
+                started_at REAL NOT NULL,
+                duration_ms REAL NOT NULL,
+                outcome TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS spans (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                run_id TEXT NOT NULL REFERENCES runs(id),
+                agent TEXT NOT NULL,
+                event_type TEXT NOT NULL DEFAULT '',
+                latency_ms REAL NOT NULL DEFAULT 0,
+                error TEXT,
+                reads TEXT NOT NULL DEFAULT '[]',
+                writes TEXT NOT NULL DEFAULT '[]',
+                relations TEXT NOT NULL DEFAULT '[]',
+                llm_calls TEXT NOT NULL DEFAULT '[]'
+            );
+            CREATE INDEX IF NOT EXISTS idx_spans_run ON spans(run_id);
+            """
+        )
+        self._conn.commit()
+
+    def _migrate(self) -> None:
+        """Adds columns that appeared after the old schema (like teff)."""
+        try:
+            cols = {row[1] for row in self._conn.execute("PRAGMA table_info(spans)")}
+        except sqlite3.OperationalError:
+            return
+        if "llm_calls" not in cols:
+            self._conn.execute(
+                "ALTER TABLE spans ADD COLUMN llm_calls TEXT NOT NULL DEFAULT '[]'"
+            )
+        if "relations" not in cols:
+            self._conn.execute(
+                "ALTER TABLE spans ADD COLUMN relations TEXT NOT NULL DEFAULT '[]'"
+            )
+        self._conn.commit()
+
+    # ---- async public API (bridged to the sync core) ----------------------- #
+
+    async def export(self, trace: RunTrace) -> None:
+        await asyncio.to_thread(self._export_sync, trace)
+
+    async def prune(self, keep: int) -> int:
+        return await asyncio.to_thread(self._prune_sync, keep)
+
+    async def query(
+        self,
+        *,
+        session_id: str | None = None,
+        outcome: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        return await asyncio.to_thread(
+            self._query_sync, session_id, outcome, limit, offset
+        )
+
+    async def get(self, trace_id: str) -> RunTrace | None:
+        return await asyncio.to_thread(self._get_sync, trace_id)
+
+    # ---- sync core --------------------------------------------------------- #
+
+    def _export_sync(self, trace: RunTrace) -> None:
+        started = trace.started_at.timestamp() if trace.started_at else time.time()
+        self._conn.execute(
+            "INSERT INTO runs (id, session_id, started_at, duration_ms, outcome) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (trace.id, trace.session_id, started, trace.duration_ms, trace.outcome),
+        )
+        for span in trace.spans:
+            self._conn.execute(
+                "INSERT INTO spans (run_id, agent, event_type, latency_ms, error, "
+                "reads, writes, relations, llm_calls) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    trace.id,
+                    span.agent,
+                    span.event_type,
+                    span.latency_ms,
+                    span.error,
+                    json.dumps([r.model_dump(mode="json") for r in span.reads]),
+                    json.dumps([w.model_dump(mode="json") for w in span.writes]),
+                    json.dumps([r.model_dump(mode="json") for r in span.relations]),
+                    json.dumps([c.model_dump(mode="json") for c in span.llm_calls]),
+                ),
+            )
+        self._conn.commit()
+        if self.max_runs is not None:
+            self._prune_sync(self.max_runs)
+
+    def _prune_sync(self, keep: int) -> int:
+        """Keeps the last `keep` traces, deletes older ones (retention)."""
+        cur = self._conn.execute(
+            "DELETE FROM runs WHERE id NOT IN "
+            "(SELECT id FROM runs ORDER BY started_at DESC LIMIT ?)",
+            (keep,),
+        )
+        self._conn.execute(
+            "DELETE FROM spans WHERE run_id NOT IN (SELECT id FROM runs)"
+        )
+        self._conn.commit()
+        return cur.rowcount
+
+    def _query_sync(
+        self,
+        session_id: str | None,
+        outcome: str | None,
+        limit: int,
+        offset: int,
+    ) -> dict[str, Any]:
+        """Latest traces with filters and pagination (§54).
+
+        Returns ``{"items": [...], "total": n}``, where total is before pagination.
+        """
+        where: list[str] = []
+        args: list[Any] = []
+        if session_id is not None:
+            where.append("session_id = ?")
+            args.append(session_id)
+        if outcome is not None:
+            where.append("outcome = ?")
+            args.append(outcome)
+        where_sql = (" WHERE " + " AND ".join(where)) if where else ""
+
+        total = self._conn.execute(
+            f"SELECT COUNT(*) FROM runs{where_sql}", tuple(args)
+        ).fetchone()[0]
+        rows = self._conn.execute(
+            f"SELECT id, session_id, started_at, duration_ms, outcome, "
+            f"(SELECT COUNT(*) FROM spans WHERE run_id = runs.id) AS spans_count "
+            f"FROM runs{where_sql} ORDER BY started_at DESC LIMIT ? OFFSET ?",
+            (*args, limit, offset),
+        ).fetchall()
+        items = [
+            {
+                "id": row[0],
+                "session_id": row[1],
+                "started_at": row[2],
+                "duration_ms": round(row[3], 1),
+                "outcome": row[4],
+                "spans": row[5],
+            }
+            for row in rows
+        ]
+        return {"items": items, "total": total}
+
+    def _get_sync(self, trace_id: str) -> RunTrace | None:
+        row = self._conn.execute(
+            "SELECT id, session_id, started_at, duration_ms, outcome "
+            "FROM runs WHERE id = ?",
+            (trace_id,),
+        ).fetchone()
+        if row is None:
+            return None
+        span_rows = self._conn.execute(
+            "SELECT agent, event_type, latency_ms, error, reads, writes, relations, llm_calls "
+            "FROM spans WHERE run_id = ? ORDER BY id",
+            (trace_id,),
+        ).fetchall()
+        spans = [
+            AgentSpan(
+                agent=r[0],
+                event_type=r[1],
+                latency_ms=r[2],
+                error=r[3],
+                reads=[ArtifactRef(**d) for d in json.loads(r[4])],
+                writes=[ArtifactRef(**d) for d in json.loads(r[5])],
+                relations=[RelationRef(**d) for d in json.loads(r[6])],
+                llm_calls=[LLMCall(**d) for d in json.loads(r[7])],
+            )
+            for r in span_rows
+        ]
+        return RunTrace(
+            id=row[0],
+            session_id=row[1],
+            started_at=datetime.fromtimestamp(row[2], tz=UTC),
+            duration_ms=row[3],
+            outcome=row[4],
+            spans=spans,
+        )

reactifact/tracing/templates/ui.html

@@ -0,0 +1,196 @@
+<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>reactifact traces</title>
+<script>(function(){try{var s=localStorage.getItem('reactifact-theme');var d=s?s==='dark':true;document.documentElement.classList.toggle('dark',d);}catch(e){document.documentElement.classList.add('dark');}})();</script>
+<style>
+  :root{
+    --bg:#f7f7f9;--panel:#ffffff;--panel-alt:#fafafc;--border:#e6e6ee;--border-strong:#d3d3de;
+    --text:#17171f;--muted:#6f6f7e;--accent:#4f46e5;--accent-soft:#eef0ff;
+    --ok:#15803d;--err:#b91c1c;--ok-soft:#e9f7ef;--err-soft:#fdeeee;--chip:#eef0ff;--chip-text:#4338ca;
+    --hover:#f4f4f8;--shadow:0 1px 2px rgba(16,16,30,.04),0 1px 6px rgba(16,16,30,.05);
+    --mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
+  }
+  html.dark{
+    --bg:#0f1016;--panel:#171820;--panel-alt:#1d1e27;--border:#262733;--border-strong:#33344a;
+    --text:#e7e7f0;--muted:#9a9aae;--accent:#8b93ff;--accent-soft:#232448;
+    --ok:#3ecf7c;--err:#f97c7c;--ok-soft:#123522;--err-soft:#3c1718;--chip:#262a48;--chip-text:#a9b1ff;
+    --hover:#1f202b;--shadow:0 1px 2px rgba(0,0,0,.4),0 1px 8px rgba(0,0,0,.3);
+  }
+  *{box-sizing:border-box;}
+  body{margin:0;background:var(--bg);color:var(--text);font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Inter,sans-serif;font-size:14px;line-height:1.5;-webkit-font-smoothing:antialiased;}
+  header{position:sticky;top:0;z-index:10;background:var(--panel);border-bottom:1px solid var(--border);backdrop-filter:saturate(1.4) blur(6px);}
+  .header-inner{max-width:1240px;margin:0 auto;padding:0 28px;height:56px;display:flex;align-items:center;gap:14px;}
+  .logo{display:flex;align-items:center;gap:9px;color:var(--text);text-decoration:none;}
+  .logo b{font-size:15px;letter-spacing:.1px;}
+  .logo .sub{color:var(--muted);font-family:var(--mono);font-size:12px;font-weight:400;}
+  .spacer{flex:1;}
+  #theme{border:1px solid var(--border);background:var(--panel);color:var(--text);border-radius:8px;padding:5px 11px;font-size:12.5px;cursor:pointer;}
+  #theme:hover{border-color:var(--accent);color:var(--accent);}
+  main{max-width:1240px;margin:0 auto;padding:28px;}
+  .page-head{display:flex;align-items:center;gap:14px;margin-bottom:20px;}
+  .page-head h1{font-size:21px;margin:0;font-weight:650;letter-spacing:-.2px;}
+  .page-head .meta{color:var(--muted);font-size:13px;font-variant-numeric:tabular-nums;}
+  .card{background:var(--panel);border:1px solid var(--border);border-radius:12px;box-shadow:var(--shadow);}
+  .toolbar{display:flex;align-items:end;gap:14px;padding:16px 18px;border-bottom:1px solid var(--border);flex-wrap:wrap;}
+  .field{display:flex;flex-direction:column;gap:5px;}
+  .field label{font-size:11px;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.5px;}
+  .pills{display:flex;gap:5px;flex-wrap:wrap;}
+  .pill{border:1px solid var(--border);background:var(--panel);color:var(--muted);border-radius:20px;padding:4px 12px;font-size:12.5px;cursor:pointer;}
+  .pill.active{background:var(--accent-soft);color:var(--accent);border-color:var(--accent);}
+  .toolbar input,.toolbar select{border:1px solid var(--border);background:var(--panel);color:var(--text);border-radius:8px;padding:6px 10px;font-size:13px;font-family:inherit;}
+  .btn{border:1px solid var(--border);background:var(--panel);color:var(--muted);border-radius:8px;padding:6px 12px;font-size:13px;cursor:pointer;}
+  .btn:hover{border-color:var(--accent);color:var(--accent);}
+  table{width:100%;border-collapse:collapse;}
+  thead th{text-align:left;font-size:11px;font-weight:600;letter-spacing:.6px;text-transform:uppercase;color:var(--muted);padding:10px 14px;border-bottom:1px solid var(--border);background:var(--panel);}
+  tbody td{padding:11px 14px;border-bottom:1px solid var(--border);font-size:13px;vertical-align:middle;}
+  tbody tr:last-child td{border-bottom:none;}
+  tbody tr.row{cursor:pointer;}
+  tbody tr.row:hover td{background:var(--hover);}
+  .status{display:inline-flex;align-items:center;gap:7px;font-weight:600;font-size:12.5px;}
+  .dot{width:8px;height:8px;border-radius:50%;flex:none;}
+  .dot.ok{background:var(--ok);} .dot.err{background:var(--err);} .dot.amber{background:#d97706;}
+  .status.ok{color:var(--ok);} .status.err{color:var(--err);} .status.amber{color:#d97706;}
+  .mono{font-family:var(--mono);} .num{font-variant-numeric:tabular-nums;color:var(--muted);}
+  .run-id{font-weight:600;color:var(--accent);font-family:var(--mono);}
+  .empty{padding:48px 20px;text-align:center;color:var(--muted);}
+  .empty .big{font-size:26px;display:block;margin-bottom:8px;}
+  .pager{display:flex;align-items:center;gap:12px;padding:12px 16px;border-top:1px solid var(--border);color:var(--muted);font-size:12.5px;}
+  .pager button{border:1px solid var(--border);background:var(--panel);color:var(--text);border-radius:8px;padding:5px 12px;cursor:pointer;font-size:12.5px;font-family:inherit;}
+  .pager button:hover:not(:disabled){border-color:var(--accent);color:var(--accent);}
+  .pager button:disabled{opacity:.4;cursor:default;}
+  .pager .pageinfo{font-variant-numeric:tabular-nums;}
+  .pager select{border:1px solid var(--border);background:var(--panel);color:var(--text);border-radius:8px;padding:5px 8px;font-size:12.5px;font-family:inherit;}
+  .poll{font-size:12px;color:var(--muted);}
+</style>
+</head>
+<body>
+<header>
+  <div class="header-inner">
+    <a class="logo" href="/traces">
+      <svg width="22" height="22" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+        <circle cx="5" cy="12" r="2.6" fill="currentColor"/>
+        <circle cx="19" cy="5" r="2.6" fill="currentColor"/>
+        <circle cx="19" cy="19" r="2.6" fill="currentColor"/>
+        <path d="M7.4 11 16.6 6M7.4 13l9.2 5" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+      </svg>
+      <b>reactifact <span style="color:var(--accent)">traces</span></b>
+      <span class="sub">artifact run observer</span>
+    </a>
+    <div class="spacer"></div>
+    <span class="poll" id="poll"></span>
+    <button id="theme" title="toggle dark mode">dark</button>
+  </div>
+</header>
+<main>
+  <div class="page-head">
+    <h1>Traces</h1>
+    <span class="meta" id="summary">loading…</span>
+  </div>
+  <div class="card">
+    <div class="toolbar">
+      <div class="field">
+        <label>outcome</label>
+        <div class="pills" id="outcome-pills">
+          <button class="pill active" data-v="">all</button>
+          <button class="pill" data-v="completed">completed</button>
+          <button class="pill" data-v="budget_runs_exceeded">budget</button>
+        </div>
+      </div>
+      <div class="field">
+        <label>session</label>
+        <input id="f-session" type="search" placeholder="search…" style="min-width:170px"/>
+      </div>
+      <div class="spacer"></div>
+      <button class="btn" id="reset">clear filters</button>
+    </div>
+    <div id="runs"></div>
+    <div class="pager">
+      <button id="prev" disabled>← prev</button>
+      <span class="pageinfo" id="pageinfo">–</span>
+      <button id="next" disabled>next →</button>
+      <div style="flex:1"></div>
+      <span>per page</span>
+      <select id="f-limit">
+        <option value="10">10</option><option value="25" selected>25</option>
+        <option value="50">50</option><option value="100">100</option>
+      </select>
+    </div>
+  </div>
+</main>
+<script>
+const state = { outcome: '', session: '', limit: 25, offset: 0, total: 0, runs: [] };
+
+function applyTheme(dark){document.documentElement.classList.toggle('dark',dark);document.getElementById('theme').textContent=dark?'light':'dark';try{localStorage.setItem('reactifact-theme',dark?'dark':'light');}catch(_){}}
+function initTheme(){let s=null;try{s=localStorage.getItem('reactifact-theme');}catch(_){}applyTheme(s?s==='dark':true);}
+document.getElementById('theme').addEventListener('click',()=>applyTheme(!document.documentElement.classList.contains('dark')));
+
+async function load(){
+  const q=new URLSearchParams({limit:state.limit,offset:state.offset});
+  if(state.outcome)q.set('outcome',state.outcome);
+  if(state.session)q.set('session_id',state.session);
+  const res=await fetch('/api/traces?'+q);
+  const data=await res.json();
+  state.runs=data.items||[]; state.total=data.total||0;
+  render();
+  document.getElementById('poll').textContent='обновлено '+new Date().toLocaleTimeString();
+}
+
+function render(){
+  const el=document.getElementById('runs');
+  document.getElementById('summary').textContent=`${state.total} trace${state.total===1?'':'s'}`;
+  if(!state.runs.length){el.innerHTML='<div class="empty"><span class="big">∅</span>Нет трейсов. Запустите прогон, чтобы увидеть спаны.</div>';updatePager();return;}
+  let html='<table><thead><tr><th>outcome</th><th>run</th><th>session</th><th style="text-align:right">duration</th><th style="text-align:right">spans</th><th style="text-align:right">created</th></tr></thead><tbody>';
+  for(const r of state.runs){
+    const cls=r.outcome==='completed'?'ok':'err';
+    html+='<tr class="row" onclick="openRun(\''+r.id+'\')">'+
+      '<td><span class="status '+cls+'"><span class="dot '+cls+'"></span>'+escapeHtml(r.outcome)+'</span></td>'+
+      '<td class="run-id" title="'+escapeHtml(r.id)+'">#'+String(r.id).slice(0,8)+'</td>'+
+      '<td>'+escapeHtml(r.session_id||'—')+'</td>'+
+      '<td class="num" style="text-align:right">'+Number(r.duration_ms).toFixed(0)+' ms</td>'+
+      '<td class="num" style="text-align:right">'+Number(r.spans)+'</td>'+
+      '<td class="num" style="text-align:right">'+fmtTime(r.started_at)+'</td></tr>';
+  }
+  el.innerHTML=html+'</tbody></table>';
+  updatePager();
+}
+
+function updatePager(){
+  const pages=Math.max(1,Math.ceil(state.total/state.limit));
+  const page=Math.floor(state.offset/state.limit)+1;
+  document.getElementById('prev').disabled=state.offset<=0;
+  document.getElementById('next').disabled=page>=pages;
+  document.getElementById('pageinfo').textContent=`${Math.min(state.total,state.offset+1)}–${Math.min(state.total,state.offset+state.limit)} of ${state.total} · page ${page}/${pages}`;
+}
+
+function openRun(id){window.location.href='/traces/'+id;}
+function fmtTime(t){
+  try{
+    const d=typeof t==='number'?new Date(t*1000):new Date(t);
+    return d.toLocaleString(undefined,{day:'2-digit',month:'2-digit',hour:'2-digit',minute:'2-digit'});
+  }catch(_){return '—';}
+}
+function escapeHtml(s){return String(s??'').replace(/[&<>"']/g,(ch)=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[ch]));}
+function debounce(fn,ms){let t;return(...a)=>{clearTimeout(t);t=setTimeout(()=>fn(...a),ms||200);};}
+
+document.getElementById('outcome-pills').addEventListener('click',(e)=>{
+  const p=e.target.closest('.pill'); if(!p)return;
+  document.querySelectorAll('#outcome-pills .pill').forEach(x=>x.classList.remove('active'));
+  p.classList.add('active'); state.outcome=p.dataset.v; state.offset=0; load();
+});
+document.getElementById('f-session').addEventListener('input',debounce((e)=>{state.session=e.target.value.trim();state.offset=0;load();}));
+document.getElementById('f-limit').addEventListener('change',(e)=>{state.limit=Number(e.target.value);state.offset=0;load();});
+document.getElementById('prev').addEventListener('click',()=>{state.offset=Math.max(0,state.offset-state.limit);load();});
+document.getElementById('next').addEventListener('click',()=>{state.offset+=state.limit;load();});
+document.getElementById('reset').addEventListener('click',()=>{
+  document.querySelectorAll('#outcome-pills .pill').forEach(x=>x.classList.toggle('active',x.dataset.v===''));
+  document.getElementById('f-session').value='';
+  state.outcome='';state.session='';state.offset=0;load();
+});
+
+initTheme(); load(); setInterval(load,3000);
+</script>
+</body>
+</html>