---
pretty_name: Postgres Incident Diagnosis Benchmark
license: mit
task_categories:
  - question-answering
  - text-classification
language:
  - en
tags:
  - postgres
  - databases
  - observability
  - sre
  - agents
  - benchmark
size_categories:
  - n<1K
---

# Postgres Incident Diagnosis Benchmark

Real telemetry from a Postgres 16 database in six states — one healthy, five
broken — paired with the ground-truth root cause of each.

The task: given the stats views, say what is wrong. Or say that nothing is.

## Why this exists

There is no standard benchmark for database incident diagnosis, so everyone
building an AI SRE tool invents their own eval. This is a small, reproducible
one with a specific property: **on four of the five faults, the obvious answer
is wrong.**

| id | what a naive answer says | actually correct |
|---|---|---|
| `missing_index` | add an index | ✅ yes |
| `plan_regression` | add an index | ❌ run `ANALYZE` — the schema is fine |
| `bloat` | the table is just large | ❌ dead tuples, autovacuum is off |
| `lock_contention` | kill the slow queries | ❌ they're victims; one holder is at fault |
| `n_plus_1` | nothing is slow, it's healthy | ❌ 1000 calls at 0.04ms each |
| `healthy_baseline` | find something anyway | ❌ the answer is "no finding" |

The healthy baseline is included deliberately: a diagnostic tool that invents
problems on a working database is worse than one that misses them.

## Baselines

Measured, not asserted. `python -m evals.baselines` reproduces this table.

| approach | score |
|---|---|
| `always_index` — always name something; for a database that's usually an index | 1/6 |
| `slow_and_big` — slowest statement over 10ms **and** a large table → missing index | 2/6 |
| deterministic detectors (reference implementation) | 6/6 |

`slow_and_big` is right twice: it names the one genuine index problem, and it
stays quiet on the healthy database. On the other four it returns **nothing at
all** — once the rig's own statements are excluded (see below), none of those
faults presents as a slow query. Stale statistics, bloat, a lock holder and an
N+1 loop are all invisible to any heuristic that ranks by duration.

## Telemetry contains application traffic only

Each scenario clears `pg_stat_statements` *after* the fault is created and
*before* the workload runs, so the injector's own work never reaches the
snapshot. Without that, `plan_regression` ships with a 9.6-second
`INSERT INTO orders … generate_series(1, 300000)` and an
`ALTER TABLE orders SET (autovacuum_enabled = false)` sitting in the statements,
which name the root cause outright and make the scenario trivial.

For the same reason the healthy record is captured *after* running the same
background traffic as every fault case — an empty `statements` list would make
`len(statements) == 0` a free correct answer.

## Labels

`expected_detector` is one of `missing_index`, `stale_stats`, `bloat`,
`lock_contention`, `n_plus_1`, or `null` for the healthy case. Six records, one
per class, so treat this as a probe rather than a training set.

## Fields

| field | description |
|---|---|
| `id` | scenario identifier |
| `title` | human-readable name |
| `expected_root_cause` | ground truth, free text |
| `expected_detector` | ground-truth label, `null` when healthy |
| `category` | `indexing`, `statistics`, `vacuum`, `locking`, `application`, `none` |
| `fix_target` | whether the fix is in the `database`, a `session`, or the `application` |
| `naive_answer` | what a pattern-matching tool would say |
| `naive_answer_correct` | whether that happens to be right |
| `telemetry.statements` | `pg_stat_statements` rows |
| `telemetry.tables` | `pg_stat_user_tables` + size + `autovacuum_enabled` |
| `telemetry.activity` | `pg_stat_activity` rows |
| `telemetry.blocking` | waiter → blocker edges from `pg_blocking_pids()` |
| `telemetry.settings` | relevant `pg_settings` values |

## Usage

```python
from datasets import load_dataset

ds = load_dataset("yashMaini/postgres-incident-diagnosis", split="train")

correct = 0
for r in ds:
    prediction = your_model(r["telemetry"])   # -> a detector name, or None
    correct += prediction == r["expected_detector"]

print(f"{correct}/{len(ds)}")
```

`telemetry` holds the raw stats rows. A useful prompt is usually
`telemetry["statements"]` plus `telemetry["tables"]`; `lock_contention` is only
solvable from `telemetry["blocking"]`, which is the point of including it.

## Reproducing

The telemetry is generated, not hand-written — each row is captured from a live
Postgres after a scripted fault injection, against a deterministic 5.2M row
dataset (`setseed(0.42)`).

```bash
git clone https://github.com/Yashmaini30/pg-reliability-agent
docker compose up -d --build
python -m evals.export_benchmark --out data/
```

The reference implementation in that repo scores **5/5 detected, 5/5 ranked
first, 0 findings on the healthy baseline** using deterministic rules and
`EXPLAIN (GENERIC_PLAN)` — no model in the detection path.

Project overview, with the findings the detectors produce for each scenario:
<https://huggingface.co/spaces/yashMaini/pg-reliability-agent>
(a static page — the clickable sandbox runs locally from the repo above).

## Caveats

- Six records. This is a sharp probe, not a broad benchmark.
- Synthetic e-commerce schema, single Postgres 16 instance.
- Absolute timings reflect the machine that generated it; the *ratios* are the
  signal, not the milliseconds.