bonito-store 0.1.0__tar.gz

bonito_store-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: bonito-store
+Version: 0.1.0
+Summary: Bonito deep DB observability store — SQLite persistence for query/plan/lock/session events (BON-002).
+Author: Carlos Cortez
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+
+# bonito-store
+
+The persistence layer of Bonito (BON-002). Stores exactly what Prometheus
+can't: **query texts, execution plans, lock events, session snapshots and
+table stats** in a single SQLite file. Receives JSON events from
+`bonito-collector` via `POST /events`.
+
+## Quickstart
+
+```bash
+uv pip install -e bonito-store
+bonito-store serve --db bonito.db   # FastAPI on :8000
+```
+
+```bash
+curl -X POST localhost:8000/events -H 'Content-Type: application/json' \
+     -d @examples/events.sample.json
+curl localhost:8000/baselines     # 7-day mean + p95 per fingerprint
+bonito-store prune                # apply retention
+```
+
+## Config
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BONITO_DB` | `bonito.db` | SQLite file path |
+| `BONITO_STORE_PORT` | `8000` | HTTP port |
+| `BONITO_RETENTION_DAYS` | `7` | Retention window (pruned in background) |
+
+## Endpoints
+
+- `POST /events` — ingest a collector snapshot (batch capped at 100 per type)
+- `POST /plans` — ingest execution plan records (stored as JSON)
+- `GET /baselines?fingerprint=...&days=7` — rolling mean + p95 per query
+- `GET /health`
+
+## Design
+
+- **Dedupe**: `query_texts` is keyed by `fingerprint` (sha256 of the minified
+  query). Same query updates stats instead of creating a new row.
+- **Baselines**: each observation is appended to `query_samples`; baselines are
+  computed on the fly over the last N days (mean + p95).
+- **Retention**: `lock_events`, `session_snapshots`, `execution_plans`,
+  `query_samples` and `table_stats` are pruned past `BONITO_RETENTION_DAYS`.
+  Identity tables (`query_texts`) keep the latest stats forever.
+- **Plans**: stored as raw JSON (`EXPLAIN` output) — never interpolated into
+  prompts without truncation (LLM token governance).

bonito_store-0.1.0/README.md

@@ -0,0 +1,47 @@
+# bonito-store
+
+The persistence layer of Bonito (BON-002). Stores exactly what Prometheus
+can't: **query texts, execution plans, lock events, session snapshots and
+table stats** in a single SQLite file. Receives JSON events from
+`bonito-collector` via `POST /events`.
+
+## Quickstart
+
+```bash
+uv pip install -e bonito-store
+bonito-store serve --db bonito.db   # FastAPI on :8000
+```
+
+```bash
+curl -X POST localhost:8000/events -H 'Content-Type: application/json' \
+     -d @examples/events.sample.json
+curl localhost:8000/baselines     # 7-day mean + p95 per fingerprint
+bonito-store prune                # apply retention
+```
+
+## Config
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BONITO_DB` | `bonito.db` | SQLite file path |
+| `BONITO_STORE_PORT` | `8000` | HTTP port |
+| `BONITO_RETENTION_DAYS` | `7` | Retention window (pruned in background) |
+
+## Endpoints
+
+- `POST /events` — ingest a collector snapshot (batch capped at 100 per type)
+- `POST /plans` — ingest execution plan records (stored as JSON)
+- `GET /baselines?fingerprint=...&days=7` — rolling mean + p95 per query
+- `GET /health`
+
+## Design
+
+- **Dedupe**: `query_texts` is keyed by `fingerprint` (sha256 of the minified
+  query). Same query updates stats instead of creating a new row.
+- **Baselines**: each observation is appended to `query_samples`; baselines are
+  computed on the fly over the last N days (mean + p95).
+- **Retention**: `lock_events`, `session_snapshots`, `execution_plans`,
+  `query_samples` and `table_stats` are pruned past `BONITO_RETENTION_DAYS`.
+  Identity tables (`query_texts`) keep the latest stats forever.
+- **Plans**: stored as raw JSON (`EXPLAIN` output) — never interpolated into
+  prompts without truncation (LLM token governance).

