From a4cd7eb4c38c74b8df829e2590aa46805167d3f7 Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Mon, 21 Sep 2026 13:03:44 -0400 Subject: [PATCH] CHANGELOG: third splice - fifty-five entries from sixty-six merged PRs across the #3653/#3691 waves, the Azure quad, the night queue, V137 and the post-crash repairs, spliced once Sixty-six PRs merged to dev since #3751 (the second splice, 2026-09-19T15:51Z) and by rule none touched this file. Fifty-two returned an entry to a buffer; fourteen did not, because the /tmp wipe of 2026-09-20 took their lanes with it. This is the one splice. Text-only; one file; nothing outside ## [Unreleased] and the definition block moves. Forty-four entries are verbatim from the two buffers (trailing whitespace only), recovered from session transcripts and now living on the bus rather than in /tmp. Eleven are written here from the merged PRs' own bodies in the file's voice, and say so in the pull request: the V137 rung and the Query Store clutter reader (whose buffer headers were placeholders waiting on reports that never came), the capture-mode publish, the store TOAST/checkpointer consumers, the route knob's store home, the clutter viewers, the dev-red repair, the companion-object remedy, the collector-regression band, the TimescaleDB availability re-probe, and one ref-less bullet folding the wave's four orphan census pins. Twenty-one new capabilities append to ### Added, eight designed behaviour changes to ### Changed (two pair gates, the CONFIG_CHANGED anchor, the refusal envelope's wire shape, the WAL ceiling's derivation, a story's consumed leaves, the second fleet read's lineage and the bad actor's own-normal grading), twenty-six defects to ### Fixed. Order within each section is ascending PR number, as the first two splices did. Two entries have no issue to cite and cite none, like the file's ninety-six other ref-less entries; every other citation is the ISSUE the PR closes or partially addresses, checked against the API rather than the branch name. Twenty-three definitions added at the end of the [Unreleased] run, which stays one ascending run (3517..3830). tools/changelog/changelog_archive.py verify: all PASS. Every (([#N])) resolves to a definition in the same file; no duplicate definitions; CRLF throughout (read and written as bytes); 469,093 bytes, under the render ceiling. No archive touched; the split was not run. ChangelogIndexAndArchiveTests executed locally 5/5 through a one-file net10.0 xunit harness inside this worktree, because a CHANGELOG-only change takes CI's docs fast path and that class does not run there; mutation control - deleting one definition this splice introduced reds EveryFile_ResolvesItsOwnReferencesAndRendersOnGitHub by name, and the restore is byte-identical. Client-hygiene scan over the whole [Unreleased] section: zero hits across three name families and nine structural shapes (managed-database and cloud hostnames, instance ids, account ids, resource names, addresses, instance and UNC paths). --- CHANGELOG.md | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 14425eb4a4..5c443c422b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,6 +52,27 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **PostgreSQL sessions: an operator now learns which application left a transaction open and walked away** ([#3691]) - The analysis pass said nothing about idle-in-transaction sessions beyond a share of the pool; `PG_IDLE_IN_TRANSACTION` now names the longest holder (application, role, database) from `pg_session_states`, graded on duration bars the fleet calibration measured (60 s / 10 min — zero rows reached 60 s over 7 days × 50 clusters), a band higher when it pins the xmin horizon (never on the collector's "pins nothing" sentinel), amplified when the same holder recurs, joined to the saturation story only when parked sessions are a quarter of the pool, and honest when the monitoring login cannot see state (`idle_in_transaction_unobservable = 1`). The lever is the application; both server-side backstops state that they roll the work back. - **The Long-Running Query opt-out knob was read-only on Darling — V135 gives it a store home with the production read's seeds as the column default, editable in the Viewer and through `update_alert_settings` on both SKUs** ([#3653]) - Two `text[]` columns on `config_alert_settings` default to the seeded lists, so a pre-rung store evaluates exactly what it did before and a list an operator clears stays cleared; `get_alert_settings` publishes `long_running_query.excluded_program_name_prefixes` / `excluded_logins` on Lite and Darling alike, and the viewer's connect-time probe maps a current store to V135. - **PostgreSQL blocking: the pass names the head of the chain, how long the sessions behind it really waited, and whether the log agrees** ([#3691]) - `PG_BLOCKING_CHAIN` reconstructs each capture's chains from the sampled `pg_blocking_edges` (a head is a blocker not itself blocked; cycles are counted, never attributed), names the head with the most sessions behind it and grades on the blocked side's own duration — never captures × cadence — routing to the idle-in-transaction holder or the long-running query behind it. `PG_LOCK_WAIT_EVENTS` reads the event-grain `log_lock_waits` lines (count, longest, relation) and says `log_lock_waits` is off rather than reporting zero; `PG_LONG_RUNNING_QUERY` grades client backends' own query duration; `ANOMALY_PG_BLOCKING` baselines blocked sessions per minute with `collection_log` supplying the "looked and found nothing" zeros a healthy instance never writes to the edges table, gated on peak AND mean so one mid-flight handoff cannot fire it. Every bar unmeasured and says so; `deadlock_timeout` is the one engine-defined line, stated as context. +- **A PostgreSQL table that turned autovacuum off and fell behind is its own card** ([#3691]) - v1 folded a table's `autovacuum_enabled = off` reloption into the backlog fact's metadata, so an operator saw "a backlog" and had to read the fine print to learn the engine had been told not to act. `CONFIG_PG_AUTOVACUUM_DISABLED` now names the worst such table with how far past its own trigger line it sits and for how long, whether autovacuum is also off server-wide, and the shape of the other disabled tables that met the gate; it joins the backlog's story on the same table and offers re-enable or a scheduled manual `VACUUM (ANALYZE)` with each lever's cost. A disabled table with no backlog is not a finding. +- **A collector can be enabled or disabled headlessly** ([#3752]) - `long_query_completions` ships opt-in, and opting in is what creates its Extended Events session on the monitored servers — yet the only surface that could flip it was the WPF Viewer's Collector Schedules window with the store's `admin` role, on a product whose design point is running headless. `--enable-collector [--server ]` and `--disable-collector` on the service exe build the same `enable_collector` / `disable_collector` command the store's command plane already carries and run it through the executor's own plan — one write path, no SQL of their own — then read the resulting schedule back. Documented in the CLI section. +- **Stock PostgreSQL's sampled waits read per second the sampler was watching, and get their own baseline and anomaly** ([#3691]) - The service-side sampler watches 30 s of every 300 s cycle, so the sampled wait rate over the interval understated the truth ten times and stock servers had no notion of their own waiting normal. The rate now divides by V133's `sampled_ms` (a pre-V133 row reads as its whole interval and says `sampled_ms_known = 0`; never a guessed 30 s), a `pg_sampled_wait_ms_per_sec` baseline and `ANOMALY_PG_SAMPLED_WAIT_PROFILE` detector judge the peak and the mean against the server's own hour-of-week, folding onto the dominant sampled wait's card, and when both wait tables write one window the exact source wins and the fact says so. +- **Rule 6's C# half is a census, not a stated bound** ([#3653]) - Every per-second payload key on both SKUs — an MCP tool's anonymous-object member, a fact's Metadata entry, a key written through a const — is now traced to a reader field of its own rate name, a C# quotient over a measured span, a rate helper handed the interval, or an aggregate over a rate; a stored delta passed through under the name, or a cadence literal in the divisor, is a red build naming its line. Seven keys whose provenance is another name are rostered shrink-only, each resting on an alias or model quotient the census asserts. +- **CONFIG_CHANGED covers database options and trace flags, not only sp_configure** ([#3653]) - The analysis pass read one of the store's three on-connect configuration snapshot families; a database flipped to SIMPLE recovery or a trace flag enabled in the window was a history row and no finding. The same fact now diffs all three families through the shared ConfigChangeDiff arms, runs the same ±4 h banded compare, and folds changes the same connect observed together into one card naming each in its family's words; a database option's text values ride the fact's object name and its database in the database seam. Measured on a SQL Server 2022 container: DBCC TRACEON writes msgs 17550/17551 stamped with the session's database (dropped by the default-trace collector today) and ALTER DATABASE SET leaves no ErrorLog trace event, so both new families anchor on the observation with its disclosures; log_reuse_wait_desc is excluded as a live status, not a setting. +- **Every trend surface renders the identity-epoch discontinuity marker the store already held** ([#3653]) - #3694/#3705 marked every epoch change (restart, rename, failover, stats_reset, postmaster restart) on the carrier run's collection_log note and in collector_state, and no read layer drew it: the re-baselined minute looked like the workload stepping. Eight trend tools per SKU now end with a trailing discontinuities[] ({ at, reason, detail }, empty when none), both desktop viewers draw a dashed marker line per event on the four Performance Trends charts, and the web trend panels carry the sentence as a notice; one shared helper in Collectors owns the model, the closed reason vocabulary, the two store-neutral SQL texts and the grammar's inverse (CollectorMeasurementNote.TryReadCount). Two SQL Server carriers that mark one epoch fold to one marker at the first observation; the specific reason word is derived only where collector_state still holds THIS event's pair, otherwise the marker says identity and why. +- **v3 plumbing for the PostgreSQL-target engine** ([#3691]) - The plan, kernel and memory families exist as vocabulary and inert stubs behind every shared switch (scorer, amplifiers, advice, anomaly composers, graph, collector, detector, baseline provider, tool rows), so lanes 27/28/32 fill file-disjoint partials and never touch a shared file. No operator-visible change: `analyze_server` returns the same payload; a collection caveat now counts 19 family reads. +- **PostgreSQL targets get a per-database size series and the host's memory** ([#3691]) - Darling schema 136: `collect.pg_database_size_stats` stores `pg_database_size()` per database hourly for a year (BYTES; NULL, never 0, where the role may not size a database, and the instance total goes NULL with it), and `pg_cpu_utilization` gains six byte columns from Performance Insights' `os.memory.*` counters on the same call — total, free, cached, buffers, active, and the Serverless v2 capacity × 2 GiB as configured memory. A stock PostgreSQL target has no row, which a memory consumer must read as unavailable. Nothing reads either series yet; the object-growth and memory-composition lanes are next. +- **PostgreSQL buffer-pressure cards say what the cache holds** ([#3691]) - A `PG_BUFFER_CACHE_PRESSURE` card now carries `pg_buffer_composition`: the latest `pg_buffer_usage` capture as pool fill, the ten largest resident relations, the index/heap/TOAST split, the dirty share and the cold share (relations the clock sweep evicts first), with the root fact's counts beside them, and the advice states the numbers and what they mean for sizing `shared_buffers`. No capture is a read sentence — a cadence gap, or `pg_buffercache` available / absent per `pg_extension_availability` — never an empty list. Before this the card had the miss rate and none of the composition. +- **A PostgreSQL pass now names the statement whose plan changed and what it cost** ([#3691] lane 27) - `PG_PLAN_REGRESSION` joins `pg_plan_capture`'s `plan_hash` flip to `pg_statement_stats`' stored per-call deltas split at the flip (opening plan vs closing plan), graded on the after÷before ratio behind a 50 ms per-call delta and a 20-call floor per side; `PG_PARAMETER_SENSITIVITY` names the skewed predicate column (`pg_qualstats` × `pg_column_stats.top_value_frequency`) behind a statement captured under three or more plans, an advisory card lifted to 0.6 only when the regression co-fires on the same statement; `ANOMALY_PG_PLAN_REGRESSION` baselines the server-wide per-call mean hour-of-week and folds onto the regression. Absence of a captured plan is "not slow enough to log", never "no plan"; `auto_explain` off and `pg_qualstats` absent are said as such. Every bar unmeasured (`threshold_lineage = 0`); no `CREATE INDEX` anywhere. +- **A PostgreSQL target's analysis pass measures CPU where no capacity percent exists** ([#3691] lane 28) - `PG_CPU_BURN_CORES` sums pg_stat_kcache's per-statement user+system+plan CPU into cores busy, graded only by `ANOMALY_PG_CPU_BURN` against the server's own hour-of-week routine (peak AND mean), naming the statement that burned it; `PG_CPU_DECOMPOSITION` says whether backend time was burning or waiting and becomes a finding only when the dominant side's own instrument co-fires. Where the extension is absent (every Aurora cluster today) the pass emits one honest `unavailable` fact with the reason - never a zero. Every bar unmeasured and said so. +- **PostgreSQL targets learn whether the memory configuration fits the host** ([#3691]) - The engine had no line between "what the config could allocate" and "what the box has". CONFIG_PG_MEMORY_OVERCOMMIT now sums shared_buffers + max_connections × work_mem × (1 + parallel workers) + autovacuum workers × maintenance_work_mem + wal_buffers against the window's smallest memory_total_bytes (Serverless scales), an advisory at 0.4 lifted only when host-memory pressure or temp spills co-fire; PG_HOST_MEMORY_PRESSURE grades the OS's sustained reclaimable share; a stock target reads "unavailable", never a guessed ratio. +- **A baseline series can be scoped to one statement** ([#3691]) - the hour-of-week baseline provider keyed a series on (server, metric) only, so a PostgreSQL bad actor could only be judged against the whole server's habit. `GetBaselineAsync` gains a keyed overload (server, metric, key) with a third resolve seam and a `$7` bind after the local-clock parameters, and the PostgreSQL provider declares per-queryid arms for a statement's share of the collection's execution time and its per-call mean. No operator-visible change yet — the seam the statement-scoped baselines (lane 34) stand on; the SQL Server pass is byte-identical. +- **A PostgreSQL operator now learns which large relation a statement reads sequentially under a selective predicate, how often, and what an index would cost** ([#3691] lane 30) - `PG_SEQ_SCAN_ADVISORY` walks the window's captured `auto_explain` plans for Seq Scan nodes with a Filter, joins each (statement, relation) pair to `pg_qualstats`' sampled selectivity and `pg_table_bloat_stats`' heap size, and grades 0.5 only when the predicate is selective (≥ 90 % filtered), the relation large (≥ 256 MiB) and the scan recurring (≥ 3 captures per observed hour — a lower bound under `auto_explain.log_min_duration`); lifted to 0.65 when the scanning statement is the window's bad actor or its plan regressed. The advice states the evidence first and names a candidate index only where pg_qualstats named the columns and every gate holds, with its write/storage cost, the "a new index can cause regressions elsewhere — test it" caveat, and its impact labelled an estimate. All bars unmeasured, `threshold_lineage = 0`. +- **Darling V137 / Lite v64: eight nullable columns so the store can say what Query Store captures, where a lone finding goes, and how full the plan dimension's TOAST file is** ([#3796], [#3712], [#3783]) - One rung on three tables that already exist, no new table and no new hypertable (the count stays 72). `query_store_health` gains `query_capture_mode` and `wait_stats_capture_mode` in the DMV's own `*_desc` spellings, with the collector's first per-column version gate behind them — on a 2016 engine a body naming the wait-stats column fails to COMPILE for the whole database, no row at all rather than one NULL cell, so the SELECT carries it only where the engine has it and the stored NULL means "the engine predates the option", never `OFF`. `config_alert_settings` gains `analysis_uncorroborated_route`, a nullable tri-state where every numeric knob on that row ships a default, because NULL is "not set in the store — the file-level knob or its shipped `digest` governs", which is what every store reads the morning after the upgrade; it carries a CHECK where the numeric rungs deliberately did not, since a number has a clamp and a route has none — a misspelling read as "no opinion" would silently turn a decision to PAGE back into the digest. `store_metrics` gains `toast_bytes` (written from this rung on, dimension rows only) beside `toast_live_bytes` left NULL by a measurement rather than a shrug — the tuple-share proxy reads 100 % on exactly this shape where the truth is 47.9 %, and the honest instrument needs an extension the bundled image ships and does not install — and three checkpointer columns for a row the code half writes. Read by nothing here, by design, with a census holding each consumer lane to releasing its clause deliberately. +- **Nothing in the product could say which databases were cluttering Query Store, why, or what it cost the servers hosting them — while every input for that answer was already in the store** ([#3797]) - `get_query_store_clutter` composes four facts that each lived on their own surface and were never put beside each other. The fan-out rollup on `collection_log` says which database the `query_store` collector spends its time in: how often it was the run's slowest item, that item's discrete median and p95, its share of the whole pass, and this database's median cost against the pooled median of every other database on the same server. The raw rows' `plan_id` — the identity `MAX_PLANS_PER_QUERY` caps, and an index-only walk where a shape hash would fetch every heap row and collapse the parameter-sniffed recompiles that ARE this churn — says how many plans a query carries, how many were seen exactly once, and how fast new ones arrive. The newest health capture per database says what the store is configured to keep. And the `QDS_*` wait deltas with the Query Store memory clerk say what Query Store costs the instance, rated only over rows carrying a measured interval, with the restart rows and the pre-interval rows counted beside the rate rather than divided into it. Not a new query: an analysis of what was already collected. The composite is deliberately the BAND and its reason tokens rather than a number — a weighted sum of a share, a percentile and a fraction would have to invent the weights, and the first operator to ask why a database is a 7.3 could not be answered from the row — with every bar published under `thresholds` so a reader can disagree on the evidence, and rows ordered by band, then read-cost share, then plans per query. Unknown means unmeasured and never escalates. A readable secondary is excluded by architecture with the reason on the row, because its read cost and churn are its primary's. The fleet reference is opt-in, because it walks two raw hypertables fleet-wide and a default call that times out is a tool nobody uses. +- **`get_query_store_health` said "Query Store health" and skipped the one knob that names a plan-churn factory** ([#3796]) - V137 stored `query_capture_mode` and `wait_stats_capture_mode` and then nothing read them, so the tool described itself as per-database Query Store health while answering every question about the row except what the store CAPTURES, and both Query Store grids showed nine knobs of ten. Both SKUs' rows now carry the two as their TRAILING fields with the `capture_time` stamp after them, so a client that indexed the row by position still finds its ten fields where they were; both are `string?` end to end where the row's other strings coalesce an absence to the empty string, because a NULL here is an observed state — the row predates the rung, or the engine is 2016, where the wait-stats mode does not exist — and coalescing it would let a reader confuse "never asked" with a value the DMV never emits. Both desktop grids and the web tile gain `Capture Mode` and `Wait Stats Capture`, rendering the absence as the page's own em dash and never as `OFF`. The description, byte-identical on both SKUs, says what each mode costs: `ALL` captures every query the engine compiles, ad hoc one-offs included, each distinct text a new query with a new plan on the way to the cap; `AUTO` skips the insignificant ones on the engine's own thresholds; `CUSTOM` says the thresholds were tuned but not to what, since the row does not collect them; `NONE` stops capturing new queries while runtime stats keep flowing for the ones already held. No verdict on the value — that is the clutter view's arm. +- **The store could say how big its plan dimension's TOAST file was and not how full, and could not see its own checkpointer at all** ([#3783]) - The plan XML and statement text do not live in a dimension's heap, and `pg_total_relation_size` says how big that file is and nothing about how full it is, so a dimension cycling hundreds of thousands of rows a day through row-capped deletes sits at its high-water mark and the store reports the slack as size. `get_store_metrics` now publishes `toast_bytes`, `toast_live_bytes`, `toast_utilisation_pct` and a `toast_utilisation_note` on every dimension row and daily point, and the sweep writes one `checkpointer` row per run carrying the server's CUMULATIVE write-phase, sync-phase and requested-checkpoint counters (`pg_stat_checkpointer` on 17+, `pg_stat_bgwriter`'s older names below it) which the read differences into an interval whose length is measured between the two stamps rather than assumed from the cadence, with a four-state status so one row, a counter that went backwards or an absent view is SAID rather than clamped to a zero or a negative. Live bytes are NULL on the shipped store by measurement, not by shrug: the tuple-share proxy reads 100 % where the truth is 47.9 % on exactly this shape, because after a `VACUUM` the dead tuples are gone and the file keeps its pages, and the honest `file − sum(avail)` reading needs an extension the bundled image ships and does not install — a product-dependency decision — so the note names the one statement that lights the whole surface with no release, and the sweep fills the column the moment it is there, from the row's own recorded size so the quotient stays internally consistent. Nothing is ever computed from `total_bytes` or from tuple statistics. Two informational self-alerts follow, and they are conditions rather than actions: Store TOAST Slack (a dimension file over 10 GiB at a MEASURED utilisation under 50 %, dormant wherever live bytes are NULL, re-fired daily because the fact moves on a scale of days, cleared by the rebuild or by the floor) and Store Checkpointer Pressure (an observed sync phase past the read deadline the kills were measured against, or any WAL-forced checkpoint, naming the WAL-sizing and refresh-slicing levers). Neither reclaims anything, at any tier. +- **The uncorroborated-finding route knob said FILE-LEVEL, edit darling.json and restart, while the rung had already given it a store column nothing read** ([#3712]) - #3732 shipped the corroboration gate with one knob and shipped it file-level — read once at service start, refused by name on `update_alert_settings`, invisible to the Viewer, and reported only as whatever the running host had published off its file — because two rungs were in flight and the issue said so. V137 landed the column and left it written by nothing and read by nothing. One resolver now decides for every surface, and its precedence is stated: a parseable value in the store wins over the file, NULL there defers to darling.json, and a file value that is neither spelling falls to the shipped `digest`. The store wins because the operator who flips the combo or calls the write tool expects the change to take effect without a restart, a file edit on the service box, or knowing which of two places holds the losing value — and the store is the surface this product already hot-reloads, so a route written there is live within one beacon tick. The seed leaves the column NULL on purpose: seeding the file's value in would make the store win from the first start on every install, so the file could never govern again and the tri-state's third state would exist in the schema and be reachable on no store. The two config members stay distinct for the same reason — "over file" needs the file's value to still exist when the column is NULL, including the moment an operator clears it back. A value the CHECK is supposed to make impossible is ignored and logged with the value, the home that decided and the route — never obeyed. `get_alert_settings` publishes the EFFECTIVE route, never null, beside `uncorroborated_route_source` (`store` / `file` / `default`); `update_alert_settings` writes `digest` or `page` in the CHECK's canonical spelling, writes SQL NULL for an explicit JSON null (the only way back to the third state), refuses anything else naming the three accepted spellings, and warns when a whole round-tripped payload moves the decision into the store and how to move it back; and Settings → Notifications → Automated Analysis gains the tri-state combo whose third item is the service's darling.json value, with Restore Defaults landing on it rather than on `digest`. Lite has one home, keeps its checkbox, and deliberately publishes no source key it could only answer as a constant. +- **A PostgreSQL operator now learns which database is growing, how fast, and when it doubles** ([#3691] lane 38) - `PG_DATABASE_GROWTH` trends the hourly `pg_database_size_stats` series (V136) over fourteen days — never a spot size — grading the WEAKER of two ramps above an AND gate (≥ 1 GiB and ≥ 10 %; 10 GiB / 25 % critical), naming the database, the bytes, the fraction, the slope per day and a straight-line days-to-double stated as such; databases the monitoring role cannot size are counted, never read as zero growth; `ANOMALY_PG_DATABASE_GROWTH` judges the instance's growth rate against its own hour-of-week; growth chains onto a bloat trend on the same database as its first question. Disk free space is not collected and the card says so. Every bar unmeasured and says so. +- **The Query Store clutter view had no viewer and told every reader the capture mode was uncollected** ([#3797]) - The tool shipped with its config arm hard-coded to a null capture mode beside a note saying the column would land with the rung — which had already landed, is filled hourly by the shared collector and is published by `get_query_store_health` on both SKUs — so the clutter view was the last surface in the product telling an operator the mode was uncollected, and it said so inside the recommendation they would act on. The reader and the pure composition move to the shared storage project beside the other shared readers, for the reason that project exists: the web page reads the tool over HTTP and the WPF Viewer reads the store directly, and the alternative to one reader is a second copy of four statements carrying a window floor, a discrete-median definition that has to agree with `percentile_disc`, and a replica gate read off one engine bit — a copy that drifts on any of them calls a database Critical on one surface and Healthy on the other, and the copy that drifted is never the one being read. The config arm selects the column, publishes it with `capture_mode_known` as the AND over the rows so one pre-rung database makes the flag false rather than being averaged away, and publishes a NULL as never-asked and never as the engine's `NONE`, which is a mode a store can really be in; the one sentence both churn recommendations end on is written from the mode the row carries — `ALL` beside churn is the switch-to-`AUTO` case, `AUTO` points at the workload, `CUSTOM` is `AUTO` with thresholds this row does not collect, `NONE` means the churn is inside the queries already held, and anything else prints verbatim rather than being mapped onto a default — while no band moves, which is pinned so a capture mode cannot become a threshold nobody published. The web server page gains one fan-out on the Queries tab feeding three panels, its verdict cell coloured off the band the server computed with the reason tokens beside it so the colour is never the only evidence. The Viewer gains a Query Store Clutter sub-tab whose data service contains no SQL at all, every measured column bound as a nullable number with the absence rendered by the binding, because a `DataGrid` sorts on the binding's path and text columns would sort 9 above 1,234 on the one grid in the app whose purpose is to rank by magnitude — and it would look like a working sort. It takes no default sort, and that is the decision rather than the omission: the composition's arrival order IS the ranking, and the nearest single-column stand-in sorts the worst database to the bottom. A readable secondary stays in the grid on both surfaces with its exclusion and the architectural reason named, because dropping the row would leave an operator who knows the database exists unable to tell "not cluttered" from "not shown", and file the second as the first. ### Changed @@ -64,6 +85,14 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **Confidence chooses the channel** ([#3712]) - a scheduled-analysis finding now earns a page by corroboration, never by severity alone: two or more facts in its chain, a matched co-fire check on its root, or one of the two by-construction stories. A lone uncorroborated fact at or above the notify floor is persisted, visible on the web and MCP surfaces the instant it fires, recorded in the alert history as `notification_type: digest` with the gate's reason (`routing` / `routing_reason` on `get_alert_history`), marked *Not paged* in Lite's Recommendations, and named once a day in Darling's new Analysis Singles Digest - but delivered to no paging channel; the day it gains corroboration it pages as a new firing. Measured on the first day the recalibrated engine ran on a large production fleet: forty-plus anomaly pages in seven hours at confidence 0.20-0.35, mostly true and redundant. One knob, `analysis.uncorroborated_route` (`digest` default, `page` restores the old behaviour): Lite's Settings → Alerts, Darling's file-level `analysis.uncorroboratedRoute`. - **Blocking Wait Time paged on one snapshot and cleared on the next, and Long-Running Query had no way to stop reporting the same permanent background sessions forever; blocking now fires on one snapshot at 3× the bar or on 3 consecutive collections through the shared persistence gate, and long-running queries gain an opt-out knob seeded from the production read** ([#3653]) - Measured on one production store class, 97 of 102 Blocking Wait Time episodes were a single snapshot, so a plain consecutive gate would have dropped exactly the severe pile-ups; the fire names which arm admitted it (`single_snapshot_3x` / `consecutive_k3`), a quiet collector cycle starts a new episode, and a stale snapshot still clears. The Long-Running Query knob is two editable lists — program-name PREFIXES seeded with `SQLAgent - TSQL JobStep` and exact logins seeded with the two `NT AUTHORITY` service accounts, the classes a 7-day read of one large production store showed to be permanent background; the application's admin login is deliberately not excluded and named humans never are — applied inside the read ahead of the row cap, with the card counting the sessions each list removed. Darling's store column and both SKUs' `get_alert_settings` twins follow as rung V135. - **PostgreSQL saturation now tells queueing from load** ([#3691]) - the connection-saturation finding is amplified when the session-count anomaly fired against the server's own hour-of-week baseline while the transaction-rate anomaly did not — more connections than this hour usually carries, doing no more work — and says so in the advice with the measured multiple. The parked raw TPS-trend co-fire is retired: the fleet calibration showed routine 20–50× in-window TPS bursts on every cluster, so that trend was noise. +- **A story's root card now names the leaves it consumed** ([#3691]) - When the greedy traversal walked a higher-severity root down to a leaf that named something — the application parked in a transaction, the lead-blocker session, the Agent job — the leaf rooted no card and its name reached no surface: the exit check's grep for the holder over `analyze_server` found nothing. The engine now records the identity-bearing hops on the story (highest severity first, at most three) and the root's investigation gains one "Behind it:" sentence per hop, on both engines; chains that name nothing are byte-identical. +- **The wait-profile anomaly judges the window peak AND the window mean** ([#3741]) - The last baseline detector still firing on the window peak alone goes through the shared pair gate #3724 gave the others: the all-types wait rate's window mean must clear the same heavy-tail 5.0 robust cutoff beside the peak, so one hot collection in a quiet window no longer reads as a profile shift. The no-baseline fallback keeps its peak-only absolute bar; the story now names both rates. +- **CONFIG_CHANGED now anchors on when RECONFIGURE ran, not when the snapshot first noticed** ([#3740]) - The finding's ±4 h compare anchors on the default trace's sp_configure line (msg 15457) when the store holds one for the changed option, the prose says "changed at … (default trace)" and the fact records which clock it used; with no matching line the observation anchor and its disclosures stand unchanged. The collector had been dropping that line before storage whenever sp_configure ran from master or an excluded database (the trace stamps the session's database context); it is now kept outside every database predicate, while the config-change event classes stay dropped and the snapshot diff stays the source of what changed. +- **MCP refusals carry a status word: the invalid envelope on both SKUs, and PostgreSQL refusals answer 400 not 500** ([#3739]) - Every validation bail — an unresolvable server, an hours_back or limit the tool cannot honor, a missing required parameter — now answers {"status":"invalid","message":…,"hints":{"parameter":…}} instead of a bare sentence, built once in the validators and resolvers. The web read surface passes it through as a 400 exactly as the mute-rule routes always did; nine PostgreSQL refusals that borrowed the error word stop answering 500. Wire change for MCP clients and the frozen Dashboard. +- **PostgreSQL wait standouts, the I/O admission floor and the ratio multiple carry the second fleet read's lineage** ([#3691]) - The 2026-09-20 calibration (50 Aurora PostgreSQL clusters) read per event, per quarter-hour and per hour-of-week ratio what the 2026-09-19 read could not: `WaitStandoutConcerning`/`Critical` (0.15/1.0 ≈ p99.6/p99.99 of non-IO event buckets), `IoBaselineBucketMinimumReads` (250; 57 % of fleet buckets under it, hour-of-DAY tier for half the fleet stated) and `PgRatioAnomalyThreshold` (3.0; well placed for TPS, routine alone for the wait rate where the floor and peak-AND-mean gate decide, unplaced for deadlocks) now say *measured* with that date. Every Aurora wait fact — standouts and yielded rollups included — reads `threshold_lineage = 1`; stock sampled wait facts, the deadlock-rate and wait-profile anomalies stay 0 (sampled population 0 on the fleet; SQL Server heavy-tail cutoff by reference; chosen ramp spans), each stamp saying why. No bar value changed. +- **The managed store's WAL ceiling is derived from the data volume's headroom, not v4's fixed 4 GB on every box** ([#3802]) - The bundled store's `max_wal_size` was one constant for every install (v4's `4GB`, not PostgreSQL's 1 GB default as the issue read), so a small box risked filling its data volume with WAL while a large one checkpointed more often than its disk asked for. The v12 conf block derives `max_wal_size` from free space on the data volume (free / 8, clamped to a 1–16 GB power-of-two ladder so the heal does not churn as free disk drifts), sets `min_wal_size` to a quarter of it (80 MB floor), pins `checkpoint_completion_target = 0.9` only where PostgreSQL is older than 14 (14 made it the default), heals on every start by stamp, and logs one INFORMATION line with the derived values and the free-disk figure. An `ALTER SYSTEM` override in `postgresql.auto.conf` for any of the three is logged with the `RESET` that would lift it, never fought — PostgreSQL's precedence, the `lc_messages` precedent. +- **Stock PostgreSQL's sampled wait profile fires its first-occurrence reading on the peak alone, like its Aurora and SQL Server twins** ([#3691]) - The `pg_wait_sampling` profile detector pair-gated its `is_new` arm on the window mean as well as the peak, so a young stock server whose sampler saw a full backend-equivalent of waiting for one cycle said nothing while the same numbers on Aurora fired. By the 2026-09-20 ruling the arm now takes the twins' peak-only bar; the robust and ratio arms keep the peak-AND-mean gate. Lineage unmeasured (population 0 on the fleet), revisit when a sampled cluster exists. +- **A PostgreSQL bad actor is graded against its OWN normal** ([#3691] lane 34) - The absolute share bars (0.25 / 0.60) were routine on the measured fleet — a single statement dominating a busy hour is the normal shape of a concentrated workload — so `ANOMALY_PG_BAD_ACTOR_SHARE` now judges each top statement's window share against THAT statement's hour-of-week share bucket (the per-key baseline seam, #3810) on the peak-AND-mean gate, and walks into the `PG_BAD_ACTOR_` card it names; the card itself becomes a context band under the story line with the absolute share carried as measured-routine context. A statement at its usual 60 % is the workload; a statement at 55 % that usually takes 10 % is the story. The busy floor (measured) still admits. ### Fixed @@ -167,6 +196,32 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **`get_fleet_overview` runs its collection-health rollup once per minute per host, however many overview calls race** ([#3735]) - the 7-day per-collector health aggregate behind every fleet card is the one read in the overview that does not depend on `hours_back`, so a caller racing three calls with three windows had the store run three identical copies of it concurrently — photographed on the largest production store inside the collectors' flush band, the slowest crossing the `mcp` role's 15 s `statement_timeout` while the plan runs in 680 ms alone. Concurrent callers now share one in-flight scan and a result under 60 seconds old (the fastest collector cadence, so nothing the rollup bands can have moved) is served from memory, per host; a caller that gives up releases only itself, a failed scan is never memoized, and the payload's new trailing `collection_health_age_seconds` says how old that half of the roll-up is. The SQL, the command deadline and the server-side cap are unchanged - the cap did its job. - **`compare_analysis` sigma-bands the v2 PostgreSQL baselined metrics, and the write family has one definition of "WAL tracked"** ([#3691]) - The v2 lanes stored three more hour-of-week buckets (I/O read latency, replay lag bytes, WAL bytes per second) and their detectors judged against them, but the compare tool still banded those keys by the absolute ladder — a 16× latency move read as a ladder step in the same window its detector called 25σ. `PG_IO_READ_LATENCY_MS`, `PG_REPLICATION_LAG` and `PG_WAL_VOLUME_SHIFT` now band in their bucket's sigma (a fact that is `unavailable`, under its ops floor or holding a mean rather than the peak is withheld from sigma, never banded in the wrong unit); the checkpoint and WAL-volume reads apply the same `WalIsTracked` predicate, so a 0-not-NULL WAL series can no longer be "tracked" to one fact and "not reported" to the other. SQL Server output unchanged. - **Hour-of-week baselines key on the target's local clock, not UTC** ([#3653]) - Both SKUs keyed the hour×dow baseline on the collector's UTC `collection_time`, so one bucket pooled two local hours across a DST change and a finding's `baseline_bucket` named an hour nobody on the server keeps. The scaffold and the two event arms now key on `collection_time` shifted by the target's offset step function (from `server_properties.time_zone_id`, falling back to `utc_offset_minutes`, then UTC), the lookup uses the same numbers, and nothing keyed is stored, so existing baselines re-bucket at the next compute with no migration. +- **PostgreSQL targets key their hour-of-week baselines on their own clock** ([#3691]) - Q6 (#3749) read the target's clock from `server_properties`, a table only the SQL Server collectors write, so every PostgreSQL baseline bucket stayed UTC hour-of-week while the SQL Server side went local. The clock read is now a second seam on the baseline provider, and the PostgreSQL provider reads the `TimeZone` setting from the latest `pg_server_config` snapshot at or before the window end (session-scoped sources excluded); UTC is the fallback when no snapshot carries one, not the rule. A "Tue 09:00" bucket on a New York target is 09:00 in New York. +- **The long-query completion XE session could never be created on Azure SQL DB** ([#3753]) - `sqlserver.server_principal_name` is not an action a database-scoped session may carry, so the `CREATE` failed with error 25744 on every database, every sweep, and the collector was dead on Azure by construction. The Azure DDL is now generated from a closed list of the actions Azure rejects (`nt_username`, `server_principal_name`) and carries `sqlserver.username` in their place — the action Microsoft's own Azure profiler template substitutes — so the `server_principal_name` column is populated on Azure rather than NULL. On-prem DDL and payload are unchanged; pins assert the Azure DDL names none of the rejects. +- **database_scoped_config collected nothing on Azure SQL DB, and said so nowhere: the three-part `[db].sys.sp_executesql` it called Azure-compatible is rejected there** ([#3755]) - on a logical-server registration every enumerated database was rejected with "Reference to database and/or server name ... is not supported", the host tolerated each as a per-database skip, and the run logged SUCCESS with zero rows behind a HEALTHY row (the swallowing itself is [#3754]). The collector's Azure branch had only ever been in its database LIST. It now declares `RunsPerDatabase` on Azure SQL DB and rides the per-database connection loop both hosts already check before enumeration - the `query_store` / `plan_correction` shape - running one shared payload body bare on the connected database while on-prem, RDS and Managed Instance keep the enumeration idiom byte-for-byte in structure; the same body carries the on-prem list's system-database screen on `DB_ID()`, so master's read-only defaults stay out of the Azure row set exactly as they always have on a box. +- **A pass whose fact families could not be read says so, on both SKUs** ([#3691]) - every family read in the three fact collectors (Lite DuckDB, Darling SQL Server, Darling PostgreSQL target) degraded to "no facts" and only logged, so a pass whose reads timed out or hit a half-migrated store scored an empty list and `analyze_server` rendered the `empty` all-clear. Each failure is now recorded on the analysis context beside its log line (family, read, outcome: timeout / cancelled / missing_schema / error) and both `analyze_server` and `get_analysis_facts` carry `collection_caveats` ({families_failed, families_total, entries}) plus a "N of M fact families could not be read — the absence of findings is not evidence" sentence, emitted ONLY when a family failed so a clean pass's payload is byte-identical; the `empty` envelope also states `fact_count` and `facts_scored`. #3767 corrected the live pin to count missing families rather than reads after step 22 gave `pg_autovacuum_stats` a second vacuum read. +- **A collector run whose every item failed is no longer SUCCESS, and get_collection_health stops saying a faulted collector read and found nothing** ([#3754]) - On an Azure SQL DB logical server two collectors failed on every database every sweep and recorded `status = SUCCESS, rows_collected = 0`; the health tool banded them HEALTHY with `errors: 0` and a finding that said, in one sentence, four false things. Three mechanisms produced it — the enumerated fan-out's per-item catch handed the exception to a closure that only logged, the XE reconcile's failure never reached the run record, and the health prose inferred "read and found nothing" from the absence of a note that the swallow itself had guaranteed — and each takes the fix its sibling path already had: all-items-failed is `FAILED` with the first error carried, some-failed carries the partial note (#2623's shape), and the "found nothing" sentence is gated on zero recorded errors. The two Azure platform gaps underneath are #3753 and #3755, fixed separately; the collectors' SQL is untouched here. +- **The PostgreSQL Long-Running Query twin honours the program/login opt-out knob** ([#3743]) - Since #3734/#3736 the knob was visible, editable and read back on a PostgreSQL target and did nothing there, so a permanent ETL or replication worker under a service role filled the page every sweep. The twin now applies the same knob through the shared predicate builder over `application_name`/`usename` (prefix / exact, case-insensitive, escaped), ahead of the row cap, and renders the excluded-by-arm counts on the card exactly as the SQL Server twin does. The SQL Server seeds match nothing on PostgreSQL by construction; PostgreSQL-specific seeds are a production read, not a guess. +- **The materialization hole scan reports on every start** ([#3756]) - The scan wrote a summary only when it had repaired, deferred or failed something, so a start that found nothing left the same silence as a start that never reached it. The worker now writes one unconditional INFORMATION line per start with the pass's full tally (aggregates walked, holes and buckets found before the cap, repaired, deferred, still-reading, isolated failures, elapsed), a distinct line when shutdown cancels the scan, and the pass itself no longer writes a summary of its own. +- **The Long-Running Query alert applies `excludedDatabases` ahead of the row cap on both SQL Server SKUs** ([#3742]) - Both reads dropped excluded databases' rows client-side AFTER `LIMIT`, so an excluded database whose sessions were the longest consumed the page and the alert came back short or empty while matches existed. The list is now the read's third pre-cap flag beside the opt-out knob's two, the card carries an `Excluded By Database` receipt when the list is set, and the two adapters' post-read filters are gone. The PostgreSQL-target read follows separately. +- **The CPU alert gate identifies a sample by equality, not order, and keys on the stored UTC instant** ([#3744]) - The persistence gate counted a sample as fresh only when its stamp was strictly greater than the last one, fed the target's local clock, so every autumn fall-back left CPU alerting blind for the repeated hour on non-UTC servers, and #3730 had to leave the gate on the local stamp to avoid the same freeze at the V134 upgrade. A different instant is now a different sample whichever clock stamped it; both SKUs' latest-CPU reads hand the gate sample_time_utc where the row has one, and the frame switch costs at most one extra count of one sample per server, once. +- **query_store_health collects per database on Azure SQL DB** ([#3764]) - The collector fanned out through EXECUTE [db].sys.sp_executesql, which Azure SQL DB rejects for every database that is not the connection's own, so logical-server registrations stored nothing while reading HEALTHY and the READ_ONLY cap-hit transition the collector exists for was never observed there. It now takes the host's per-database connection loop on Azure (the #3760 shape), one payload body serves both paths, and the Azure enumerator set is pinned empty. +- **The PostgreSQL Long-Running Query read applies `excludedDatabases` in the read, ahead of the row cap, and the Aurora wait-profile detector gates on peak AND mean** ([#3742], [#3691]) - The PostgreSQL twin dropped excluded databases in C# after `LIMIT`, so a reporting database's ETL could fill the page and the alert came back short or empty while real long-running sessions existed; the list is now the `candidates` CTE's third flag through the shared builder's five-argument overload, counted on the card as `Excluded By Database` beside the knob's counts. The Aurora `ANOMALY_PG_WAIT_PROFILE` detector took #3773's shared peak-AND-mean gate, so one hot five-minute delta in a quiet window no longer reads as a profile shift; `mean_ms_per_sec` / `mean_modified_z` ride beside the peak. No bar values changed. +- **PostgreSQL connection saturation now divides the real population by the ceiling** ([#3691]) - `PG_CONNECTION_SATURATION` read its peak off `pg_session_states`, an exception table — high on servers that capture often, blind on ones that never do. The numerator is now `pg_stat_database.numbackends` (V133), summed over databases at one minute and peaked over the window, with the capture peak as the stated fallback on stores that lack the column; the fact carries both readings and which one decided, the advice names the instrument, and the 0.8 / 0.9 bars stand (measured 2026-09-20: numbackends/ceiling p99 median 1.8 %, fleet max 10.0 %). +- **The rollup-routed daily calendar prints NULL, not 0, for a day the tier never materialized, and names it** ([#3653]) - A day at or below a server's rollup ceiling with no rollup row fell out of the queries LEFT JOIN and COALESCE printed unique_queries = 0 beside that day's real wait, CPU and deadlock numbers — the same 0 a measured-quiet day prints. The routed CTE now asks the hole scan's own two questions per day (no rollup row AND the aggregate's source holds admitted rows), emits NULL for such a day, and get_daily_summary / get_daily_summary_range carry unique_queries: null plus a trailing days_missing[]; the desktop and web calendars print "not materialized at this tier" and the band, which never read the count, does not move. Darling only — Lite has no rollup tier. +- **The CPU collector's watermark and dedup key on the UTC twin where the store has it, with the frame stated** ([#3778]) - The ring-buffer read deduplicated against MAX(sample_time), the target's LOCAL clock, so from the autumn fall-back every sample for the repeated hour read as already collected and no cpu_utilization_stats row landed for ~1 h on every non-UTC server once a year — the collector half of #3744's blind hour. Definitions may now declare a UTC watermark twin; both hosts read the pair in one statement and hand the collector the twin's maximum with its frame when any row carries it, else the local maximum, and the dedup compares the row in the watermark's frame. The first post-upgrade run is local-to-local exactly as before (zero duplicates, zero extra drops), every run after it is UTC-to-UTC; Azure SQL DB's server-side arm is pinned unchanged. +- **A quiet PostgreSQL pool is graded from numbackends alone, and the Aurora wait-profile advice names the window mean** ([#3691]) - A window with no session capture emitted no connection-saturation fact even at 96% of its usable ceiling; now, where pg_stat_database.numbackends covers the window, the card is emitted as a level-only card that says its state, application and idle-in-transaction shares are unobserved (no capture-derived keys, so the parked-share amplifier, the idle edge and compare banding read "not measured", not 0), while a window with a capture is byte-identical. The Aurora wait-profile advice now states the window's mean rate against its routine beside the peak, so one hot collection is no longer read as the whole window's number. +- **The trend family's window floor is `window_truncated`, not the page dialect's `truncated`** ([#3653]) - get_query_trend, the three duration-trend tools and get_query_store_top published "the store did not hold the whole requested window" under the same key twenty paged tools use for "your limit bit", two facts with opposite remedies — no limit changes the window floor. The flag is now window_truncated beside effective_start / effective_hours_back on both SKUs; every consumer (the web query-trend notice, nine tool descriptions, nine instructions rows, five web catalog rows) follows, each description states the wire change, and the payload census fails a bare truncated beside effective_hours_back on either SKU so the homonym cannot return. The C# members keep their names; the page cut keeps truncated. +- **Item 17's three unpinned description fixes get their pins: get_ag_health names its reader's traps, the catalogue's duration-trend line says rates not percentiles, and the server page reads every stamped tool by captured_at** ([#3653]) - The six A15/A16 drifts the item still listed were already delivered by #3665, #3696 and #3697; three of the fixed texts had nothing holding them. `DarlingMcpAgToolsSurfaceTests` anchors on `DarlingAgReader`'s own trap paragraphs and holds the description and instructions to both; `DarlingMcpTrendToolsSurfaceAndSqlTests` holds the web catalogue line to the two rates `SerializeTrend` publishes and refuses "percentile" anywhere in the catalogue unless negated; `ServerPageTabsTests` derives the Stamped roster from the stamp census and refuses a `collection_time` descriptor against any of them, tile or column. Pins only — no wire change. +- **Four census pins the V137 wave outran** - The rung shipped with a "no product source names any of these eight columns yet" scan so that each consumer lane would have to release its clause deliberately, and that pin's honest lifetime runs from the rung's merge to the first consumer's — which was forty minutes. Three pull requests edited the one method body inside an hour, each to get a reader past it, before it was retired whole in favour of the positive ownership pins the consumer lanes already carry and which are stronger than a name scan: a census cannot tell a payload key that PROMISES a column from a read of it. Beside it, three roster repairs: the clutter lane's fence was moved off the tool file, which contains no SQL and so matched nothing, onto the reader and judgment files where a capture-mode read would actually land; the DuckDB ladder pin restated the climb the rung had just moved; and the member scan's known-truncated roster followed dev's own run in both directions at once, one expression-bodied property arriving with the plan-regression lane and one leaving as the buffer-composition lane reshaped it into a block the walk reads whole. Test rosters only — no product change, and nothing a reader of the product sees. +- **The plan tools stopped saying "no CREATE INDEX text — a hint, not a design"** ([#3805]) - #3696 dropped `missing_indexes[].create_statement` from `analyze_*_plan` on both SKUs and the Dashboard citing a rule the maintainer never made. The statement is back on every row beside `impact_basis`, each row carries one fixed `caveat` (requests are weak, plan-cache-bounded evidence that corroborate a measured-slow plan and never drive a finding; any new index can regress other statements and adds write cost — test it), the descriptions say "corroboration, with caveats", and the analysis engine's MISSING_INDEX card opens with the same sentence at the Information rung, below every standing misconfiguration. +- **pg_statement_stats runs again on PostgreSQL clusters whose pg_stat_statements is below 1.9 or installed outside public** ([#3818]) - The statements-epoch read of pg_stat_statements_info was gated on the server major, which says nothing about the extension's catalog version; on an upgraded fleet it failed the whole collector with 42P01 on every cluster left at 1.8. The read is now gated on the relation's existence at query time, in the schema the extension actually lives in, and a missing companion object is recorded as the extension present below 1.9 with ALTER EXTENSION ... UPDATE as the remedy, never as the extension missing. +- **Held retention policies no longer wait for a restart: the coverage gate is re-judged on the running service's hourly store-maintenance tick** ([#3812]) - EnsureRetentionPoliciesAsync had one call site, the start path, so a backfill that worked left the policy held and the Retention Held alert firing until someone restarted. The sweep now also runs after the compression-job check on the hourly tick, failure-isolated under a five-minute budget, counts transitions (armed/re-held this pass) off the job's scheduled flag rather than verdicts, and writes one unconditional 'Retention re-evaluation: N policies held, M armed this pass, K unchanged' line every hour. The alert text, runbook, --backfill-rollups verb and README now make the restart optional. +- **The PostgreSQL engine absorbs what waves 4–5 reported back, and the stock load storm can now page** ([#3691]) - `get_pg_database_stats` surfaces `numbackends`; `get_pg_cpu_utilization` projects the six host-memory columns the composition checks read; a temp spill chains onto the memory-overcommit advisory; `ANOMALY_PG_CPU_BURN` joins the load-family confirmers, so the TPS / session-spike pair lane 36's real-stock storm measured at exactly 1.30 reaches 1.6 with kernel CPU firing beside it; the replication live test is anchored on its own `as_of`; four stale docs say what the code does. And a real defect from that storm: `PgAutovacuumStatsCollector` compared the reloption to `'false'` while PostgreSQL stores `off` (also `0`, `no`, `f`, `n`, `fal`) — `NOT option_value::boolean` now, in both places the flag is computed, so `CONFIG_PG_AUTOVACUUM_DISABLED` can fire for the docs' own spelling. +- **Two counts nothing re-derived turned dev red on three checks** - The PostgreSQL anomaly-key census asserted thirteen keys where fourteen are declared and the comment directly above the assertion enumerated all fourteen. Neither lane was wrong alone: two of them each added one key to a base of twelve and each wrote the same `Assert.Equal(13, ...)` line, so because the two lines were textually identical the three-way merge took them as ONE change, raised no conflict, and the arithmetic was never re-done — the spelled-out sibling in the same file did conflict, and was corrected. The second defect is the fleet-scoped read inventory, the prose every collection-health surface concatenates to name the reads that can put a number in the instance total and in no server's count: it promised nine reads where eleven can fail, because the plan dimension's slack read and the store checkpointer read were added and named nowhere, and an operator reading a nonzero instance total against that list would have hunted a cause the list does not contain. That half had been red for two merges and nothing reported it, because the pull request that introduced it merged while its own build check was CANCELLED rather than failing. Both counts are now re-derived from source, both new sites are named in the constant and asserted present in the recorded set, and the Darling-only tally in the mute-rule comment is recounted as well — it said four where the answer is nine. +- **The companion-object remedy told twenty-three clusters to UPDATE an extension none of them had** ([#3830]) - A 42P01 naming `pg_stat_statements_info` was recorded as a companion fault with one remedy, `ALTER EXTENSION pg_stat_statements UPDATE`, and that remedy was reached by inference: the base object resolved, therefore the extension is present, therefore it is present below 1.9. The middle step does not survive the Aurora flavor, where the object that resolved is the native statements function — not the extension's, and needing no extension at all — and the store-side read of extension availability settled what those twenty-three clusters of the measured fifty actually were: no `pg_extension` row in any database, the extension never created anywhere, the collector productive throughout. The row now ARRIVES at the fault mapping instead of being inferred: one more scalar on the statement every PostgreSQL connect already runs — no second query, no extra round trip, no grant beyond what the connect already needs — carried on the runtime with an `Observed` flag whose default is "not observed" rather than "no row", because those two readings are opposite remedies, and scoped to the database the fault came from, since `pg_extension` is per database and a per-database collector faults in databases the connect-time read never saw. Four verdicts, four sentences, each asserted as a whole string because the defect was a sentence whose clauses were individually plausible and wrong together: no row on Aurora says the create is OPTIONAL and buys the companion and nothing else; no row on vanilla asks for the create with the preload-library clause back; below 1.9 names the version read out of the catalog rather than offering it as the first of two possibilities; at or above 1.9 says no update is owed and would change nothing. A version nothing can rank keeps the old two-possibilities hedge, kept only where there is no answer to prefer over it — and the version comparison is a comparison rather than a string compare, because an ordinal compare ranks 1.10 below 1.9 and would send a fleet two releases ahead back to run an update it has already run twice, which is this defect one version further on. One tripwire pin was repaired rather than worked around on the way past: it asserted that the connected-database column ends each detection query while its own doc said what it was protecting — the readers index by number, so a column inserted AHEAD of it shifts five other fields onto the wrong values — and "last in the list" forbids appending, which cannot shift anything, while passing the insertion that can. It now parses each select list's trailing aliases and compares that ordinal against the one the reader's own body passes, with neither number written down. +- **A collector that STOPPED producing read as one that never produced** ([#3819]) - `get_collection_health` had no way to tell a regression from an optional module's resting state: one install took a PostgreSQL collector from 85 % productive to `EXTENSION_MISSING` every cycle on twenty-three of the measured fifty clusters, and every surface called it the Aurora optional-extension class — a legitimate resting state — for a full day. The band agreed, and it is worth being precise about why, because it is not the reason the issue assumes: the classifier's two skip arms are gated on the window holding zero successes, so a regressed collector's seven-day window still holds its productive days, never reaches either arm, and falls through to the staleness ladder where its last productive cycle is hours old and everything reads fine. It banded HEALTHY, not the skip status, until that success aged out of the failing cutoff — and then FAILING, which is loud and says the wrong thing: nothing is failing, something changed what the collector can read. Both per-server reads and both fleet rollups now select `last_non_skip_time` (a NULL status counts as non-skip, deliberately, so a status this build never wrote cannot manufacture a streak) and `last_productive_time`, and with the run time already there those three instants answer the question: a collector is regressed when its newest run postdates its newest non-skip and its newest productive run sits at or before that same instant. All three are plain aggregates, which is what lets the fleet rollup ask at all — a window function would put a sort of the fleet's whole seven-day log in front of a `GROUP BY` on the very statement that had to be memoized because three concurrent copies of it crossed the store role's statement timeout. The band is a FLOOR, never a re-band: WARNING where the ladder said HEALTHY, the ladder's own answer everywhere else, so a regression can only make a row louder and a row that keeps its louder band keeps the attribution that came with it. The fleet card gains `regressed_collector_count`, counted off the PREDICATE rather than the band — keyed on the band it would go quiet exactly when the regression got worse — and it overlaps `failed_collector_count` and must never be added to it. Both MCP tools publish the flag, the last productive instant, the pre-regression row count under a name that claims seven pre-regression days only where the flag is true, and one finding sentence; the three named skip statuses are enumerated from the constants that declare them into the SQL list the reads interpolate, so a rename reaches the store with nobody editing SQL. The Viewer's twin reads take the instants and the floor through the same shared classifier. A skip older than the window leaves no productive row to find and the collector reverts to its ordinary band, which is the honest answer, since at that point the read holds no evidence of a regression. +- **TimescaleDB availability was decided once, by a probe whose failures last a minute** ([#3815]) - `TryEnableAsync` had one call site, the start path, and the block around it force-cleared the availability latch in its catch. The catch is right and the fallback is right — a partially converted store works fine on DELETE-based retention, so degrading to plain-PostgreSQL mode is always safe — but the fallback was PERMANENT on a service designed to run for months, while the conditions that trigger it are minutes long: the store restarting, a failover, a lock held somewhere else, a connection that dropped once. The migrate step directly above it retries with a budget; this one never reconsidered. The flag is not "does the store have TimescaleDB", it is "did one detection attempt succeed", and six later decision points read it as if it were the first thing. The one that matters is the hourly store background-job health check, the only surface that reports a dead compression policy job, a job running past its cadence or a held retention policy — so a store running on a spuriously false latch had that backstop off AND could not say so, because the alert that would say so is behind the same gate. The re-probe now runs on the hourly store-maintenance tick, and the ordering is the whole of the fix: due-time guard, stamp, availability probe, THEN the flag gate and the reads behind it. Above the latch, because inside it the correction is unreachable in exactly the state it exists for — a false value suppresses its own correction, forever, quietly. Above the stamp, because left behind the flag a plain-PostgreSQL store's due time would never move and the probe would fire on every fifteen-second sweep pass; hoisted, it costs one statement an hour on every store shape. It takes a connection of its own, runs under one linked ten-second budget derived from the compression read's phase guard band rather than picked, and is failure-isolated with nothing rethrown into the sweep loop. This is the re-probe, not a re-probe-and-converge: conversion, compression policies, continuous aggregates and retention policies stay on the start path, because putting that sequence on a cadence is another issue's entire subject — and it is not a partial fix, because every consumer reads the flag at call time, so the flip alone restores the job health check, the chunk-drop branch of the daily purge, the per-hypertable self-metrics rows and both provider delegates on their next pass. The recovery is announced at Information naming the three checks that were off and stating that anything the last start left unbuilt stays unbuilt, so an operator is not left believing more was restored than was; the unchanged pass is Debug, and the probe hands down a null logger so a store that is genuinely plain PostgreSQL — a fully supported configuration — is not punished with a line an hour for it. ## [3.8.0] - 2026-09-17 @@ -1438,6 +1493,29 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#3710]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3710 [#3712]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3712 [#3735]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3735 +[#3739]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3739 +[#3740]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3740 +[#3741]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3741 +[#3742]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3742 +[#3743]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3743 +[#3744]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3744 +[#3752]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3752 +[#3753]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3753 +[#3754]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3754 +[#3755]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3755 +[#3756]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3756 +[#3764]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3764 +[#3778]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3778 +[#3783]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3783 +[#3796]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3796 +[#3797]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3797 +[#3802]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3802 +[#3805]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3805 +[#3812]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3812 +[#3815]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3815 +[#3818]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3818 +[#3819]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3819 +[#3830]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3830 [#3514]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3514 [#3477]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3477 [#3495]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3495