diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c443c422b..7e72697e34 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -73,6 +73,13 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **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. +- **The three report alerts carry their rows as structure as well as prose, so every surface that can render a table has one** ([#3834]) - `Collector Cost Digest`, `Fleet Sweep Rollup` and `Analysis Singles Digest` are the three alerts that carry a table's worth of content - the collector digest names thirteen (server, collector) pairs and each line holds eleven fields - and all three reached the emit path as one prose string with `context: null`. The renderers that would display that well already existed and were already wired to something else: the Viewer's `AlertDetailWindow` binds `AlertContext.Details` as Heading/Label/Value pairs and falls back to the raw string in a box roughly 45 characters across when the context is null, the Teams card renders fact sets and has split them at the ten-fact ceiling since #3442, Slack renders field sections, and `{{context_json}}` carries structure to downstream automation - so the data was tabular, the surfaces could render tables, and the only thing in between was that these three alerts did not build a context. Three pure static builders now sit beside the three renderers and project the same figures into detail items: one per (server, collector) mover for the digest plus the heaviest-collector census that is #2862's whole catch, one per band transition, watch event and would-have-paged family for the rollup under a leading item carrying the covered window and its aggregate counts, and one per top mover and one per family for the singles digest, each carrying the KEY a page would have carried, the gate's routing reason and the #1140 dedup fingerprints - which is the point of structuring that one at all, because an operator promoting a single to a drill-down needs those identifiers by name and an automation reading `{{context_json}}` was previously parsing them out of a sentence. The prose is unchanged to the byte, and that is load-bearing rather than merely polite: it states that this is a REPORT and not an incident, that nothing is degraded and nothing needs doing before morning, and it names the materiality floor and the absence of a ratio factor, none of which a field list contains - and `AlertDetailText.ProseForDelivery` suppresses an alert's prose only when it is textually EQUAL to `Flatten()` of its context (the engine alerts, whose detail text IS their flattened context), so an essay can never trip that gate and the paragraph keeps delivering on every channel exactly as it did. That is pinned rather than assumed, because had the equality fired this change would have deleted the very sentence the issue went out of its way to keep. Every cap the prose applies is applied to the rows and a cap that binds says so in the structure - the census cut, the transition and watch-event cuts and the singles cuts each append the heading-only `+N more` remainder item the paragraph prints, so a surface rendering only rows cannot read the document as complete - and none of the three populates `Incidents`, because those keys are other findings' fingerprints quoted for lookup and an incident-carrying context would enter a once-a-day report into per-event splitting and the incident delivery filter, which are paging mechanisms these documents stay outside of. That last fact retires a comment in `DarlingAlertDeliverer.DeliverAndReportAsync` that had just become false ("the digest and the rollup fire with `Context: null`"): the invariant that actually holds is Details-but-no-Incidents, and the Per-event branch is gated on incidents rather than on a context existing, so it stays unreachable for them and their disposition is still always reported, which is what #3580's delivery stamps read. +- **A baseline's dispersion floor says in words that it does not cover a dead metric, a Flat-tier fact admits its distinct-day count is a ceiling proxy, and the three copies of the stamping helper are held to one key set** ([#3859] items 1–3) - Three residue findings from #3691 lane 41, all of them contracts that read as something they are not rather than defects in shipped behaviour. `EffectiveStdDev` and `EffectiveRobustSigma` each open with a zero-activity arm returning 0 and only then consult `AbsStdDevFloor`, while both doc comments described the floor as unconditional — so an all-zero bucket on a metric that carries one (memory 4.0, CPU 5.0) reports dispersion 0, not 4.0, and every reader of those comments believed otherwise. The RULING is that the ordering is right and the prose was wrong: the floor exists to spread a LIVE metric's dispersion so a variance-collapsed baseline cannot manufacture a 25σ event out of one ordinary point of movement, not to hide a dead one, and that ordering is the only reason #3849's zero-history arm is reachable on the bounded metrics at all — a floor consulted first hands the gate a dispersion no sample ever showed and the month of measured quiet scores against a number it never produced. No behaviour moves; both comments gain the exemption and the ordering gains a pin, because making the comments true by lifting the `Math.Max` above the zero check is a one-line change that looks like a correction, reds nothing else in the suite, and silently re-gates the arm on exactly the metrics it was written to reach. The pin asserts both reads return 0 under memory's real floor (read from `AbsStdDevFloorFor`, not retyped), that the bucket still reads `IsZeroHistory`, and — the other half, so this is an exemption and not the floor abandoned — that the same floor on a bucket with real movement under it still binds at 4.0. Second, `CollapseToFlat` has always admitted in a comment that its `MAX(DistinctDays)` is a ~5 CEILING (a calendar day recurs across the 24 hour buckets so summing would double-count; each (hour, dow) bucket holds at most about five same-weekday dates in a 30-day window) chosen over a second global DISTINCT-days query — but since lane 41 that number is stamped as `baseline_distinct_days` on every z-family fact and surfaced through `get_analysis_facts`, where a comment cannot travel and an operator sees "5 days" beside a sample count with no way to tell a ceiling from a count. The Flat tier now stamps `baseline_distinct_days_is_proxy = 1` beside it in all three live `AddBaselineContext` copies, conditioned on `BaselineTier.Flat` — the same signal the existing `baseline_tier` stamp writes, and the reason the flag can be trusted, since the Full and HourOnly tiers count their own days and an unconditional flag would say nothing about any of them. No existing key moves and no value changes, so the SQL Server pass is byte-identical on every non-Flat bucket and gains one key on the Flat ones, and the `CollapseToFlat` site now names the stamp it feeds because that is where whoever replaces the proxy with a real read will be standing. Third, those three bodies are hand-maintained copies that nothing pinned: lane 41 edited all three identically and got away with it, and the next such edit is the one that lands in two — which fails silently in the direction that costs, because the payload keeps its shape for the SKU that got the stamp and a reader of the other SKU's facts cannot tell a key that was never stamped from a condition that never held. The new delegation-equality census locates each declaration on a comment-stripped copy through the shared walker, reads the body back out of the ORIGINAL text over the same offsets (the keys are string literals, which the stripped copy has blanked), and compares the SET of stamped keys rather than the body text — the Darling copies carry extra comments on purpose and text equality would red on prose. Three floors stop it passing on nothing: a minimum body length, a per-file key count against the named contract, and an assertion that the expectation itself has not been emptied; the expected set is written out rather than derived from one of the bodies, which would have made the census a tautology on whichever file it read. Verified by mutation — dropping the new stamp from `PgTargetAnomalyDetector` alone reds it by name, which is the exact drift the stamp is exposed to. Items 4–5 of #3859 (the typed story path and the side-leaf payload) are a second PR, so this one does not close the issue. +- **A summary card can name its top few objects, not only its worst** ([#3691]) — `Fact` gains a typed `Ranked` list (capped at three; the first entry IS the fact's own object, pinned) so a card stops saying "two more, 3.1× for 5 h" without saying which. Both engines' `analyze_server` root fact and `get_analysis_facts` entries carry `ranked` (object, database, value, figures) only when two or more objects ride — every other card, and the whole SQL Server pass, is byte-identical. The autovacuum-disabled card names the other disabled tables, the bloat trends name their top three instead of hiding names inside metadata keys, and the vacuum-backlog card ranks two more tables beside the worst; the three encodings those cards used are retired. `Fact` is never persisted, so no migration. +- **`get_collection_log` can be asked for the failures** ([#3869]) - the log's single most common triage question had no filter: a caller hunting failures paged the newest-first tail, which on a busy fleet covers seconds per page, so a failure twenty minutes old was unreachable by the tool that exists to show it. Both SKUs' tools gain `status`, matched case-insensitively against the log's own nine-word vocabulary (SUCCESS, SKIPPED, YIELDED, ABANDONED, ERROR, PERMISSIONS, EXTENSION_MISSING, SESSION_MISSING, WARNING), promoted to one shared roster on the collector driver so the filter, its validation and its docs cannot drift apart. An unknown value is REFUSED naming the accepted set - the sibling of #3870's unknown-argument refusal, because an equality filter on a misspelled status returns an empty page a caller reads as "no failures" - and the applied value echoes as `status_filter` since `status` on a miss is the miss word. The filter applies in SQL before the row cap, so `run_count`/`truncated` describe matching rows, and both instruction tables name the third filter beside the two that existed. +- **`get_collection_health` now says when the analysis pass could not read one of its fact families** ([#3691]) — both SKUs carry `analysis_caveats` when a recent pass failed a family read: which families, how each read failed, and "failed on 6 of the last 6 passes" — the persistence figure that tells one timeout from a family dark all night. A different layer from the collector rows beside it (which say whether data was WRITTEN): forty-three healthy collectors can sit above a family the pass timed out reading, and until now the only record was one Warning line, because the scheduled sweep builds a fresh analysis service per pass and its caveats reached no readable surface. The `analyze_now` result carries the same sentence, composed with the window-empty one rather than replacing it. The ledger behind both is process memory by design — the last 24 passes per server, never persisted (persisting it would mean writing to the store the pass just failed to read), and every block states that a restart forgets, so an absent block never reads as "every pass was clean". +- **A `pg_server_config` row now says whose setting it is** ([#3691]) — `pg_settings` is the resolved view for the collector's own backend, so a database or role that overrode `work_mem` or `statement_timeout` with `ALTER DATABASE … SET` / `ALTER ROLE … SET` was invisible, and the `CONFIG_PG_*` facts graded a value those sessions never ran with. V138 adds `database_name` and `role_name` (nullable; NULL means server-wide), the collector unions `pg_db_role_setting` onto `pg_settings`, every server-wide read excludes the overrides (ten readers, pinned by anchor so the eleventh trips it) and one selects them, and `get_pg_server_config` publishes them as `database_overrides` — present only when the cluster has any, so a pre-V138 snapshot and "no overrides" both say nothing rather than `[]`. Disk free space is struck from the line: no in-engine SQL source exists on either engine. +- **`get_object_locking` says when its snapshot was collected** ([#3880], Erik's ruling on #3878's flagged call) - #3879's fix made the read visible to the latest-anchored census for the first time (its old per-name anchor sat in a CTE the scanner ignores - the defect had hidden it), and the lane rostered it on the shrink-only exemption list with the debt-made-visible argument. Erik ruled for the better end state: both SKUs' payloads now carry the snapshot's own `collection_time` stamp, projected on the row statement rather than re-read (a second MAX could stamp the NEXT capture), the sweep takes the read through its stamped arm, the roster entry is deleted so the shrink-only census resumes shrinking, and the live rename pin asserts the stamp against a real store. ### Changed @@ -93,6 +100,15 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **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. +- **Dependencies: `Microsoft.Data.SqlClient` and `Microsoft.Data.SqlClient.Extensions.Azure` to 7.1.0, `AWSSDK.PI` and `AWSSDK.RDS` to their next patch, with every lock file the bump reaches regenerated** - the driver and its companion packages share one aligned version from 7.0.2 onward, so the Entra extension package #3838 added has to move with the core package rather than behind it; `AssemblyVersion` is unchanged across the pair, so no binding redirect follows. The lock files are regenerated by restore rather than patched textually, which is what a grouped bump needs and what the group had previously got wrong. +- **`ANOMALY_PG_PLAN_REGRESSION` judges each plan-flipped statement against its own routine** ([#3691]) - the detector now reads each plan-flipped statement's OWN hour-of-week per-call mean (the keyed series #3810 made possible) and names ONE statement on `ObjectName`, folding onto `PG_PLAN_REGRESSION` only for the SAME `queryid` through one shared predicate behind both the amplifier and the edge; the server-wide mean is retained solely as the cold fallback (`series = 0`), whose advice now says it is a pointer, not a verdict. The third fleet calibration read (2026-09-21, 50 clusters, fenced before the .453 statement-stats regression) evidenced the switch: the server-wide ratio never reached 3.0 in a week while the keyed series carries the tail. Lineage round 3 cites `ANOMALY_PG_BAD_ACTOR_SHARE`'s 3.0 and the keyed mean-ms multiple as measured (≈ p99.1 / p99.3); no bar value changed. +- **The alert pass retries a store read once before counting it failed** ([#3848]) - A read that crosses the alert pass's ten-second store deadline is now retried once, two seconds later, on a command timeout and nothing else - never on an error the store returned, and never during shutdown. The week's alert-read kills were all sparse transients inside the store's own write bands, where the next pass thirty seconds later ran into the same band still on. `get_collection_health`'s `alert_read_health` block reports `retried_reads` beside the failure counts, so a write band's cost stays a visible count instead of a blind alert. +- **Store-object convergence runs every hour, not only at start** ([#3817]) - Every store object the service builds — hypertables, compression policies, continuous aggregates and their refresh windows, the baseline relations, the composer's covering indexes — is re-ensured on the hourly store-maintenance tick from the same one list the start path walks, so a single ensure that failed at startup heals within the hour instead of lasting until someone restarts the service. Each pass writes one `Store object convergence:` line naming what it changed and what failed, even when that is nothing. The compression-enable `ALTER` is now guarded by a catalog read: measured on TimescaleDB 2.28.1, the no-op form of that statement takes an `AccessExclusiveLock` and queues every writer behind one long reader — seventy-three of them an hour at :30 would have been a lock convoy on every store. +- **The alert pass's other seven store reads retry once on a command timeout, through the same seam as the adapter's twelve** ([#3854]) - #3851 gave every read on `DarlingAlertReadAdapter` one retry two seconds after a command timeout; the seven store reads the same pass issues elsewhere - six in `DarlingSelfAlertEvaluator` (collection signals, missing capture sessions, the two agent-status reads, the two Availability-Group grains) and the worker's latest-CPU read - still ran bare, so a light read crossing ten seconds during a write band skipped a cycle unretried. The seam stays ONE truth: `ExecuteWithOneRetryAsync`'s body moves to a static overload taking the counter and the pause, the adapter's twelve forwarders and their census pin are untouched, the evaluator forwards through a private wrapper over its own `_readFailures`, and the worker calls it directly - so the discrimination (a `TimeoutException` anywhere in the chain and nothing else: never a store-returned `PostgresException`, never a pass-token cancellation, never a torn stream), the cancellation-first ordering, and the single attempt-pair count are defined once for all nineteen retried reads. Each of the seven became a thin forwarder over a `…CoreAsync` sibling holding its body byte-identical, read names promoted to constants at the catch arm's granularity so one spelling reaches both the retry and the failure count, and `AlertReadFailureCounter.FleetScopedReads`' surrounding prose now says what the seam covers. `alert_read_health.retried_reads` counts them with no payload change. Follow-up to #3848 / PR #3851. +- **The compression band seats its three heaviest hypertables on spread minutes instead of the consecutive minutes registry order gave them** ([#3678], [#3781]) - Every hypertable's hourly compression ran at the minute its registry position implied, and the three largest raw tables sit at consecutive positions, so their 550 / 360 / 200-second compressions overlapped three-wide for five minutes every hour and cancelled eleven alert reads in one such window on the largest store. A declared, measured heaviest set now takes the band's first, ninth and seventeenth minutes — widest clearance to the longest run — and every other table fills the remaining seats in registry order, three per minute; the band's width, start and minute list are unchanged, so the refresh ceiling and its margin do not move. The :35 aggregate-compression minute's coordination fact — it is also the minute readers read — is recorded on its constant, and that issue closes count-only with its re-open bar. +- **Daily continuous-aggregate refreshes run one bucket per transaction** ([#3745]) - A daily refresh policy materialized its whole three-day window in one transaction — on the largest store, eight million rows at once, enough to blow through the WAL ceiling into a forced second checkpoint and kill every read for four minutes; the 16 GB ceiling absorbed the storm class, but the checkpoint and fsync tail still scale with the burst. The daily policies now set `buckets_per_batch = 1`, which TimescaleDB runs as one transaction per bucket (measured on 2.28.1: `batch N of M` per day), and the hourly store-object convergence sets the same key on every already-deployed daily policy without touching its schedule. Hourly tiers have one bucket per window and are unchanged. +- **`audit_config` answers a PostgreSQL target with the target's own settings instead of redirecting it** ([#3691]) — the analysis pass's `CONFIG_PG_*` facts project into the same recommendations shape: `engine` stands where `edition` does, each `current_value` carries its unit as a string, and there is no `suggested_value` — the recommendation sentence carries the evidence. On Aurora, `checkpoint_timeout` and `max_wal_size` read `not_applicable` (the storage layer owns checkpointing), counted apart and excluded from the checked count. The description changed once; three doc comments that still claimed edition-aware analysis now say resource-based. The SQL Server arm is untouched. +- **The same blocking storm grades the same on every pass length** ([#3871]) - `BLOCKING_EVENTS` graded the pass window's average, so 232 blocked-process reports in one hour read CRITICAL on a 4-hour pass (58/hr) and Information on a 24-hour one (9.7/hr); the (10, 50) pair was measured on 4-HOUR windows (#3653 box (a): non-zero p99 = 59/hr, five windows ≥ 50), so it sits on the storm mode at that grain and no other. The pair stays; the value moves to its grain: all three collectors compute the busiest 4-hour sub-window inside the same statement (bucketing CTE + MAX, origin at the WINDOW START so a ≤4h window is one bucket and grades exactly what it always did - an epoch origin would split a scheduled pass and read its peak below its own average), divided by min(4, observed hours) per #3538 A2 (the frozen Dashboard, which has no observed-hours concept, divides by the nominal min(4, period hours), stated at the site). The whole-window average stays as `events_per_hour` context beside `events_per_hour_peak_4h` and `peak_4h_event_count`. The scorer's "inherited, not measured" paragraph is superseded by the measurement's lineage. Live-verified against a real store before leaving the branch: both pre-existing fixture pins hold to six decimals, the storm fixture grades past CRITICAL on the 24-hour pass, and a steady 3/hr day stays under the concern bar. Rider (fold-in): `DefaultRatioThreshold = 4.0` carries its measured lineage (3,655 windows / two store classes / 14 d / p99 3.14 / p99.9 28.3 / 0.63% above bar, 2026-09-22, value unchanged) and the two live wait-profile facts stamp `threshold_lineage = 1`; the frozen Dashboard mirror deliberately does not, since its private copy is pinned as unmeasured on that tier. ### Fixed @@ -222,6 +238,22 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **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. +- **`PG_XMIN_HOLD` grades the horizon's persistence, not one winner's** ([#3691]) - the fact read 0 when several equally-old transactions alternated as the horizon's `is_winner` — the identity arm saw each win once and a set of holders that together pinned the horizon for an hour was invisible. The fact now grades the horizon's PERSISTENCE (the longest run of captures with the oldest xmin above the bar, on the run's floor age) with attribution as a separate arm (distinct holders, the modal holder's share, whether the set is attributable); the advice names the set rather than the latest winner. +- **Store job self-heal covers every policy family, and a held retention policy is never mistaken for a dead one** ([#3816]) - #1581's watch over background jobs read compression and columnstore jobs only, so a `policy_refresh_continuous_aggregate` or `policy_retention` job the scheduler had retired with `next_start = -infinity` was never detected, alerted or re-armed — a rollup could stop materializing silently until the coverage gate held its retention. One read now covers every store-scoped policy job and bands per family: `Refresh Job Stuck` (CRITICAL — readers go quietly stale), `Retention Job Stuck` (WARNING — disk, nothing lost) and `Store Job Failing` (INFO — a job failing and retrying is alive; read the log) beside the untouched `Compression Job Stuck`. A policy the coverage gate paused (`scheduled = false`) is counted as held, never dead, and never handed to `alter_job`; on TimescaleDB 2.26.4 and later a persistent `-infinity` is the scheduler's own crash backoff, so every family is detected and alerted there but not re-armed, as compression has been since #3629. Every hourly pass logs one line — jobs read per family, dead, stuck, held, re-armed, alerted — so a tick can prove it ran. +- **A live store test stops racing the statistics collector** - the TOAST-utilisation live test deleted half a dimension's rows, ran `VACUUM`, and asserted the tuple-share proxy read ~100 % on the vacuumed file; the `DELETE`'s dead-tuple increment sits in the backend's pending statistics until PostgreSQL's once-a-second report while `VACUUM` writes its reset straight to shared statistics, so on a fast runner the zero landed first and the count second and the proxy read 64 %. `pg_stat_force_next_flush()` around the `VACUUM` puts the counters in order. Test-only. +- **A month of zeros is the strongest baseline there is, not the absence of one** ([#3691]) — An all-zero bucket has no dispersion, so it could never be trustworthy, and a server with thirty logged days that never blocked was told "first occurrence, no baseline yet": 92 blocked sessions against a clean month scored 0.5. A bucket that clears its tier's sample and day floors with nothing but zeros is now zero-history: any peak over the magnitude floor fires as an extremity (σ pinned at the cap, `baseline_zero_history = 1`, `baseline_distinct_days` stamped), on both SKUs, and the advice says this hour saw none of it all month. No existing verdict on a non-zero history changed. +- **A configuration lever hanging off a diagnostic chain is attached to that finding instead of orphaned into a card of its own** ([#3691]) — The greedy story walk followed one edge per node, so `CONFIG_PG_MAINT_WORK_MEM` — the memory bound on how fast a vacuum backlog can clear — was never visited, never consumed, and rooted its own card at 0.6 beside the backlog → wraparound → hold chain it belongs to: two cards, neither mentioning the other. Config leaves off any path node now ride on the story as `side_leaves` (both engines' `analyze_server`), with one sentence in the story text naming the lever, and are consumed so they no longer root alone. Path, hash, severity and confidence are untouched — incident identity is byte-identical; the SQL Server graph cannot produce a side leaf and is pinned so. +- **Darling's Entra service-principal connections can find their authentication provider** ([#3838]) - `Microsoft.Data.SqlClient` 7.x split the Active Directory (Entra ID) authentication providers out of the core package into `Microsoft.Data.SqlClient.Extensions.Azure`; Lite picked that package up when the 7.0 bump landed, and Darling then grew non-interactive Entra auth (#3484) and its add-server GUI (#3485) without it. Every service-principal and managed-identity connection the service opened therefore failed at `Open()` with *Cannot find an authentication provider for 'ActiveDirectoryServicePrincipal'* — a runtime failure on a path that compiles clean, which is why it arrived as an operator report against a managed instance rather than as a red build. The driver resolves the provider by the assembly being PRESENT in the running application's dependency closure (measured on 7.0.3: `GetProvider` returns null for all four AAD methods without the package and `ActiveDirectoryAuthenticationProvider` for all four with it), so there is no registration call and no startup wiring — the fix is the reference itself, on the Service (every SQL Server connection the collector opens, and the `test_connect` command the Viewer's Test Connection button enqueues rather than opening itself) and on Darling.Analysis (the plan fetcher opens its own connection on the same resolved string). The Viewer needs nothing: it opens no `SqlConnection` at all. The version was already pinned centrally for Lite, so `Directory.Packages.props` is untouched and the whole product change is two versionless `PackageReference` lines. `EntraProviderPackageCensusTests` now derives the requirement from the tree — every shipped project that assigns `SqlAuthenticationMethod.ActiveDirectory*` declares the package, and every project whose reference closure reaches one of those has it somewhere in its own closure — so a third SKU or a new Entra call site inherits the rule instead of remembering it. +- **Every button in every theme recognizes its access key again** ([#3835]) - `ContentPresenter.RecognizesAccessKey` defaults to FALSE and WPF's stock `Button` template sets it true, so a CUSTOM button template that omits it silently opts every button out of access keys: the marker in `Content` renders as a literal character and the `Alt` combination binds to nothing. That is how `E_dit Collector Schedules...`, `_Save` and `_Close` reached an operator's screen with the underscore visible — with a green build, no warning and no runtime error, because the defect is a rendering fact about a template and nothing executes it. The report counted fifteen templates in three theme files; the tree holds **fifty-five**, across three PARALLEL theme families (`Darling/…Viewer/Themes/`, `Lite/Themes/`, and `deprecated/Dashboard/Themes/`, the last still in the solution) plus five one-off templates outside any of them — including `ViewerDarkTheme.xaml`'s `ViewerButton`, the implicit `Button` style for every secondary window and therefore the template the reported `_Save` and `_Close` actually hit. Forty-two presenters took the attribute; `TabCloseButton` is outside the rule by construction (it renders a literal `×` `TextBlock` and has no presenter), and the `ToggleButton` and calendar templates are deliberately left alone because none of them carries a caption. Turning the attribute on changes how EVERY underscore in every caption is read, so the escaping was censused BEFORE the switch rather than after: all fifty-one distinct underscore-bearing `Button` captions carry exactly one underscore and every one is an intended access key, and the only literal identifiers in this idiom (`SP_SERVER_DIAGNOSTICS` and the three beside it) sit on CheckBoxes, whose template has always set the attribute and whose captions were therefore already doubled in Darling and Lite — the `deprecated/Dashboard` copy was not, and was doubled in the same change so the fix does not leave a known-wrong rendering behind it. `ViewerButtonAccessKeyTests` now derives both halves from the tree, so a fourth theme family or a new button template inherits the rule instead of remembering it, and a caption that grows a `snake_case` identifier reds on the odd-length underscore run instead of quietly losing a character. +- **Store self-alert triage pages stop rendering "Could not resolve server" for every metric added after #2768** ([#3833]) - #2768 fixed the store family's triage pages by naming the four store metrics that existed in `SectionsByMetric`, and the seven store families that landed since (retention hold, custom-rule health, TOAST slack, checkpointer pressure, and the three report digests) each reopened the defect because the fallback for an unmapped metric is the per-server section pair. `SectionsFor` now derives the decision from the metric's `AlertFamily` - the census a new alert cannot ship without joining - with the map kept as an override layer for tailored reads and a three-name exception list for the self-monitor metrics that genuinely fire under a monitored server's name. Resolution titles are covered too: four store families' all-clear rows ("Retention Hold Cleared", "Custom Alert Rules Recovered", "Store TOAST Slack Cleared", "Store Checkpointer Pressure Recovered") had no `ResolutionAliases` entry and would have kept rendering the defect from the history's triage links; they are aliased, the retention title is promoted from an inline literal to a shared constant, and the alias loop's type-initialization guard widens to accept a fleet-level canonical while still failing loudly on a typo. Three census tests pin the rule from `AlertFamily.MetricFamilies`, so the next store metric is in the census the day it registers, and every evaluator resolution-title constant must carry an alias or the suite reds. +- **`get_collection_health` per server no longer races the store's write bands with an unmemoized 7-day scan** ([#3856]) - #3738 single-flighted the fleet rollup's collection-health scan after three racing copies died at the `mcp` role's 15 s `statement_timeout` inside write bands; the per-server twin kept running its own `v_collection_log` scan on every call and was cancelled by that same cap (57014) for the first time on 2026-09-21. The issue preferred deriving the per-server read from the fleet memo's scan and gated that on the windows matching - they do (both cut `now - 7 days`) - but the derivation fails one level deeper: the fleet statement holds twelve aggregates with every per-collector fact summed away, while the per-server read carries twenty-nine columns per collector over four window functions, so there is nothing to filter and widening the fleet scan would spend the headroom #3735 bought. So the fix is the issue's first shape with the window in the key: `PerServerCollectionHealthMemo`, keyed `(server id, window start)`, 60 s lifetime read off the fleet reader's own declaration so one cadence governs both, single-flight primitive copied from the fleet memo rather than re-derived. The payload gains `collection_health_age_seconds` - trailing, unconditional, the field the fleet overview has carried since #3735 - and the tool's instruction row says why repeat calls inside a minute read the memo. Eleven pins mirror the fleet suite: one scan under concurrency, positive age on a memo hit, a failed scan never memoized, a different window missing by key. +- **The typed story path reaches the finding, six readers stop splitting its display string, and the lever beside an incident finally names the read that acts on it** ([#3859] items 4–5) - `AnalysisStory` has always known its chain as a LIST of fact keys; on the way to `AnalysisFinding` that list was joined into a display string and then dropped, so six consumers on both SKUs recovered it by splitting the rendered path back apart on `" → "` — the two `ToolRecommendations.GetForStoryPath` bodies, the three drill-down collectors, and the frozen `deprecated/Dashboard` copy of each. The producer had the typed list the whole time; only the string crossed, and the string was a rendering. That is a corruption surface rather than a style complaint: a fact key that ever contained the arrow, or any edit to the separator in `InferenceEngine.BuildStory`, would have broken all six readers at once — each splitting one key into two halves that match nothing — with a green build and no line in the product saying so. `SameStatementPileupDetector` is the sharper case and was already living it: it arrow-joins the root key to a STATEMENT HASH, which is not a fact key and never was, so every split reader has been treating 16 hex characters as a fact key on every pileup finding and silently matching nothing. `AnalysisFinding.PathKeys` now carries the list, populated at the join in both finding stores beside the `SideLeafKeys` they already copied, and `StoryKeys` pairs the chain with the levers for the consumers that want both, with one rule (`All`) for reading them in one order — chain first, levers after, de-duplicated ordinally, because a recommendation list is read top-down and the incident is what the operator came for, while a lever that is also a hop on another chain must not appear twice as two different suggestions. `PathKeys` is EPHEMERAL, exactly like `SideLeafKeys`: no `analysis_findings` column, none added, no migration rung, and both are write-path lists for write-path consumers (the collectors enrich the pass's own findings; `next_tools` is rendered by `analyze_server`, which renders the pass's own findings), so the persisted, read-back spelling of a chain stays the `StoryPath` string — which does not change by one byte anywhere, on either engine. Item 5 rides the same widening, which is why the issue paired them: with the path alone, `GetForStoryPath` could not see the config leaf #3691 swept onto the story, so a finding whose lever was, say, `CONFIG_PG_MAINT_WORK_MEM` told its reader three times that a lever existed (the `side_leaves` card, the sentence in the root's investigation, the key itself) and then handed over a `next_tools` list pointing at no read for it — `get_pg_autovacuum_health` was reachable only if that key ALSO rooted a finding of its own, which is precisely what #3691 stopped it from doing, so the fix for one gap opened another. Widening the input to `StoryKeys` closes it and MOVES `next_tools` BYTES, deliberately, on every finding that carries a lever: the levers' reads append after the chain's. A finding with no lever is byte-for-byte what it was — nearly all of them, and all of the SQL Server pass except where #3691 swept a lever — so the #3849/#3850-era byte-identity pins hold, which is the evidence that the rendered string and the incident identity did not move. Both call sites sit BESIDE the `StorySideLeaves.Attach` and `FactRanked.Attach` shapes from #3864 and neither attach is restructured: those render the lever's CARD and the root's ranked objects, and this renders the third thing a lever owes a reader, the read that acts on it. Nine test call sites follow the widened input by NAMING their keys instead of rendering a path for the code to re-split — the Darling surface census keeps its identical assertions, which is the evidence the parse was overhead and not behaviour — and the six planted-finding drill-down fixtures gain `PathKeys` beside their `StoryPath`, without which their key tests would match nothing and each test would pass vacuously on a drill-down that never ran. +- **An argument a tool does not declare is refused by name instead of silently dropped, on both SKUs, from one filter** ([#3870]) - `get_collection_log {"server_name":"…","hours":1,"status_filter":"failure"}` returned two hundred rows, every one SUCCESS, at the 24-hour default: `status_filter` does not exist and the real window knob is `hours_back`, so BOTH arguments the caller set were discarded by the SDK's bind-by-name and the tool answered a question nobody asked, with no tell in the payload beyond an `hours_back` echo the caller had no reason to re-read. For a surface whose callers are language models that is the worst available failure shape - the caller believes it asked something narrower than it did and reads the answer under that belief - and the codebase already held the principle one level down, in that same tool, on `limit`: "rejects out of range rather than silently clamping, so a caller asking for 5000 is told no instead of quietly given 1000." A wrong VALUE was refused and a wrong NAME was swallowed, same defect class, and the misspelled name is by far the likelier mistake from an LLM caller. The SDK owns deserialization, so there was nothing to fix inside a tool body - by the time a method runs the unknown key is already gone - which makes the choke point a validation pass over the RAW argument keys against the tool's own advertised input schema, BEFORE dispatch. That is a call-tool filter, the seam `GcfCallToolFilter` already uses and the same "registered once; covers every tool" argument: one `McpUnknownArgumentGuard` in `PerformanceMonitor.Common`, registered by both hosts, so the two SKUs cannot drift into refusing differently and a tool added tomorrow is covered the day it is registered. Nothing in any of the ~240 tool bodies changed. +- **`checkpoint_timeout` says `not_applicable` in the FACT on Aurora, not just at the tool that renders it** ([#3868]) - lane 15 (#3728) stamped `not_applicable` / `not_applicable_on_aurora` on `CONFIG_PG_MAX_WAL_SIZE` alone, so on an `aurora-postgres` target its sibling `CONFIG_PG_CHECKPOINT_TIMEOUT` came out of the collector unqualified: `get_analysis_facts` showed it as an ordinary graded fact and its composed advice told an operator to "tune it with max_wal_size" — a knob Aurora's storage layer ignores, on a fleet where all fifty measured clusters reported sixty timed checkpoints an hour and a requested share of 0. `audit_config` had been made to say the right thing at the surface by #3867's engine-side arm (`isAurora && key == CONFIG_PG_CHECKPOINT_TIMEOUT`), which satisfied rider 1 of Erik's ruling for that one tool and left every other reader of the fact — the pass, the stories, the drill-downs — reading a knob as live that the engine does not consult. The collector now takes the same stamp for the pair, off the same one registry read `max_wal_size` uses (`is_aurora` on the `SERVER_MAJOR_VERSION` fact, through `MonitoredEngineKind`, never a column's presence — #2530), so the fact is the truth and the tools agree with it rather than compensating for it. The value is still emitted, because what a parameter group holds for a knob nothing reads is a fact about the parameter group and worth seeing; `PgTargetScorer.Config`'s existing `not_applicable` read scores it 0 unchanged, which it already did for the stamped sibling, so nothing roots and no co-fire can lift it. +- **FinOps Locking & Contention stops showing databases that were renamed away** ([#3876], user-reported) - the grid and its database selector resolved "latest" PER NAME (`MAX(collection_time) GROUP BY database_name`), which makes every name the store has ever seen its own immortal group: a renamed database's old name still owns the last pre-rename capture forever, so a month after a rename the old names rendered beside the new ones and the dropdown still offered them - while the three sibling tabs, anchored on the server's latest capture or a sliding window, had already moved on (the reporter's own four-tab split was the diagnosis). Rename propagation was never broken: the collector re-derives the name via `DB_NAME()` every pass, and one run stamps all its databases with a single `collection_time`, so the per-name MAX equals the server-wide MAX for every live database - the grouping only ever added dead names. Both reads now anchor on the server's latest capture, the same resolution the working tabs use; capture-time names stay in the store as history. Pinned with the reporter's repro: old-name rows in an older capture, new-name in the newest - grid and selector return only the current name, and scoping to the dead name finds nothing rather than resurrecting pre-rename rows. The Darling edition ports this read verbatim (viewer + both SKUs' MCP object-locking tools); that is a separate issue. +- **Darling's four object-locking reads stop showing databases that were renamed away** ([#3878]) - #3877 fixed Lite's Locking & Contention grid; the Darling edition carried the same read, ported verbatim before the fix, and the audit Erik ordered after that merge found the mechanism at exactly four remaining sites and nowhere else in either SKU: the viewer's `IndexLockingAllSql`, `IndexLockingByDbSql` and `IndexLockingDatabasesSql`, plus `DarlingObjectStatsReader.IndexLockingSql` behind the MCP tool `get_object_locking`. Resolving "latest" as `MAX(collection_time) GROUP BY database_name` makes every name the store has ever seen its own immortal group, so a renamed-away database keeps a group whose newest row is the last capture before the rename - truthfully "the latest row for that name", and therefore returned forever beside the live names as a peer. On the viewer that is the reporter's stale grid; through MCP it is worse, because an agent asking which objects are contended is handed month-dead database names with nothing in the payload marking them dead. All four now anchor on `(SELECT MAX(collection_time) FROM v_index_object_stats WHERE server_id = $1)`, the shape `DatabaseSizeLatestSql`, `StorageGrowthSql` and `IndexUsageSql` have always used. The grouping being removed never bought what it looks like it bought: one collector run stamps every database it collects with a single `collection_time`, so for any database present in the newest pass the per-name MAX IS the server-wide MAX - the very same rows - while for one absent from it the grouping adds nothing but a name that is gone. Grid, filtered arm and selector move together deliberately: the selector is how a dead name could still be PICKED rather than merely displayed, and the filtered arm is what a pick lands on, so a partial fix leaves the old name reachable by the act of selecting it. Capture-time names stay in the store untouched - honest history, simply no longer read as the present. +- **The pin that held the defect as intended behavior is renamed, which is why this was its own issue.** `DarlingMcpObjectStatsToolsTests.IndexLockingSql_PerDatabaseLatest_NonzeroWaits_ContendedFirst` asserted per-database "latest" as the read's purpose, by name; rewriting a behavior a test claims as intended is a stated design change rather than a quiet edit, and the rename is the statement. It is now `..._ServerLatestCapture_...`, and its anchor assertion pins the whole server-latest subquery instead of a bare `MAX(collection_time)` - the retired shape contained one of those too, so the old needle could not tell the fix from the defect - with the grouping asserted absent so the pin cannot pass again by going back. `ViewerFinOpsSqlTests`' three literal fragments are re-fragmented to the new SQL with the anchor pinned in all three, the database filter moving to `SqlTextPin` because the fix qualified it to `ios.database_name` when the CTE referencing the bare name went away - #3217's exact case, where an alias appearing in front of a column must not red a pin asserting a read still filters. `McpLatestSnapshotStampTests`' comment claiming this read "takes MAX per database, not one instant" was true when written and is now false; the correction is recorded rather than deleted, because the read IS one instant now, which is precisely what a `captured_at` stamp needs to be truthful and makes the A10 residual it still sits in easier to close. `StorageCommandTimeoutTests` needed no re-anchoring - its fixture pins the `GetIndexLockingAsync` ternary's C# body text and the substitution changed only the const strings that method selects between - verified by reading the method after the edit rather than assumed. +- **A census caught what no pin was watching for, and its roster grew rather than shrank.** `McpPayloadContractCensusTests` rosters latest-anchored reads that do not project their anchor column, shrink-only by design, and the fix ADDED `IndexLockingSql` to it. The reason is the defect restated from another angle: the read was invisible to that census because its anchor sat inside a CTE, which the scan deliberately ignores on the grounds that such an anchor picks a SET rather than a snapshot - exactly true of per-name groups, which picked one row per name the store had ever seen. Becoming a real snapshot read is what made the census see it at all. It is rostered beside its two neighbours with that reasoning written into the roster's own comment, and all three leave together when the A10 lane stamps the family. ## [3.8.0] - 2026-09-17 @@ -1488,6 +1520,7 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#3650]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3650 [#3652]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3652 [#3653]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3653 +[#3678]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3678 [#3691]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3691 [#3704]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3704 [#3710]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3710 @@ -1499,6 +1532,7 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#3742]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3742 [#3743]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3743 [#3744]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3744 +[#3745]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3745 [#3752]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3752 [#3753]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3753 [#3754]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3754 @@ -1506,6 +1540,7 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#3756]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3756 [#3764]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3764 [#3778]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3778 +[#3781]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3781 [#3783]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3783 [#3796]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3796 [#3797]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3797 @@ -1513,9 +1548,26 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#3805]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3805 [#3812]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3812 [#3815]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3815 +[#3816]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3816 +[#3817]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3817 [#3818]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3818 [#3819]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3819 [#3830]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3830 +[#3833]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3833 +[#3834]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3834 +[#3835]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3835 +[#3838]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3838 +[#3848]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3848 +[#3854]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3854 +[#3856]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3856 +[#3859]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3859 +[#3868]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3868 +[#3869]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3869 +[#3870]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3870 +[#3871]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3871 +[#3876]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3876 +[#3878]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3878 +[#3880]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3880 [#3514]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3514 [#3477]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3477 [#3495]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3495