bonito_store-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "bonito-store"
+version = "0.1.0"
+description = "Bonito deep DB observability store — SQLite persistence for query/plan/lock/session events (BON-002)."
+authors = [{ name = "Carlos Cortez" }]
+license = { text = "Apache-2.0" }
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.110",
+    "uvicorn>=0.29",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "ruff>=0.6", "httpx>=0.27"]
+
+[project.scripts]
+bonito-store = "bonito_store.cli:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py311"
+
+[tool.ruff.lint]
+ignore = ["BLE001", "S608"]

bonito_store-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bonito_store-0.1.0/src/bonito_store/__init__.py

@@ -0,0 +1,2 @@
+"""bonito-store v0.1.0 — query/plan/lock/session event storage (BON-002)."""
+__version__ = "0.1.0"

bonito_store-0.1.0/src/bonito_store/api.py

@@ -0,0 +1,52 @@
+"""FastAPI app — POST /events receiver + baseline reads (BON-002 deliverables 2, 5)."""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+
+from .store import BATCH_LIMIT, BonitoStore
+
+
+class EventsIn(BaseModel):
+    """One collector snapshot. Optional fields match the collector payload."""
+
+    collected_at: str | None = None
+    top_queries: list[dict[str, Any]] = Field(default_factory=list)
+    locks: list[dict[str, Any]] = Field(default_factory=list)
+    sessions: list[dict[str, Any]] = Field(default_factory=list)
+    tables: list[dict[str, Any]] = Field(default_factory=list)
+    plans: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class PlansIn(BaseModel):
+    plans: list[dict[str, Any]] = Field(default_factory=list)
+
+
+def create_app(db_path: str, retention_days: int = 7) -> FastAPI:
+    store = BonitoStore(db_path, retention_days)
+
+    app = FastAPI(title="bonito-store", version="0.1.0")
+
+    @app.get("/health")
+    def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.post("/events")
+    def ingest(events: EventsIn) -> dict[str, Any]:
+        summary = store.ingest(events.model_dump(exclude_none=True))
+        return {"status": "ok", **summary}
+
+    @app.post("/plans")
+    def plans(payload: PlansIn) -> dict[str, Any]:
+        summary = store.ingest({"plans": payload.plans})
+        return {"status": "ok", **summary}
+
+    @app.get("/baselines")
+    def baselines(fingerprint: str | None = None, days: int | None = None) -> dict[str, Any]:
+        return {"baselines": store.baselines(fingerprint, days or retention_days)}
+
+    app.state.store = store
+    app.state.batch_limit = BATCH_LIMIT
+    return app

bonito_store-0.1.0/src/bonito_store/cli.py

@@ -0,0 +1,46 @@
+"""bonito-store CLI — serve the API or run retention pruning."""
+from __future__ import annotations
+
+import argparse
+import os
+
+import uvicorn
+
+from .api import create_app
+from .store import BonitoStore
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, str(default)))
+    except ValueError:
+        return default
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(prog="bonito-store")
+    sub = ap.add_subparsers(dest="command", required=True)
+
+    serve = sub.add_parser("serve", help="run the FastAPI receiver")
+    serve.add_argument("--host", default="0.0.0.0")
+    serve.add_argument("--port", type=int, default=_env_int("BONITO_STORE_PORT", 8000))
+    serve.add_argument("--db", default=os.environ.get("BONITO_DB", "bonito.db"))
+    serve.add_argument(
+        "--retention-days", type=int, default=_env_int("BONITO_RETENTION_DAYS", 7)
+    )
+
+    prune = sub.add_parser("prune", help="apply retention pruning once")
+    prune.add_argument("--db", default=os.environ.get("BONITO_DB", "bonito.db"))
+    prune.add_argument("--days", type=int, default=_env_int("BONITO_RETENTION_DAYS", 7))
+
+    args = ap.parse_args()
+    if args.command == "serve":
+        app = create_app(args.db, args.retention_days)
+        uvicorn.run(app, host=args.host, port=args.port)
+    else:
+        store = BonitoStore(args.db, args.days)
+        print(store.prune(args.days))
+
+
+if __name__ == "__main__":
+    main()

bonito_store-0.1.0/src/bonito_store/normalize.py

@@ -0,0 +1,19 @@
+"""Fingerprint normalization (BON-002 deliverable 3).
+
+Same query text normalizes to the same fingerprint regardless of whitespace
+and keyword casing. If the collector already supplies a fingerprint (the
+Postgres ``queryid``), it takes precedence; this module is the fallback.
+"""
+from __future__ import annotations
+
+import hashlib
+
+
+def minify_sql(query: str) -> str:
+    """Collapse whitespace and lowercase the query text."""
+    return " ".join(query.split()).lower()
+
+
+def fingerprint_of(query: str) -> str:
+    """sha256 hex of the minified query — the dedupe key."""
+    return hashlib.sha256(minify_sql(query).encode()).hexdigest()

bonito_store-0.1.0/src/bonito_store/schema.py

@@ -0,0 +1,80 @@
+"""SQLite schema for bonito-store (BON-002 deliverable 1).
+
+Timestamps are stored as ISO-8601 UTC text so retention pruning and baselines
+are trivially comparable.
+"""
+SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS query_texts (
+    fingerprint TEXT PRIMARY KEY,
+    query_text  TEXT NOT NULL,
+    first_seen  TEXT NOT NULL,
+    last_seen   TEXT NOT NULL,
+    calls       INTEGER NOT NULL DEFAULT 0,
+    avg_ms      REAL,
+    max_ms      REAL
+);
+
+CREATE TABLE IF NOT EXISTS query_samples (
+    fingerprint TEXT NOT NULL,
+    ts          TEXT NOT NULL,
+    calls       INTEGER,
+    mean_ms     REAL,
+    rows        INTEGER,
+    PRIMARY KEY (fingerprint, ts)
+);
+CREATE INDEX IF NOT EXISTS idx_samples_ts ON query_samples (ts);
+
+CREATE TABLE IF NOT EXISTS execution_plans (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    fingerprint TEXT NOT NULL,
+    ts          TEXT NOT NULL,
+    plan_json   TEXT,
+    cost        REAL
+);
+CREATE INDEX IF NOT EXISTS idx_plans_fp_ts ON execution_plans (fingerprint, ts);
+
+CREATE TABLE IF NOT EXISTS lock_events (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts           TEXT NOT NULL,
+    db_instance  TEXT,
+    blocking_pid INTEGER,
+    blocked_pids TEXT,
+    lock_mode    TEXT,
+    duration_s   REAL
+);
+CREATE INDEX IF NOT EXISTS idx_locks_ts ON lock_events (ts);
+
+CREATE TABLE IF NOT EXISTS session_snapshots (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts             TEXT NOT NULL,
+    pid            INTEGER,
+    user           TEXT,
+    database       TEXT,
+    state          TEXT,
+    wait_event_type TEXT,
+    wait_event     TEXT,
+    query_age_s    INTEGER,
+    query          TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_ts ON session_snapshots (ts);
+
+CREATE TABLE IF NOT EXISTS table_stats (
+    fingerprint     TEXT NOT NULL,
+    ts              TEXT NOT NULL,
+    seq_scan        INTEGER,
+    idx_scan        INTEGER,
+    live_rows       INTEGER,
+    dead_rows       INTEGER,
+    bloat_pct       REAL,
+    last_autovacuum TEXT,
+    PRIMARY KEY (fingerprint, ts)
+);
+
+CREATE TABLE IF NOT EXISTS change_history (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts          TEXT NOT NULL DEFAULT (datetime('now')),
+    change_type TEXT NOT NULL,
+    entity      TEXT,
+    detail      TEXT
+);
+"""

bonito_store-0.1.0/src/bonito_store/store.py

@@ -0,0 +1,239 @@
+"""Persistence layer for bonito-store (SQLite).
+
+BON-002 deliverables 2-6: ingest (POST /events), dedupe by fingerprint,
+retention pruning and 7-day baselines.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+from .normalize import fingerprint_of
+from .schema import SCHEMA_SQL
+
+BATCH_LIMIT = 100
+PRUNE_EVERY_S = 3600  # throttle automatic retention pruning
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def iso_days_ago(days: int) -> str:
+    return (datetime.now(UTC) - timedelta(days=days)).isoformat()
+
+
+class BonitoStore:
+    """SQLite-backed event store. All writes go through fixed SQL."""
+
+    def __init__(self, db_path: str | Path, retention_days: int = 7) -> None:
+        self._path = str(db_path)
+        self.retention_days = retention_days
+        self._last_prune = 0.0
+        if self._path != ":memory:":
+            Path(self._path).parent.mkdir(parents=True, exist_ok=True)
+        with self._conn() as conn:
+            conn.executescript(SCHEMA_SQL)
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    # ── ingest (deliverable 2) ─────────────────────────────────────────
+    def ingest(self, events: dict[str, Any]) -> dict[str, int]:
+        """Persist one collector snapshot. Batch capped at BATCH_LIMIT/type."""
+        now = events.get("collected_at") or _now()
+        summary = {
+            "top_queries": 0,
+            "locks": 0,
+            "sessions": 0,
+            "tables": 0,
+            "plans": 0,
+            "new_fingerprints": 0,
+        }
+        with self._conn() as conn:
+            for q in events.get("top_queries", [])[:BATCH_LIMIT]:
+                self._upsert_query(conn, q, now, summary)
+            for lock in events.get("locks", [])[:BATCH_LIMIT]:
+                self._insert_lock(conn, lock, now)
+                summary["locks"] += 1
+            for sess in events.get("sessions", [])[:BATCH_LIMIT]:
+                self._insert_session(conn, sess, now)
+                summary["sessions"] += 1
+            for t in events.get("tables", [])[:BATCH_LIMIT]:
+                self._insert_table(conn, t, now)
+                summary["tables"] += 1
+            for p in events.get("plans", [])[:BATCH_LIMIT]:
+                self._insert_plan(conn, p, now)
+                summary["plans"] += 1
+        self._maybe_prune()
+        return summary
+
+    def _upsert_query(
+        self,
+        conn: sqlite3.Connection,
+        q: dict[str, Any],
+        now: str,
+        summary: dict[str, int],
+    ) -> None:
+        fingerprint = q.get("fingerprint") or fingerprint_of(q.get("query", ""))
+        query_text = (q.get("query") or "")[:4000]
+        calls = q.get("calls", 0)
+        if conn.execute(
+            "SELECT 1 FROM query_texts WHERE fingerprint = ?", (fingerprint,)
+        ).fetchone() is None:
+            conn.execute(
+                "INSERT INTO query_texts "
+                "(fingerprint, query_text, first_seen, last_seen, calls, avg_ms, max_ms) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (fingerprint, query_text, now, now, calls, q.get("mean_ms"), q.get("max_ms")),
+            )
+            conn.execute(
+                "INSERT INTO change_history (change_type, entity, detail) "
+                "VALUES ('fingerprint_new', ?, ?)",
+                (fingerprint, query_text[:200]),
+            )
+            summary["new_fingerprints"] += 1
+        else:
+            conn.execute(
+                "UPDATE query_texts SET last_seen = ?, calls = ?, avg_ms = ?, max_ms = ? "
+                "WHERE fingerprint = ?",
+                (now, calls, q.get("mean_ms"), q.get("max_ms"), fingerprint),
+            )
+        conn.execute(
+            "INSERT OR REPLACE INTO query_samples (fingerprint, ts, calls, mean_ms, rows) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (fingerprint, now, calls, q.get("mean_ms"), q.get("rows")),
+        )
+        summary["top_queries"] += 1
+
+    def _insert_lock(self, conn: sqlite3.Connection, lock: dict[str, Any], now: str) -> None:
+        conn.execute(
+            "INSERT INTO lock_events "
+            "(ts, db_instance, blocking_pid, blocked_pids, lock_mode, duration_s) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (
+                now,
+                lock.get("database"),
+                lock.get("blocking_pid"),
+                json.dumps([lock["blocked_pid"]]) if lock.get("blocked_pid") else None,
+                lock.get("lock_mode") or lock.get("wait_event"),
+                lock.get("duration_s"),
+            ),
+        )
+
+    def _insert_session(
+        self, conn: sqlite3.Connection, sess: dict[str, Any], now: str
+    ) -> None:
+        conn.execute(
+            "INSERT INTO session_snapshots "
+            "(ts, pid, user, database, state, wait_event_type, wait_event, query_age_s, query) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                now,
+                sess.get("pid"),
+                sess.get("user"),
+                sess.get("database"),
+                sess.get("state"),
+                sess.get("wait_event_type"),
+                sess.get("wait_event"),
+                sess.get("query_age_s"),
+                (sess.get("query") or "")[:2000],
+            ),
+        )
+
+    def _insert_table(self, conn: sqlite3.Connection, t: dict[str, Any], now: str) -> None:
+        conn.execute(
+            "INSERT OR REPLACE INTO table_stats "
+            "(fingerprint, ts, seq_scan, idx_scan, live_rows, dead_rows, bloat_pct, last_autovacuum) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                f"{t.get('schema')}.{t.get('table')}",
+                now,
+                t.get("seq_scan"),
+                t.get("idx_scan"),
+                t.get("live_rows"),
+                t.get("dead_rows"),
+                t.get("bloat_pct"),
+                t.get("last_autovacuum"),
+            ),
+        )
+
+    def _insert_plan(self, conn: sqlite3.Connection, p: dict[str, Any], now: str) -> None:
+        plan = p.get("plan")
+        conn.execute(
+            "INSERT INTO execution_plans (fingerprint, ts, plan_json, cost) "
+            "VALUES (?, ?, ?, ?)",
+            (
+                p.get("fingerprint") or fingerprint_of(p.get("query", "")),
+                now,
+                json.dumps(plan) if plan is not None else None,
+                p.get("cost"),
+            ),
+        )
+
+    # ── baselines (deliverable 5) ──────────────────────────────────────
+    def baselines(
+        self, fingerprint: str | None = None, days: int | None = None
+    ) -> list[dict[str, Any]]:
+        """7-day rolling mean + p95 per fingerprint, computed from samples."""
+        days = days or self.retention_days
+        where = "WHERE ts >= ?"
+        params: list[Any] = [iso_days_ago(days)]
+        if fingerprint:
+            where += " AND fingerprint = ?"
+            params.append(fingerprint)
+        with self._conn() as conn:
+            rows = conn.execute(
+                f"SELECT fingerprint, mean_ms FROM query_samples {where} ORDER BY fingerprint",
+                params,
+            ).fetchall()
+        grouped: dict[str, list[float]] = {}
+        for r in rows:
+            if r["mean_ms"] is not None:
+                grouped.setdefault(r["fingerprint"], []).append(float(r["mean_ms"]))
+        out: list[dict[str, Any]] = []
+        for fp, vals in grouped.items():
+            vals.sort()
+            p95 = vals[int(0.95 * (len(vals) - 1))]
+            out.append(
+                {
+                    "fingerprint": fp,
+                    "samples": len(vals),
+                    "mean_ms": round(sum(vals) / len(vals), 2),
+                    "p95_ms": round(p95, 2),
+                }
+            )
+        return out
+
+    # ── retention pruning (deliverable 4) ──────────────────────────────
+    def prune(self, days: int | None = None) -> dict[str, int]:
+        days = days or self.retention_days
+        cutoff = iso_days_ago(days)
+        removed: dict[str, int] = {}
+        with self._conn() as conn:
+            for table in (
+                "query_samples",
+                "execution_plans",
+                "lock_events",
+                "session_snapshots",
+                "table_stats",
+            ):
+                cur = conn.execute(f"DELETE FROM {table} WHERE ts < ?", (cutoff,))
+                removed[table] = cur.rowcount
+            conn.execute(
+                "INSERT INTO change_history (change_type, entity, detail) "
+                "VALUES ('retention_prune', 'all', ?)",
+                (f"pruned older than {cutoff}",),
+            )
+        self._last_prune = time.time()
+        return removed
+
+    def _maybe_prune(self) -> None:
+        if time.time() - self._last_prune > PRUNE_EVERY_S:
+            self.prune()

bonito_store-0.1.0/src/bonito_store.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: bonito-store
+Version: 0.1.0
+Summary: Bonito deep DB observability store — SQLite persistence for query/plan/lock/session events (BON-002).
+Author: Carlos Cortez
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+
+# bonito-store
+
+The persistence layer of Bonito (BON-002). Stores exactly what Prometheus
+can't: **query texts, execution plans, lock events, session snapshots and
+table stats** in a single SQLite file. Receives JSON events from
+`bonito-collector` via `POST /events`.
+
+## Quickstart
+
+```bash
+uv pip install -e bonito-store
+bonito-store serve --db bonito.db   # FastAPI on :8000
+```
+
+```bash
+curl -X POST localhost:8000/events -H 'Content-Type: application/json' \
+     -d @examples/events.sample.json
+curl localhost:8000/baselines     # 7-day mean + p95 per fingerprint
+bonito-store prune                # apply retention
+```
+
+## Config
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BONITO_DB` | `bonito.db` | SQLite file path |
+| `BONITO_STORE_PORT` | `8000` | HTTP port |
+| `BONITO_RETENTION_DAYS` | `7` | Retention window (pruned in background) |
+
+## Endpoints
+
+- `POST /events` — ingest a collector snapshot (batch capped at 100 per type)
+- `POST /plans` — ingest execution plan records (stored as JSON)
+- `GET /baselines?fingerprint=...&days=7` — rolling mean + p95 per query
+- `GET /health`
+
+## Design
+
+- **Dedupe**: `query_texts` is keyed by `fingerprint` (sha256 of the minified
+  query). Same query updates stats instead of creating a new row.
+- **Baselines**: each observation is appended to `query_samples`; baselines are
+  computed on the fly over the last N days (mean + p95).
+- **Retention**: `lock_events`, `session_snapshots`, `execution_plans`,
+  `query_samples` and `table_stats` are pruned past `BONITO_RETENTION_DAYS`.
+  Identity tables (`query_texts`) keep the latest stats forever.
+- **Plans**: stored as raw JSON (`EXPLAIN` output) — never interpolated into
+  prompts without truncation (LLM token governance).

bonito_store-0.1.0/src/bonito_store.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/bonito_store/__init__.py
+src/bonito_store/api.py
+src/bonito_store/cli.py
+src/bonito_store/normalize.py
+src/bonito_store/schema.py
+src/bonito_store/store.py
+src/bonito_store.egg-info/PKG-INFO
+src/bonito_store.egg-info/SOURCES.txt
+src/bonito_store.egg-info/dependency_links.txt
+src/bonito_store.egg-info/entry_points.txt
+src/bonito_store.egg-info/requires.txt
+src/bonito_store.egg-info/top_level.txt
+tests/test_store.py

bonito_store-0.1.0/src/bonito_store.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bonito_store-0.1.0/src/bonito_store.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bonito-store = bonito_store.cli:main

bonito_store-0.1.0/src/bonito_store.egg-info/requires.txt

@@ -0,0 +1,7 @@
+fastapi>=0.110
+uvicorn>=0.29
+
+[dev]
+pytest>=8.0
+ruff>=0.6
+httpx>=0.27

bonito_store-0.1.0/src/bonito_store.egg-info/top_level.txt

@@ -0,0 +1 @@
+bonito_store

bonito_store-0.1.0/tests/test_store.py

@@ -0,0 +1,170 @@
+"""Tests for bonito-store — dedupe, baselines, pruning, batch + API."""
+from fastapi.testclient import TestClient
+
+from bonito_store.api import create_app
+from bonito_store.normalize import fingerprint_of, minify_sql
+from bonito_store.store import BonitoStore
+
+
+def sample_events() -> dict:
+    return {
+        "collected_at": "2026-09-04T02:10:00+00:00",
+        "top_queries": [
+            {
+                "fingerprint": "-6842865755026457642",
+                "calls": 1284,
+                "total_ms": 15932.11,
+                "mean_ms": 12.43,
+                "max_ms": 841.02,
+                "rows": 245680,
+                "buffer_hit_ratio": 99.2,
+                "query": "SELECT * FROM orders WHERE customer_id = $1",
+            }
+        ],
+        "locks": [
+            {
+                "blocked_pid": 1412,
+                "blocked_user": "app",
+                "blocked_query": "UPDATE orders SET status='paid' WHERE id=$1",
+                "blocking_pid": 1408,
+                "blocking_user": "app",
+                "blocking_query": "SELECT ... FOR UPDATE",
+                "wait_event_type": "Lock",
+                "wait_event": "transactionid",
+            }
+        ],
+        "sessions": [
+            {
+                "pid": 1412,
+                "user": "app",
+                "database": "app",
+                "state": "active",
+                "wait_event_type": "Lock",
+                "wait_event": "transactionid",
+                "query_age_s": 42,
+                "query": "UPDATE orders SET status='paid' WHERE id=$1",
+            }
+        ],
+        "tables": [
+            {
+                "schema": "public",
+                "table": "orders",
+                "seq_scan": 1200,
+                "idx_scan": 45800,
+                "live_rows": 245680,
+                "dead_rows": 10241,
+                "bloat_pct": 4.2,
+                "last_autovacuum": "2026-09-04T00:00:00+00:00",
+            }
+        ],
+    }
+
+
+def test_minify_and_fingerprint():
+    assert (
+        minify_sql("  SELECT  *\nFROM   users WHERE id = 1 ")
+        == "select * from users where id = 1"
+    )
+    assert fingerprint_of("SELECT 1") == fingerprint_of("select 1")
+
+
+def test_ingest_dedupe_by_fingerprint(tmp_path):
+    store = BonitoStore(tmp_path / "t.db")
+    s1 = store.ingest(sample_events())
+    s2 = store.ingest(sample_events())
+    assert s1["new_fingerprints"] == 1
+    assert s2["new_fingerprints"] == 0
+    assert s1["top_queries"] == 1 and s1["locks"] == 1
+    assert s1["sessions"] == 1 and s1["tables"] == 1
+    with store._conn() as conn:
+        rows = conn.execute(
+            "SELECT calls, avg_ms FROM query_texts WHERE fingerprint = ?",
+            ("-6842865755026457642",),
+        ).fetchall()
+        assert len(rows) == 1  # dedupe: one row, stats updated
+        assert rows[0]["calls"] == 1284
+
+
+def test_fallback_fingerprint_from_query(tmp_path):
+    store = BonitoStore(tmp_path / "t.db")
+    events = sample_events()
+    del events["top_queries"][0]["fingerprint"]
+    events["top_queries"][0]["query"] = "  SELECT 1 "
+    summary = store.ingest(events)
+    assert summary["new_fingerprints"] == 1
+    assert fingerprint_of("SELECT 1") in [
+        b["fingerprint"] for b in store.baselines()
+    ]
+
+
+def test_baseline_mean_and_p95(tmp_path):
+    store = BonitoStore(tmp_path / "t.db")
+    for i in range(10):
+        events = sample_events()
+        events["collected_at"] = f"2026-09-04T02:{i:02d}:00+00:00"
+        store.ingest(events)
+    bl = store.baselines()
+    assert len(bl) == 1
+    assert bl[0]["samples"] == 10
+    assert bl[0]["mean_ms"] == 12.43
+    assert bl[0]["p95_ms"] == 12.43  # all samples equal
+
+
+def test_prune_removes_old_samples(tmp_path):
+    store = BonitoStore(tmp_path / "t.db", retention_days=1)
+    with store._conn() as conn:
+        conn.execute(
+            "INSERT INTO query_samples (fingerprint, ts, calls, mean_ms, rows) "
+            "VALUES ('old', '2000-01-01T00:00:00+00:00', 1, 5.0, 1)"
+        )
+    removed = store.prune()
+    assert removed["query_samples"] >= 1
+    with store._conn() as conn:
+        row = conn.execute(
+            "SELECT 1 FROM query_samples WHERE fingerprint = 'old'"
+        ).fetchone()
+        assert row is None
+
+
+def test_batch_capped_at_100(tmp_path):
+    store = BonitoStore(tmp_path / "t.db")
+    events = sample_events()
+    events["top_queries"] = [sample_events()["top_queries"][0]] * 150
+    summary = store.ingest(events)
+    assert summary["top_queries"] == 100  # capped by BATCH_LIMIT
+
+
+def test_api_events_and_baselines(tmp_path):
+    app = create_app(str(tmp_path / "api.db"))
+    client = TestClient(app)
+    r = client.post("/events", json=sample_events())
+    assert r.status_code == 200
+    assert r.json()["new_fingerprints"] == 1
+    bl = client.get("/baselines").json()["baselines"]
+    assert bl[0]["fingerprint"] == "-6842865755026457642"
+    assert client.get("/health").json() == {"status": "ok"}
+
+
+def test_api_plans_endpoint(tmp_path):
+    app = create_app(str(tmp_path / "plans.db"))
+    client = TestClient(app)
+    r = client.post(
+        "/plans",
+        json={
+            "plans": [
+                {
+                    "fingerprint": "abc",
+                    "plan": {"Plan": {"Node Type": "Seq Scan"}},
+                    "cost": 42.0,
+                }
+            ]
+        },
+    )
+    assert r.status_code == 200
+    assert r.json()["plans"] == 1
+    with app.state.store._conn() as conn:
+        row = conn.execute(
+            "SELECT plan_json, cost FROM execution_plans WHERE fingerprint = 'abc'"
+        ).fetchone()
+        assert row["cost"] == 42.0
+        assert "Seq Scan" in row["plan_json"]