From 401a779ed40184c70b242e8e461d37c21c7ff156 Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Wed, 30 Sep 2026 14:37:26 -0400 Subject: [PATCH 1/5] CHANGELOG: splice the 09-28 -> 09-30 merges into [Unreleased] Splices the entries carried by PRs merged to dev after 2026-09-28T17:40:00Z: 4 Added, 18 Changed and 120 Fixed bullets, with 104 definitions. Folds the daylight-saving and alert-retry families into one entry each, combines #4739 with #4763, replaces #4632's and #4688's row-label text with #4698's end state, and amends the [Unreleased] entries for #4278, #4341, #4396 and #4413. --- CHANGELOG.md | 254 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 250 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 637358d762..d43bbac7ed 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,6 +23,10 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ### Added +- **`--drop-xe-sessions`** ([#4852]) - a command-line verb that drops the Extended Events sessions a removed server left behind. Run it just before removing the server. `--dry-run` lists them. `--print-sql` prints guarded statements to run by hand when the server is no longer configured. +- **Collection Falling Behind self-alert** ([#4851]) - it fires when the fleet collection gate skips at least 5% of the slots due in the last hour. At least 20 slots must be skipped too. It resolves after a full hour under 1%. An hourly log line gives the slots run and skipped, how long collection waited for a gate slot, and the gate width. +- **PostgreSQL targets: a finding when pg_stat_statements keeps evicting statements** ([#4680]) - When a target's pg_stat_statements module has had to drop its least-used entries in at least 3 of the last 6 hours, analysis reports it, says Darling's statement totals can under-report, and recommends raising pg_stat_statements.max (a restart, or on RDS and Aurora a parameter-group change and a reboot). It never fires where the eviction count is unknown. +- **Per-rule plan analyzer overrides** ([#4602]) - `darling.json`'s (Darling) and `settings.json`'s (Lite) new optional `analyzer` section can disable a specific plan-analysis rule or override its severity, e.g. `"analyzer": { "rules": { "disabled": [20] } }` hides Local Variables findings. Applies to the MCP plan tools, the drill-down views, and the plan viewer window. - **Plan viewer: a Server Context card** ([#4614]) - The Plan Insights strip now opens with a Server Context card, as in PerformanceStudio's desktop viewer. It shows the server a plan belongs to: its name, edition and version, CPUs and memory, MAXDOP, cost threshold for parallelism, max server memory, and the plan's database with its compatibility level, from what the collector has stored for that server. - **Plan viewer: a Parameters card** ([#4604]) - The Plan Insights strip now includes a Parameters card, listing each statement parameter's data type, compiled value and runtime value, and flagging a runtime value that differs from its compiled value as possible parameter sniffing. - **Plan viewer minimap** ([#4596]) - The plan viewer's toolbar has a "Minimap" toggle that opens a scaled-down overview of the whole plan, with a box showing the current scroll position and a click-to-center shortcut. @@ -118,6 +122,24 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ### Changed +- **Per-server Query Store reads fetch fewer rows** ([#4861]) - This covers the Queries grid, MCP's Query Store top read and the Trends Query Store chart. Each filtered one server's rows of the per-interval table by collection time only, which no index held. So it fetched every stored row of that server. Each read now also bounds first_execution_time, which the table's unique key holds, so older rows are dropped before they are fetched. Results do not change. On a large store, a day-long MCP read went from 3.1 s to 0.6 s. +- **SQL Server blocking and deadlock baselines count the hours collection covered** ([#4853]) - each hour-of-week's mean now divides by the days collection ran in that hour. It used to divide by the days that had events. A covered hour with no blocking or deadlocks is a measured zero, so a spike into it says the baseline measured zero instead of "first occurrence". This needs at least one captured event in the 30 days, so a server that cannot capture the events keeps no baseline. Hours with occasional events get lower means. More hours are trusted, and a trusted hour must also pass the rate multiple, so those hours alert less often. An hour whose events cluster on a few days can alert at a lower event rate than before. These baselines are now computed once per UTC day, like the CPU and I/O latency baselines. Events earlier on the current day are not part of the baseline. +- **The plan viewer's Runtime Summary lists CE model above Optimization, with Early abort under it** ([#4849]) - this matches PerformanceStudio. The Early abort label is indented when an Optimization row is shown. +- **Purge Now runs in the background and is paced like the daily purge** ([#4835]) - the command ran the whole purge before it answered, so every other command waited behind it. Its deletes were not paced, which slows collection on every server the way the daily purge did. It now answers at once with "started", or "already running" when another purge holds the slot. When the purge finishes, its totals and each raw table's result are written to the collection log under (fleet), which `get_collection_log` reads, and the viewer shows the totals. Update viewer seats along with the service: a viewer from an earlier release reads the new answer as 0 rows purged. +- **get_pg_deadlocks explains an empty answer more completely** ([#4832]) - The tool's text now names the log line prefix check beside the message language check (as does the empty answer of get_pg_deadlock_detail), and says the RDS read position is saved, so a restart resumes where the last read stopped. +- **Darling reads a quiet database's watermark from its cache instead of from the store every cycle** ([#4818]) - A database whose newest row was recent but had no new batch since the cache was seeded missed the cache on every cycle, at about 30 ms a time. +- **Query Store rows now record when each interval ended, in both apps' stores** ([#4802]) - The Query Store stats in Darling and Lite gain an `interval_end_time_utc` column next to the interval's start time. Rows collected before the upgrade leave it empty. +- **Query Store backfill: the per-tick database list no longer walks the newest chunk's index** ([#4703]) - every backfill tick listed a server's databases with a read bounded at the backfill horizon. Inside the chunk that holds the horizon that bound can only filter, so the read walked the chunk's index entry by entry, and it grew as the chunk filled. On a store monitoring 43 servers, with the horizon 20 minutes before the end of its chunk, one round of these reads cost 495,218 buffers and 560 ms (up to 24,457 buffers and 44 ms for one server). The read now starts at that chunk's start, taken from the TimescaleDB catalog, and the same round cost 1,815 buffers and 5.3 ms. On plain PostgreSQL the list comes from a walk of the index, one seek per database. A quiet database whose newest rows are in that chunk but older than the horizon is now marked done at once, so if it comes back after those rows leave raw retention, its first-contact history is not backfilled. A recorded outage gap is still backfilled. +- **Query Store views over windows longer than the raw tier now show the full window from the interval table, and say how far back it reaches** ([#4700]) - The Queries grid, the get_query_store_top MCP tool and Compose Query Store panels read the per-interval table below the raw tier's floor, down to the exact point where it provably holds the same rows raw held. The MCP tool reports history_source and effective_start, and its note says which bound set the start. +- **Analyzer wording for Nested Loops outer sides and row estimate mismatches now counts rows the way the plan viewer does** ([#4698]) - Rule 16's Nested Loops outer-side detail now prints the total actual rows when the outer input is not on a Nested Loops inner side, for example "actual 100,000 (1000x underestimate)" where it used to print "actual 12,500 (125x underestimate)" at DOP 8. Rule 5's "(N rows x M executions)" text now appears only on a Nested Loops inner side. +- **PostgreSQL targets: the top-queries views say when pg_stat_statements evicted entries during the window** ([#4680]) - Darling now records each target's pg_stat_statements eviction count (`pg_stat_statements_info.dealloc`) with its statement statistics. When the module had to drop its least-used entries in the window, `get_pg_top_queries`, the Darling Viewer and the web dashboard's Top Query Shapes say so and that the totals can under-report, and name pg_stat_statements.max as the fix; where the info view is absent the count is reported as unknown rather than zero. +- **Web dashboard: each notebook and Custom View has its own auto-refresh setting, notebooks start with it off, and slow pages back off** ([#4671]) - A labelled "Auto-refresh" control on each saved view and notebook (Off, 1, 5 or 15 minutes) is saved with the definition; notebooks default to Off and Custom Views to 5 minutes, and the fleet and server pages keep refreshing every minute. The header button now pauses all auto-refresh. A page whose last render took more than half its interval waits at least four times that render (up to 15 minutes) before refreshing again, and says when it will. +- **Query Store collection: each database's watermark comes from the store only when a cached value can't be proven current** ([#4669]) - The collector read `MAX(last_execution_time)` for every database on every cycle; on one production store that was about 6,900 s of store time and 112 million blocks read in four days. The value is now cached per server and database, advanced only after a batch commits and dropped on any fault, reconnect or backfill write, and used only while the row that set it is still inside the read's three-hour floor, so every cycle collects from exactly the same point as before, and re-read from the store at least hourly. +- **Alert pass: the forced-plan failure check reads the store only when its answer can have changed** ([#4667]) - Between Query Store collections every pass re-read two hours of one server's Query Store rows to reach the same answer; on one production store that was the second-largest statement, about 27,700 s of store time in four days. A one-row probe now decides, every Query Store write clears the saved answer, and the previous answer is reused otherwise (less any plan whose older collection has left the window), so alerts fire exactly as before. +- **Query Store collection: the orphaned per-database state cleanup runs at most once an hour per server** ([#4665]) - It ran three deletes after every Query Store cycle to catch the rare dropped database; on one production store that was about 5,600 s of store time in four days. It now runs on the first cycle after a start and then hourly, in Darling and Lite; a failed run is still retried on the next cycle. +- **The Darling Viewer's Query Store trend chart and `get_query_store_duration_trend` no longer re-scan the hourly rollup's oldest and newest hour on every load** ([#4618]) - They take the rollup's range from the coverage the service already caches, instead of a fresh `min`/`max` read over the rollup on every call. +- **Custom Views Query Store panels over a recent window read the per-interval table instead of re-sorting raw snapshots** ([#4617]) - A Query Store panel of 12 hours or more, whose window the store's per-interval table fully covers, now reads that table, with the same numbers, instead of deduplicating every raw snapshot in the window. On a large fleet that dedupe spilled gigabytes of temporary files and could run to the 60-second read timeout. +- **`get_store_metrics` reports the per-interval Query Store tables by name** ([#4616]) - Their size and growth get their own daily rows instead of being counted in "other", so a stalled purge on them shows up. - **Darling Viewer and MCP store reads can no longer spill unbounded temporary files** ([#4610]) - The viewer and mcp store roles now carry a temp_file_limit, so a Custom Views panel that would have written gigabytes of temporary files fails at once with a message naming the limit, instead of running to the 60-second statement timeout and slowing the collector's writes. - **Plan viewer minimap: resize, double-click zoom, and accuracy-coloured edges** ([#4603]) - The plan viewer's minimap panel can now be resized and remembers its size across plans, double-clicking a minimap node zooms to and selects it, and minimap edges pick up the same over/underestimate colouring as the main canvas. - **Rule 38 can now flag a Standard Edition DOP limit as a Warning** ([#4601]) - Plan analysis reads each server's collected edition and MAXDOP wherever it analyzes a stored plan (the MCP plan tools, the drill-downs, and the Darling Viewer and Lite plan viewers). A plan that ran at DOP 2 with batch-mode operators on a Standard Edition server with MAXDOP above 2 now gets a Warning; it stays Info when the edition isn't known. @@ -147,14 +169,14 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **The store now gives the web dashboard's and MCP server's reads up to 60 s before cancelling them, instead of 15 s** ([#4447]) - existing stores still at the shipped 15 s default move to 60 s through store schema rung V147, and an operator-set value other than 15 is left alone. Reads over 5 s are still written to the store's log. The desktop viewer's reads and the shared storage-layer readers keep their own 15 s and 30 s client limits for now. Bring-your-own stores re-run `tools/provision-roles.sql` to pick up the new value. - **The managed store checkpoints every 15 minutes instead of 5, cutting write-ahead log volume** ([#4426]) - a new marker block ships `checkpoint_timeout = 15min`, after a trial on one store kept the checkpoint sync phase far under the checkpointer's own sync-phase self-alert. - **Report alerts link to their own page: the Fleet Sweep Rollup opens the sweeps page, and the digests carry no link** ([#4421]) -- **`get_top_procedures_by_cpu` and the Top Procedures grid now route to the hourly rollup once raw ages past its retention window, instead of returning nothing** ([#4413]) - Mirrors the routing already shipped for `get_top_queries_by_cpu`; the payload discloses which tier answered and what an hourly-routed row is missing (`object_type`). +- **`get_top_procedures_by_cpu` and the Top Procedures grid now route to the hourly rollup once raw ages past its retention window, instead of returning nothing** ([#4413]) - Mirrors the routing already shipped for `get_top_queries_by_cpu`; the payload discloses which tier answered, and the columns the hourly rollup lacks (`object_type`, the handles, the I/O totals and the min/max extremes) are null, not 0. - **Sized the Linux compose store's background-worker slots and `work_mem` from the product's own - **Cache the server-scoped watermark read across a runner's lifetime, cutting repeated `MAX()` reads against `job_history`, `default_trace_events`, `system_health_events`, and `memory_pressure_events` to one seed per (server, collector) pair instead of one per collection cycle** ([#4399]) -- **Top-N-by-CPU queries now route to the hourly rollup once raw's retention has dropped the window, instead of returning empty** ([#4396]) - `get_top_queries_by_cpu` (MCP tool, Storage reader, and Viewer) degrades to the hourly continuous aggregate for a window older than raw's floor and discloses the precision loss (`tier_used`, `precision_note`) rather than silently returning nothing. +- **Top-N-by-CPU queries now route to the hourly rollup once raw's retention has dropped the window, instead of returning empty** ([#4396]) - `get_top_queries_by_cpu` (MCP tool, Storage reader, and Viewer) degrades to the hourly continuous aggregate for a window older than raw's floor and discloses the precision loss (`tier_used`, `precision_note`) rather than silently returning nothing. The raw-only filters (`min_dop`, `parallel_only`, `group_by=host_object`) keep the read on raw, and when raw holds nothing in the window the answer is status `empty` with `window_truncated` set. On the hourly tier, the columns the rollup lacks (plan hash and handle, DOP, reads, writes, physical reads, rows, spills, `avg_reads`, `is_parallel`, `distinct_texts` and the min/max CPU and elapsed times) are null, not 0, and `sql_handle` is returned. The read counts no bucket past the rollup's materialization ceiling, and `cpu_attribution` divides by the span the rollup served. - **The Performance Trends Query Store duration chart reads the interval table for windows of 48 hours or more** ([#4382]) - the table measured faster than raw from 48 hours (361 ms vs 423 ms at 48 h; 374 ms vs 1,045 ms at 7 days) and returns exactly raw's points; shorter windows stay on raw. The interval-table gate also reads raw for any window that still holds legacy rows without an interval start. - **The Darling viewer's TempDB file I/O trend now buckets like the File I/O tab's own reads** ([#4353]) - a 7-day window used to return one row per collection per tempdb file (40,324 rows measured for 4 files at 1-minute cadence); it now buckets to the chart's point budget (4,036 rows measured for the same seed) and still stamps a short window's raw points unchanged. - **Raw hypertables now re-tune their own chunk interval once a day from actual ingest** ([#4344]) - Every raw hypertable used the same fixed one-day chunk interval whatever its write rate, so a busy table's open chunk, with its indexes, could outgrow the memory meant to hold it. Darling now reads each raw hypertable's compressed ingest rate daily, alongside a RAM-derived budget, and narrows the interval one rung at a time through `set_chunk_time_interval` when the store-wide total is over budget, and widens it one rung when the total would stay under half the budget; a new rung history table records every change, alongside a per-run WAL-volume record. On by default; set `rawChunkIntervalReconcileEnabled: false` in the config file to turn it off. -- **The Queries grid and MCP's Query Store top read use a per-interval table for long windows** ([#4341]) - both used to deduplicate the whole raw Query Store slice on every read. The grid now reads a table that keeps one row per interval for windows of 12 hours or more, and the MCP read for 24 hours or more. On a 15-day seed of 3.47 million raw rows, a 7-day window took 2,754 ms against 7,065 ms for the grid, and 1,627 ms against 9,249 ms for the MCP read. Shorter windows, and any window the table's history doesn't cover yet (after an upgrade), read raw as before. +- **The Queries grid and MCP's Query Store top read use a per-interval table for long windows** ([#4341]) - both used to deduplicate the whole raw Query Store slice on every read. The grid now reads a table that keeps one row per interval for windows of 12 hours or more, and the MCP read for 24 hours or more. On a 15-day seed of 3.47 million raw rows, a 7-day window took 2,754 ms against 7,065 ms for the grid, and 1,627 ms against 9,249 ms for the MCP read. Shorter windows, and any window the table's history doesn't cover yet (after an upgrade), read raw as before. A BRIN index on the table's `collection_time`, which the service builds in the background from about 20 minutes after it starts without blocking writes (skipped below PostgreSQL 16 and on a hypertable), serves Custom Views Query Store panels of 12 hours or more where `random_page_cost` is about 1.1 or lower. - **Lite's memory clerk and File I/O trend charts bucket long windows in DuckDB** ([#4340]) - The memory clerk, File I/O latency, File I/O throughput and TempDB File I/O trend charts, and the Overview I/O lane, read one point per collection. They now gather collections into buckets sized to the window, at most 1,500 points per series. A bucket's latency is its summed stall over its summed operations, and its throughput is its summed bytes over its summed seconds. A window short enough that every bucket holds one collection plots each point at its own collection time, as before. The memory clerk picker's name list is cached for 15 minutes. - **Lite keeps one DuckDB connection open, so reads attach to it instead of reopening the database file** ([#4339]) - Every read used to open and close its own connection to the local database file. One connection now stays open for the app's life, which cut a 20-tick, ten-way Overview read on a 1 GB store from 871 ms to 43 ms. Because that connection keeps DuckDB's buffer pool resident, a periodic check trims it after a heavy read: on a 1.1 GB store, one trim took process private bytes from 1,115 MB to 148 MB. - **Lite's Performance Trends charts bucket long windows in DuckDB** ([#4338]) - The query duration, procedure duration and execution count charts read one point per collection, about 10,080 points each for a 7-day window at one collection a minute. They now gather collections into buckets sized to the window, rating each bucket as its summed work over its summed seconds, and a window short enough that every bucket holds one collection plots each point at its own collection time, as before. @@ -247,6 +269,126 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ### Fixed +- **A shutdown during a managed PostgreSQL tool step is no longer missed** ([#4867]) - A shutdown that came just before a tool ran was missed. When the tool finished at once, the work went on to its next step. Each tool run now checks for a shutdown before it starts. Steps that stop PostgreSQL or put files back during a shutdown still run their tools. +- **Rollup reads stop at the window end** ([#4859]) - an hourly rollup read counted one extra hour when its window ended exactly on the hour. It took the whole hour that starts at the end. This affected the Queries and Procedures tabs, the top-queries and top-procedures tools, the hourly trends, one query's hourly history, and Custom Views. A Custom View on the daily rollup counted the next day when its end fell at midnight. These reads now stop at the end. +- **Grid time columns sort by time** ([#4858]) - clicking a time column's header in Lite or the Darling viewer sorts the rows by time. Before, most time columns sorted as text, so "10/1/2026" came before "9/30/2026". +- **Six Postgres time columns follow the time display mode** ([#4858]) - six time columns on the Darling viewer's Postgres tabs always showed UTC. They are Lock Stats Last Seen, Wait Sampling Last Seen, Replication Connected Since, Column Stats Captured, and Index Bloat Measured and Estimated. They now show the same server, local or UTC time as the rest of the tab. +- **Server times and charts are right across a daylight saving change** ([#4783], [#4829], [#4838], [#4840], [#4841], [#4847], [#4848], [#4855]) - Where SQL Server reports its time zone (SQL Server 2022 and later), Lite and Darling convert a server's local times with the offset in force at each time, instead of one offset for every time. Older servers keep the fixed offset. In Server time mode, Lite and the Darling viewer follow the server's time zone and read it again on every refresh. This covers chart times, picker and custom ranges and System Events (Default Trace) times in both apps, and Job History run times and the SQL Agent next run in the Darling viewer. It also covers Custom Views Default Trace markers, config-change attribution, the parameter-sensitivity checks, the long-running job alert's "Started" time, and the server-local times in Darling's MCP tools (blocking, default trace, version store, object stats and running jobs) and in Lite's (`get_blocked_process_reports`, `get_running_jobs`, `get_index_usage`, `get_pvs_stats` and `get_default_trace_events`). Lite's `get_top_queries_by_cpu` and `get_top_procedures_by_cpu` compare last run times on the server's own clock, so a server west of UTC no longer drops a query last run early in the window and a server east of UTC no longer keeps one from before it. Recommendations "Ask AI" times use the selected server's own offset at each end of the window, and the Darling viewer's "Last analyzed" line shows the selected server's time and names its zone. Lite and the Darling viewer plot each chart point at its exact instant. In the repeated autumn hour, a chart no longer folds two hours onto one, and a drill or a typed range there reads the hour it names. The spring gap shows no hour that never happened, and the Darling viewer's Overview lanes axis spans the whole window. Grid and text times in the repeated hour end in their UTC offset, so the two 01:30s read `01:30:00 -04:00` and `01:30:00 -05:00`, and time columns that show the offset sort by time. Times read from a stored server wall clock (Default Trace events, job history and the next Agent run) stay plain in that hour, because the stored time does not say which of the two passes it was. Lite's FinOps First Seen and Last Seen and its collection health times follow the display mode, not this machine's clock. A chart CSV export's time column now names its zone, such as `DateTime (UTC)`, and every row gains a 4th column, `UTC offset`, so a script that matches the header `DateTime` or expects three columns needs updating. +- **Anomaly tiles agree on the window end** ([#4854]) - every SQL Server anomaly tile now leaves out a sample stamped exactly at the window's end. This holds in Lite and Darling. Eight of the eleven tile reads used to count it and three did not. So a boundary sample counted in one tile and not in another. +- **Lite shows a refused capture read as a failure** ([#4853]) - SQL Server can refuse the read of a blocking, deadlock or long-query session. Lite used to log a refused read (error 297 or 15151) as a success with zero rows, so collection health showed the capture as working. It now shows PERMISSIONS or ERROR, as a session that failed to start does. A read refused for permission (error 297) stops that capture until Lite restarts. A read that fails with error 15151 is retried every cycle. The Capture Not Running notice now names a long-query capture that could not start. It used to call it deadlock. +- **A backward clock step no longer pauses collection or delays repeat alerts** ([#4851]) - only a clock that stepped back can put a due time more than one interval ahead. Such work now runs at once instead of waiting out the step. This covers Darling's collectors, custom alert rules, retries and periodic checks, and Lite's collectors, collection cycle and background jobs. After a step back, a repeat alert waits one cooldown from the first check that sees the step. Before, it waited the step plus the cooldown. +- **A server edited during its connect no longer runs on the old connection string** ([#4851]) - the connect checks the definition again before its first pass. If it changed, the runtime is thrown away. +- **PostgreSQL spike advice names a baseline that measured zero** ([#4850]) - an hour-of-week can see no deadlocks, or no waiting, for the whole 30-day baseline. A spike in that hour now says the baseline measured zero, and prints no multiple. It used to say "first occurrence, no baseline yet". +- **Lite's View Block Chain reads the Blocking slicer's window when a report has no event time** ([#4848]) - For a blocked process report row with no event time, the chain is rebuilt from the slicer's selected window. That selection was converted to the server's local time before it filtered the reports' event times, which are UTC, so the chain came from a window shifted by the server's UTC offset. It now reads the window the slicer selected. +- **Fleet views show WARNING when half or more of a collector's databases fail** ([#4846]) - the run still records SUCCESS. Only its note records the loss. The collector's own Collection Health tab read that note. The fleet overview, the `get_fleet_overview` MCP tool and the viewer's Overview cards did not, so they showed the collector as Healthy. On its first start after the upgrade, the service rebuilds the hourly collection-health rollup and fills eight days of it in the background. +- **`run_custom_view_panel` runs count in read latency with the web dashboard off** ([#4839]) - the run's timing went to a slot only the web dashboard filled. With the dashboard off (the default), these runs were left out. They are now recorded as composed-panel reads, the same as a panel run from the web dashboard. +- **An alert that no channel delivered is tried again a minute later instead of waiting out its cooldown** ([#4786], [#4804], [#4826], [#4827], [#4828], [#4837]) - A send fails like this when, for example, a webhook answers HTTP 429 or 5xx or times out, or the mail server cannot be reached. The alert is tried again a minute later while its condition holds, and the wait doubles after each failed try (1, 2, 4 minutes and so on) and never passes the alert's cooldown. In Darling this covers the SQL Server high CPU, blocking, blocking wait time, deadlock, poison wait, long-running query, tempdb space, volume free space, version store, file growth, long-running job, failed agent job, database state and forced plan alerts; the PostgreSQL findings, high CPU, deadlock, blocking, long-running query and poison wait alerts; and the repeating self-alerts, such as Collection Stopped, Capture Down, Agent Not Running, Collector Cost Regression and store disk pressure. Lite reports a send that no email or webhook channel received as failed, so its alerts are retried the same way, and the tray notice shows again on each retry. In both apps, "Server Unreachable" and the availability group alerts (replica disconnected, failover, data movement suspended, and in Lite, sync fell behind) are tried again while the server stays down, with re-fire off or on, and so is a Per-event deadlock, blocking or poison wait alert whose sends all failed. A delivered alert is not repeated, and neither are the Restored and Reconnected notices. A custom alert rule has no cooldown, so its wait stops doubling at 15 minutes. A severity change that no channel delivered is sent again the same way, and a resolve goes out only for an alert that was delivered. A deadlock or blocking alert that fails to send no longer uses up its count. A failed agent job is no longer recorded as announced when every channel failed, so a restart before the retry no longer loses it; a crash between a send and that record can send the same failure again. Closing Lite ends a webhook alert post that is still in flight, instead of letting it run out its timeout. +- **A removed server no longer leaves alert state behind** ([#4837]) - an alert check or send could still be running when its server was removed. It then left state behind, and the server inherited that state when it was added again. A stale availability group role could page a failover. A stale "already reported" mark could hold back the server's first alert. In Darling, a stale offline mark sent "Server Restored" on the first connect. A check that finished after the removal could also claim an availability group for the removed server, so the group's other monitored replicas stopped judging it. The removal now drops that state, and a check or alert send that finishes afterwards records nothing. +- **The daily retention purge paces its deletes** ([#4835]) - it deleted rows at full speed, and the store wrote about 6 GB of WAL in 7 minutes. The PostgreSQL checkpoint running at the time took 23.5 seconds to sync, and collection slowed on every server. The purge now waits between batches to hold the store's WAL to half of what its checkpoint settings absorb. The collection log shows the store's WAL during the purge and how long it waited. +- **The Store Checkpointer Pressure alert sees one long checkpoint sync** ([#4835]) - it judged only the hour's average sync per checkpoint. A single 23-second sync among several short ones stayed under the 10-second bar. It now also judges the longest single sync, sampled once a minute. +- **get_store_metrics reports the longest checkpoint sync the alert judges** ([#4835]) - the hour's longest single sync is stored with the hourly checkpointer counters. The tool shows it and judges it against the same 10-second bar, so the tool and the alert agree. +- **Query Store trends no longer read low after a quiet interval** ([#4833]) - Query Store stores no row for an interval with no executions, so the next interval's rate was divided by the gap plus its own length. It now uses the interval's own length, for rows collected after the upgrade. The `get_query_store_duration_trend` description in both apps now describes that rate: its head says only a point with no stored end and no earlier point has null rates, and its guide text says each point is rated over its own stored interval. +- **Editing a server's host in the Darling viewer keeps its favorite star with the server** ([#4831]) - Before, the star stayed behind under the old address and marked any server added there later, and unchecking it in the same edit did not clear it. +- **get_store_metrics no longer reads two days of store growth as one** ([#4830]) - A day whose last snapshot came early in the day, after the service was down, was compared with the next day's last snapshot almost two days later and shown as one day's growth. Such a pair is now left out, and the tool says its times are UTC. +- **Darling and Lite count the I/O anomaly tiles' samples the same way** ([#4820]) - Darling counted a row once for both the read and the write tile, so it counted some read-latency tiles that Lite correctly left out, and the sample count on those tiles differed between the products. Darling now counts read samples and write samples separately, as Lite does. +- **A tile's peak time no longer changes between runs when two samples tie** ([#4820]) - when two samples tied on the peak value, the time shown for the peak was whichever the engine reached first, so it could differ from one run to the next with no change in the data. Both products now show the later of the tied samples, for Lite's CPU tile and for every Darling tile that reports a peak time. A Darling tile's peak time also skips a sample with no value, as the tile's peak value already did. +- **Lite's archive views stay readable while compaction swaps files** ([#4816]) - A query that ran during a compaction, or while a run finished the swap an interrupted run left behind, could find an archive table empty or missing rows for a moment. +- **Lite no longer counts archived rows twice during an archive run** ([#4816]) - a new archive file was visible before its rows were removed from the database, so a query in between counted them twice. The file is now added and the rows removed under one lock. +- **"Recurring at this hour" survives a daylight saving change** ([#4814]) - After the clocks changed, older findings shifted by an hour, so the label went missing for up to three weeks, and a job that had not moved could read as "Maintenance window moved". +- **A nightly job no longer reads as "Maintenance window moved"** ([#4814]) - Rows from other weekdays were compared as if they were the same weekly slot. +- **Reading a PostgreSQL log no longer records a false error when the read starts inside a multi-byte character** ([#4813]) - a first read, or a read after a fallback, starts 4 MB before the end of the log, and when that byte was inside a multi-byte character PostgreSQL refused the whole slice and the cycle logged an error that blamed a planted byte. The read is now repeated in the same cycle from 1, 2 and 3 bytes later, and the error row is written only if all four attempts are refused, with a message that says a split character is possible and that later reads resume from a full line. +- **A byte that is invalid in the database encoding costs one log read per cycle, not four** ([#4813]) - the retry from a later start cannot cure an invalid byte anywhere in the 4 MB window, and it is refused at every start on every cycle. After a cycle that used every start and was refused at each, the collector now makes one read per cycle until a read succeeds, and goes back to retrying after that. The memory is kept in process, so a restart pays one four-read cycle. +- **PostgreSQL error rows under the pgBadger log prefix now carry their user and database** ([#4813]) - a `log_line_prefix` written as `user=%u,db=%d` gave a null user and database on every error row, because only `user@db` was read. Both `user=` and `db=` are read now, wherever they sit in the prefix. +- **The plan-capture readiness read now reports a log prefix the log readers cannot read** ([#4813]) - a `log_line_prefix` with an unbracketed process id (`%m %p`, `%t %p:`, `%t [%p-%l]`) makes the stderr log readers drop every line, and the target looked quiet. A new `log_line_prefix_readable` row says whether the prefix starts with a timestamp and carries `[%p]`. +- **A deadlock report cut at the end of a read waits for its last lines instead of being stored as a fragment** ([#4813]) - a report whose HINT line the read did not reach was stored from the lines the read had, and one cut inside its DETAIL block was stored again under another hash when the next read had it whole; on the RDS log API, which never offers the rest again, only the fragment was stored. The newest report of a self-hosted read with no line after its DETAIL block is now left for the next read, which covers those lines again. On RDS the report is held until the next chunk and stored as it is if it is still unfinished after one more chunk, if its file has ended, or if it is larger than 1 MB. A report that other log lines follow is stored at once. +- **The fleet sweep bands a server outage as No Data instead of Warning** ([#4811]) - While a server could not be reached, its "Collection Stopped" alerts counted as data. The outage then showed as a Warning with an alert count, counted as reported, and hid the stale-collection item. +- **A collector that fails on half or more of its databases now bands Warning** ([#4811]) - A run that skipped half or more of its databases still recorded success, so Collection Health read Healthy with no errors. +- **The Darling viewer's Collection Health tab no longer re-reads the store's schema version on every refresh** ([#4811]) +- **Plan-forcing advice says when SQL Server's own recommendation names the proposed plan as the regressed one** ([#4810]) - The plan-force bot's journal now records a blocked decision for that plan instead of a would-force one. Each target in the script now also shows how long ago its plan was last seen. +- **Lite no longer archives the same rows twice after it is stopped in the middle of an archive run** ([#4808]) - If Lite was closed or killed after it wrote an archive file but before it deleted those rows, the next run archived them again, and the archive counted them twice. Leftover partial files from an interrupted run are now removed, and the archive views are rebuilt even when compaction fails. +- **Lite's Query Store repair also covers archive months that compaction split into parts** ([#4808]) - Rows in those part files were never repaired. +- **Darling retries a store that is at its connection limit when the service starts** ([#4806]) - Before, a store that was briefly full at start, after a restart storm or while another application held its connections, stopped collection until someone restarted the service. Other resource errors (disk full, out of memory, a configuration limit) still stop it, because they need an operator. +- **The compose `darling` container reports unhealthy when a startup failure has stopped collection** ([#4806]) - It used to show as running although it never collected. +- **The docs now name the oldest supported builds: SQL Server 2016 SP2 and SQL Server 2017 CU3** ([#4805]) - The query stats and procedure stats collectors read columns that older builds do not have. The docs said SQL Server 2016 and named no service pack. +- **A webhook that never answers no longer holds up alert delivery** ([#4803]) - each webhook post (Teams, Slack, generic and PagerDuty, and the test sends for them) waited up to 30 seconds with no way to cancel it, and a delivery makes those posts one after another. Each post now gives up after 10 seconds and records the channel as failed with "timed out after 10 seconds" as the reason. When the Darling service stops, an alert post in flight is cancelled instead of waited out, and the abandoned delivery writes no history row. Analysis-finding alerts, and every alert in Lite, get the 10-second bound but are not cancelled. +- **Query Store backfill now logs a warning when it cannot read its list of work** ([#4801]) - when the backfill's read of the databases to work on, or of a database's stored floor, failed, both apps logged it only at Debug and stopped filling tails and outage holes with no visible sign. Both apps now log one warning at the first failure of a run of failures, and again on the next failure after a read succeeds. +- **Query Store backfill keeps a slice size that works instead of swinging back to the size that timed out** ([#4801]) - after a timeout the slice halved, but any completed slice sent the server back to the full hour, so a database whose 30-minute slice fit and whose 60-minute slice did not wasted a 60-second read on every other tick. The slice still halves after a timeout, now keeps its size after a slice completes, and widens by one step (never above one hour) after three completed slices in a row. Both apps. +- **PostgreSQL analysis: a configuration setting shown under another finding now carries its own advice** ([#4799]) - A setting that hung off another finding, such as maintenance_work_mem under an autovacuum backlog, was described as "see its card", and only analyze_server shows that card. The viewer, get_analysis_findings and the e-mail showed neither the setting's advice nor its fix. The finding's text now names each such setting with its own headline and adds its fix, so every place that shows the finding shows the advice. +- **The advice for turning autovacuum back on now names the provider's parameter group** ([#4799]) - The advice said only "autovacuum = on in postgresql.conf", which managed PostgreSQL (RDS, Aurora, Azure, Cloud SQL) does not let you edit. It now names the provider's parameter group or server parameters, which apply the change themselves, and keeps the reload for postgresql.conf. +- **A webhook channel that keeps failing no longer goes unnoticed while another channel delivers** ([#4798]) - A Teams, Slack, generic or PagerDuty channel could fail for weeks with nothing but log lines while another channel delivered every alert. A channel that fails three times in a row now raises a "Notification Channel Failing" alert in Darling and a tray notice in Lite, and clears with "Notification Channel Recovered" when it delivers again. Turning a failing channel off closes the alert with an entry that says the channel was turned off. The alert and the notice name the channel and the count and carry no error text, since a webhook error can carry the webhook URL. +- **The configuration change card no longer calls a metric "resolved" when only minutes have passed since the change** ([#4797]) - Until the after-window reaches an hour, a metric that appeared or vanished is shown as not yet comparable. +- **A server that is down when the Darling service starts now gets a "Collection Stopped" alert once the threshold passes** ([#4796]) - the check was skipped until the service had seen the server online, so a server that stayed down across a service restart got no "Collection Stopped" alert, and no reminders, until it came back. Staleness is now judged from the later of the server's last success and the service start, so the alert fires once the staleness window (30 minutes by default) has passed since the start, and its text counts the minutes from the start. A healthy server whose last success predates the restart still does not alert at startup, and a server that reconnects after a restart is judged from the start rather than from its pre-restart rows. +- **Adding a server whose id matches a different server's no longer overwrites it in the Darling viewer, and Lite now refuses to add or edit onto it** ([#4794]) - Two different servers can hash to the same id. In the Darling viewer, Add Server and Add Multiple Servers wrote with an upsert that rewrote the server already holding it: that server stopped being monitored and its history showed under the new one, with no message. Add Server now refuses the add, saves nothing and names the server that holds the id, and adding a server that is already monitored at the same address shows the "already monitored" message instead of rewriting its row. Add Multiple Servers refuses that row, counts it apart from added, skipped and failed, and shows the count in its status text. The `--add-server` totals line now counts collided servers, and the command exits 1 when a server was not added because its id collides. In Lite, both servers were added and then collected into one history, so each tab showed both servers' rows with no message. Lite's Add Server and Edit Server now refuse a server whose id a different server holds and name that server, and adding the same server twice shows the "already monitored" message. Lite's Add Multiple Servers marks such a row "Not added", counts it apart from added, skipped and failed, and the main window's summary shows the count. An edit that keeps its id is still allowed, so a pair saved earlier stays editable. Importing follows the same rule: Lite's Import Settings no longer adds a server whose id a different server holds, and the Darling viewer's migration and Import Settings no longer leave such a server out silently as if it were already monitored. Each refuses it and reports it: Lite's Import Settings message shows the count and its log names the entry and the server that holds the id, and the Darling viewer logs both servers, with its Import Settings message showing how many servers it did not add. +- **`get_store_metrics` no longer reports a gap of several days in the store's size history as one day's growth, and it marks today's partial day as partial** ([#4792]) - The whole-store `daily_growth` labeled the difference between two neighboring daily points with the later day without checking that they were a day apart, so the first day after a stretch with no snapshots carried the whole stretch's growth as a single-day spike, and the per-server ingest rate built on it overstated what onboarding a server costs. Today's point, the latest snapshot of a day still in progress, was shown as a full day. A day is now compared only with the calendar day before it, and a wider pair is left out of the list (a hole in `daily_growth` is missing snapshots, not zero growth). Each point also carries `metric_time` (the snapshot it was read at), `span_days` (always 1) and `partial` (true for today), which makes each point about 74 bytes larger. +- **The store checkpointer alert no longer tells you to raise max_wal_size for every requested checkpoint** ([#4791]) - The informational Store Checkpointer Pressure alert, and the checkpointer note in the MCP store metrics, called any requested checkpoint "WAL-forced" and said the store had written more WAL than max_wal_size allows. PostgreSQL also counts a base backup or a CHECKPOINT statement as requested, and its counters do not say which one happened, so the suggested remedy was sometimes wrong. The alert's text now says "requested checkpoint(s)". The alert detail and the note now list all three causes, and when a requested checkpoint is what fired them, they also point at the log_checkpoints lines that say which and suggest raising max_wal_size only for the WAL cause. The get_store_metrics tool description says the same about its requested field. The alert fires on the same conditions and stays informational. +- **`mute_analysis_finding`, in Darling and in Lite, no longer mutes the pattern on whichever matching server sorts first** ([#4790]) - a `server_name` that matched more than one server (a partial name, or a display name shared by per-database and read-only registrations of one machine) muted the pattern on whichever sorted first and echoed the caller's spelling. Both products now resolve it to exactly one server, Darling the way `remove_server` does: a name that matches more than one server answers `ambiguous` with the candidates and mutes nothing, a name that matches nothing (a blank one included) answers `not_found`, and a successful call reports the resolved server name. `remove_server` resolves the same way: a name that matches one registration's own server name exactly, in the same letter case, picks it even when a sibling shows that name as its display name, while a partial name, a display name or a different letter case that matches several registrations still answers `ambiguous`, and the successful answers of both tools now say which kind of registration was picked (`kind`: plain, read-only or per-database). +- **Repeating a `create_mute_rule` call no longer creates a second identical rule** ([#4790]) - a client retry, from MCP or the web route (`POST /api/mute-rules`), left two identical mute rules. A create that repeats an enabled, unexpired rule's scope, patterns and expiry now inserts nothing and answers `already_exists` with the existing rule's id (HTTP 409 on the web route). A disabled or expired rule does not count, and a different expiry is a different rule. +- **`add_servers` reports every server in the batch when a later entry fails to save, and no longer says "added" for a save that wrote nothing** ([#4787]) - `add_servers` now reports every server in the batch when a later entry fails to save, instead of reporting the whole call as failed after it had already added the earlier ones: the failed entry and the ones after it come back as the new status `not_saved` (counted as failed) and the earlier ones stay `added`. It rejects a literal SQL password or service principal client secret on Linux, where it cannot be encrypted, and points at the `env:` or `file:` reference form. When the save wrote nothing because another server holds the same id, it answers `collides` (or `duplicate` for a concurrent add of the same server) instead of "added". +- **The plan-force bot no longer reads a database missing from the newest automatic-tuning capture as "automatic correction off"** ([#4784]) - it uses that database's last state from the past 24 hours, and blocks the database as unknown when there is none. +- **After a failed state read, the plan-force bot looks at the same plans again after 1 hour instead of holding them for a day** ([#4784]) - the blocked row from a failed read now holds its plan for 1 hour, and every other blocked row keeps the 24-hour cooldown. +- **Web viewer: a page left loading in a hidden or paused tab refreshes normally again** ([#4781]) - A page whose data finished loading while its browser tab was hidden, or while auto-refresh was paused, used to count the whole hidden or paused time as its load time. It then waited 15 minutes before its next refresh and showed "(slow page)". The page now counts its load as finished when its data arrives, and refreshes on its normal schedule. +- **The PostgreSQL plan-regression finding now reports the worst regression when more than 50 statements changed plans in the window** ([#4780]) - the plan-change read kept the 50 lowest query ids, so the worst regression could be dropped, or no regression reported at all when the kept rows had too few calls. The read now keeps the statements the pick would choose from, worst first. +- **A standby that was removed or replaced no longer outranks the live standbys for the rest of the window** ([#4780]) - its last row stayed in the window, so the finding described it in the present tense, kept its synchronous weighting and reported the whole table's span. Live standbys now rank first, and a standby that stopped reporting gets advice that says when it was last seen. +- **A dropped replication slot no longer grades Critical for the rest of the window** ([#4780]) - an inactive, growing slot kept grading Critical from its last row after it was dropped, and its inactive hours kept growing. A slot or database that stopped reporting now grades nothing, ranks behind the ones still reporting, and measures its inactive hours to its last row. +- **The alert history now records whether each notification channel delivered or failed** ([#4779]) - an alert that reached one channel and failed on another was stored as a plain delivery, so a broken channel was invisible while a sibling kept delivering. The route record on each history row now says `delivered`, `failed` or `not attempted` per channel, in both Darling and Lite, and `get_alert_history` returns it as `outcome`. No error text is stored, because a webhook error can name its endpoint URL; `send_error` is unchanged. +- **The alert notebook finds an alert's resolution even when it came late, was dismissed, or sat behind many newer alerts** ([#4778]) - The notebook's status only looked at the first 24 hours after the alert, at most 200 rows, and skipped dismissed rows. A store alert that cleared more than 24 hours later, a Cleared row hidden by "Dismiss all", or a fleet-level alert whose resolution sat behind 200 newer alerts from other servers read "Fired again" or "Unknown" instead of "Resolved at ...". The status now reads the first resolution row and the first later firing of the metric directly, with no 24-hour limit and no row cap, dismissed rows included, and scoped to the alert's server when it has one. +- **A fleet-level store alert with no resolution reads "No resolution recorded" instead of saying collection stopped** ([#4778]) - A store self-alert with no resolution row and no later firing read "Unknown (not collected since ...)" in the alert notebook, which says a collector stopped. Store alerts have no collector, and the process that evaluates them serves the page, so it now reads "No resolution recorded". +- **Darling now sends alert email through notification routes when the default recipient list is blank, instead of treating email as not set up** ([#4777]) - A notification route that named email recipients as its only destination sent nothing when the SMTP settings had a server and a from address but no default recipients, because email counted as set up only with the default list. Email is now set up with a server and a from address, and a route's recipients are enough to send. An alert that no route covers and that has no default recipients is skipped without a failed row or a cooldown, and an alert nothing else delivered is recorded as undelivered. The Send Test Email button still needs the default list. The Settings window's Validate message for a blank default list now says what the list is for. +- **`--configure-network` keeps the web listener's `tls` and `oidc` settings** ([#4775]) - Re-running the wizard for the web listener no longer drops `web.network.tls`, `web.network.oidc` or any other setting it does not ask about, so the dashboard keeps HTTPS and OIDC sign-in after the restart. The MCP and store blocks keep their other settings too, and the wizard prints a `Kept ... from the existing darling.json.` line naming what it kept. +- **A repaired hourly hole no longer leaves a partial day in the daily rollups, and days an earlier repair left short are rebuilt once after the upgrade** ([#4739], [#4763]) - After an hourly hole repair, the daily rollups that already held a bucket for the repaired day were not refreshed again, so a day older than the daily policy's 3-day window stayed partial and became the only copy once the hourly aged out. The repair now force-refreshes those complete days (at most 3 per daily per range), including the day-grain daily behind the interval daily, and the seam repair log line reports the holes still standing. After the upgrade, the service also checks each daily rollup against the hourly data under it, once, and rebuilds any day an earlier hourly repair left short, one day at a time. The repair logs each daily day it rebuilds with the seconds it took, and a day rebuilt after a repaired seam range is no longer rebuilt twice and counted twice in the repair's chained-days count. +- **Darling upgrade no longer says "New build in place." after copying nothing** ([#4762]) - when the staging folder's name contained [ or ], the upgrade script's copy matched nothing and threw nothing, so it reported success over the old build. It now copies the folder by literal path, and stops with a plain message if the installed service executable does not match the new build's after the copy. The installer no longer skips hardening older darling.json backups, or looks up its own files by wildcard, in an install folder with [ or ] in its name. +- **An older Lite refuses to open a data file from a newer version** ([#4753]) - An older Lite pointed at a data folder that a newer Lite had upgraded kept running, and every batch for the 13 tables that gained columns in schema versions 60 to 65 failed with only a log line to show for it. Lite now stops at startup with a message that names the file and both schema versions, and does not write to the file. +- **Lite re-applies its newer columns on every start** ([#4753]) - A data file where one of the columns added in schema versions 60 to 65 failed to apply, or was stamped without it, kept failing that table's collection on every start. Lite now adds any of those columns that are missing on each start, so the file gets it back. A column that still cannot be added is logged as an error naming the table and column, and the next start tries again. +- **After the computer sleeps and resumes, Lite runs each due collector once** ([#4753]) - After a sleep, each collector that was due ran twice about a minute apart, which wasted queries and stored an extra sample per collector. Lite now starts the cycle at the current collection slot after a resume, so each due collector runs once. +- **Two analyze_server calls that overlap no longer give the second one a false all-clear** ([#4742]) - The Darling and Lite MCP servers shared one analysis service, so a second analyze_server call made while the first was still running got "No significant findings" for a server it never analyzed. Each call now runs its own analysis in both products. +- **In Lite, a server that just went down no longer holds a connection slot while its retries wait** ([#4740]) - Each connect attempt now takes a slot and gives it back when the attempt ends, so a server that went down since its last status check no longer holds a slot through four connect timeouts and seven seconds of backoff, and can't stall collection for the other servers that way. +- **The self-hosted PostgreSQL log tail no longer stays on the outgoing log file after a rotation in the same second** ([#4738]) - When a size or age rotation put the old file's last write and the new file's first write in the same second, the tail could pick the old file as current on the stderr, csvlog or jsonlog route, so lines in the new file were not collected until the next line was logged in a later second; it now breaks that tie by file name, so the newer file is read. +- **Store upgrade: copy mode is chosen from the data folder's own volume and a finished size count** ([#4725]) - The pre-upgrade headroom check read the free space of the data directory's drive letter and took a size walk an error had cut short as the size, so a data directory on a folder-mounted volume, or one whose walk failed partway, could be upgraded in copy mode and fill the disk (the store came back on its old major, but was down for the attempt). The free space is now read for the data directory's parent itself, and an unfinished size walk falls back the way too little room does: hard-link mode where the volume supports it, otherwise no upgrade. +- **Store upgrade: hard-link mode removes the pre-upgrade directory even when a settings carry fails, after saving the old `postgresql.conf`** ([#4725]) - In hard-link mode the moved-aside pre-upgrade directory shares its files with the upgraded cluster and is not a rollback copy, but a failure carrying `postgresql.auto.conf` or the operator's `postgresql.conf` lines left it in place for two service starts. It is now removed as soon as the carries are done with it, whether they succeeded or failed. The old `postgresql.conf` holds the operator's lines below the `darling-managed.conf` include and exists nowhere else, so every major upgrade now first copies it beside the data folder as `postgresql.conf.pre-upgrade` (restricted to the service account like `postgresql.auto.conf.pre-upgrade`, covered by `--harden-files`, and kept until a later major upgrade replaces it), and hard-link mode removes the directory only once that copy exists, or when there was no `postgresql.conf` to copy. If the copy cannot be made, the directory is kept with a warning and ages out after two service starts, as before. The warnings for an operator line the new major rejects now name where the original line is kept (the saved copy) instead of the pre-upgrade directory. +- **Store settings migration: a repeated attempt restores the newest backup of `postgresql.conf`** ([#4725]) - A failed migration attempt restored the FIRST attempt's backup, so edits made to `postgresql.conf` between attempts were lost. A new backup is taken when the file changed since the last one, and a failed or resumed attempt restores the newest. +- **Store free-space checks and reports read the data folder's own volume** ([#4725]) - The free-space check before `--backfill-rollups` and the plan dimension compaction, the WAL sizing (`max_wal_size` and `min_wal_size` at every service start), the store host profile (the start-up log, `--check-settings` and the MCP host tool), and the store disk-pressure alert read the size and free space of the data directory's drive letter. A data directory on a volume mounted at a folder was therefore judged by another volume: a backfill or a compaction could start on a volume with no room for it, the WAL ceiling and the reported size and free space came from the wrong disk, and the disk-pressure alert watched a disk the store is not on. On Windows they now ask for the data directory itself, as the upgrade check does. The alert's free figure is now the space available to the service account, as the other reads use, which differs from the volume's total free space only where the account has a disk quota. Where that read fails, each keeps its old answer for an unreadable volume (the verbs refuse, the WAL sizing is skipped and the WAL settings in force stay, the host profile shows a volume that is not ready, the disk-pressure alert gives no signal that check). The filesystem name in the host profile still comes from the drive letter, and other platforms keep the old read. +- **Lite archive compaction no longer loses a month when a promote fails** ([#4718]) - hourly compaction deleted the month's existing parquet file before moving the merged replacement in; a move that failed (a scanner or backup agent holding the fresh file) then deleted the merged copy too and the month was gone, with part files losing both old parts and double-counting the new rows. The swap now sets the existing files aside, moves every merged file in, and deletes inputs only after all of them are in place; a failed or interrupted swap is undone or finished on the next run. +- **The size-triggered Lite reset no longer deletes the database after a failed export** ([#4718]) - when the store hit its size limit and one table's export failed, the reset ran anyway and that table's hot window was lost; a kill mid-export could also leave a truncated file that hid every archived month of the table. Exports now go to temp files, nothing is promoted until every export succeeded, a failure leaves the database and archive untouched and backs off, and a kill between export and reset no longer duplicates the hot window. +- **The tab Refresh button no longer runs collectors during a Lite database reset** ([#4718]) - a reset could delete the database under a Refresh run and lose everything collected until the next restart; the run now registers with the reset gate like the scheduled and tab-open collections. +- **Lite archive views now include compaction's part files** ([#4718]) - a month that compaction split into `_ptNNN` files dropped out of the archive views, and a table with only part files showed no archive at all. +- **Importing a previous Lite install no longer overwrites this install's part files, and imported files now expire with retention** ([#4718]) - an imported part file of the same month and table was compacted over the local one; imported files also never aged out because their prefix hid the date. +- **A failed archive export no longer leaves a partial file on disk** ([#4718]) - When DuckDB failed partway through writing an archive export (out of memory, disk full), the partial `.tmp` file stayed behind, and the size-triggered reset repeated that every 15 minutes. The reset and the hourly archival now delete the partial file when the export fails. +- **Reads of an archive view no longer fail after old archive files expire** ([#4718]) - Expiring a table's last multi-part month (or its last single-file month while part files remained) made every read of that table's history view fail until the next hourly refresh. The views are now rebuilt right after retention deletes files, and after the cleanup of files a killed size-triggered reset left behind. +- **A managed store moved aside by a failed upgrade is no longer replaced by an empty one** ([#4717]) - When an in-place PostgreSQL upgrade could not move the data directory back, the next service start initialized an empty store in its place, wrote a new superuser credential over the old one, and deleted the real store as an expired rollback copy two starts later. A start now refuses to initialize while a `-old-*` or `-upgrade-*` sibling holds a cluster and names the rename to do by hand, and the rollback sweep counts no start until a cluster is back at the data directory. +- **A start after an interrupted store upgrade resumes it instead of refusing every start** ([#4717]) - When the service died between the runtime swap and the upgrade's commit, or the revert was refused, every later start stopped with "the PostgreSQL 17 binaries are not on this host" although they were in `pg-runtime-prev`, and deleting the runtime stamp to force a retry deleted them. The start now finds the store's binaries there, the runtime update never empties `pg-runtime-prev` while the store still needs it, and the refusal's hint names a path a start reads. +- **A failed store upgrade that left no startable store stops the start** ([#4717]) - A failure that could not put the data directory back, or could not revert the runtime, used to let the start go on, into the empty-store initialize above or onto PostgreSQL 18 binaries in front of a PostgreSQL 17 cluster. It now stops with the hand step in the message, and the worker does not retry it. +- **The pre-upgrade rollback copy survives the two service starts it is kept for** ([#4717]) - A start the worker retried in the same process counted as two starts against the copy. The sweep now runs once per service start. +- **PostgreSQL 13 servers read through csvlog are no longer reported as quiet** ([#4714]) - The csvlog parser required exactly 26 columns, but PostgreSQL 13 writes 24 (`leader_pid` and `query_id` arrived in 14), so every PostgreSQL 13 record was rejected. Log events, deadlocks and plan capture came back empty, and the run counted one discard however many records were rejected. The parser now accepts 24 or 26 fields, and a read it cannot use reports how many records it dropped. A PostgreSQL 13 auto_explain capture has no query id, so it is stored as an orphan plan (query id 0) instead of being counted as forged. +- **RDS and Aurora PostgreSQL log reads now collect the lines a log file received before RDS rotated it, and resume where they stopped after a restart** ([#4713]) - Deadlock, log-event and plan-capture reads opened only the newest RDS log file, so whatever the previous file received after the last read was never collected, a new stderr file was read from its last 10,000 lines instead of its first line, and the read position lived only in memory, so a restart re-read just the last 10,000 lines of the newest file. A read now finishes the file it was reading before it moves to the newest one, in the same cycle (at most four reads per cycle), and a new file is read from its first line. Each read saves its position to collect.collector_state once its rows are stored and loads it at start; a saved file RDS no longer lists falls back to the newest file's last 10,000 lines. Files that rotate away entirely between two reads are still not read, but the run now records how many in log_files_skipped_by_rotation, and a missing saved file in log_resume_file_missing, with a sentence on the collection_log row. The read also lists every log file even when the listing is paged (up to 20 pages), so a listing too long for one page can't hide the newest file or the file a saved position names; past 20 pages it uses the files it has and logs a warning, at most once an hour for each instance. +- **Down servers no longer use up the fleet's collection slots, and a command timeout no longer drops a healthy connection** ([#4712]) - A connect attempt against a dead server takes about 15 seconds to fail, and it ran inside the fleet collection gate, so about 22 down servers filled the default gate and healthy servers queued behind them. Connect attempts now run in their own small gate, and the retry delay grows from 60 seconds to about 4 minutes (with jitter) while a server stays down; it resets when the server connects or its definition is edited. A definition edit made while a connect attempt is running is no longer lost: the attempt remembers the definition it used, and a stale attempt installs nothing and lets the next sweep connect with the new definition. Separately, a SQL Server command timeout dropped the server's connection and re-ran the Extended Events setup and on-load snapshots even though the connection was still good, costing a stressed server 75 seconds or more of collection; the service now drops the connection only when a probe on a fresh connection fails. +- **A memory grant that used none of its memory now gets an Excessive Memory Grant finding** ([#4705]) - Rule 9 skipped any plan whose `MaxUsedMemory` was 0, so a grant of 1 GB or more that the query never used, the largest possible waste, got no finding. The parser now records whether the plan carried a `MaxUsedMemory` attribute, and the rule fires for a grant of at least 1 GB that used 0 KB with the message "Granted N MB but the query used none of it." A plan with no `MaxUsedMemory` attribute (an estimated plan, or one with no runtime grant info) still does not fire, and the ratio message and 10x threshold for a grant that used some of its memory are unchanged. +- **Estimated Plan CE Guess names the predicate behind each default guess and follows the plan's CE model version** ([#4705]) - Rule 33 called the 30% guess an equality guess (it is the inequality guess), called 10% and 1% inequality guesses that no predicate produces, never looked for the real equality guess, and ignored the statement's CE model version. It now labels each guess for what produces it, detects the equality guess (the square root of the row count from CE 120, the row count to the power 0.75 under CE 70), and reports a band only when the plan's estimator has it. The warning type, the 100,000-row minimum and the rest of the message are unchanged; the label text changes. +- **Expensive Operator no longer names an exchange operator** ([#4705]) - An exchange (Gather, Distribute or Repartition Streams) spends most of its elapsed time waiting on the operators around it, so Rule 35 could name the exchange while the operator next to it did the work. Rule 35 now skips exchange operators; the operator that did the work, such as a spilling Sort, keeps its warning. The 20% share, the 1,000 ms floor, the warning type and the message text are unchanged. +- **Self-hosted PostgreSQL targets no longer lose the log lines written just before a log rotation** ([#4704]) - The log tail keeps a resume marker per target, finishes the previous log file before reading the newest, and says so on the collection log when a file is gone or the log outgrew the read window. When one read holds more deadlock reports or captured plans than the collector's row limit, the newest are now kept, and the collection log says the limit was hit. +- **A Query Store backfill database that keeps failing no longer blocks the databases after it on the same server** ([#4703]) - The backfill runs at most one slice per server per pass in a fixed database order, so a database whose slice always failed stayed first in line and the databases behind it never got a slice. In Darling and Lite, a database that fails 3 slices in a row is now skipped while any other database on that server has work, one Warning is logged when it starts being skipped, and it is retried only when no other database has work, longest-ago failure first. A completed slice clears its count. The slice window still narrows per server after failed slices, as before. +- **The plan viewer's row label, edge colours and minimap, and analyzer rules 5 and 26, no longer misread operators in a parallel zone** ([#4632], [#4688], [#4698]) - Actual rows in a plan are a total, the estimate is per execution, and the execution count is a real loop count only on the inner side of a Nested Loops join (elsewhere in a parallel zone it is the thread count). The node label now prints the totals against the expected rows, for example "609 of 2,983 (20%)" (on a Nested Loops inner side the expected rows are the estimate times the executions, so "609 of 613 (99%)"), with just enough decimals that the numbers agree with the percentage: a Key Lookup that ran 117 times for 1 row reads "1 of 1.128 (89%)". An operator that returned exactly its estimate used to read "12 of 100 (12%)" at DOP 8 and, from DOP 11, was drawn in the critical colour; it now reads "100 of 100 (100%)" and stays neutral. The edge colours and the minimap follow the same rule: accurate operators in a parallel zone at DOP 11 or more stop drawing Blue, LightBlue or FluoBlue edges, and real misestimates in a parallel zone now show their full tier (a 20x underestimate at DOP 11 draws LightOrange, where it drew no colour before). On a Nested Loops inner side, the edge colour comes from the same ratio as the node's label, so an operator that ran thousands of times no longer gets a worst-misestimate red edge while its label shows the estimate was close. Rule 5 no longer reports a false overestimate on a parallel operator (a DOP 8 join with estimate 2,983 and 609 actual rows used to read "Estimated 2,983 vs Actual 609 (76 rows x 8 executions) - 39x overestimated" and is now silent), and rule 26 now reports "Row goal active: estimate reduced from 1,000 to 100" for a parallel scan that returned 500 rows, where it used to be swallowed. +- **Selecting the plan viewer's "+" tab through UI Automation (screen readers) adds one new sub-tab, not two** ([#4688]) - a UI Automation select on "+" sets focus on the tab and then selects it, and each counted as a click on "+", so one select added two empty "New Plan" sub-tabs in Lite and in the Darling Viewer. The plan viewer now treats the pair as one gesture and re-selects the sub-tab it just added. A mouse click or keyboard selection of "+" still adds one tab, and two separate selections still add two. +- **The Darling Viewer's server list is no longer a solid white box when the store is unavailable** ([#4685]) - While the store is unavailable the sidebar server list is disabled, and the stock list template painted it white in every theme, out of place next to the themed sidebar. Each theme now has its own list template: a disabled list keeps its themed background and border and dims instead. The same applies to the tag list in Manage Tags, which is disabled on a read-only seat. Enabled lists render as before. +- **Custom tab headers and the status-bar collector text now use readable, theme-following ink** ([#4682]) - In Lite, a selected server tab or Plan Viewer tab, and in Lite and the Darling Viewer a selected plan sub-tab, drew its label in the page text colour on the accent fill (1.99:1 on Dark, 2.71:1 on Cool Breeze); it now uses the theme's on-accent ink. In both apps, the status bar's "Collectors: N OK / erroring" text kept the previous theme's colour after a live theme switch until the next 30 second tick; it now follows the switch. In Lite, "Logging: BROKEN" uses the theme's critical text colour instead of a fixed red that was under 4.5:1 on every theme. +- **Web dashboard: a slow notebook or Custom View panel is no longer re-run while its previous read is still running** ([#4671]) - Composed panels read through a request the page's in-flight guard did not count, so a periodic refresh could fire a panel again while its last read was still running on the store. Panel reads are now counted like every other page read, so the page waits for them and the new slow-page back-off measures them. +- **Custom Views: window-total Query Store measures are no longer labelled "(ratio)"** ([#4664]) - "Query Store total CPU time" and "Query Store total duration" showed "(ratio)" in the measure pickers although they divide by nothing; each is a window total. The suffix now appears only on measures that are ratios. +- **Cool Breeze's warning text now reads clearly on the plan viewer's properties panel** ([#4658]) - In Lite, the Darling Viewer and the Dashboard, warning-tier text in the Cool Breeze theme (the missing-index impact percentage and per-thread skew on the plan viewer's properties panel) was a shade too light to meet the accessibility contrast guideline there. The warning color is now slightly darker by default, so that text meets the guideline on the panel and on the theme's cards, plan nodes and status bar. +- **Darling: the daily digests keep their time of day** ([#4656]) - The collector-cost digest, the fleet-sweep daily rollup and the analysis singles digest were due 24 hours after their last send and checked on an hourly tick that itself slid, so each arrived up to an hour later than the day before. Each now keeps a daily slot, and a late tick no longer moves the next day's. +- **Darling Viewer: the Plan Viewer opens when the viewer has no configuration or can't reach the store** ([#4649]) - The failure message now covers only the content area. Open Plan Viewer, View Log, Open Log Folder and About stay usable; the entries that need the store are disabled. +- **Custom Views AVG panels read from a rollup match raw to the last digit** ([#4647]) - The rollup route divided in floating point after rounding the sum, so for very large sums it could differ from raw's average by one unit in the last place. +- **Darling Viewer: restarting as administrator during an upgrade keeps its configuration** ([#4646]) - The restarted viewer read its own `--upgrade-takeover` flag as the path to darling.json and showed "darling.json not found"; it now reads its arguments the way `--test` does and passes the first launch's arguments on. +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - Each collector's next run was scheduled from when its pass started (Darling) or waited a full minute after the pass's work (Lite), so late starts accumulated: busy Darling stores ran 1-minute collectors about every 71 seconds and lost about 15% of per-minute samples. Both now keep a fixed grid and skip, rather than replay, a slot missed during a stall. Stores that were drifting collect correspondingly more data per day: up to about 20% more for the per-minute tables. +- **The plan viewer's minimap now draws the first time you open it** ([#4643]) - Opening the minimap on a freshly loaded plan tab used to show only the "Minimap" header with nothing below it, until you dragged its resize grip or closed and reopened it. It now draws the plan overview immediately. +- **Double-clicking a minimap node now centers it correctly** ([#4643]) - Double-clicking a node in the minimap to zoom to it used to leave the node off to the side once the properties panel opened, by as much as 200 pixels. It now centers in the space that's actually left after the properties panel opens. +- **Jumping from a plan warning to its operator now centers the operator** ([#4643]) - Clicking a warning header's link to jump to the operator it came from used to leave that operator off to one side, because the properties panel opening alongside it narrowed the view after the centering had already happened. It now centers in the space that's actually left once the panel opens. +- **Copy and paste no longer freeze the window for up to 9 seconds when another app holds the clipboard** ([#4634]) - In Lite, the Darling Viewer and the Dashboard, a copy or paste that found the clipboard busy tried 8 times, and each try could take about a second, so the window stopped responding for up to about 9 seconds. It now tries twice and gives up after about 2 seconds. +- **get_store_metrics no longer reports retired store objects as a failing sweep** ([#4633]) - The inventory counted every row left from an older sweep as a sweep that "is not completing", and pointed at a Warning line that does not exist. On an upgraded store those rows belong to objects the product retired, such as the superseded baselines and the frozen rollups' jobs. It now checks whether each object still exists. Retired objects appear in their own `dropped_objects` list with the time of their last row. Only an object that still exists is reported as a sweep gap, with the service-log lines that say why. The compression line also explains why `collection_health_hourly` is uncompressed instead of listing it as DISABLED. +- **The Runtime Summary no longer says a query used "100%" of a memory grant it never got** ([#4632]) - When a query's memory grant was zero, the plan viewer now says "No memory grant" instead of a fabricated "0 KB granted, 0 KB used (100%)". +- **Plan viewer orange text now reads clearly in the Light theme** ([#4632]) - In Lite and the Darling Viewer, the warning badge, missing-index impact percentage, per-thread skew text, and the node cost/elapsed/CPU/row-estimate text used a fixed orange that was too pale to read on a white background; they now use theme-aware colours that stay readable in both Light and Dark. +- **Collector status text in the status bar now reads clearly in the Light theme** ([#4632]) - When collectors were erroring or capture was down, the status bar text used a fixed orange that was too pale to read on a white background; it now uses the same theme-aware colour the plan viewer uses, readable in both Light and Dark. +- **The repro script declares each parameter once** ([#4626]) - When a batch's plan lists the same parameter, or an auto-parameterized `@0`/`@1`, for more than one statement, the repro script declared it once per statement and failed to run. Each name is now declared once; a name the statements give different types is left out with a warning, and a warning says when the statements' compiled values differ. Matches PerformanceStudio. +- **Collection health no longer calls an idle activity-only collector regressed** ([#4625]) - `waiting_tasks`, `query_snapshots`, `running_jobs`, `job_history`, `procedure_stats`, `pg_lock_stats` and `pg_session_states` store rows only while the target is busy, so three empty runs in a row is normal for them, and working collectors showed WARNING. They are now flagged as stopped only after 72 hours without a row. Errors, denials and staleness are still flagged at once. Every row flagged as regressed now carries the sentence that explains it, including the default `get_collection_health` rows, and the web Collection Health table has a Regression column. +- **The daily purge of the per-interval Query Store tables no longer scans each table in full** ([#4615]) - The two tables get an index on the column the purge and the Query Store read gate filter on, so a purge with nothing to delete no longer costs minutes on a large store (measured: a cold-cache no-op purge dropped from ~4.1s to ~0.6ms on a 4M-row table). - **A rare deadlock between a chunk drop and the alert pass's database-state check no longer fails that pass** ([#4612]) - The alert pass retries its database-state statements once when PostgreSQL picks them as a deadlock victim, the way the daily purge already retries its chunk drop. - **Copying from Lite or the Darling Viewer no longer crashes when another program holds the clipboard** ([#4600]) - Every remaining unguarded clipboard write (recommendation copy/AI-prompt buttons, MCP command/URL copy, grid/row/cell copy, chart image copy, alert detail T-SQL copy, sign-in device-code copy) now retries briefly instead of throwing when another process is holding the clipboard. - **The plan viewer no longer crashes when another program is holding the clipboard, and "Copy Query Text" now hands back the full query on a truncated single-statement plan** ([#4593]) - Copying anything from the plan viewer, blocking chain, deadlock graph, or a results grid used to crash the app if the Windows clipboard was briefly locked by another program; copies now fail quietly instead. Separately, "Copy Query Text" on a single-statement plan whose text hit SQL Server's 4,000-character cap now returns the full query the plan was captured from, instead of a copy cut off mid-word — for the Query Store and Active Queries plan sources that pass the original query text. @@ -351,7 +493,7 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **Web viewer timeouts now show a message and get logged** ([#4281]) - A read that ran past the store's timeout used to show a blank error. The service log had nothing, so a timeout looked the same as a bug. Now the page says "The store took too long to answer this read. Try again in a moment." Other failures show a short generic message. For both, the service log records the route, how long the read ran and what kind of failure it was. - **A major store upgrade keeps your ALTER SYSTEM settings** ([#4280]) - A major PostgreSQL upgrade of the managed store used to drop every `ALTER SYSTEM` setting. A raised `shared_buffers`, for example, went back to the default with no warning. The upgrade now checks each setting against the new version, test-starts the new store with the settings it accepts, and keeps them if that start works. A setting the new version rejects is left out with a warning that names it. If the test start fails, the store starts on its defaults instead, and a warning names each setting it dropped. The logs name settings but never show their values. The original file is kept as `postgresql.auto.conf.pre-upgrade` next to the data directory, so a dropped setting can be re-applied by hand. - **Lite says when a query window was cut short** ([#4279]) - Three MCP tools read raw tables with no rollup fallback: `get_top_queries_by_cpu`, `get_top_procedures_by_cpu` and `get_query_store_top`. Lite keeps those tables 30 days by default, and a user can lower that per collector. So a long window was read from much less history, with nothing to say so. Each tool now returns `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note` when the window was cut short. The three grids show "Showing since" and the effective start above the grid in the same case, after a time-range change or a slicer drag. On Lite and Darling alike, each tool's short description now explains `window_truncated`. The false line that said Lite always reads the full window is gone. -- **Top-CPU reads disclose a short window** ([#4278]) - Two MCP tools read raw tables that the store purges at 4 days with the rollups on. They are `get_top_queries_by_cpu` and `get_top_procedures_by_cpu`. A longer window came back short, and `hours_back` came back unchanged. Both tools now return `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note`, like `get_query_store_top`. The desktop viewer's Top Queries, Top Procedures and Query Store grids show "Showing since" and the effective start in the same case. The web viewer shows the same note on those panels. +- **Top-CPU reads disclose a short window** ([#4278]) - Two MCP tools read raw tables that the store purges at 4 days with the rollups on. They are `get_top_queries_by_cpu` and `get_top_procedures_by_cpu`. A longer window came back short, and `hours_back` came back unchanged. Both tools now return `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note`, like `get_query_store_top`. The desktop viewer's Top Queries, Top Procedures and Query Store grids show "Showing since" and the effective start in the same case. The web viewer shows the same note on those panels. On the hourly tier, `window_truncated` and `effective_start` come from a per-server check of where the rollup starts. When the window ends past the rollup's materialization ceiling, the note says nothing after it was read, or that the end edge is not verified when the ceiling is unknown. - **`get_query_store_top` stays under the MCP response-size budget** ([#4198]): The default call returned about 48 KB, over the 32 KB limit some MCP clients enforce. `query_text` is now a 400-character preview by default. A new `full_text` argument returns the whole statement. A new `query_text_truncated` flag on each row says whether the text was cut. The web viewer is unchanged and still shows up to 2,000 characters. - **`describe_custom_view_catalog` stays under the MCP response budget** ([#4198]): The Custom Views compose catalog returned 98 KB by default, three times the budget. It now returns a compact, source-grouped list by default (name, purpose, aggregate/unit vocabulary only). A new `source` argument drills into one source's full detail. A new `full_detail` argument returns the complete catalog as before. The web Custom Views editor is unaffected: it reads the full catalog through its own endpoint. - **MCP `get_collection_health` caps its response size** ([#4198]): A default call on a busy SQL Server fleet reached 41,669 bytes, over the 32 KB limit. Healthy collectors with nothing to report now compact to a shorter row by default. Any failing, stale, stopped, erroring, denied, or regressed collector keeps every field. A new `full_detail` argument restores every field on request. The web dashboard and Custom Views are unaffected. @@ -4221,8 +4363,112 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#4599]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4599 [#4600]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4600 [#4601]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4601 +[#4602]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4602 [#4603]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4603 [#4604]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4604 [#4610]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4610 [#4612]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4612 [#4614]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4614 +[#4615]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4615 +[#4616]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4616 +[#4617]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4617 +[#4618]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4618 +[#4625]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4625 +[#4626]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4626 +[#4632]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4632 +[#4633]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4633 +[#4634]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4634 +[#4643]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4643 +[#4644]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4644 +[#4646]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4646 +[#4647]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4647 +[#4649]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4649 +[#4656]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4656 +[#4658]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4658 +[#4664]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4664 +[#4665]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4665 +[#4667]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4667 +[#4669]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4669 +[#4671]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4671 +[#4680]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4680 +[#4682]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4682 +[#4685]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4685 +[#4688]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4688 +[#4698]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4698 +[#4700]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4700 +[#4703]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4703 +[#4704]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4704 +[#4705]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4705 +[#4712]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4712 +[#4713]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4713 +[#4714]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4714 +[#4717]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4717 +[#4718]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4718 +[#4725]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4725 +[#4738]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4738 +[#4739]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4739 +[#4740]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4740 +[#4742]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4742 +[#4753]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4753 +[#4762]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4762 +[#4763]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4763 +[#4775]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4775 +[#4777]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4777 +[#4778]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4778 +[#4779]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4779 +[#4780]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4780 +[#4781]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4781 +[#4783]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4783 +[#4784]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4784 +[#4786]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4786 +[#4787]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4787 +[#4790]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4790 +[#4791]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4791 +[#4792]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4792 +[#4794]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4794 +[#4796]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4796 +[#4797]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4797 +[#4798]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4798 +[#4799]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4799 +[#4801]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4801 +[#4802]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4802 +[#4803]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4803 +[#4804]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4804 +[#4805]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4805 +[#4806]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4806 +[#4808]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4808 +[#4810]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4810 +[#4811]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4811 +[#4813]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4813 +[#4814]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4814 +[#4816]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4816 +[#4818]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4818 +[#4820]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4820 +[#4826]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4826 +[#4827]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4827 +[#4828]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4828 +[#4829]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4829 +[#4830]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4830 +[#4831]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4831 +[#4832]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4832 +[#4833]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4833 +[#4835]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4835 +[#4837]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4837 +[#4838]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4838 +[#4839]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4839 +[#4840]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4840 +[#4841]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4841 +[#4846]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4846 +[#4847]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4847 +[#4848]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4848 +[#4849]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4849 +[#4850]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4850 +[#4851]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4851 +[#4852]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4852 +[#4853]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4853 +[#4854]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4854 +[#4855]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4855 +[#4858]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4858 +[#4859]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4859 +[#4861]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4861 +[#4867]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4867 From c82cdb8b501245be24e3b7d2f790538d4a70b77d Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Wed, 30 Sep 2026 14:40:52 -0400 Subject: [PATCH 2/5] CHANGELOG: splice #4863 (managed store random_page_cost = 1.1) into [Unreleased] Changed --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d43bbac7ed..4cdd461b9d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -122,6 +122,7 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ### Changed +- **The managed store sets `random_page_cost = 1.1`** ([#4863]) - the managed PostgreSQL store now renders `random_page_cost = 1.1`, a value suited to SSD storage, in place of PostgreSQL's default of 4, which prices a random page read at four sequential ones. The planner now picks index and bitmap scans that the default priced out. Measured on a production store over an hour at each value, back to back, total statement time was 2.3% lower at 1.1, with some statements faster and a few slower. A store upgrading from 3.8 moves its settings into the managed file at the upgrade start and gets the line there, and the value is in force from the service's next start after that. A `random_page_cost` set with `ALTER SYSTEM` still wins, and one already set in `postgresql.conf` when the store upgrades is carried into the managed file unchanged. - **Per-server Query Store reads fetch fewer rows** ([#4861]) - This covers the Queries grid, MCP's Query Store top read and the Trends Query Store chart. Each filtered one server's rows of the per-interval table by collection time only, which no index held. So it fetched every stored row of that server. Each read now also bounds first_execution_time, which the table's unique key holds, so older rows are dropped before they are fetched. Results do not change. On a large store, a day-long MCP read went from 3.1 s to 0.6 s. - **SQL Server blocking and deadlock baselines count the hours collection covered** ([#4853]) - each hour-of-week's mean now divides by the days collection ran in that hour. It used to divide by the days that had events. A covered hour with no blocking or deadlocks is a measured zero, so a spike into it says the baseline measured zero instead of "first occurrence". This needs at least one captured event in the 30 days, so a server that cannot capture the events keeps no baseline. Hours with occasional events get lower means. More hours are trusted, and a trusted hour must also pass the rate multiple, so those hours alert less often. An hour whose events cluster on a few days can alert at a lower event rate than before. These baselines are now computed once per UTC day, like the CPU and I/O latency baselines. Events earlier on the current day are not part of the baseline. - **The plan viewer's Runtime Summary lists CE model above Optimization, with Early abort under it** ([#4849]) - this matches PerformanceStudio. The Early abort label is indented when an Optimization row is shown. @@ -4471,4 +4472,5 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#4858]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4858 [#4859]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4859 [#4861]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4861 +[#4863]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4863 [#4867]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4867 From f8d6df2431382b3948f3d48ba6fc4b8f21520ffe Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Thu, 1 Oct 2026 17:53:23 -0400 Subject: [PATCH 3/5] Release 3.9.0: version, CHANGELOG heading and late entries --- CHANGELOG.md | 100 +++++++++++++++++++++++++++++++++++++++++- Directory.Build.props | 2 +- 2 files changed, 99 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4cdd461b9d..56b732fb1f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,14 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ## [Unreleased] +## [3.9.0] - 2026-10-01 + +### Important + +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - After upgrading, 1-minute collectors run every 60 s instead of drifting to about 70 s on large fleets, so per-minute data and store growth rise by up to ~20% compared with 3.8. + +- **Upgrading from 3.8 runs the Darling store migrations V126 through V157 on the service's first start** - the ones that touch existing data were measured at 43-server fleet scale to finish in about a second or less each (the largest, V150's two indexes over the collection log and job history). V157 adds a nullable `server_id` column to `config.config_mute_rules`. Adding a nullable column with no default is a metadata-only change in PostgreSQL, so it takes no time on a store of any size. V126 through V156 ran on production monitoring stores during the 3.9 pre-release builds, and V157 ran there at the release-candidate install, with no install stalled by a migration, so no maintenance window is needed. + ### Added - **`--drop-xe-sessions`** ([#4852]) - a command-line verb that drops the Extended Events sessions a removed server left behind. Run it just before removing the server. `--dry-run` lists them. `--print-sql` prints guarded statements to run by hand when the server is no longer configured. @@ -90,9 +98,9 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **The CPU sample's UTC instant and the server's time-zone id are now stored, so UTC-window readers stop deriving an offset that is an hour wrong across DST** ([#3653]) - `cpu_utilization_stats.sample_time` is the monitored server's LOCAL wall clock, and every reader that aligned it against UTC derived the offset per batch or from the single collected `utc_offset_minutes`, placing the samples nearest a DST transition an hour wrong. Darling V134 / Lite v63 add `sample_time_utc` beside the unchanged local stamp (the same instant off `SYSUTCDATETIME()`), which the viewer, MCP `get_cpu_utilization` and the Lite CPU window now prefer, and `server_properties.time_zone_id` (`CURRENT_TIMEZONE_ID()`, SQL Server 2022+ / Azure SQL; NULL elsewhere) beside the offset that could not say which side of a transition an instant fell on. Nullable, no backfill: the offset a server had at a past sample's instant is exactly what the store never recorded. - **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. +- **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 `log_lock_waits` lines (count, longest, relation), counting each wait once, even when PostgreSQL 18 logs it again while it goes on, and each line once, even when the log is read again ([#4886]) 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. +- **A collector can be enabled or disabled headlessly** ([#3752], [#4809]) - `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. They exit 0 on success, 1 for bad arguments or configuration, and 2 when the store can't be reached or refuses the login. - **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. @@ -267,6 +275,7 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **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. +- **The Extended Events collectors use less CPU on the monitored server to filter events by time** ([#4912]) - The blocked process report, deadlock, long query completion and system_health collectors now compare each event's timestamp inside the XQuery, instead of converting it with a value() cast first. In local tests that filter used 3 to 14 percent less CPU. The events collected are the same. ### Fixed @@ -736,6 +745,47 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **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. +- **`provision-roles.sql` stops at a role-name collision** ([#4809]) - When a role the script would create (`admin`, `viewer` or `mcp`) already exists without Darling's `darling-managed` marker, psql stops there with exit status 3 and leaves that role as it was. A caller's own `ON_ERROR_STOP` setting is kept. The README's psql command now passes `-X`, so an operator's psqlrc can't change the run, and asks for psql 10 or later. +- **Command-line verbs that open the store report an unusable store setting instead of crashing** ([#4809]) - Every verb that opens the store (`--validate-config`, `--check-settings`, the MCP and web endpoint verbs, `--add-server`, `--backfill-rollups` and the others) now exits 1 with a clear message when the store connection string can't be used. A managed store's unreadable credential, a DPAPI failure included, is reported as that. +- **Azure SQL Database and Managed Instance servers show their platform, not a SQL Server year** ([#4870]) - An Azure SQL Database showed as "SQL Server 2014". The MCP `list_servers` tool, the Viewer's server list and the Add-server test now say "Azure SQL Database" or "Azure SQL Managed Instance". Other servers keep their label. +- **Lite's MCP plan tools say Lite keeps no plans** ([#4871]) - They said a plan "may have been evicted from the plan cache", but Lite never stores plans. `analyze_query_plan`, `analyze_procedure_plan` and `get_plan_xml` now answer `not_collected`, say so, and point to `analyze_plan_xml`, and Lite's `analyze_server` next-step hints suggest `analyze_plan_xml` too. +- **Lite's MCP tools and FinOps inventory read the collected server properties** ([#4872]) - Lite looked up the edition and FinOps figures in a table that is never filled. On Azure SQL Database, 15 MCP tools answered `empty` or "may not have run yet" instead of `not_collected`, and the Server Inventory never showed average CPU, storage, idle database count or provisioning status. Both now read the collected server properties. `audit_config` names editions correctly in Lite and Darling. A server with no CPU sample in the last 24 hours shows no provisioning verdict, where it read as 0% CPU and over-provisioned. +- **Alert History's expanded rows show their labels** ([#4873]) - Blocking and incident details in Alert History showed bare values, with their labels pushed out of sight. Each value now shows its label, and each item's heading sits on its own row. +- **The server health starter dashboard can be created again, server pages show display names, and count charts use whole numbers** ([#4874]) - Creating the "Server health at a glance" dashboard failed, server pages showed registry keys instead of display names, and count axes repeated labels. +- **Darling stores Query Store text and plans for Azure SQL Database** ([#4875]) - On Azure SQL Database, Darling stored Query Store rows with no statement text and no plan, so plan analysis reported the plan as unavailable and blamed the database's capture mode. Darling now fetches the text and plan for each database it reads, and the missing-plan message also covers a plan that hasn't been collected yet. +- **Azure SQL Database no longer shows the host's hardware as its own** ([#4876], [#4882]) - On Azure SQL Database, the web's Server Properties, `get_server_properties`, the server inventory and FinOps showed the host machine's memory, sockets, cores per socket and hyperthread ratio as if they were the database's. Those now read n/a, with a note that they describe the host, and the service objective is shown. Logical CPUs still show, as the database's own scheduler count. +- **FinOps stops advising shrinks without CPU data, or VM and memory changes on Azure SQL Database** ([#4877]) - A server with no CPU sample in the window read as 0% CPU and was told to cut cores. It now gets no CPU or VM right-sizing advice. On Azure SQL Database, VM and memory right-sizing advice no longer appears, since a database's memory comes with its service objective and can't be resized on its own. CPU advice still applies there. +- **File I/O shows real file sizes on Azure SQL Database, and no size for a Hyperscale log** ([#4878]) - On Azure SQL Database, File I/O now takes each file's size from the database's own file list, so a Hyperscale data file shows its real size instead of a fraction of a megabyte. A Hyperscale log file lives in the log service, so it shows "n/a (log service)" with no size, and no size total counts it. Both apps. SQL Server and Managed Instance are unchanged. +- **Web panels show the history their read keeps when the Range asks for more** ([#4881]) - With the web server page's Range at "last 30 days", a panel whose read keeps only 7 days showed a "pick a shorter range" notice and no data. It now shows the last 7 days, says so, and its chart spans those days. Saved views behave the same way. In the view editor, Save and Auto-detect work for such a panel. +- **Azure SQL Database figures use the database's own vCores and memory limit** ([#4879]) - On Azure SQL Database, CPU share in top queries and top procedures is now measured against the database's vCores, so a 1-vCore database no longer shows half its real share. The FinOps Utilization card's CPU count shows the vCores too. A DTU-model database or an elastic pool names no vCores, so there the count and the share read n/a instead of using the host's count. The card's memory figure is captioned "Memory limit", since it is the database's own limit and not physical RAM. Both apps. +- **A Hyperscale log file no longer counts as ~1 TB of database storage** ([#4880]) - On Azure SQL Database Hyperscale the log lives in the log service, but its file reported about 1 TB, which inflated Database Sizes and the FinOps storage totals. It now reads "n/a (log service)" and stays out of every allocated total, in Lite, the Darling Viewer and the web, and `get_database_sizes` returns no size for it, with a note. Storage Growth leaves it out of the earlier sums too, so a database's older rows don't show up as a sudden shrink. +- **Wait names with a trailing space are trimmed, and two Hyperscale timer waits are ignored** ([#4884]) - Four wait names come back from SQL Server with a trailing space: EXTERNAL_GOVERNANCE_ATTR_SYNC_BACKGROUND, EDC_DOPP_LOCK, EDC_DOPP_BACKGROUND and SQP_STATS_REPORTING. An ignore entry or a lookup by the clean name never matched them. Both apps now trim the name as they read it. The first sample under the trimmed name starts fresh, so the upgrade shows no spike, and rows stored with the space stay until retention removes them. RBIO_COMM_RETRY and SQP_STATS_REPORTING, fixed-interval timers on Hyperscale, join the default ignore list for Darling and for new Lite installs. An existing Lite install keeps its own list. REMOTE_BLOCK_IO stays visible. +- **Lite no longer stores events twice, or loses its settings, after its 512 MB archive-and-reset** ([#4887]) - When the database passed 512 MB, Lite archived it to Parquet and reset it. The next collection then stored recent deadlocks, blocked-process reports, long queries and CPU and memory-pressure samples a second time, and re-read default trace and job history from the start. After the next restart, alerts that had already been sent could fire again, and a restart during an alert's cooldown could send it again. The reset also lost the user's analysis mutes, server tags and tag assignments. On a store created by an older version, it could fail to restore saved alert state or swap two of its timestamps. Lite now carries on from where it stopped across the reset, and keeps its alert, collector and user settings. Copies that an earlier reset stored now count once: blocked process reports, long query completions and system_health events show and count once ([#4918]), and deadlock copies are removed or counted once ([#4910]). Copied CPU and memory-pressure samples are not removed. +- **Perfmon rate counters show a per-second rate** ([#4883]) - The web Perfmon Counters grid showed a rate counter's stored value, which is a running total since the counter started, so Batch Requests/sec could read 11,641. The grid now shows the rate under "Per second" and the running total under "Total since counter start", and the trend chart below it plots rate counters per second. A small rate no longer reads as 0: one deadlock in 300 seconds shows 0.0033 a second. `get_perfmon_stats` and `get_perfmon_trend` add a `per_second` field for rate counters, in Lite and in Darling. +- **On Azure SQL Database, empty tabs say their collector doesn't run there, and the page file and memory state read n/a** ([#4888]) - Default Trace said there were no events in the window, CPU Scheduler showed nothing, and the ten System Events tabs fed by the system_health session said there were no events. None of those collectors runs on Azure SQL Database, and each tab now says so, in Lite and the Darling Viewer. Memory > Overview showed the page file as 0 MB and the memory state as "Available", values the collector stores because it has no source for them there. Both now read n/a in both apps and on the web, and `get_memory_stats` returns the state as null with a note. Lite's `get_blocked_process_reports` labels each row's source ("blocked-process-report" or "DMV snapshot"), as Darling's `get_blocking` does. +- **Lite keeps its saved settings through a crash during the archive-and-reset, and no longer double-counts an interrupted one** ([#4889]) - When Lite archived and reset its database, it copied the settings it keeps (mute rules, dismissed archive alerts, and, with #4887, alert state and server tags) to a temporary folder and put them back after the reset. A crash, a forced restart or an end-task between those two steps lost them silently. The copy now lives in the archive folder behind a marker, and the next start puts the settings back before anything reads them. While a restore is pending, those settings are read-only, so a change can't be undone at the next start. Changes made to them while the reset was starting are no longer lost either, which happened on every reset. A reset interrupted before the database was replaced no longer leaves its archive files counting history twice. A mute-rule edit or snooze that couldn't be saved is now reported as not saved, instead of taking effect until the next restart. +- **Azure SQL Database shows its own CPU count and calls its memory a limit** ([#4882]) - On Azure SQL Database, Logical CPUs show again in Server Properties, the server inventory and `get_server_properties`, as the database's own scheduler count. Memory, sockets, cores per socket and hyperthread ratio stay blank, because they describe the host. The Memory tabs in Lite, the Darling Viewer and the web, and the ready-made memory dashboard, label the totals "Memory limit" and "Available under limit", and `get_memory_stats` adds a note that the total is the database's limit, so use near 100% is normal. FinOps says "vCores" beside the CPU count and in CPU right-sizing advice, and shows Worker Threads in use as n/a when it wasn't collected, instead of 0. The plan viewer's Server Context card shows vCores and no host memory. On every edition, the FinOps health score now leaves out the CPU term when the window has no CPU sample, where it used to score a full 100. +- **Other databases on an Azure SQL Database server show their allocated size, with used space beside it** ([#4890]) - Database Sizes showed each other database's used space as its size, so a Hyperscale database read 119 MB with 10,240 MB allocated. Each now shows its allocated size as the total and its used space beside it. Its log size reads n/a in the Database Sizes grids, the web table and `get_database_sizes`, because the server doesn't report it, and Storage Growth and the Allocated vs Used chart say when a database's log isn't counted. At upgrade, the stored size of these databases jumps from used to allocated. Storage Growth and the file growth alert leave the older rows out, so the jump isn't read as growth, and these databases show no past size until new history builds up. A used size that wasn't read is reported as null, not 0. +- **On Azure SQL Database, an unknown volume is no longer reported as 0 MB free** ([#4892]) - Azure SQL Database doesn't expose the volume under a database file, so none is collected. Lite's `get_database_sizes` reported that as an empty mount point with 0 MB total and 0 MB free, which reads as a full volume. It now returns null for all three, as Darling does. The file-growth alert in both apps shows the free space and the file's share of the volume as n/a instead of 0.0 GB and 0%, and the FinOps grids show n/a for an unknown volume. +- **A new Azure SQL Database Hyperscale database no longer raises a wait-profile anomaly on every analysis window for its first three days** ([#4893]) - Until a server has three days of history, the wait-profile anomaly fires on a fixed bar of 250 ms of waiting per second. On Hyperscale, REMOTE_BLOCK_IO alone runs at about 1,000 ms/s on an idle database, so every window fired. On Azure SQL Database that bar now leaves REMOTE_BLOCK_IO out of the rate it tests. The wait is still collected, charted and counted in the reported rate, and SQL Server, Managed Instance and any server with an established baseline are judged as before. +- **Lite's FinOps advice, High Impact Queries and the SQL Server Agent check read archived data too** ([#4921]) - After Lite's 512 MB archive step, these saw only the data collected since then. The reserved-capacity, long-running-jobs and storage-latency advice judged their 7-day windows on hours of data, High Impact Queries showed only recent activity for any range, and a stopped SQL Server Agent read as never having run, as it also did 7 days after Agent last ran. They now read the archived rows too. +- **Lite keeps its learned database states, and its database state alerts stay right, after the 512 MB archive step** ([#4917]) - After Lite archived its data at 512 MB, or after a week with no database state rows for a server, the database state alert check read an empty table: it deleted every learned baseline and treated every database as recovered, so state alerts repeated or were lost. The editor also listed no databases, so their overrides couldn't be seen or changed. The check, the editor and the re-baseline button now read archived snapshots too. With fewer than two snapshots, or with data more than 7 days old, the check makes no decision: it doesn't fire, resolve or forget anything until the server collects again. +- **The Darling Viewer and Lite no longer close with an error when you check or uncheck a picker item** ([#4920]) - Checking or unchecking an item in the Wait Types, Memory Clerks or Perfmon Counters picker re-sorted the list inside the checkbox event, which WPF can reject with "Cannot modify the Visual children for this node because a tree walk is in progress", closing the app. The re-sort and chart update now run just after the event, once per burst of changes, and only when the selection changed. +- **A new server no longer reports that a collector never ran, or that it's AWS RDS, before the collector is due** ([#4915]) - Until a collector was due, `get_running_jobs` in Lite and Darling said the collector was switched off or that the server was AWS RDS. A collector is due at the server's first collection, plus its default interval, plus 10 minutes: 15 minutes for Running Jobs. Before then, it now says the collector hasn't run yet, names when the server started and last collected and how often the collector runs by default, and returns `status` `unavailable` instead of `precondition`, which matters to an MCP client that branches on it. The empty-tab notes in Lite, the Darling Viewer and both database state editors say the same. Once a collector is overdue, the never-ran note returns, and the Running Jobs note names AWS RDS as a possible cause, not a certain one. +- **Silencing one of several databases that share a display name no longer silences the others, and their alerts no longer share a dedup key** ([#4908]) - Darling and the Viewer matched a whole-server silence by display name, and a database added with no display name shows its host, so two databases on one Azure SQL Database server shared one silence. A silence now keys on the server's store id. Existing silences keep exactly the effect they had, and Unsilence keeps silenced any other server an older silence covered. Alerts from a server that shares its display name with another registration now carry the store id in their dedup key; every other server keeps its key and its open incidents. +- **Blocking and deadlock counts for a time window agree everywhere, counted by when each event happened** ([#4909], [#4913]) - Grids, slicers, trends, severity graphs, the daily summary, the MCP reads, analysis findings, drill-downs and anomaly checks counted events by when they were collected, while the Overview and fleet cards counted them by when they happened, so one window could show different counts in different places. All of them now count by when the event happened, in both apps: an event from before the window that was collected inside it no longer counts, and one collected late still counts in the window it happened in. Alerts still pick up events by when they were collected, so a late-collected event still alerts. On PostgreSQL targets, a deadlock with no timestamp is counted by when it was collected. +- **Collection Health no longer makes a collector's latest counts look like a total for every run** ([#4914]) - Collection Health showed a collector's newest counts followed by "(all N runs)", so a quiet cycle read as "nothing stored in 174 runs" beside a grid of stored rows. The counts now read "latest run: ..." when every run recorded counts, and "latest noted run: ... (k of N runs)" otherwise, in both apps' health grids and in `get_collection_health` in both MCP servers. +- **An Azure SQL Database logical server monitored at master stores each deadlock once, and loses none** ([#4900], [#4910]) - The server-wide deadlock read keyed its cutoff on rows stored under `master`, but it stores each deadlock under the database it happened in, so every run re-read the last 10 minutes and stored the same deadlocks again, up to 10 times. A deadlock that both a database's own read and the server-wide read returned was also stored twice. Each read now keeps its own cutoff and re-reads 10 minutes behind it, so a late event is still stored, and a deadlock already stored (same server, time and exact graph) isn't stored again. A deadlock only a database's own read saw can no longer be skipped. Copies stored by earlier versions are removed once at startup, and Lite's archived copies are counted once. +- **On Azure SQL Database, a monitored master no longer repeats the blocking and deadlock alerts and findings of databases you also monitor on their own** ([#4894], [#4906]) - A target on a logical server's master database collects blocked-process reports and deadlocks for every database on the server, so each event for a database you also monitor as its own target alerted twice. Master now skips those databases' events (read-only-intent targets don't count as monitored) and still alerts on events for databases that aren't monitored on their own. Its analysis does the same: the blocking, blocking-chain and deadlock findings, their drill-down evidence, the anomaly counts and `analyze_server` leave out events of databases monitored on their own. With excluded databases configured, the blocking count now follows the same Extended Events preference as the unfiltered count instead of coming out higher. `get_deadlocks` names each deadlock's database in both apps. +- **Lite's Recommendations tab says there isn't enough data yet for a newly added server, instead of "All clear"** ([#4901]) - The tab showed "All clear" for a server with less than the 24 hours of history the analysis needs, because its refresh never checked how much history there was; only the Generate button did. It now shows the same not-enough-data message as the Darling Viewer. +- **FinOps no longer gives an Azure SQL Database logical server's master database a provisioning verdict or right-sizing advice** ([#4896]) - A target on a logical server's master database was rated over-provisioned and offered CPU, memory and VM right-sizing advice, though master has no service objective to resize. Both apps now show its provisioning as N/A, in the card, the 7-day trend and Server Inventory, and give it no right-sizing advice. User databases on Azure SQL Database, and SQL Server and Managed Instance, are judged as before. +- **FinOps picks up a server added while the app is open** ([#4898]) - Lite's Database Sizes and Storage Growth grids stayed empty for a newly added server until the app restarted. They now reload when the tab is shown again if their last load came back empty or failed. The Darling Viewer's FinOps server picker now lists servers added after the Viewer started. +- **FinOps right-sizing advice says how much data it's based on, and no longer advises "reduce from 4 GB to 4 GB"** ([#4905]) - The CPU, memory and storage right-sizing texts said "over the last 7 days" even on two hours of data. They now give the number of samples and the span they cover, for example "16 samples over 3 hours", up to 7 days. Memory advice is skipped when the recommended size, as shown, equals the current size, and idle-database advice waits until there are 7 days of query statistics. Both apps. +- **The Darling Viewer says when Azure SQL Database doesn't collect a tab's data, instead of showing an empty grid** ([#4904]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, the two change grids and Memory Pressure Events showed an empty grid or chart. They now say the data isn't collected there, and the database state editor says so in its status line. On AWS RDS, Running Jobs says the same. The FinOps Logical CPUs header explains that the count can differ from the vCores you pay for, and the Memory Overview shows an N/A memory model as n/a. +- **Databases on one Azure SQL Database server no longer get mixed up** ([#4899]) - In Lite, double-clicking an Overview card opens that card's own database, and each card keeps its own silenced bell. Import Settings in Lite and the Viewer no longer skips every database after the first on one server. When a server name matches several servers, on one host or across hosts, the MCP read tools in Lite and Darling list the matches instead of answering with the first, and a full name from the list picks one. The Viewer's `--open-server` link opens a server only when exactly one has that name, and says so when several do. +- **Lite says why a tab is empty when its collector doesn't run on Azure SQL Database** ([#4903]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, Memory Pressure Events, the two configuration change grids and the Database State window showed an empty grid or chart. They now say the collector doesn't run there. On AWS RDS, Running Jobs says the same and no longer asks you to grant msdb access where no grant can help. On any engine, a tab now also says when its collector has never run for a server that is collecting other data. The FinOps Logical CPUs column has a tooltip that explains the count, and Memory Model shows n/a instead of N/A. +- **Optimized locking is read on Azure SQL Database, and a flag that couldn't be read shows as unknown, not off** ([#4907]) - Azure SQL Database reports major version 12, so the optimized-locking flag was never collected there, and every config view and `get_database_config` showed it as off. It's now collected there, and a flag that couldn't be read shows as unknown (null in MCP). When optimized locking is on, Locking & Contention and `get_object_locking` say that their per-index counters don't count transaction-ID lock waits, including when they have no rows. The upgrade doesn't record a false config change for the flag. +- **Storage Growth shows n/a, not 0, when there's no earlier size to compare** ([#4902]) - A database with no size row 7 or 30 days back, a server whose collection stopped more than a window ago, and a table in the per-table drill with no earlier sample all showed 0 growth, rate and percent in Lite and the Viewer. They now show n/a. The daily rate also divides by the real number of days between the two snapshots, instead of 7 or 30. ### Security @@ -4474,3 +4524,49 @@ Full entries: [docs/changelog/3.0.md](docs/changelog/3.0.md) [#4861]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4861 [#4863]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4863 [#4867]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4867 +[#4809]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4809 +[#4870]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4870 +[#4871]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4871 +[#4872]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4872 +[#4873]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4873 +[#4874]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4874 +[#4875]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4875 +[#4876]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4876 +[#4877]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4877 +[#4878]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4878 +[#4879]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4879 +[#4880]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4880 +[#4881]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4881 +[#4882]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4882 +[#4883]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4883 +[#4884]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4884 +[#4886]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4886 +[#4887]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4887 +[#4888]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4888 +[#4889]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4889 +[#4890]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4890 +[#4892]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4892 +[#4893]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4893 +[#4894]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4894 +[#4896]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4896 +[#4898]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4898 +[#4899]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4899 +[#4900]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4900 +[#4901]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4901 +[#4902]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4902 +[#4903]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4903 +[#4904]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4904 +[#4905]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4905 +[#4906]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4906 +[#4907]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4907 +[#4908]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4908 +[#4909]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4909 +[#4910]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4910 +[#4912]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4912 +[#4913]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4913 +[#4914]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4914 +[#4915]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4915 +[#4917]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4917 +[#4918]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4918 +[#4920]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4920 +[#4921]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4921 diff --git a/Directory.Build.props b/Directory.Build.props index c2926c61f2..c89738c72c 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -15,7 +15,7 @@ agree with the XML read, so the ordering is enforced rather than remembered. --> - 3.8.0 + 3.9.0 false From e20c88136040d5c7d1ee48bff2f88a4bf9cfd454 Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Thu, 1 Oct 2026 17:53:23 -0400 Subject: [PATCH 4/5] Release 3.9.0: archive the 3.9 entries --- CHANGELOG.md | 1473 ++++++++++++++-------------- docs/changelog/3.9.md | 1370 ++++++++++++++++++++++++++ tools/changelog/archive-census.txt | 1 + 3 files changed, 2108 insertions(+), 736 deletions(-) create mode 100644 docs/changelog/3.9.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 56b732fb1f..c2c33d3534 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,31 +23,32 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. ## [3.9.0] - 2026-10-01 -### Important +Full entries: [docs/changelog/3.9.md](docs/changelog/3.9.md) -- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - After upgrading, 1-minute collectors run every 60 s instead of drifting to about 70 s on large fleets, so per-minute data and store growth rise by up to ~20% compared with 3.8. +### Important -- **Upgrading from 3.8 runs the Darling store migrations V126 through V157 on the service's first start** - the ones that touch existing data were measured at 43-server fleet scale to finish in about a second or less each (the largest, V150's two indexes over the collection log and job history). V157 adds a nullable `server_id` column to `config.config_mute_rules`. Adding a nullable column with no default is a metadata-only change in PostgreSQL, so it takes no time on a store of any size. V126 through V156 ran on production monitoring stores during the 3.9 pre-release builds, and V157 ran there at the release-candidate install, with no install stalled by a migration, so no maintenance window is needed. +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) +- **Upgrading from 3.8 runs the Darling store migrations V126 through V157 on the service's first start** ### Added -- **`--drop-xe-sessions`** ([#4852]) - a command-line verb that drops the Extended Events sessions a removed server left behind. Run it just before removing the server. `--dry-run` lists them. `--print-sql` prints guarded statements to run by hand when the server is no longer configured. -- **Collection Falling Behind self-alert** ([#4851]) - it fires when the fleet collection gate skips at least 5% of the slots due in the last hour. At least 20 slots must be skipped too. It resolves after a full hour under 1%. An hourly log line gives the slots run and skipped, how long collection waited for a gate slot, and the gate width. -- **PostgreSQL targets: a finding when pg_stat_statements keeps evicting statements** ([#4680]) - When a target's pg_stat_statements module has had to drop its least-used entries in at least 3 of the last 6 hours, analysis reports it, says Darling's statement totals can under-report, and recommends raising pg_stat_statements.max (a restart, or on RDS and Aurora a parameter-group change and a reboot). It never fires where the eviction count is unknown. -- **Per-rule plan analyzer overrides** ([#4602]) - `darling.json`'s (Darling) and `settings.json`'s (Lite) new optional `analyzer` section can disable a specific plan-analysis rule or override its severity, e.g. `"analyzer": { "rules": { "disabled": [20] } }` hides Local Variables findings. Applies to the MCP plan tools, the drill-down views, and the plan viewer window. -- **Plan viewer: a Server Context card** ([#4614]) - The Plan Insights strip now opens with a Server Context card, as in PerformanceStudio's desktop viewer. It shows the server a plan belongs to: its name, edition and version, CPUs and memory, MAXDOP, cost threshold for parallelism, max server memory, and the plan's database with its compatibility level, from what the collector has stored for that server. -- **Plan viewer: a Parameters card** ([#4604]) - The Plan Insights strip now includes a Parameters card, listing each statement parameter's data type, compiled value and runtime value, and flagging a runtime value that differs from its compiled value as possible parameter sniffing. -- **Plan viewer minimap** ([#4596]) - The plan viewer's toolbar has a "Minimap" toggle that opens a scaled-down overview of the whole plan, with a box showing the current scroll position and a click-to-center shortcut. -- **Plan analysis flags a possible Standard Edition batch-mode DOP limit, and marks legacy findings** ([#4585]) - A plan that ran at DOP 2 with batch-mode operators gets a Standard Edition DOP Limitation finding (Info until the server's edition is known). Findings from rules that predate the benefit-scoring framework carry `is_legacy` in the MCP plan output and a [legacy] tag in the plan viewer. -- **Plan viewer: a finding's header links to the operator it came from** ([#4559]) - Plan-level and per-operator warnings that know which operator they came from now show a small arrow in their header; clicking it selects and scrolls to that operator. -- **The MCP plan tools report which operator each finding came from** ([#4556]) - Every plan analysis finding now carries the node IDs of the operators it came from, empty for findings with no single operator responsible (such as high compile CPU). Carried in `origin_node_ids` in the MCP plan tools' JSON output. -- **Plan analysis turns a plan's wait statistics into findings, and gives external and preemptive waits a real benefit estimate** ([#4555]) - When an actual plan carries wait statistics, each significant wait type becomes a "Wait: " finding with a description of what the wait means and a severity from its estimated benefit. External and preemptive waits, which the engine spends outside its own scheduler, get their own benefit formula instead of being folded into operator time. -- **Plan analysis now flags an operator that takes a large share of a statement's run time even when no other rule has advice for it** ([#4550]) - A new "Expensive Operator" finding fires when a single operator's own time is at least 20% of a statement that ran 1 second or longer, so a big chunk of runtime no longer disappears from the findings just because nothing specific was wrong with it. -- **Plan analysis warns on dynamic cursors and on cursors declared without `LOCAL`, and "Scan With Predicate" names a dynamic cursor when it is the likely cause** ([#4549]) - A dynamic cursor sees data changes between fetches, which blocks many index uses. A cursor declared without `LOCAL` defaults to global scope. A declaration inside a comment or a string does not count. -- **Plan analysis flags a query whose text was cut off by SQL Server's showplan limit** ([#4548]) - When a statement's copy of its query text hit SQL Server's roughly 4,000-character cap when the plan was captured, the analysis now says so instead of leaving the reader to work out why re-running or formatting that text fails. -- **Plan analysis: added the "Bare Scan" finding for a full-table or full-clustered-index scan with no predicate** ([#4545]) - A Clustered Index Scan or heap Table Scan with no predicate now gets a covering-index or columnstore suggestion depending on its output width. -- **Plan analysis now marks which findings are SQL Server's own warnings and which are inferences, and duplicate missing-index suggestions are no longer merged across different databases** ([#4543]) - `PlanWarning.Source` says whether a plan warning came from the engine's own `` element or from the analyzer; the plan viewer tags the engine's with `[SQL Server]` and the MCP plan tools carry it as a `source` field. Rule 30's duplicate-index-suggestion check now keys on database as well as schema and table, so same-named tables in different databases are no longer reported as duplicates of each other. -- **get_read_latency reports how long the web dashboard's and MCP server's reads take: p50, p95 and p99 per read over a chosen window, with timeout counts** ([#4454]) - the data comes from hourly histograms the service records; the percentiles are bucket upper-bound estimates; the web and MCP store sessions now show their own application_name. +- **`--drop-xe-sessions`** ([#4852]) +- **Collection Falling Behind self-alert** ([#4851]) +- **PostgreSQL targets: a finding when pg_stat_statements keeps evicting statements** ([#4680]) +- **Per-rule plan analyzer overrides** ([#4602]) +- **Plan viewer: a Server Context card** ([#4614]) +- **Plan viewer: a Parameters card** ([#4604]) +- **Plan viewer minimap** ([#4596]) +- **Plan analysis flags a possible Standard Edition batch-mode DOP limit, and marks legacy findings** ([#4585]) +- **Plan viewer: a finding's header links to the operator it came from** ([#4559]) +- **The MCP plan tools report which operator each finding came from** ([#4556]) +- **Plan analysis turns a plan's wait statistics into findings, and gives external and preemptive waits a real benefit estimate** ([#4555]) +- **Plan analysis now flags an operator that takes a large share of a statement's run time even when no other rule has advice for it** ([#4550]) +- **Plan analysis warns on dynamic cursors and on cursors declared without `LOCAL`, and "Scan With Predicate" names a dynamic cursor when it is the likely cause** ([#4549]) +- **Plan analysis flags a query whose text was cut off by SQL Server's showplan limit** ([#4548]) +- **Plan analysis: added the "Bare Scan" finding for a full-table or full-clustered-index scan with no predicate** ([#4545]) +- **Plan analysis now marks which findings are SQL Server's own warnings and which are inferences, and duplicate missing-index suggestions are no longer merged across different databases** ([#4543]) +- **get_read_latency reports how long the web dashboard's and MCP server's reads take: p50, p95 and p99 per read over a chosen window, with timeout counts** ([#4454]) - **Self-monitoring alerts (Collection Stopped, Capture Down, Collector Cost Regression) open a notebook with the server's collection health and the collector's log and cost** ([#4437]) - **Analysis-finding alerts open a notebook with that finding's summary and evidence** ([#4436]) - **Custom-rule alerts open a notebook that charts the rule's own measure with its threshold or band** ([#4433]) @@ -56,744 +57,744 @@ Releases before 3.0.0 are not archived: those entries carry no prose to move. - **High CPU alerts open an authored notebook: SQL Server and PostgreSQL CPU timelines, top queries/procedures by CPU, and scheduler pressure, instead of the mechanical read list.** ([#4420]) - **PostgreSQL Wraparound Risk, Vacuum Horizon Blocked and Replication Slot Retention alerts open an authored notebook: their own drill-down reads and a 24h trend panel, instead of the mechanical fallback section list.** ([#4419]) - **Long-Running Query and Forced Plan Failing alerts open an authored notebook: active/completed queries and a completion-duration timeline for Long-Running Query, plan corrections and a corrections timeline for Forced Plan Failing.** ([#4418]) -- **Authored Blocking and Deadlocks alert-notebook templates** ([#4395]) - `/api/alert-notebook` now returns a forensic, multi-cell layout for Blocking Detected, Blocking Wait Time, and Deadlocks Detected instead of the flat mechanical read list every other alert type gets: a blocked-process-reports or deadlocks timeline with a cross-annotation, ranked breakdowns by object/database/lock-mode, and the existing header/status/drill-down reads, all bound to the alert's own window and database. -- **Aurora per-query peak memory as a context fact** ([#4370]) - PostgreSQL-target top-statement findings now state a statement's peak executor memory (Aurora's `aurora_stat_statements()` only) as context when available, alongside its share of window time; it never changes a finding's severity, rank, or whether it fires, and reads NULL rather than 0 off Aurora. -- **Alert-notebook read-only render on `#/triage`** ([#4368]) - the alert deep link can now render the bound notebook document returned by `/api/alert-notebook` (server, status, and forensic read cells for the firing), read-only with no fleet scope picker; falls back to the existing triage assembly when the endpoint isn't present. -- **Notebook `read` cell type** ([#4367]) - Notebooks can now include a `read` cell (`{type:"read", read, params, viz, title}`), validated by the same rules as a dashboard's v1 read panel and rendered through the shared panel renderer. Those shared rules now also check a read panel's `params` on save, for dashboards as well, so a saved dashboard panel with a malformed `params` object is rejected the next time it is saved. -- **Alert-notebook binding endpoint** ([#4366]) - added `GET /api/alert-notebook`, which turns an alert link into a bound, read-only notebook definition (a dedup-matched alert, a four-arm live status, and a mechanical per-metric read cell list), the server half of the alert-to-notebook MVP (#4222). -- **A shell-level pause/resume control for the web viewer's auto-refresh** ([#4365]) - the 60s refresh loop previously only paused automatically while a browser tab was hidden. Added a button in the sidebar chrome, present on every page, that lets the operator pause and resume the tick directly; the paused state persists across reloads. Resuming runs one refresh immediately. Also added the alert-notebook triage deep-link route to the existing poll-skip guard so the periodic tick does not re-render it. -- **The store host profile now reports its cloud instance type** ([#4330]) - `get_store_host`, `--check-settings` and the store host web panel now show the EC2 instance type or Azure VM size of the machine the Darling service runs on. For a managed store, or a store on the same machine, that is the store's own host. A short, bounded probe of the cloud metadata endpoint reads it, as the metadata service reports it, and the panel says "not detected" off the cloud or when the probe finds nothing. -- **Store host visibility: an MCP read and a web panel** ([#4282]) - The managed PostgreSQL store's own host -- **`--check-settings` reports whether a managed store's sizing still matches this host** ([#4271]) - a new CLI verb prints the host and store facts (RAM, CPUs, PostgreSQL/TimescaleDB versions, store size, buffer hit ratio, uncompressed TimescaleDB chunk bytes against RAM) and a verdict for each of the eight sizing-relevant settings: matches, stale after a hardware change, operator override, or not managed. `--json` prints the same facts for scripting. Separate exit codes for a config error, an unreachable store, and a stale setting let an install or upgrade script gate on the outcome that matters to it. -- **`--validate-config` (`--test-connection`) no longer fails a healthy store over a stale entry in darling.json** ([#4271]) - once the store is reachable, this now probes its own registry of monitored servers instead of the config file's first-bootstrap seed list. A server that is only in the file (never registered, or since removed from the registry) is now a warning, not a failure. A store that cannot be reached still falls back to the file's list, and says so on the console. This closes the false failure reported on a 42-server production store whose darling.json still listed two long-removed servers. -- **Darling's MCP host now serves a /core endpoint alongside /** ([#4121]) - / keeps serving every Darling MCP tool, unchanged. /core serves a fixed 74-tool subset: the four tools a fresh conversation starts from (list_servers, get_fleet_overview, analyze_server, get_tool_guide) plus every tool the analysis engine's next_tools recommendations can point at. /core sits behind the exact same Host, bearer-token and CIDR checks as /, and a tool outside the subset fails the same way an unknown tool name would. A /core session's shared instructions now lead with a short note. The note says /core serves 74 tools, and that the tool count and tool notes after it describe the full set on /. It also says a tool outside /core fails as an unknown tool, though get_tool_guide can still describe it. Along the way, fixed eight next_tools entries that recommended get_blocked_process_reports, a tool Darling has never had (Darling's name is get_blocking), so those findings always pointed at a call that failed. -- **get_resource_semaphore also returns interval_seconds** ([#4103]) - On Darling and Lite, get_resource_semaphore now returns interval_seconds beside sample_interval_seconds. It carries the sample interval under the name get_latch_stats and get_spinlock_stats already use, and it is null when the interval cannot be known. sample_interval_seconds stays for existing readers. -- **get_query_store_top takes module_name, so one stored procedure's Query Store history can be read without widening top** ([#4057], contributed by @kendra-little) - the read ranked the whole window before capping it, so a procedure an investigation named but whose queries sat outside the top N could not be reached at all. The filter is part of the query on both SKUs. It matches the exact, case-sensitive, schema-qualified name the collector records (the full_name get_top_procedures_by_cpu returns, Adhoc for ad-hoc statements), and it applies after the #1841 interval dedup and before the ranking and the cap. Every row now carries module_name, beside the execution_type #4060 added, and the two filters compose. A filter that matches nothing answers empty only when the same read without the filters has rows, and the message names both filters. On Darling, a module miss also carries effective_start, effective_hours_back and window_truncated as hints. Otherwise the read answers as an unfiltered one would. -- **The store names its own slow queries: `get_store_query_stats` ranks the monitoring store's SQL by cost and by the role that ran it** ([#3899], hardened before release by [#3915]) - Field reports that the web viewer and MCP tools were slow could not be traced to a query from anything the product recorded: the store loaded only TimescaleDB and logged no statement durations. The managed store now preloads `pg_stat_statements` through a new v13 conf block that MERGES it into the effective `shared_preload_libraries` list (includes followed), so an operator's own libraries survive, and turns `pg_stat_statements.track_utility` off, because provisioning's `ALTER ROLE ... PASSWORD` literals are otherwise recorded verbatim (measured on the bundled PostgreSQL 18.4). Every start then checks which preload assignment is in force and logs the exact fix when an `ALTER SYSTEM` override, a later line, or an edit the block overrides leaves the library out; the `ALTER SYSTEM` fix is written one quoted literal per library, since a single literal holding the list is stored as one library name and the store will not start. A store-object convergence step, run at every start and hourly on a TimescaleDB store, creates the extension and two SECURITY DEFINER readers (pinned `search_path` and `standard_conforming_strings`, revoked from PUBLIC) granted to the admin, viewer and mcp roles. The readers refuse every statement whose text can carry a credential (role, user-mapping, subscription or server DDL, or a `PASSWORD` literal), with a backslash-free pattern a caller's string mode cannot switch off, and the step scrubs such statements from this database's entries and warns once if utility tracking is on. `get_store_query_stats` (MCP, and the `/api/read` mirror) ranks statements by total, mean or max time, calls, rows or disk reads, attributes each to its role with each role's share of the recorded time, and returns query ids as strings. It says what the figures leave out: `COPY` ingest while utility tracking is off, statements whose text the store owner may not read (and the `pg_read_all_stats` grant that fixes it), and a compose or bring-your-own store's web and MCP hosts, which connect as the owner ([#3914]). It answers `precondition` with the remedy, from the catalog, when the module is missing, not loaded, older than 1.8, or not granted, and a 1.8 install gets the ranking without the reset stamp. The viewer and mcp roles also log any statement past a third of their `statement_timeout` (5 s at the default), re-asserted with the timeout on a reload, with bind parameters off; the store-log sweep keeps those under `slow_statement`, one row per statement with comments stripped, every literal masked and parameter lines dropped, whichever role's statement it was. The Linux compose store gets the same preload on its command line, and `provision-roles.sql` carries the bring-your-own steps, including utility tracking off for its own session. Covered by unit tests for the merge, parse, include and coverage checks, the version gates, the redaction and the precondition answers, and live tests on the bundled runtime proving that a role password never reaches the reader (even with `standard_conforming_strings` off), that statements are attributed per role and normalized, that the scrub removes a password recorded with tracking forced on, that a non-superuser store owner can run the setup, and that an extension walked up from 1.7 is gated and then served. -- **Maintain your own theme colors, per theme, with a reset to default** ([#3577]) - Settings gains a Colors section beneath the theme drop-down in both Lite and the Darling viewer: twelve palette colors of the theme on screen (backgrounds, text, accent and its ink, alternating row, the four status colors), each with a swatch, hex, an HSV picker and the measured WCAG contrast ratio against the surface it renders on, color-coded at 4.5:1 and 3:1 - a warning, never a gate. Apply writes a per-user theme-overrides.json beside settings.json (the viewer's beside viewer-settings.json, local to the machine) and re-applies live; Reset to default returns that one theme to its shipped palette; Open file hands you the JSON, and saved edits apply on their own. A bad file, key or value is a logged warning and the stock theme, never a crash. -- **A PostgreSQL target with every logging setting off no longer looks identical to an instrumented one** ([#3607]) - `get_pg_logging_audit` judges log_min_duration_statement, log_lock_waits, log_temp_files, log_autovacuum_min_duration, log_checkpoints and log_connections/log_disconnections from the stored configuration snapshot, setting by setting, with what each unlocks, the recommended value and its cost, and the remedy in the hosting flavour's own syntax (ALTER SYSTEM plus a reload, or a parameter group where rds.* parameters prove RDS/Aurora). It sits beside `get_pg_plan_capture_readiness`, whose auto_explain facets it lists but never re-judges, so target onboarding has one "is this target telling us everything it could" answer. -- **A stock PostgreSQL target without pg_wait_sampling now has a wait profile instead of an empty chart** ([#3604]) - pg_wait_sampling grows a service-side arm that polls pg_stat_activity once a second for a 30-second window every five minutes and accumulates the tallies itself when the extension is absent, so the three PostgreSQL wait tiers (Aurora native › extension › service sampler) are one connect-time decision with exactly one instrument per target. get_pg_wait_stats, get_pg_wait_sampling and the Viewer disclose instrument: engine_cumulative | extension_sampled | service_sampled, with the floor caveat on the service tier. Aurora is gated off pg_wait_sampling (it cannot preload the module) and is pointed at pg_wait_stats instead. No migration. -- **PostgreSQL's server log is read by a classifier, not by two regexes** ([#3601]) - Darling now tails the same log the deadlock and plan readers tail — `pg_read_file` self-hosted, the RDS log API on Aurora/RDS — and classifies every line into families: `error` (WARNING or worse), `connection`, `lock_wait`, plus `temp_file`/`autovacuum`/`checkpoint` recognised for the structured tables #3602/#3603 add. Events land in `collect.pg_log_events` (V129, 30-day retention) with `message`/`detail`/`context` redacted by the plan parser's own patterns and the statement never stored, only fingerprinted; `get_pg_log_events` reads them with `family`/`min_severity` filters and the honest page contract. The three log readers now share one tailer (`PgServerLogTail`) instead of three copies. -- **The log said what the spill cost and what the vacuum cost; the store kept the sentence and threw away the number** ([#3602], [#3603]) - Two parser families on the log-event pipeline lift the figures out of the prose: a `temp_file` event carries the spilled file's exact bytes beside the fingerprint of the statement that spilled, and an `autovacuum` event carries the run's relation, duration, pages, tuples, buffers and WAL, on V130 columns of `pg_log_events` rather than sibling tables. `get_pg_log_events` publishes them where the line carried them; `get_pg_autovacuum_health` gains `recent_runs` per table, so "is it keeping up" and "what does each run cost" answer from one place. Line shapes pinned per PostgreSQL 16/17/18 from the server source. -- **Alert families route to their own channels** ([#3598]) - Every alert used to fan out to every configured channel from one install-time row, so self-monitor alerts, scheduled reports, job failures and performance pages interleaved in one stream and the reader did the routing in their head. A sparse `config_notification_routes` table (V131) layers over that row: a route names a family (`self-monitor`, `reports`, `agent-jobs`, `performance` — a closed taxonomy every alert maps into, census-pinned) or an exact metric, and carries a destination per channel; resolution runs once per firing after cooldown — exact name, then the firing a recovery pairs with, then family, then the parent's default — per channel, so an empty column inherits and a store with zero routes behaves byte-for-byte as before. The delivery ledger records which route matched, recoveries land where their firing did, the viewer gains a Routes grid, `get_notification_routes` / `set_notification_route` / `delete_notification_route` expose it to agents, and routes hot-reload through the same beacon mute rules use. -- **PostgreSQL targets enter the analysis pipeline** ([#3542] v1 plumbing) - The scheduled pass and every MCP analysis tool used to skip a PostgreSQL target behind an engine tombstone ("does not apply … use the get_pg_* reads"), because the pipeline read SQL Server tables and would have sat at "0 hours, still collecting" forever. The analysis service now holds two engine component sets and picks one PER CALL from the registry's `engine_kind` (two of its construction sites are singletons shared by every server, so the constructor could not be told); a PostgreSQL pass measures its 24-hour gate, its coverage witness and its baseline gate on `pg_database_stats`, scores a `pg_`-prefixed fact vocabulary declared once before any row persists, and clears the tombstone row on its first real pass. Every shared switch (scorer, advisory roots, graph, advice, anomaly reconciler, tool recommendations) gained exactly one delegating `pg_` arm so the nine content lanes build in parallel without touching shared files; `audit_config` answers `not_collected` for a PostgreSQL target instead of "the config collector may not have run yet". The SQL Server pass is byte-identical. No schema, no content. Rider (#3653/#3616): `HADR_SYNC_COMMIT` findings on Darling now carry next_tools (`get_wait_trend`, `get_ag_health`, `get_perfmon_trend`, `get_file_io_stats`), the pair of Lite's #3659. -- **A PostgreSQL target's durability posture is stated, not inferred** ([#3542] lane 8) - The analysis pass read nothing about `fsync`, `full_page_writes` or `synchronous_commit`, so a cluster running with fsync off analysed exactly like one running safe. Three `pg_posture` facts now come off the newest `pg_server_config` snapshot: fsync/full_page_writes off is a CRITICAL policy card naming the corruption trade, synchronous_commit off a 0.4 advisory naming the acknowledged-then-lost commit window, and Aurora's platform-managed pair is present, marked managed and ungraded. No amplifier, graph edge or optimisation word can reach a posture fact — pinned in source and at runtime (D6). -- **A PostgreSQL analysis pass now names the statement** ([#3542] lane 7) - A PostgreSQL target's stories ended at a server-level symptom and never said which statement. `PG_BAD_ACTOR_` facts from `pg_statement_stats` stored deltas now carry one shape's share of the window's total execution time (denominator over the whole window, never the page), its calls/sec over the span its deltas accrued and mean/max ms; the scorer grades the share behind an idle-window gate with every bar declared unmeasured (`threshold_lineage = 0`); the card states the figures, both levers with their counter-objectives and the queryid re-key caveat; the drill-down carries the normalised text, its hash and the per-database breakdown. -- **The two PostgreSQL knobs learn to speak** ([#3542] lane 2) - The analysis pass had nothing to say about `shared_buffers` and `max_wal_size`, the two settings the OtterTune field study found carry 75–95% of measured tuning value. Both are now cut from the latest `pg_server_config` snapshot: at their shipped defaults (128 MB, the line `initdb` writes; 1 GB) they root a 0.4 ADVISORY card and never an incident on their own, and reach the incident line only when the engine's own workload signal co-fires — `PG_CHECKPOINT_PRESSURE` (requested-dominant checkpoints from `pg_write_stats` deltas, with WAL bytes per interval) or `PG_BUFFER_CACHE_PRESSURE` (a composite of hit ratio, bgwriter and, on PostgreSQL 16+, `pg_io_stats` evictions, each arm carrying its own evidence and honesty flag: `evictions_tracked` below 16, `hit_ratio_suppressed` on Aurora where the storage layer answers reads). Every bar carries lineage — defaults engine-defined, ramps declared unmeasured with the calibrating read named — and the advice states the measured share, the value on the host, both levers and each lever's counter-objective. A `PgSettingValue` helper normalises PostgreSQL's unit zoo (8kB pages, kB/MB/GB, ms/s/min, -1 sentinels) once. -- **A PostgreSQL target's analysis pass gains its vacuum family, graded on the same bars the Tier-0 alerts page on** ([#3542]) - `PG_AUTOVACUUM_BACKLOG` names the worst table persistently past its own autovacuum trigger line with the ratio to that line, the dead-tuple slope over the run and whether autovacuum ran and lost (cumulative counts differenced, never summed); `PG_WRAPAROUND_TREND` grades XID and MultiXact separately through the alert evaluator's four arms and adds a time-to-wall estimate with an explicit not-computable branch; `PG_XMIN_HOLD` grades the alert's identity arm and names the fix per holder kind. The wraparound/xmin/slot constants move to one shared `PostgresOutagePredictorThresholds` that both the alert evaluator and the analysis scorer reference, pinned so the surface that pages and the surface that narrates cannot disagree; the three facts chain into one story with value-stated advice that never suggests disabling autovacuum. -- **A PostgreSQL pool near its connection ceiling is graded as the outage it is** ([#3542]) - A PostgreSQL target's analysis pass had no session fact: a pool at 96 of 97 usable slots — one deploy from `FATAL: too many clients already` — produced an empty verdict at full coverage. `PG_CONNECTION_SATURATION` now grades the window's peak session count from `pg_session_states` against the engine's own line, `max_connections − superuser_reserved_connections` (read off the config facts, never re-read), scoring zero below 0.8 and 1.0 at 0.9 with `threshold_lineage = 0`; the card states the division with all three numbers, the peak capture's active / idle-in-transaction / other breakdown, and both levers — a pooler or a higher ceiling — with what each costs. When the monitoring login lacks `pg_read_all_stats` and most stored rows are redacted, `PG_MONITORING_PERMISSIONS` says so instead of a ratio built on blank rows. -- **A PostgreSQL analysis pass now names temp-file spill and gates work_mem on it** ([#3542]) - PG_TEMP_SPILL grades spilled bytes per second of observed time from the reset-aware pg_database_stats difference (a pg_stat_reset() mid-window is clamped and reported), names the database that spilled the most, and leads a story to CONFIG_PG_WORK_MEM, which scores 0 without that evidence and reaches the incident line only beside it; the drill-down lists the statements that wrote the most temp blocks and the advice states the host's own work_mem × max_connections arithmetic. The same read emits PG_TPS (with a half-window trend) and PG_DEADLOCK_RATE from the engine's counter on the alert band's measured tiers, saying how many the log captured beside how many the engine counted. -- **A PostgreSQL analysis pass reads the wait profile — measured on Aurora, estimated on stock, and says which** ([#3542]) - Lock, LWLock, IO and IPC rollups with the Lock:relation, LWLock:WALWrite, IO:DataFileRead and IO:WALSync standouts, each a fraction of the wait source's own observed time. Aurora's pg_wait_stats deltas are summed under the three-state interval (a restart collection is not a sample); a stock target's pg_wait_sampling counts × profile_period are read only when the Aurora table is empty and every such fact carries is_sampled and its resolution, with advice that says "estimated from sampling" and never "spent". Bars are unmeasured and say so; a rollup yields to its fired standout so one wait is graded once; WAL waits chain into checkpoint pressure, data-file reads into buffer-cache pressure, and Lock waits mesh with connection saturation. Lock advice names PostgreSQL's levers, not the SQL Server isolation remedy. -- **A PostgreSQL target learns its own normal** ([#3542] lane 9) - A PostgreSQL analysis pass had no baseline and no anomaly detector, so a 6× throughput surge, a tripled connection pool or a serverless instance pinned at its configured ceiling was indistinguishable from a quiet Tuesday - and had the anomalies existed, they would have scored 0 and never left the 1.49 cap (#3584's defect, again). Five baselines over the pg_* raw hypertables (TPS and deadlocks/hour off the reset-aware per-database difference, the capture's total_sessions, the Aurora all-types wait rate with CPU excluded, percent of the configured ACU ceiling - never raw cpu_percent) and five detectors through the shared AnomalyGate writing the metadata the shared ramp and extremity escape read; a PostgreSQL ratio ramp with no sentinel for a first occurrence; load-family co-fires confirmed only by a measured capacity reading; PG_CPU_PERCENT graded only when capacity was measured; advice in PostgreSQL nouns. Every unmeasured bar carries its lineage and threshold_lineage = 0. Stock PostgreSQL's sampled waits get no anomaly baseline in v1. -- **The measurement contract had ten rules and two tests** ([#3653]) - The contract #3540 stated in one sentence is now a numbered list in `Lite.Tests/MeasurementContractCensusTests` (4 and 7 keep their tests' numbers; 9–10 are left empty because the review's enumeration is not on the record), and rules 1, 2, 3 and 6 are censuses over both SKUs' sources with positive controls and population floors: no reader divides by a stored interval except through NULLIF, no rate assumes a cadence, exactly two carriers observe an epoch and every forget site is named, every per-second alias is a quotient. Rule 5 is rostered against the real continuous-aggregate definitions — the #3698 successors carry the interval predicate; the superseded pair and three hourly rollups do not — and rule 8 waits, pinned, on the `cntr_type` rung. -- **v2 plumbing for the PostgreSQL-target engine, and the wait-profile anomaly now folds onto its wait and can page** ([#3691]) - The I/O, replication and bloat families exist as stubs behind one delegating arm per shared switch, with the v2 vocabulary declared once so lanes 11–15 never touch a shared file. `ANOMALY_PG_WAIT_PROFILE` stopped sitting one hundredth under the page line: it folds onto the wait card its dominant contributor names and leaves the 1.49 cap on the same three readings as its SQL Server twin, anchored on its own firing multiple. -- **Schema 133: the PostgreSQL saturation numerator and the sampler's duty cycle are stored** ([#3691]) - `pg_database_stats` gains `numbackends` (the client backends connected per database at the instant of the read, a level, never differenced) and `pg_wait_sampling` gains `sampled_ms` (the milliseconds each five-minute collection actually observed - 30,000 from the service-side sampler, NULL from the extension arm that watches the whole interval), because "count / max_connections" had only an exception-capture count to divide and "samples × period / interval" understated the sampler arm ~10× with nothing in the row saying so. Written by the collectors from this rung; read by nothing yet. Lite stores no `pg_*` table, so no DuckDB bump. -- **The pull-request review learns the repository's traps and stops answering LGTM by default** ([#3710]) - The bot review had read several hundred pull requests and posted LGTM on very nearly all of them; every defect it missed was later found by behaviour, not by reading. Three structural causes, three fixes: a `.github/REVIEW-TRAPS.md` of the repository's recurring defect shapes, each citing the pull request that bit, which the review must consult and name; a blind first phase that reads the diff and its callers before it is allowed the author's account, then reports where the two diverge; and a structured verdict — every claim in the body VERIFIED, UNVERIFIED or REFUTED, the three riskiest lines and what pins each, a machine-readable ledger line — without which the run fails, so a bare LGTM is no longer a valid review. A paths filter sends analysis, collectors, storage, service, alerting and notification changes to a full-tier Opus pass with the 1M context window and everything else to a lighter Sonnet pass; the verdict contract is identical either way. Lands dark under the workflow-drift rule; the first live run is the first pull request after the release sync. -- **A server configuration change now has a consequence the engine states — `CONFIG_CHANGED` compares the ±4 h around it and says what moved, or that nothing did** ([#3653]) - The analysis engine graded the current value of seven `sp_configure` settings and never asked whether a change had an effect; that join lived in the operator's head between `get_server_config_changes` and `compare_analysis`. Both SKUs now emit one Information-level `CONFIG_CHANGED` finding per change event observed inside the pass window, running `ComparePeriodsAsync` over the four hours before the observation and the (honestly clamped) four hours after, banded by the same dispersion rules as `compare_analysis`, with the setting, old → new, and the moved metrics — or the sentence that none moved — frozen into the finding. Because `server_config` is captured on connect, the finding says "first observed", states the span the real change landed in, and never claims to be a causal test; database-config and trace-flag changes are the next slice. -- **PostgreSQL deadlock cards carry the captured exemplars, grouped by shape and ranked by recurrence** ([#3691]) - The card said "the engine counted N; M were captured from the log" and stopped. The drill-down now reads pg_deadlocks for the window, groups reports into shapes (participants, lock modes, resources — deadlock_hash identifies one report, not a shape), carries the top three with bounded statement and graph text, reuses the counter the card was graded on, and re-freezes the advice with the value-stated sentence and the ordering lever. Zero capture beside a non-zero counter names the logging-posture settings instead of showing an empty list. -- **The PostgreSQL bloat family grades fourteen-day GROWTH behind a size floor, never a spot percentage** ([#3691]) - `bloat_pct_estimate` read 71–99.8 % on most of the measured fleet's small heaps while their fourteen-day growth was zero bytes, so a percentage-graded finding would have paged everywhere and argued for VACUUM FULL on a Tuesday. `PG_BLOAT_TREND` (hourly `pg_table_bloat_stats`) and `PG_INDEX_BLOAT_TREND` (daily `pg_index_bloat`) now grade the estimate's growth across a fourteen-day lookback — 256 MiB and 25 % of the earlier value, 1 GiB critical, 64 MiB floor, all measured on the dogfood fleet — exclude `estimate_unavailable` and skipped rows outright, name the top three objects, state their own sample counts, and chain onto a same-table `PG_AUTOVACUUM_BACKLOG` as its damage. Withheld estimates are facts that say why, never zero bloat. -- **A chain that fired every Tuesday at the same hour was rated a fresh incident each week and nobody was told; the pass now labels it "recurring at this hour" at unchanged severity, and a weekly Agent job whose slot slid gets "maintenance window moved"** ([#3653]) - Ruling Q3: label, not discount. After the anomaly fold and before the finding is persisted, one store read of the prior three weeks (on the target's clock via `server_properties.utc_offset_minutes`, UTC disclosed when absent) lets `RecurrenceLabeler` append one sentence to the frozen advice of every chain that fired in the same hour×weekday slot for three consecutive weeks, and one naming the job and both slots to every story tied to a fired `RUNNING_JOBS` whose slot moved since last week. Severity is bit-identical with and without the label; both `get_analysis_findings` twins publish `recurring_at_this_hour`, `recurrence_weeks` and `maintenance_window_moved`. -- **PostgreSQL read latency is now a graded fact, and the pass says why when it cannot know** ([#3691]) - `PG_IO_READ_LATENCY_MS` states milliseconds per data-file read from `pg_stat_io`, graded against bars measured on the dogfood fleet's Aurora storage (10 / 30 ms, population named), with `ANOMALY_PG_IO_LATENCY` when an hour departs this server's own routine. With `track_io_timing` off the pass reports the reads it counted and that none were timed — never 0.000 ms — and on a pre-16 major it says `pg_stat_io` is absent; write latency is stated, not graded. -- **Replication lag and slot retention stories for the PostgreSQL-target engine** ([#3691]) - A PostgreSQL operator's agent now hears whether a standby is behind or FALLING behind and at which stage (sent / write / flush / replay), whether a replication slot is filling the disk or has already lost the WAL its consumer needs, and whether a slot's horizon is what holds vacuum back — three facts, one chain into PG_XMIN_HOLD, and the replay-lag anomaly against the server's own hour-of-week baseline. Every shared bar is the Tier-0 slot alert's own by reference; bytes are graded and NULL replay_lag_ms is tolerated; the drift multiple is unmeasured (n = 1). -- **The CPU sample's UTC instant and the server's time-zone id are now stored, so UTC-window readers stop deriving an offset that is an hour wrong across DST** ([#3653]) - `cpu_utilization_stats.sample_time` is the monitored server's LOCAL wall clock, and every reader that aligned it against UTC derived the offset per batch or from the single collected `utc_offset_minutes`, placing the samples nearest a DST transition an hour wrong. Darling V134 / Lite v63 add `sample_time_utc` beside the unchanged local stamp (the same instant off `SYSUTCDATETIME()`), which the viewer, MCP `get_cpu_utilization` and the Lite CPU window now prefer, and `server_properties.time_zone_id` (`CURRENT_TIMEZONE_ID()`, SQL Server 2022+ / Azure SQL; NULL elsewhere) beside the offset that could not say which side of a transition an instant fell on. Nullable, no backfill: the offset a server had at a past sample's instant is exactly what the store never recorded. -- **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 `log_lock_waits` lines (count, longest, relation), counting each wait once, even when PostgreSQL 18 logs it again while it goes on, and each line once, even when the log is read again ([#4886]) 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], [#4809]) - `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. They exit 0 on success, 1 for bad arguments or configuration, and 2 when the store can't be reached or refuses the login. -- **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. -- **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. +- **Authored Blocking and Deadlocks alert-notebook templates** ([#4395]) +- **Aurora per-query peak memory as a context fact** ([#4370]) +- **Alert-notebook read-only render on `#/triage`** ([#4368]) +- **Notebook `read` cell type** ([#4367]) +- **Alert-notebook binding endpoint** ([#4366]) +- **A shell-level pause/resume control for the web viewer's auto-refresh** ([#4365]) +- **The store host profile now reports its cloud instance type** ([#4330]) +- **Store host visibility: an MCP read and a web panel** ([#4282]) +- **`--check-settings` reports whether a managed store's sizing still matches this host** ([#4271]) +- **`--validate-config` (`--test-connection`) no longer fails a healthy store over a stale entry in darling.json** ([#4271]) +- **Darling's MCP host now serves a /core endpoint alongside /** ([#4121]) +- **get_resource_semaphore also returns interval_seconds** ([#4103]) +- **get_query_store_top takes module_name, so one stored procedure's Query Store history can be read without widening top** ([#4057]) +- **The store names its own slow queries: `get_store_query_stats` ranks the monitoring store's SQL by cost and by the role that ran it** ([#3899], [#3915], [#3914]) +- **Maintain your own theme colors, per theme, with a reset to default** ([#3577]) +- **A PostgreSQL target with every logging setting off no longer looks identical to an instrumented one** ([#3607]) +- **A stock PostgreSQL target without pg_wait_sampling now has a wait profile instead of an empty chart** ([#3604]) +- **PostgreSQL's server log is read by a classifier, not by two regexes** ([#3601]) +- **The log said what the spill cost and what the vacuum cost; the store kept the sentence and threw away the number** ([#3602], [#3603]) +- **Alert families route to their own channels** ([#3598]) +- **PostgreSQL targets enter the analysis pipeline** ([#3542]) +- **A PostgreSQL target's durability posture is stated, not inferred** ([#3542]) +- **A PostgreSQL analysis pass now names the statement** ([#3542]) +- **The two PostgreSQL knobs learn to speak** ([#3542]) +- **A PostgreSQL target's analysis pass gains its vacuum family, graded on the same bars the Tier-0 alerts page on** ([#3542]) +- **A PostgreSQL pool near its connection ceiling is graded as the outage it is** ([#3542]) +- **A PostgreSQL analysis pass now names temp-file spill and gates work_mem on it** ([#3542]) +- **A PostgreSQL analysis pass reads the wait profile — measured on Aurora, estimated on stock, and says which** ([#3542]) +- **A PostgreSQL target learns its own normal** ([#3542]) +- **The measurement contract had ten rules and two tests** ([#3653]) +- **v2 plumbing for the PostgreSQL-target engine, and the wait-profile anomaly now folds onto its wait and can page** ([#3691]) +- **Schema 133: the PostgreSQL saturation numerator and the sampler's duty cycle are stored** ([#3691]) +- **The pull-request review learns the repository's traps and stops answering LGTM by default** ([#3710]) +- **A server configuration change now has a consequence the engine states — `CONFIG_CHANGED` compares the ±4 h around it and says what moved, or that nothing did** ([#3653]) +- **PostgreSQL deadlock cards carry the captured exemplars, grouped by shape and ranked by recurrence** ([#3691]) +- **The PostgreSQL bloat family grades fourteen-day GROWTH behind a size floor, never a spot percentage** ([#3691]) +- **A chain that fired every Tuesday at the same hour was rated a fresh incident each week and nobody was told; the pass now labels it "recurring at this hour" at unchanged severity, and a weekly Agent job whose slot slid gets "maintenance window moved"** ([#3653]) +- **PostgreSQL read latency is now a graded fact, and the pass says why when it cannot know** ([#3691]) +- **Replication lag and slot retention stories for the PostgreSQL-target engine** ([#3691]) +- **The CPU sample's UTC instant and the server's time-zone id are now stored, so UTC-window readers stop deriving an offset that is an hour wrong across DST** ([#3653]) +- **PostgreSQL sessions: an operator now learns which application left a transaction open and walked away** ([#3691]) +- **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]) +- **PostgreSQL blocking: the pass names the head of the chain, how long the sessions behind it really waited, and whether the log agrees** ([#3691], [#4886]) +- **A PostgreSQL table that turned autovacuum off and fell behind is its own card** ([#3691]) +- **A collector can be enabled or disabled headlessly** ([#3752], [#4809]) +- **Stock PostgreSQL's sampled waits read per second the sampler was watching, and get their own baseline and anomaly** ([#3691]) +- **Rule 6's C# half is a census, not a stated bound** ([#3653]) +- **CONFIG_CHANGED covers database options and trace flags, not only sp_configure** ([#3653]) +- **Every trend surface renders the identity-epoch discontinuity marker the store already held** ([#3653]) +- **v3 plumbing for the PostgreSQL-target engine** ([#3691]) +- **PostgreSQL targets get a per-database size series and the host's memory** ([#3691]) +- **PostgreSQL buffer-pressure cards say what the cache holds** ([#3691]) +- **A PostgreSQL pass now names the statement whose plan changed and what it cost** ([#3691]) +- **A PostgreSQL target's analysis pass measures CPU where no capacity percent exists** ([#3691]) +- **PostgreSQL targets learn whether the memory configuration fits the host** ([#3691]) +- **A baseline series can be scoped to one statement** ([#3691]) +- **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]) +- **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]) +- **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_health` said "Query Store health" and skipped the one knob that names a plan-churn factory** ([#3796]) +- **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 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]) +- **A PostgreSQL operator now learns which database is growing, how fast, and when it doubles** ([#3691]) +- **The Query Store clutter view had no viewer and told every reader the capture mode was uncollected** ([#3797]) +- **The three report alerts carry their rows as structure as well as prose, so every surface that can render a table has one** ([#3834]) +- **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]) +- **A summary card can name its top few objects, not only its worst** ([#3691]) +- **`get_collection_log` can be asked for the failures** ([#3869]) +- **`get_collection_health` now says when the analysis pass could not read one of its fact families** ([#3691]) +- **A `pg_server_config` row now says whose setting it is** ([#3691]) +- **`get_object_locking` says when its snapshot was collected** ([#3880]) ### Changed -- **The managed store sets `random_page_cost = 1.1`** ([#4863]) - the managed PostgreSQL store now renders `random_page_cost = 1.1`, a value suited to SSD storage, in place of PostgreSQL's default of 4, which prices a random page read at four sequential ones. The planner now picks index and bitmap scans that the default priced out. Measured on a production store over an hour at each value, back to back, total statement time was 2.3% lower at 1.1, with some statements faster and a few slower. A store upgrading from 3.8 moves its settings into the managed file at the upgrade start and gets the line there, and the value is in force from the service's next start after that. A `random_page_cost` set with `ALTER SYSTEM` still wins, and one already set in `postgresql.conf` when the store upgrades is carried into the managed file unchanged. -- **Per-server Query Store reads fetch fewer rows** ([#4861]) - This covers the Queries grid, MCP's Query Store top read and the Trends Query Store chart. Each filtered one server's rows of the per-interval table by collection time only, which no index held. So it fetched every stored row of that server. Each read now also bounds first_execution_time, which the table's unique key holds, so older rows are dropped before they are fetched. Results do not change. On a large store, a day-long MCP read went from 3.1 s to 0.6 s. -- **SQL Server blocking and deadlock baselines count the hours collection covered** ([#4853]) - each hour-of-week's mean now divides by the days collection ran in that hour. It used to divide by the days that had events. A covered hour with no blocking or deadlocks is a measured zero, so a spike into it says the baseline measured zero instead of "first occurrence". This needs at least one captured event in the 30 days, so a server that cannot capture the events keeps no baseline. Hours with occasional events get lower means. More hours are trusted, and a trusted hour must also pass the rate multiple, so those hours alert less often. An hour whose events cluster on a few days can alert at a lower event rate than before. These baselines are now computed once per UTC day, like the CPU and I/O latency baselines. Events earlier on the current day are not part of the baseline. -- **The plan viewer's Runtime Summary lists CE model above Optimization, with Early abort under it** ([#4849]) - this matches PerformanceStudio. The Early abort label is indented when an Optimization row is shown. -- **Purge Now runs in the background and is paced like the daily purge** ([#4835]) - the command ran the whole purge before it answered, so every other command waited behind it. Its deletes were not paced, which slows collection on every server the way the daily purge did. It now answers at once with "started", or "already running" when another purge holds the slot. When the purge finishes, its totals and each raw table's result are written to the collection log under (fleet), which `get_collection_log` reads, and the viewer shows the totals. Update viewer seats along with the service: a viewer from an earlier release reads the new answer as 0 rows purged. -- **get_pg_deadlocks explains an empty answer more completely** ([#4832]) - The tool's text now names the log line prefix check beside the message language check (as does the empty answer of get_pg_deadlock_detail), and says the RDS read position is saved, so a restart resumes where the last read stopped. -- **Darling reads a quiet database's watermark from its cache instead of from the store every cycle** ([#4818]) - A database whose newest row was recent but had no new batch since the cache was seeded missed the cache on every cycle, at about 30 ms a time. -- **Query Store rows now record when each interval ended, in both apps' stores** ([#4802]) - The Query Store stats in Darling and Lite gain an `interval_end_time_utc` column next to the interval's start time. Rows collected before the upgrade leave it empty. -- **Query Store backfill: the per-tick database list no longer walks the newest chunk's index** ([#4703]) - every backfill tick listed a server's databases with a read bounded at the backfill horizon. Inside the chunk that holds the horizon that bound can only filter, so the read walked the chunk's index entry by entry, and it grew as the chunk filled. On a store monitoring 43 servers, with the horizon 20 minutes before the end of its chunk, one round of these reads cost 495,218 buffers and 560 ms (up to 24,457 buffers and 44 ms for one server). The read now starts at that chunk's start, taken from the TimescaleDB catalog, and the same round cost 1,815 buffers and 5.3 ms. On plain PostgreSQL the list comes from a walk of the index, one seek per database. A quiet database whose newest rows are in that chunk but older than the horizon is now marked done at once, so if it comes back after those rows leave raw retention, its first-contact history is not backfilled. A recorded outage gap is still backfilled. -- **Query Store views over windows longer than the raw tier now show the full window from the interval table, and say how far back it reaches** ([#4700]) - The Queries grid, the get_query_store_top MCP tool and Compose Query Store panels read the per-interval table below the raw tier's floor, down to the exact point where it provably holds the same rows raw held. The MCP tool reports history_source and effective_start, and its note says which bound set the start. -- **Analyzer wording for Nested Loops outer sides and row estimate mismatches now counts rows the way the plan viewer does** ([#4698]) - Rule 16's Nested Loops outer-side detail now prints the total actual rows when the outer input is not on a Nested Loops inner side, for example "actual 100,000 (1000x underestimate)" where it used to print "actual 12,500 (125x underestimate)" at DOP 8. Rule 5's "(N rows x M executions)" text now appears only on a Nested Loops inner side. -- **PostgreSQL targets: the top-queries views say when pg_stat_statements evicted entries during the window** ([#4680]) - Darling now records each target's pg_stat_statements eviction count (`pg_stat_statements_info.dealloc`) with its statement statistics. When the module had to drop its least-used entries in the window, `get_pg_top_queries`, the Darling Viewer and the web dashboard's Top Query Shapes say so and that the totals can under-report, and name pg_stat_statements.max as the fix; where the info view is absent the count is reported as unknown rather than zero. -- **Web dashboard: each notebook and Custom View has its own auto-refresh setting, notebooks start with it off, and slow pages back off** ([#4671]) - A labelled "Auto-refresh" control on each saved view and notebook (Off, 1, 5 or 15 minutes) is saved with the definition; notebooks default to Off and Custom Views to 5 minutes, and the fleet and server pages keep refreshing every minute. The header button now pauses all auto-refresh. A page whose last render took more than half its interval waits at least four times that render (up to 15 minutes) before refreshing again, and says when it will. -- **Query Store collection: each database's watermark comes from the store only when a cached value can't be proven current** ([#4669]) - The collector read `MAX(last_execution_time)` for every database on every cycle; on one production store that was about 6,900 s of store time and 112 million blocks read in four days. The value is now cached per server and database, advanced only after a batch commits and dropped on any fault, reconnect or backfill write, and used only while the row that set it is still inside the read's three-hour floor, so every cycle collects from exactly the same point as before, and re-read from the store at least hourly. -- **Alert pass: the forced-plan failure check reads the store only when its answer can have changed** ([#4667]) - Between Query Store collections every pass re-read two hours of one server's Query Store rows to reach the same answer; on one production store that was the second-largest statement, about 27,700 s of store time in four days. A one-row probe now decides, every Query Store write clears the saved answer, and the previous answer is reused otherwise (less any plan whose older collection has left the window), so alerts fire exactly as before. -- **Query Store collection: the orphaned per-database state cleanup runs at most once an hour per server** ([#4665]) - It ran three deletes after every Query Store cycle to catch the rare dropped database; on one production store that was about 5,600 s of store time in four days. It now runs on the first cycle after a start and then hourly, in Darling and Lite; a failed run is still retried on the next cycle. -- **The Darling Viewer's Query Store trend chart and `get_query_store_duration_trend` no longer re-scan the hourly rollup's oldest and newest hour on every load** ([#4618]) - They take the rollup's range from the coverage the service already caches, instead of a fresh `min`/`max` read over the rollup on every call. -- **Custom Views Query Store panels over a recent window read the per-interval table instead of re-sorting raw snapshots** ([#4617]) - A Query Store panel of 12 hours or more, whose window the store's per-interval table fully covers, now reads that table, with the same numbers, instead of deduplicating every raw snapshot in the window. On a large fleet that dedupe spilled gigabytes of temporary files and could run to the 60-second read timeout. -- **`get_store_metrics` reports the per-interval Query Store tables by name** ([#4616]) - Their size and growth get their own daily rows instead of being counted in "other", so a stalled purge on them shows up. -- **Darling Viewer and MCP store reads can no longer spill unbounded temporary files** ([#4610]) - The viewer and mcp store roles now carry a temp_file_limit, so a Custom Views panel that would have written gigabytes of temporary files fails at once with a message naming the limit, instead of running to the 60-second statement timeout and slowing the collector's writes. -- **Plan viewer minimap: resize, double-click zoom, and accuracy-coloured edges** ([#4603]) - The plan viewer's minimap panel can now be resized and remembers its size across plans, double-clicking a minimap node zooms to and selects it, and minimap edges pick up the same over/underestimate colouring as the main canvas. -- **Rule 38 can now flag a Standard Edition DOP limit as a Warning** ([#4601]) - Plan analysis reads each server's collected edition and MAXDOP wherever it analyzes a stored plan (the MCP plan tools, the drill-downs, and the Darling Viewer and Lite plan viewers). A plan that ran at DOP 2 with batch-mode operators on a Standard Edition server with MAXDOP above 2 now gets a Warning; it stays Info when the edition isn't known. -- **Plan viewer: one neutral card design for the insights strip** ([#4599]) - Runtime Summary, Missing Index Suggestions, and Wait Stats now share one neutral surface with a thin per-card accent edge instead of a full-color tinted background, and an empty card (for example, no missing index suggestions) shows a dimmed, muted state instead of a loud tinted block. -- **The plan viewer's Wait Stats rows show each wait's potential benefit and never clip** ([#4595]) - As in PerformanceStudio's desktop viewer, each wait row gains an "up to N%" benefit column taken from the plan's matching wait finding, the name and duration columns take the spare width with an ellipsis and a tooltip, and the bar and benefit columns size to their content so the percentage is never cut off. -- **Plan viewer costs are formatted as in PerformanceStudio** ([#4592]) - Costs in the properties panel and node tooltips show a trimmed, thousands-separated number instead of six raw decimal places. The sub-millisecond duration format is ported too, but the viewer's statement times are whole milliseconds today, so nothing shows it yet. -- **The plan viewer's Wait Stats header shows the total wait time and wait-type count on hover** ([#4591]) - Matches the desktop viewer's tooltip behavior; no visible layout change otherwise. -- **The plan viewer's runtime summary card matches PerformanceStudio's** ([#4590]) - It's titled "Predicted Runtime" for an estimated-only plan, rows are reordered (Elapsed, CPU:Elapsed, DOP, CPU, Compile, Memory grant, Optimization, CE model), the memory grant row is colored by utilization (red over 100% used, orange when any operator spilled or utilization is moderate-low, red when utilization is very low) with a "⚠ spill" tag when any operator in the plan spilled, and compile time is always shown. -- **The plan viewer's properties panel can be filtered and copied, and keeps its width** ([#4588]) - The panel now has a filter box, a copy menu with "Copy value" / "Copy name and value" / "Copy all properties", and remembers the width you drag it to for the session. -- **The plan viewer rolls per-thread stats into one collapsed breakdown** ([#4587]) - For an actual parallel plan, the per-thread stats in each properties section collapse into one "Per-thread breakdown (N threads)" section, as in PerformanceStudio, with a skew note in its header when the work is unbalanced, instead of an inline row per thread per metric. -- **The plan viewer colours actual-plan edges by how far actual rows diverged from the estimate** ([#4586]) - As in PerformanceStudio, an edge turns orange to red when the operator returned far more rows than estimated and blue when it returned far fewer, in three tiers each way, beyond a divergence limit that defaults to 10 and can be set in the settings file of Lite and the Darling Viewer. Estimated plans keep the plain edge colour. -- **Wait-category colours use PerformanceStudio's contrast-checked palette** ([#4583]) - Wait-category chart colours in the plan viewer and Lite's wait charts now use a laid-out, contrast-checked palette instead of individually picked colours, and three colours that fell short of readable contrast against the dark chart background are fixed. -- **Plan analysis drops three rules that PerformanceStudio removed** ([#4565]) - CTE Multiple References, Ineffective Parallelism and Parallel Wait Bottleneck are no longer reported. They guessed at what the runtime stats and wait stats already show. The plan viewer's runtime summary shows a CPU:Elapsed ratio instead, with external-wait time left out of CPU, as PerformanceStudio does. -- **Dependencies: Velopack to 1.2.158, with the release packer moved to match** ([#4563]) - The Lite and Darling Viewer installers and self-updater move from Velopack 1.2.0 to 1.2.158, the `vpk` tool that packs each release moves with it, and every lock file the bump reaches is regenerated. -- **The store writes much less WAL refreshing its Query Store rollups** ([#4506]) - store rung V152 drops the rollups' automatically created group indexes that no reader uses, and keeps the time and server indexes the reads need. -- **The store writes less WAL maintaining its query plan and text dimensions** ([#4502]) - a plan or query text that keeps being seen now refreshes its `last_seen` at most every 6 hours instead of every hour, so there are up to 6× fewer of these non-HOT updates. Retention is unchanged: the dimension prune's 2-day margin still covers the guard. -- **The store's own PostgreSQL log now names the application behind each line** ([#4501]) - Managed stores gain a new configuration block that adds the connecting application's name to each log line, alongside the existing timestamp and process id. This makes it possible to tell which of the service's own connections (or another client) wrote a given line. Both log readers refuse a line whose application name would make it read as a different kind of message (for example, a log line recorded as an error), instead of recording it. Reading RDS and Aurora logs is unchanged. -- **Darling and Lite now record each Availability Group's `group_id`, so two monitored secondaries of one AG count as one group even without its primary** ([#4495]) - store rung V151 adds the column. Rows collected before it fall back to matching by name and replica. -- **The Viewer's Job History reads each server's newest runs through an index instead of sorting the whole fleet's window** ([#4493]) - it shows the same rows in the same order, including a server whose registry entry has since been removed. -- **The service's startup watermark read looks up each collector's newest run through a new index instead of scanning the recent `collection_log` chunks** ([#4489]) - store rung V150 also adds a per-server `job_history` index for the Viewer's Job History. -- **Darling's service, Viewer, CLI and store-upgrade connections now name themselves in `application_name`** ([#4486]) - as the web and MCP pools already did (now also on a configured or owner-fallback connection), so `pg_stat_activity` and a store log with `%a` in `log_line_prefix` show which surface ran a statement. A bring-your-own connection string's own application name is kept. -- **The Viewer's Overview runs its fleet collection-health read once per refresh however many server cards load at once, and the status bar measures the store's size at most every 5 minutes** ([#4482]) - in a measured session the Overview issued that read 40 times in 4.5 minutes, and the size walk ran on every refresh. -- **The startup watermark read no longer walks every compressed `collection_log` chunk in retention** ([#4480]) - it reads only the last two days, which is all the schedule seed needs. -- **`get_ag_health` returns at most 11 Availability Group views by default, the least healthy first, and says when more exist** ([#4474]) - a fleet-wide call on a large fleet returned hundreds of kilobytes; scope by `server_name` or raise `limit` for the rest. -- **The Query Store stores write less WAL keeping their plan and text maps current (a quarter to a third less per touch on a test store)** ([#4472]) - the liveness touch now updates rows in place instead of writing a new row version and index entry each time; the two `last_seen` indexes are dropped (store migration V149), and their retention prune reads each table once per run. -- **Scheduler issues now report SQL Server CPU, other-process CPU, idle CPU, memory utilization, page faults and working-set change from each scheduler-monitor sample, flagged the way sp_HealthParser flags them** ([#4456]) - the old view read scheduler fields that event never carries, so every row came back empty apart from its time; Darling and Lite now read the fields the event does carry, and a sample is significant when SQL Server's CPU is at least 90%, other processes use at least 50%, or memory utilization is at most 50%. -- **The store now gives the web dashboard's and MCP server's reads up to 60 s before cancelling them, instead of 15 s** ([#4447]) - existing stores still at the shipped 15 s default move to 60 s through store schema rung V147, and an operator-set value other than 15 is left alone. Reads over 5 s are still written to the store's log. The desktop viewer's reads and the shared storage-layer readers keep their own 15 s and 30 s client limits for now. Bring-your-own stores re-run `tools/provision-roles.sql` to pick up the new value. -- **The managed store checkpoints every 15 minutes instead of 5, cutting write-ahead log volume** ([#4426]) - a new marker block ships `checkpoint_timeout = 15min`, after a trial on one store kept the checkpoint sync phase far under the checkpointer's own sync-phase self-alert. +- **The managed store sets `random_page_cost = 1.1`** ([#4863]) +- **Per-server Query Store reads fetch fewer rows** ([#4861]) +- **SQL Server blocking and deadlock baselines count the hours collection covered** ([#4853]) +- **The plan viewer's Runtime Summary lists CE model above Optimization, with Early abort under it** ([#4849]) +- **Purge Now runs in the background and is paced like the daily purge** ([#4835]) +- **get_pg_deadlocks explains an empty answer more completely** ([#4832]) +- **Darling reads a quiet database's watermark from its cache instead of from the store every cycle** ([#4818]) +- **Query Store rows now record when each interval ended, in both apps' stores** ([#4802]) +- **Query Store backfill: the per-tick database list no longer walks the newest chunk's index** ([#4703]) +- **Query Store views over windows longer than the raw tier now show the full window from the interval table, and say how far back it reaches** ([#4700]) +- **Analyzer wording for Nested Loops outer sides and row estimate mismatches now counts rows the way the plan viewer does** ([#4698]) +- **PostgreSQL targets: the top-queries views say when pg_stat_statements evicted entries during the window** ([#4680]) +- **Web dashboard: each notebook and Custom View has its own auto-refresh setting, notebooks start with it off, and slow pages back off** ([#4671]) +- **Query Store collection: each database's watermark comes from the store only when a cached value can't be proven current** ([#4669]) +- **Alert pass: the forced-plan failure check reads the store only when its answer can have changed** ([#4667]) +- **Query Store collection: the orphaned per-database state cleanup runs at most once an hour per server** ([#4665]) +- **The Darling Viewer's Query Store trend chart and `get_query_store_duration_trend` no longer re-scan the hourly rollup's oldest and newest hour on every load** ([#4618]) +- **Custom Views Query Store panels over a recent window read the per-interval table instead of re-sorting raw snapshots** ([#4617]) +- **`get_store_metrics` reports the per-interval Query Store tables by name** ([#4616]) +- **Darling Viewer and MCP store reads can no longer spill unbounded temporary files** ([#4610]) +- **Plan viewer minimap: resize, double-click zoom, and accuracy-coloured edges** ([#4603]) +- **Rule 38 can now flag a Standard Edition DOP limit as a Warning** ([#4601]) +- **Plan viewer: one neutral card design for the insights strip** ([#4599]) +- **The plan viewer's Wait Stats rows show each wait's potential benefit and never clip** ([#4595]) +- **Plan viewer costs are formatted as in PerformanceStudio** ([#4592]) +- **The plan viewer's Wait Stats header shows the total wait time and wait-type count on hover** ([#4591]) +- **The plan viewer's runtime summary card matches PerformanceStudio's** ([#4590]) +- **The plan viewer's properties panel can be filtered and copied, and keeps its width** ([#4588]) +- **The plan viewer rolls per-thread stats into one collapsed breakdown** ([#4587]) +- **The plan viewer colours actual-plan edges by how far actual rows diverged from the estimate** ([#4586]) +- **Wait-category colours use PerformanceStudio's contrast-checked palette** ([#4583]) +- **Plan analysis drops three rules that PerformanceStudio removed** ([#4565]) +- **Dependencies: Velopack to 1.2.158, with the release packer moved to match** ([#4563]) +- **The store writes much less WAL refreshing its Query Store rollups** ([#4506]) +- **The store writes less WAL maintaining its query plan and text dimensions** ([#4502]) +- **The store's own PostgreSQL log now names the application behind each line** ([#4501]) +- **Darling and Lite now record each Availability Group's `group_id`, so two monitored secondaries of one AG count as one group even without its primary** ([#4495]) +- **The Viewer's Job History reads each server's newest runs through an index instead of sorting the whole fleet's window** ([#4493]) +- **The service's startup watermark read looks up each collector's newest run through a new index instead of scanning the recent `collection_log` chunks** ([#4489]) +- **Darling's service, Viewer, CLI and store-upgrade connections now name themselves in `application_name`** ([#4486]) +- **The Viewer's Overview runs its fleet collection-health read once per refresh however many server cards load at once, and the status bar measures the store's size at most every 5 minutes** ([#4482]) +- **The startup watermark read no longer walks every compressed `collection_log` chunk in retention** ([#4480]) +- **`get_ag_health` returns at most 11 Availability Group views by default, the least healthy first, and says when more exist** ([#4474]) +- **The Query Store stores write less WAL keeping their plan and text maps current (a quarter to a third less per touch on a test store)** ([#4472]) +- **Scheduler issues now report SQL Server CPU, other-process CPU, idle CPU, memory utilization, page faults and working-set change from each scheduler-monitor sample, flagged the way sp_HealthParser flags them** ([#4456]) +- **The store now gives the web dashboard's and MCP server's reads up to 60 s before cancelling them, instead of 15 s** ([#4447]) +- **The managed store checkpoints every 15 minutes instead of 5, cutting write-ahead log volume** ([#4426]) - **Report alerts link to their own page: the Fleet Sweep Rollup opens the sweeps page, and the digests carry no link** ([#4421]) -- **`get_top_procedures_by_cpu` and the Top Procedures grid now route to the hourly rollup once raw ages past its retention window, instead of returning nothing** ([#4413]) - Mirrors the routing already shipped for `get_top_queries_by_cpu`; the payload discloses which tier answered, and the columns the hourly rollup lacks (`object_type`, the handles, the I/O totals and the min/max extremes) are null, not 0. +- **`get_top_procedures_by_cpu` and the Top Procedures grid now route to the hourly rollup once raw ages past its retention window, instead of returning nothing** ([#4413]) - **Sized the Linux compose store's background-worker slots and `work_mem` from the product's own - **Cache the server-scoped watermark read across a runner's lifetime, cutting repeated `MAX()` reads against `job_history`, `default_trace_events`, `system_health_events`, and `memory_pressure_events` to one seed per (server, collector) pair instead of one per collection cycle** ([#4399]) -- **Top-N-by-CPU queries now route to the hourly rollup once raw's retention has dropped the window, instead of returning empty** ([#4396]) - `get_top_queries_by_cpu` (MCP tool, Storage reader, and Viewer) degrades to the hourly continuous aggregate for a window older than raw's floor and discloses the precision loss (`tier_used`, `precision_note`) rather than silently returning nothing. The raw-only filters (`min_dop`, `parallel_only`, `group_by=host_object`) keep the read on raw, and when raw holds nothing in the window the answer is status `empty` with `window_truncated` set. On the hourly tier, the columns the rollup lacks (plan hash and handle, DOP, reads, writes, physical reads, rows, spills, `avg_reads`, `is_parallel`, `distinct_texts` and the min/max CPU and elapsed times) are null, not 0, and `sql_handle` is returned. The read counts no bucket past the rollup's materialization ceiling, and `cpu_attribution` divides by the span the rollup served. -- **The Performance Trends Query Store duration chart reads the interval table for windows of 48 hours or more** ([#4382]) - the table measured faster than raw from 48 hours (361 ms vs 423 ms at 48 h; 374 ms vs 1,045 ms at 7 days) and returns exactly raw's points; shorter windows stay on raw. The interval-table gate also reads raw for any window that still holds legacy rows without an interval start. -- **The Darling viewer's TempDB file I/O trend now buckets like the File I/O tab's own reads** ([#4353]) - a 7-day window used to return one row per collection per tempdb file (40,324 rows measured for 4 files at 1-minute cadence); it now buckets to the chart's point budget (4,036 rows measured for the same seed) and still stamps a short window's raw points unchanged. -- **Raw hypertables now re-tune their own chunk interval once a day from actual ingest** ([#4344]) - Every raw hypertable used the same fixed one-day chunk interval whatever its write rate, so a busy table's open chunk, with its indexes, could outgrow the memory meant to hold it. Darling now reads each raw hypertable's compressed ingest rate daily, alongside a RAM-derived budget, and narrows the interval one rung at a time through `set_chunk_time_interval` when the store-wide total is over budget, and widens it one rung when the total would stay under half the budget; a new rung history table records every change, alongside a per-run WAL-volume record. On by default; set `rawChunkIntervalReconcileEnabled: false` in the config file to turn it off. -- **The Queries grid and MCP's Query Store top read use a per-interval table for long windows** ([#4341]) - both used to deduplicate the whole raw Query Store slice on every read. The grid now reads a table that keeps one row per interval for windows of 12 hours or more, and the MCP read for 24 hours or more. On a 15-day seed of 3.47 million raw rows, a 7-day window took 2,754 ms against 7,065 ms for the grid, and 1,627 ms against 9,249 ms for the MCP read. Shorter windows, and any window the table's history doesn't cover yet (after an upgrade), read raw as before. A BRIN index on the table's `collection_time`, which the service builds in the background from about 20 minutes after it starts without blocking writes (skipped below PostgreSQL 16 and on a hypertable), serves Custom Views Query Store panels of 12 hours or more where `random_page_cost` is about 1.1 or lower. -- **Lite's memory clerk and File I/O trend charts bucket long windows in DuckDB** ([#4340]) - The memory clerk, File I/O latency, File I/O throughput and TempDB File I/O trend charts, and the Overview I/O lane, read one point per collection. They now gather collections into buckets sized to the window, at most 1,500 points per series. A bucket's latency is its summed stall over its summed operations, and its throughput is its summed bytes over its summed seconds. A window short enough that every bucket holds one collection plots each point at its own collection time, as before. The memory clerk picker's name list is cached for 15 minutes. -- **Lite keeps one DuckDB connection open, so reads attach to it instead of reopening the database file** ([#4339]) - Every read used to open and close its own connection to the local database file. One connection now stays open for the app's life, which cut a 20-tick, ten-way Overview read on a 1 GB store from 871 ms to 43 ms. Because that connection keeps DuckDB's buffer pool resident, a periodic check trims it after a heavy read: on a 1.1 GB store, one trim took process private bytes from 1,115 MB to 148 MB. -- **Lite's Performance Trends charts bucket long windows in DuckDB** ([#4338]) - The query duration, procedure duration and execution count charts read one point per collection, about 10,080 points each for a 7-day window at one collection a minute. They now gather collections into buckets sized to the window, rating each bucket as its summed work over its summed seconds, and a window short enough that every bucket holds one collection plots each point at its own collection time, as before. -- **Lite's Overview CPU, wait and memory lanes bucket long windows in DuckDB** ([#4337]) - The Overview tab's CPU, wait and memory lines, and the CPU and Memory tab charts, read one point per collection: about 10,080 points each for a 7-day window at one sample a minute. They now gather collections into at most 1,500 points per line, and a window short enough that every bucket holds one sample or collection plots each point at its own collection time, as before. -- **Settings the service manages now live in one included file, not stacked append blocks** ([#4336]) - the v1-v15 `postgresql.conf` append blocks are replaced by a single included file, `darling-managed.conf`, rewritten wholesale on every start. Existing stores migrate their current effective values into it on the first start after upgrade, without changing any value. An operator's own lines are kept, moved below the include so they keep winning, and settings set with `ALTER SYSTEM` are never changed. From then on, sizing values can change on the first start after an upgrade, and each change is logged with the inputs that produced it. A failed verification restores the previous settings files and raises the store-settings alert. Operator lines placed below the include are not yet carried across a major PostgreSQL version upgrade ([#4358]). -- **Darling viewer's Performance Trends charts bucket server-side over long windows** ([#4333]) - The query duration, procedure duration and execution count charts read one point per collection on the raw tier, about 10,080 points each for a 7-day window at one collection a minute. The store now gathers collections into buckets sized to the window, rating each bucket as its summed work over its summed seconds, and the chart title names the bucket width. A window narrow enough that every bucket holds one collection plots each point at its own collection time, as before. -- **Lite's Wait Stats and Perfmon charts bucket long windows instead of shipping one point per collection** ([#4331]) - A 7-day Wait Stats or Perfmon chart carried one row per stored collection, about 10,080 rows per wait type or counter at one collection a minute (about 200,000 for 20 wait types). It now buckets each wait type or counter to at most about 1,500 points (the chart budget, not the MCP tools' 200-point budget), and a window short enough that every bucket holds one collection still plots each point at its own collection time. The wait-type and perfmon-counter pickers also cache their name list for 15 minutes per server and window length instead of re-reading it on every 1-minute auto-refresh. -- **Darling viewer's File I/O and memory clerk charts load faster over long windows** ([#4329]) - the -- **Darling viewer's CPU, Overview wait and Overview memory charts bucket server-side over long windows** ([#4327]) - The CPU chart, and the Overview tab's total-wait and buffer-pool lanes, used to return one row per ring-buffer sample or per collection with no cap: about 10,080 rows each for a 7-day window at one collection a minute. Postgres now buckets all three to a fixed row budget, matching the sizing already applied to the Wait Stats and Perfmon trend charts. A window narrow enough that every bucket holds exactly one sample or collection still renders each point at its own exact timestamp rather than a bucket boundary, so short windows look unchanged. -- **PostgreSQL-target baselines recompute once a day instead of every hour** ([#4324]) - Every PostgreSQL-target baseline arm (13 unkeyed metrics plus the 2 statement-keyed ones) was recomputing its full 30-day window every hour; one of them cost up to 2.45 seconds and 262 MB of temp space per pass. They now share the once-a-day cache lifetime the two heaviest SQL Server baselines (Cpu, IoLatency) already used. Because a daily baseline covers history up to the start of the UTC day, a PostgreSQL target added today has no baselines, and its baseline-driven anomaly checks sit out, until the next UTC midnight. -- **Three legacy query-stats rollups stop refreshing** ([#4186]) - `query_stats_hourly`, `procedure_stats_hourly`, `query_stats_db_hourly` and their daily rollups keep the history they already hold. Their interval-honest successors take over. Reads older than the successors' own history still use them. New data goes only to the successors, so the store no longer spends refresh time on the old rollups. The raw `query_stats` and `procedure_stats` purge now waits until the successors and the old rollups together cover every raw row. After a long outage, the service fills the gap at startup, up to a day of it per start. Only then does the purge resume. `--backfill-rollups` fills it in one run. Existing compression jobs move to new hours once. Dashboards, alerts and queries do not change. -- **llms.txt and CITATION.cff now match the shipped product** ([#4157]) - llms.txt said 41 T-SQL collectors (it is 42), listed Azure SQL Database under Lite only (Darling supports it too), never mentioned Darling's 29 PostgreSQL collectors or its Windows/Linux and web-dashboard support, named only email and tray alerts (Teams, Slack, PagerDuty and generic webhooks also fire), and undercounted downloads (15,000+, not 4,300+). SentryOne is now named as SolarWinds SQL Sentry. CITATION.cff drops a version and release date no release step keeps current. A new test compares both collector counts in llms.txt against the collector catalog so they cannot go stale silently again. -- **The MCP tool list's size limit now matches its size** ([#4141]) - #3898 moved reading guidance out of the tool list. The budget test's total limit now equals the tool list's measured size. On Darling that is 170,798 bytes, down from a limit of 329,494. On Lite it is 89,719 bytes, down from 148,216. Any later growth has to raise the limit on purpose. The window_truncated note on the time-series tools also drops its issue number, and now says the field was formerly named truncated. -- **get_spinlock_stats puts a short description in the tool list** ([#4127]) - Before this change, this Darling and Lite MCP tool put 597 and 1,306 characters into the tool list. It now serves a head of 595 characters on both, under the usual 620-character cap. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **analyze_query_plan puts a short description in the tool list** ([#4126]) - Before this change, this Darling and Lite MCP tool put 915 and 903 characters into the tool list. It now serves a head of 616 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_pvs_stats puts a short description in the tool list** ([#4125]) - Before this change, this Darling and Lite MCP tool put 1,156 characters into the tool list. The tool now serves 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The guide now also says that a database size of 0 leaves pct_of_database null, as the tool already did. Nothing was deleted, and no tool behavior changed. -- **get_deadlocks (Darling and Lite) and get_blocked_process_reports (Lite) put a short description in the tool list** ([#4123]) - Before this change, these MCP tools put up to 822 characters (get_deadlocks on Darling), 694 characters (get_deadlocks on Lite), and 1,340 characters (get_blocked_process_reports on Lite) into the tool list. get_deadlocks now serves the same 591-character head on both products, and get_blocked_process_reports serves a 483-character head, and the get_tool_guide tool returns the rest of the guide by tool name. Darling's get_deadlocks dedup_key parameter lost its reference to issue #1140 in the move. No other guidance was deleted, and no tool behavior changed. -- **get_long_query_completions puts a short description in the tool list** ([#4122]) - Before this change, this Darling and Lite MCP tool put 1,037 characters into the tool list on each product. It now serves a head of 604 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_memory_pressure_events puts a short description in the tool list** ([#4120]) - Before this change, this Darling and Lite MCP tool put 835 and 1,018 characters into the tool list on the two products. It now serves a head of fewer than 620 characters on both. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_latch_stats puts a short description in the tool list** ([#4119]) - Before this change, this Darling and Lite MCP tool put 1,027 and 1,372 characters into the tool list. It now serves a head of fewer than 620 characters on both products. The get_tool_guide tool returns the rest of the guide by tool name. The description also no longer says that high ACCESS_METHODS_DATASET_PARENT or FGCB_ADD_REMOVE latch waits mean TempDB allocation contention. Microsoft's documentation says the first synchronizes parallel operations and the second covers file add, drop, grow and shrink operations. The Dashboard's copy of the sentence gets the same fix. No tool behavior changed. -- **get_index_usage puts a short description in the tool list** ([#4118]) - Before this change, this Darling and Lite MCP tool put 856 and 493 characters into the tool list. The tool now serves a head of 488 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **analyze_procedure_plan puts a short description in the tool list** ([#4117]) - Before this change, this Darling and Lite MCP tool put 926 and 912 characters into the tool list. The tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **validate_custom_view and run_custom_view_panel put a short description in the tool list** ([#4116]) - Before this change, these two Darling MCP tools put 1,576 and 1,084 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **analyze_plan_xml puts a short description in the tool list** ([#4115]) - Before this change, this Darling and Lite MCP tool put 880 characters into the tool list on both products. It now serves a head of 618 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_ag_health and get_store_query_stats put a short description in the tool list** ([#4114]) - Before this change, these two Darling MCP tools put 1,529 and 984 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **Claude Code keeps the MCP entry tools loaded even when it defers the rest** ([#4113]) - list_servers, get_fleet_overview (Darling only), analyze_server and get_tool_guide now carry anthropic/alwaysLoad in their tool metadata. A Claude Code session that defers other tools to save context still sees these four at session start. -- **get_query_store_regressions puts a short description in the tool list** ([#4109]) - Before this change, this Darling and Lite MCP tool put 1,187 characters into the tool list on both products. The tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_blocking and get_pg_replication_slots put a short description in the tool list** ([#4108]) - Before this change, these two Darling MCP tools put 1,645 and 803 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. -- **get_active_queries puts a short description in the tool list** ([#4107]) - Before this change, this Darling and Lite MCP tool put 1,406 and 1,421 characters into the tool list. It now serves a head of fewer than 620 characters on both. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_plan_corrections puts a short description in the tool list** ([#4105]) - Before this change, this Darling and Lite MCP tool put 1,672 characters into the tool list. It now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_query_store_duration_trend and get_perfmon_trend put a short description in the tool list** ([#4101]) - Before this change, get_query_store_duration_trend put 1,537 characters (Darling) and 1,276 characters (Lite) into the tool list, and get_perfmon_trend put 1,057 characters into the tool list on both products. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_resource_semaphore and get_memory_grants put a short description in the tool list** ([#4100]) - Before this change, these two Darling and Lite MCP tools put 1,310 and 988 characters into the tool list. Each tool now serves a head of 617 and 556 characters. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_daily_summary and get_daily_summary_range put a short description in the tool list** ([#4099]) - Before this change, these two Darling and Lite MCP tools put 1,414 and 1,903 characters into Darling's tool list, and 1,034 and 1,474 characters into Lite's. Each tool now serves a head of fewer than 620 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_query_store_health and get_default_trace_events put a short description in the tool list** ([#4095]) - Before this change, these two Darling and Lite MCP tools put up to 2,587 and 866 characters into the tool list. On both products, each tool now serves a head of fewer than 620 characters. The get_tool_guide tool returns the rest of the guide by tool name. The heads also state what an empty or unavailable answer means for each tool. Two issue numbers and a story about one production store were removed from the text of get_query_store_health. No guidance was deleted, and no tool behavior changed. -- **get_pg_kernel_stats, get_pg_xmin_horizon and get_pg_table_bloat put a short description in the tool list** ([#4093]) - Before this change, these three Darling MCP tools put 1,298, 1,294 and 1,191 characters into the tool list. Each tool now serves a head under 620 characters (613, 590 and 605). The get_tool_guide tool returns the rest of the guide by tool name. The heads also state what an empty answer means for get_pg_kernel_stats and get_pg_table_bloat, which the old descriptions left out. Two long parameter descriptions also got shorter, and their full text moved to the guide. The limit parameter of get_pg_kernel_stats went from 204 to 180 characters, and that of get_pg_table_bloat went from 270 to 187. Nothing was deleted, and no tool behavior changed. -- **get_pg_io_trend, get_pg_database_trend and get_pg_cpu_utilization put a short description in the tool list** ([#4092]) - Before this change, these three Darling MCP tools put 1,596, 1,373 and 1,341 characters into the tool list. Each tool now serves a head of 620 characters or fewer, and the get_tool_guide tool returns the rest of the guide by tool name. The backend_type parameter of get_pg_io_trend went from 205 to 86 characters, and the rest of its text moved to the guide. get_pg_cpu_utilization's description also corrects a wrong claim. It said the tool covered both Aurora and RDS, with only a self-hosted server returning empty. The collector behind this tool runs only on Aurora, so a plain RDS server was never covered either. The description now says that a plain RDS server and a self-hosted server both report not_collected, not empty. No guidance was deleted, and no tool behavior changed. -- **get_pg_column_stats, get_pg_replication_stats and get_pg_predicate_stats put a short description in the tool list** ([#4091]) - Before this change, these three Darling MCP tools put 1,105, 925 and 841 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The heads also state facts that the old descriptions left out. get_pg_column_stats returns the newest capture for each column, and a window shorter than a day can be empty because the collector runs daily. get_pg_predicate_stats reports filtered_pct as a percent that is null when no rows were evaluated, and its queryid is a string. Nothing was deleted, and no tool behavior changed. -- **The Darling service account can no longer change its own program files** ([#4090]) - The install and upgrade scripts gave the service account Modify rights on the whole install folder. It now gets Read & Execute there. It keeps Modify only on the bundled PostgreSQL runtime folders (pg-runtime and pg-runtime-prev) and, when you bring your own PostgreSQL, on the darling-keys folder. A compromised service or database process can no longer replace the service's program files to survive a restart. -- **mute_analysis_finding and audit_config put a short description in the tool list** ([#4088]) - Before this change, these two Darling and Lite MCP tools put as much as 1,444 and 932 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_pg_blocking, get_pg_wait_stats and get_pg_index_usage put a short description in the tool list** ([#4087]) - Before this change, these three Darling MCP tools put 1,606, 1,483 and 1,471 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Two long parameter descriptions also shrank with no loss of meaning: get_pg_wait_stats's limit went from 214 to 190 characters, and get_pg_index_usage's limit went from 257 to 93. Nothing was deleted, and no tool behavior changed. -- **get_pg_plan_capture_readiness, get_pg_plans and get_pg_session_states put a short description in the tool list** ([#4086]) - Before this change, these three Darling MCP tools put 1,950, 1,374 and 1,617 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of each tool's limit parameter is also shorter: 389 to 158, 235 to 72 and 282 to 117 characters. get_pg_plans' query_id parameter is shorter too, 320 to 88. Nothing was deleted, and no tool behavior changed. -- **get_query_duration_trend and get_procedure_duration_trend put a short description in the tool list** ([#4085]) - Before this change, these two Darling and Lite MCP tools put up to 1,180 characters into the tool list. get_query_duration_trend served 1,172 characters on Darling and 1,136 on Lite. get_procedure_duration_trend served 1,180 characters on both. Each tool now serves a head of 614 or 445 characters on both products. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_analysis_facts and get_analysis_findings put a short description in the tool list** ([#4083]) - Before this change, these two Darling and Lite MCP tools put 1,825 and 2,875 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_analysis_facts's source parameter is also shorter (515 to 180 characters), and so is get_analysis_findings's include_drilldown parameter (235 to 122 characters). get_analysis_findings' description now also says that its truncated and truncation_note fields can mean its occurrence counts are undercounted. get_analysis_facts' guide now also says what its total_facts, shown and filters fields count. get_analysis_findings' head and tail also lost their two issue-number references. The guardrails they carried stay. get_analysis_facts carried none to begin with. No tool behavior changed. -- **get_pg_database_stats, get_pg_autovacuum_health and get_pg_top_queries put a short description in the tool list** ([#4082]) - Before this change, these three Darling MCP tools put 2,361, 2,215 and 2,210 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of each tool's limit parameter is also shorter: 229 to 175, 261 to 161 and 228 to 163 characters. get_pg_autovacuum_health's description now also says that its disabled, past-threshold and growing counts cover only the returned page, not the whole server. No guidance was deleted, and no tool behavior changed. -- **get_pg_logging_audit, get_pg_io_stats and get_pg_wait_sampling put a short description in the tool list** ([#4081]) - Before this change, these three Darling MCP tools put 2,086, 2,045 and 2,032 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_pg_io_stats's limit parameter also went from 235 to 194 characters, with no loss of meaning. get_pg_logging_audit's tail also lost its parenthetical issue numbers (#3601, #3602 and #3603). The sentence still says PLANNED without naming them. No tool behavior changed. -- **validate_custom_alert_rule, test_custom_alert_rule, update_custom_alert_rule and list_custom_alert_templates put a short description in the tool list** ([#4079]) - Before this change, these four Darling MCP tools put 2,078, 922, 890 and 751 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The descriptions of update_custom_alert_rule and create_custom_alert_rule now say that enabling a rule is refused once 100 rules are enabled across the fleet. The guide of test_custom_alert_rule now says that a rule with no in-scope servers returns the status no_in_scope_servers. Nothing was deleted, and no tool behavior changed. -- **get_alert_history, set_notification_route_enabled, create_mute_rule and set_mute_rule_enabled put a short description in the tool list** ([#4077]) - Before this change, get_alert_history put 4,740 characters into the tool list on Darling and 3,573 on Lite. The three Darling-only write tools put 841, 959 and 1,477 characters. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_alert_history's include_dismissed parameter also went from 360 to 114 characters on Darling and from 357 to 111 on Lite, and the text it lost moved to the guide. get_alert_history's tail also lost its issue-number references on both Darling and Lite. The sentences that carried them are otherwise unchanged. The three write tools carried none to begin with. No tool behavior changed. -- **get_pg_extensions, get_pg_write_stats, get_pg_server_config and get_pg_server_config_changes put a short description in the tool list** ([#4078]) - Before this change, these four Darling MCP tools put 1,727, 1,509, 2,252 and 1,146 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_collector_stall_probes, describe_custom_view_catalog and get_sweep_reports put a short description in the tool list** ([#4074]) - Before this change, these three Darling MCP tools put 2,678, 2,589 and 2,274 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The guide of get_collector_stall_probes lost one example of a single measured stall. Nothing else was deleted, and no tool behavior changed. -- **analyze_server and compare_analysis put a short description in the tool list** ([#4073]) - Before this change, these two MCP tools put 4,160 and 1,647 characters into the tool list, on both Lite and Darling. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of compare_analysis's baseline_hours_back parameter also went from 211 to 139 characters, and the sentence it lost moved to the guide. Nothing was deleted, and no tool behavior changed. -- **get_fleet_overview, add_servers and remove_server put a short description in the tool list** ([#4071]) - Before this change, these three Darling MCP tools put 3,287, 3,285 and 1,784 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. -- **get_pg_log_events, get_pg_index_bloat and get_pg_deadlocks put a short description in the tool list** ([#4068]) - Before this change, these three Darling MCP tools put 4,199, 3,491 and 2,839 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. -- **get_query_store_clutter and get_oversized_plan_backlog put a short description in the tool list** ([#4067]) - Before this change, these two Darling MCP tools put 5,147 and 2,997 characters into the tool list. Each tool now serves a head of about 610 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. -- **update_alert_settings and update_mute_rule put a short description in the tool list** ([#4066]) - Before this change, these two Darling MCP tools put 8,123 and 2,530 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted. The heads keep the facts that a caller needs to change settings safely. Both tools make partial updates. In update_alert_settings, one invalid field means that no field is written. The retired poison_wait.threshold_ms setting does not change when the alert fires. health_bands and fleet_sweep are not alert families. In update_mute_rule, a rule with every scope field cleared mutes every alert. The reading guides of get_alert_settings and get_notification_routes also lost their issue numbers, on Lite and Darling. -- **get_collection_log and get_query_store_top put a short description in the tool list** ([#4065]) - Before this change, get_collection_log put its whole reading guide into the MCP tool list. The description was 6,995 characters on Darling and 4,405 characters on Lite. The tool list now gets a head of 606 characters, and the get_tool_guide tool returns the rest of the guide by tool name. get_query_store_top now serves the same head on both products. That head states that only Darling marks a window floor with window_truncated. Three parameter descriptions of get_collection_log were longer than 200 characters. Each one keeps its main fact, and the rest moves to the guide under the parameter name. Nothing was deleted. -- **Three self-monitoring MCP tools put a short description in the tool list** ([#4064]) - The tools are get_store_metrics, get_store_log and get_collector_cost. They are Darling only. Before this change, each tool put its whole reading guide into the MCP tool list. Each description is now split the same way as the earlier system_health and data-read tools. The tool list keeps the facts that a caller needs to read the answer correctly. get_store_metrics and get_store_log report on the monitoring store itself, not on a monitored SQL Server. get_collector_cost reports what the collectors cost, not the health of a server. A daily size point is the last snapshot of the day, not its peak. An empty job-history block can mean that the reader has no visibility, not that nothing ran. For query_store, most of the time that get_collector_cost reports is the store's own probe and write work. The get_tool_guide tool returns the rest of the guide by tool name. -- **get_collection_health's tools/list entry drops from 21,026 characters to 583** ([#4063]) - This was the largest tool description an MCP client had to load before asking a question, on both Darling and Lite. No guidance is lost. The guardrail facts a caller needs stay in the short entry every client loads: a stopped collector is not a failing one, a zero rows-stored count is not automatically a fault, last_error can be stale, a regression is counted separately from a failure, and the alert-read-health block covers a different window than the rest of the payload. The rest of the reading guide moves to get_tool_guide, available on request. -- **get_alert_settings and get_notification_routes serve a short head, with the rest available from get_tool_guide** ([#4061]) - These two MCP tools served 7,530 and 1,746 characters on Darling, and 3,954 and 600 on Lite, before the first question. Both now serve a head under 610 characters on both products, with a pointer to get_tool_guide for the full text. Nothing was deleted. The head keeps the facts a caller needs to read the answer correctly. For example, one cooldown gates whether an alert fires, and a separate one bounds the resulting post. It also says what an unseeded store or an empty knob list means. -- **Seven data-read MCP tools put a short description in the tool list** ([#4055]) - The tools are get_wait_stats, get_file_io_stats, get_perfmon_stats, get_server_properties, get_top_queries_by_cpu, get_top_procedures_by_cpu and list_servers. Before this change, each tool put its whole reading guide into the MCP tool list, on both Lite and Darling. Each description is now split in the same way as the system_health tools. The tool list keeps the facts that a caller needs to read the answer correctly. For example, a page holds only the heaviest rows, and a null latency is not 0 ms. Also, the min and max CPU values cover the whole life of the plan in the cache. Offline means different things on Lite and Darling. The get_tool_guide tool returns the rest of the guide by tool name. -- **MCP clients load less context up front, and a new get_tool_guide tool serves the long-form guidance on request** ([#4048]) - Every tool description went into the MCP tool list in full, so a client that loads the whole catalog paid for all of it before the first question (about 330 KB on Darling). A description can now split into a short head, which the tool list serves, and a reading guide, which get_tool_guide returns by tool name or cross-tool topic, on both Lite and Darling. The nine system_health tools are converted first, at about half their previous size. Heads keep the facts a caller needs to read the answer correctly, such as which events are filtered out and what an empty answer means. A size check keeps the tool list from growing back. -- **Darling's MCP server instructions drop from 88,532 to 7,992 characters and Lite's from 52,942 to 7,721, both now under a pinned 8,000-character budget** ([#4039]) - Phase 2 of #3898: the per-tool "Tool Reference" tables and prose that used to restate what each tool's own tools/list description already says are gone, because nothing enforced that the two copies stayed in sync. What stays in the instructions is what no single tool's description can say by itself: the read-only preamble, the status-word vocabulary (empty, unavailable, not_collected, precondition, error, invalid), the as_of/hours_back anchor rule, and a one-line tool census. Every fact the old tables carried that a tool needs to be used correctly was checked against where it landed. get_collection_health's analysis_caveats clause, get_ag_health's per-replica-column trap, get_blocking/get_deadlocks/get_deadlock_detail's dedup_key scoping, and get_sweep_reports's and get_query_store_clutter's family facts all moved into the tool's or parameter's own description. Several others (add_servers, remove_server, mute_analysis_finding, compare_analysis, the plan tools' create_statement caveat) were already fully stated there, so the instructions row was pure duplication. get_memory_pressure_events's description pointed at an instructions section this phase renamed and gutted. It now states its own follow-up-tool guidance instead of pointing anywhere. Both SKUs' tools/list grew by under 400 bytes total from the handful of relocated facts, negligible next to the instructions cut. -- **PostgreSQL log messages show as PostgreSQL wrote them, and the SQL in them is normalized with every literal replaced by ?** ([#3996]) - Regex masking of free-form log prose kept missing shapes: RAISE text, libxml lines, a value typed after a noun, and a command's stderr. So it is removed from the store's own log (`get_store_log`) and from every PostgreSQL target's log events (`get_pg_log_events` and both viewers' Log Events panels). Messages, DETAIL and CONTEXT prose, HINT and LOCATION now appear exactly as the server logged them. SQL is still read by the lexer, and withheld when it cannot be read to its end. That covers STATEMENT and QUERY lines, slow statements, a crash's or a deadlock's queries, a function's SQL frames, a postgres_fdw remote command, a statement's bound parameters, and PL/pgSQL `print_strict_params` values. An auto_explain plan logged at WARNING keeps only its duration line. The review also closed two ways one statement's text could decide how another's was read. A deadlock query cut inside a literal no longer pairs its quote with the next process's query, which could show that query's literal as a plain word. A COPY value shaped like a CONTEXT frame can no longer swallow the real frame after it. Store-log rows now count messages that differ only in a quoted value or a number as one. The existing hourly pass brings rows stored by earlier releases to these rules. A security review then closed more. The token a syntax error quotes is read as SQL in every language PostgreSQL's catalogues write it in, not only English: Spanish, Indonesian and Japanese keep the ERROR label in English, so their syntax errors are stored. An unterminated literal or a jsonpath token there is withheld. A deadlock report cut between its lines withholds every query after one that cannot be read to its end, unless the entry proves the report whole. PL/pgSQL parameter lists and portal parameter lists must read back as name and masked-value pairs, or they are withheld. Under a translated `lc_messages`, a log line whose field label this reader does not know is withheld, with the rest of its entry, rather than kept as prose, and the Turkish and Korean labels written without spaces are labels whatever follows their colon. Such a line never opens an entry from inside a statement's literal. The same applies to a `log_line_prefix` that renders a label-shaped token of its own, such as an application name ending in a colon and two spaces. Reading a deadlock report of hundreds of waiters, or a CONTEXT of a thousand frames, no longer allocates over 100 MB. `get_pg_log_events` no longer returns `raw_line_hash`, an unkeyed hash of the raw line that a reader could use to test guesses at a hidden value. -- **The shared `as_of` description is 167 characters instead of 379, cutting Darling's `tools/list` by 22,040 characters (6.4%) and Lite's by 14,246 (8.8%)** ([#3965]) - It is the `as_of` parameter on 91 Darling and 56 Lite tools, so at 379 characters it was a tenth of Darling's catalog, paid on every request by every client that loads the full tool list. The short text keeps the rule a caller acts on: the anchor is the window's END, a bare date is 00:00 UTC, omitting it means now, and a past incident is `as_of` at its end, never a wider `hours_back`; the reason stays in both SKUs' server instructions. The days twin (416 → 166), the `window_truncated` clause (441 → 254, keeping its WIRE CHANGE sentence until the rename ships) and the `discontinuities[]` sentence (489 → 317, now naming all six reason words) are cut the same way. No description grew, `get_procedure_duration_trend` drops back under the 2,048-character cut Claude Code applies, and a new pin holds the rule's words, the 200-character parameter budget and the instructions' reason on both SKUs. Part of [#3898]. -- **The review guard tells a pending workflow fix from hostile drift** - When `dev`'s `claude-review.yml` differs from `main`'s because a reviewed dev PR changed it and the release has not synced yet, the guard now warns "review pending release" and names the merged PR instead of failing every PR in the repo as if the file had been tampered with; unexplained drift still fails, and an origin the guard cannot determine fails closed. -- **The tempdb Space alert stops paging on a single collected sample** ([#3653]) - it fired on the first `tempdb_stats` row at or above the threshold and resolved on the next one under it, which on one production store class was 22 page/resolve pairs in 14 days about runs of 1-4 samples lasting at most 206 s. The arm now sits behind the shared persistence gate High CPU adopted in #3282: 3 consecutive breaching COLLECTIONS to fire (identified by the row's `collection_time`, so a 30 s sweep re-reading the last row does not count twice), the first collected sample under the bar to resolve, the open-incident bit persisted under its own metric name in the existing state table so a restart neither re-announces nor forgets it, and a tempdb reading that stops arriving freezes the gate instead of announcing "back to N/A". Blocking Wait Time and Long-Running Query await their rulings. -- **The analysis names the Agent job that is running long instead of counting it** ([#3653]) - the RUNNING_JOBS fact on both SKUs now carries the name of the job furthest past its own history (chosen among the running-long rows by percent of average, then duration), and the job card's headline, first sentence and remediation say which job — and "and N others" when several overran — where they used to send the operator to the Running Jobs view to find out. Findings persisted before this, and windows where jobs ran but none ran long, read exactly as before. -- **MCP tool failures were two wire shapes — a bare sentence on 214 tools and a JSON envelope on the PostgreSQL reads — and a `status`-keyed client read the sentences as successful text; now every tool on both SKUs answers a caught exception with one envelope through `McpHelpers.FormatError`** ([#3653]) - **WIRE CHANGE.** A tool that throws returns `{"status":"error","message":"Error during : …","hints":{"operation":""}}` — the same envelope and serializer the four miss words use, the message text unchanged — including the frozen Dashboard twin, which links the same helper. The 30 PostgreSQL catches drop their "Reading X failed" dialect for the one grammar; the web surface maps the envelope to HTTP 500 (so PostgreSQL failures that passed through as 200 are 500 now) and keeps its `{"error": sentence}` body; the payload-contract census retires its two-shape inventory and fails by name on any catch that bypasses the helper. Validation refusals are unchanged and still bare sentences — a separate ruling. -- **PostgreSQL bars the fleet measured now say so** ([#3691]) - Every v1 bar the 2026-09-19 calibration of 50 Aurora PostgreSQL clusters validated (temp 1/10 MiB/s, backlog 3/10×/5, deadlocks 5/20, bad-actor busy floor 0.05, wait rollups 0.20/1.0 and io 0.40/2.0, CPU 80/95, TPS floor 50 / fallback 500, CPU floor 40 / fallback 95, deadlock floor 1/h, wait fallback 500 ms/s) carries a measured comment naming its percentile, population and date, and the facts graded on them show `threshold_lineage = 1` in get_analysis_facts instead of calling the bar a judgment; sessions 0.8/0.9 stay engine-defined with the measured note (fleet max 10.3 % of ceiling). Still unmeasured and still saying so: wait standout bars and sampling floor, session COUNT floors, the ratio families' firing multiple, every co-fire boost, checkpoint pressure (not applicable on Aurora) and buffer cache. No bar value changed. -- **Anomaly detectors fired on one hot sample and fired more the longer the window was; the gate now judges the window peak AND the window mean, and I/O reads the pair like its siblings** ([#3653]) - Every z-score detector tested the window MAX against a per-sample hour×dow distribution, so a 24-hour anchored pass mechanically reported more anomalies than the 4-hour scheduled pass on identical behaviour. The shared AnomalyGate fires only when both the peak and the window mean clear the existing cutoffs (z on both when the baseline is trustworthy; the fallback bar on the peak and the magnitude floor on the mean when it is not) — no cutoff moves, the reported sigma stays the peak's, and the mean's sigma rides beside it in the story. I/O latency, the one family reading AVG alone, now reads MAX and AVG on both SKUs and reports the peak. -- **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. -- **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. -- **The Extended Events collectors use less CPU on the monitored server to filter events by time** ([#4912]) - The blocked process report, deadlock, long query completion and system_health collectors now compare each event's timestamp inside the XQuery, instead of converting it with a value() cast first. In local tests that filter used 3 to 14 percent less CPU. The events collected are the same. +- **Top-N-by-CPU queries now route to the hourly rollup once raw's retention has dropped the window, instead of returning empty** ([#4396]) +- **The Performance Trends Query Store duration chart reads the interval table for windows of 48 hours or more** ([#4382]) +- **The Darling viewer's TempDB file I/O trend now buckets like the File I/O tab's own reads** ([#4353]) +- **Raw hypertables now re-tune their own chunk interval once a day from actual ingest** ([#4344]) +- **The Queries grid and MCP's Query Store top read use a per-interval table for long windows** ([#4341]) +- **Lite's memory clerk and File I/O trend charts bucket long windows in DuckDB** ([#4340]) +- **Lite keeps one DuckDB connection open, so reads attach to it instead of reopening the database file** ([#4339]) +- **Lite's Performance Trends charts bucket long windows in DuckDB** ([#4338]) +- **Lite's Overview CPU, wait and memory lanes bucket long windows in DuckDB** ([#4337]) +- **Settings the service manages now live in one included file, not stacked append blocks** ([#4336], [#4358]) +- **Darling viewer's Performance Trends charts bucket server-side over long windows** ([#4333]) +- **Lite's Wait Stats and Perfmon charts bucket long windows instead of shipping one point per collection** ([#4331]) +- **Darling viewer's File I/O and memory clerk charts load faster over long windows** ([#4329]) +- **Darling viewer's CPU, Overview wait and Overview memory charts bucket server-side over long windows** ([#4327]) +- **PostgreSQL-target baselines recompute once a day instead of every hour** ([#4324]) +- **Three legacy query-stats rollups stop refreshing** ([#4186]) +- **llms.txt and CITATION.cff now match the shipped product** ([#4157]) +- **The MCP tool list's size limit now matches its size** ([#4141]) +- **get_spinlock_stats puts a short description in the tool list** ([#4127]) +- **analyze_query_plan puts a short description in the tool list** ([#4126]) +- **get_pvs_stats puts a short description in the tool list** ([#4125]) +- **get_deadlocks (Darling and Lite) and get_blocked_process_reports (Lite) put a short description in the tool list** ([#4123]) +- **get_long_query_completions puts a short description in the tool list** ([#4122]) +- **get_memory_pressure_events puts a short description in the tool list** ([#4120]) +- **get_latch_stats puts a short description in the tool list** ([#4119]) +- **get_index_usage puts a short description in the tool list** ([#4118]) +- **analyze_procedure_plan puts a short description in the tool list** ([#4117]) +- **validate_custom_view and run_custom_view_panel put a short description in the tool list** ([#4116]) +- **analyze_plan_xml puts a short description in the tool list** ([#4115]) +- **get_ag_health and get_store_query_stats put a short description in the tool list** ([#4114]) +- **Claude Code keeps the MCP entry tools loaded even when it defers the rest** ([#4113]) +- **get_query_store_regressions puts a short description in the tool list** ([#4109]) +- **get_blocking and get_pg_replication_slots put a short description in the tool list** ([#4108]) +- **get_active_queries puts a short description in the tool list** ([#4107]) +- **get_plan_corrections puts a short description in the tool list** ([#4105]) +- **get_query_store_duration_trend and get_perfmon_trend put a short description in the tool list** ([#4101]) +- **get_resource_semaphore and get_memory_grants put a short description in the tool list** ([#4100]) +- **get_daily_summary and get_daily_summary_range put a short description in the tool list** ([#4099]) +- **get_query_store_health and get_default_trace_events put a short description in the tool list** ([#4095]) +- **get_pg_kernel_stats, get_pg_xmin_horizon and get_pg_table_bloat put a short description in the tool list** ([#4093]) +- **get_pg_io_trend, get_pg_database_trend and get_pg_cpu_utilization put a short description in the tool list** ([#4092]) +- **get_pg_column_stats, get_pg_replication_stats and get_pg_predicate_stats put a short description in the tool list** ([#4091]) +- **The Darling service account can no longer change its own program files** ([#4090]) +- **mute_analysis_finding and audit_config put a short description in the tool list** ([#4088]) +- **get_pg_blocking, get_pg_wait_stats and get_pg_index_usage put a short description in the tool list** ([#4087]) +- **get_pg_plan_capture_readiness, get_pg_plans and get_pg_session_states put a short description in the tool list** ([#4086]) +- **get_query_duration_trend and get_procedure_duration_trend put a short description in the tool list** ([#4085]) +- **get_analysis_facts and get_analysis_findings put a short description in the tool list** ([#4083]) +- **get_pg_database_stats, get_pg_autovacuum_health and get_pg_top_queries put a short description in the tool list** ([#4082]) +- **get_pg_logging_audit, get_pg_io_stats and get_pg_wait_sampling put a short description in the tool list** ([#4081]) +- **validate_custom_alert_rule, test_custom_alert_rule, update_custom_alert_rule and list_custom_alert_templates put a short description in the tool list** ([#4079]) +- **get_alert_history, set_notification_route_enabled, create_mute_rule and set_mute_rule_enabled put a short description in the tool list** ([#4077]) +- **get_pg_extensions, get_pg_write_stats, get_pg_server_config and get_pg_server_config_changes put a short description in the tool list** ([#4078]) +- **get_collector_stall_probes, describe_custom_view_catalog and get_sweep_reports put a short description in the tool list** ([#4074]) +- **analyze_server and compare_analysis put a short description in the tool list** ([#4073]) +- **get_fleet_overview, add_servers and remove_server put a short description in the tool list** ([#4071]) +- **get_pg_log_events, get_pg_index_bloat and get_pg_deadlocks put a short description in the tool list** ([#4068]) +- **get_query_store_clutter and get_oversized_plan_backlog put a short description in the tool list** ([#4067]) +- **update_alert_settings and update_mute_rule put a short description in the tool list** ([#4066]) +- **get_collection_log and get_query_store_top put a short description in the tool list** ([#4065]) +- **Three self-monitoring MCP tools put a short description in the tool list** ([#4064]) +- **get_collection_health's tools/list entry drops from 21,026 characters to 583** ([#4063]) +- **get_alert_settings and get_notification_routes serve a short head, with the rest available from get_tool_guide** ([#4061]) +- **Seven data-read MCP tools put a short description in the tool list** ([#4055]) +- **MCP clients load less context up front, and a new get_tool_guide tool serves the long-form guidance on request** ([#4048]) +- **Darling's MCP server instructions drop from 88,532 to 7,992 characters and Lite's from 52,942 to 7,721, both now under a pinned 8,000-character budget** ([#4039]) +- **PostgreSQL log messages show as PostgreSQL wrote them, and the SQL in them is normalized with every literal replaced by ?** ([#3996]) +- **The shared `as_of` description is 167 characters instead of 379, cutting Darling's `tools/list` by 22,040 characters (6.4%) and Lite's by 14,246 (8.8%)** ([#3965], [#3898]) +- **The review guard tells a pending workflow fix from hostile drift** +- **The tempdb Space alert stops paging on a single collected sample** ([#3653]) +- **The analysis names the Agent job that is running long instead of counting it** ([#3653]) +- **MCP tool failures were two wire shapes — a bare sentence on 214 tools and a JSON envelope on the PostgreSQL reads — and a `status`-keyed client read the sentences as successful text; now every tool on both SKUs answers a caught exception with one envelope through `McpHelpers.FormatError`** ([#3653]) +- **PostgreSQL bars the fleet measured now say so** ([#3691]) +- **Anomaly detectors fired on one hot sample and fired more the longer the window was; the gate now judges the window peak AND the window mean, and I/O reads the pair like its siblings** ([#3653]) +- **Confidence chooses the channel** ([#3712]) +- **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]) +- **PostgreSQL saturation now tells queueing from load** ([#3691]) +- **A story's root card now names the leaves it consumed** ([#3691]) +- **The wait-profile anomaly judges the window peak AND the window mean** ([#3741]) +- **CONFIG_CHANGED now anchors on when RECONFIGURE ran, not when the snapshot first noticed** ([#3740]) +- **MCP refusals carry a status word: the invalid envelope on both SKUs, and PostgreSQL refusals answer 400 not 500** ([#3739]) +- **PostgreSQL wait standouts, the I/O admission floor and the ratio multiple carry the second fleet read's lineage** ([#3691]) +- **The managed store's WAL ceiling is derived from the data volume's headroom, not v4's fixed 4 GB on every box** ([#3802]) +- **Stock PostgreSQL's sampled wait profile fires its first-occurrence reading on the peak alone, like its Aurora and SQL Server twins** ([#3691]) +- **A PostgreSQL bad actor is graded against its OWN normal** ([#3691]) +- **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** +- **`ANOMALY_PG_PLAN_REGRESSION` judges each plan-flipped statement against its own routine** ([#3691]) +- **The alert pass retries a store read once before counting it failed** ([#3848]) +- **Store-object convergence runs every hour, not only at start** ([#3817]) +- **The alert pass's other seven store reads retry once on a command timeout, through the same seam as the adapter's twelve** ([#3854]) +- **The compression band seats its three heaviest hypertables on spread minutes instead of the consecutive minutes registry order gave them** ([#3678], [#3781]) +- **Daily continuous-aggregate refreshes run one bucket per transaction** ([#3745]) +- **`audit_config` answers a PostgreSQL target with the target's own settings instead of redirecting it** ([#3691]) +- **The same blocking storm grades the same on every pass length** ([#3871]) +- **The Extended Events collectors use less CPU on the monitored server to filter events by time** ([#4912]) ### Fixed -- **A shutdown during a managed PostgreSQL tool step is no longer missed** ([#4867]) - A shutdown that came just before a tool ran was missed. When the tool finished at once, the work went on to its next step. Each tool run now checks for a shutdown before it starts. Steps that stop PostgreSQL or put files back during a shutdown still run their tools. -- **Rollup reads stop at the window end** ([#4859]) - an hourly rollup read counted one extra hour when its window ended exactly on the hour. It took the whole hour that starts at the end. This affected the Queries and Procedures tabs, the top-queries and top-procedures tools, the hourly trends, one query's hourly history, and Custom Views. A Custom View on the daily rollup counted the next day when its end fell at midnight. These reads now stop at the end. -- **Grid time columns sort by time** ([#4858]) - clicking a time column's header in Lite or the Darling viewer sorts the rows by time. Before, most time columns sorted as text, so "10/1/2026" came before "9/30/2026". -- **Six Postgres time columns follow the time display mode** ([#4858]) - six time columns on the Darling viewer's Postgres tabs always showed UTC. They are Lock Stats Last Seen, Wait Sampling Last Seen, Replication Connected Since, Column Stats Captured, and Index Bloat Measured and Estimated. They now show the same server, local or UTC time as the rest of the tab. -- **Server times and charts are right across a daylight saving change** ([#4783], [#4829], [#4838], [#4840], [#4841], [#4847], [#4848], [#4855]) - Where SQL Server reports its time zone (SQL Server 2022 and later), Lite and Darling convert a server's local times with the offset in force at each time, instead of one offset for every time. Older servers keep the fixed offset. In Server time mode, Lite and the Darling viewer follow the server's time zone and read it again on every refresh. This covers chart times, picker and custom ranges and System Events (Default Trace) times in both apps, and Job History run times and the SQL Agent next run in the Darling viewer. It also covers Custom Views Default Trace markers, config-change attribution, the parameter-sensitivity checks, the long-running job alert's "Started" time, and the server-local times in Darling's MCP tools (blocking, default trace, version store, object stats and running jobs) and in Lite's (`get_blocked_process_reports`, `get_running_jobs`, `get_index_usage`, `get_pvs_stats` and `get_default_trace_events`). Lite's `get_top_queries_by_cpu` and `get_top_procedures_by_cpu` compare last run times on the server's own clock, so a server west of UTC no longer drops a query last run early in the window and a server east of UTC no longer keeps one from before it. Recommendations "Ask AI" times use the selected server's own offset at each end of the window, and the Darling viewer's "Last analyzed" line shows the selected server's time and names its zone. Lite and the Darling viewer plot each chart point at its exact instant. In the repeated autumn hour, a chart no longer folds two hours onto one, and a drill or a typed range there reads the hour it names. The spring gap shows no hour that never happened, and the Darling viewer's Overview lanes axis spans the whole window. Grid and text times in the repeated hour end in their UTC offset, so the two 01:30s read `01:30:00 -04:00` and `01:30:00 -05:00`, and time columns that show the offset sort by time. Times read from a stored server wall clock (Default Trace events, job history and the next Agent run) stay plain in that hour, because the stored time does not say which of the two passes it was. Lite's FinOps First Seen and Last Seen and its collection health times follow the display mode, not this machine's clock. A chart CSV export's time column now names its zone, such as `DateTime (UTC)`, and every row gains a 4th column, `UTC offset`, so a script that matches the header `DateTime` or expects three columns needs updating. -- **Anomaly tiles agree on the window end** ([#4854]) - every SQL Server anomaly tile now leaves out a sample stamped exactly at the window's end. This holds in Lite and Darling. Eight of the eleven tile reads used to count it and three did not. So a boundary sample counted in one tile and not in another. -- **Lite shows a refused capture read as a failure** ([#4853]) - SQL Server can refuse the read of a blocking, deadlock or long-query session. Lite used to log a refused read (error 297 or 15151) as a success with zero rows, so collection health showed the capture as working. It now shows PERMISSIONS or ERROR, as a session that failed to start does. A read refused for permission (error 297) stops that capture until Lite restarts. A read that fails with error 15151 is retried every cycle. The Capture Not Running notice now names a long-query capture that could not start. It used to call it deadlock. -- **A backward clock step no longer pauses collection or delays repeat alerts** ([#4851]) - only a clock that stepped back can put a due time more than one interval ahead. Such work now runs at once instead of waiting out the step. This covers Darling's collectors, custom alert rules, retries and periodic checks, and Lite's collectors, collection cycle and background jobs. After a step back, a repeat alert waits one cooldown from the first check that sees the step. Before, it waited the step plus the cooldown. -- **A server edited during its connect no longer runs on the old connection string** ([#4851]) - the connect checks the definition again before its first pass. If it changed, the runtime is thrown away. -- **PostgreSQL spike advice names a baseline that measured zero** ([#4850]) - an hour-of-week can see no deadlocks, or no waiting, for the whole 30-day baseline. A spike in that hour now says the baseline measured zero, and prints no multiple. It used to say "first occurrence, no baseline yet". -- **Lite's View Block Chain reads the Blocking slicer's window when a report has no event time** ([#4848]) - For a blocked process report row with no event time, the chain is rebuilt from the slicer's selected window. That selection was converted to the server's local time before it filtered the reports' event times, which are UTC, so the chain came from a window shifted by the server's UTC offset. It now reads the window the slicer selected. -- **Fleet views show WARNING when half or more of a collector's databases fail** ([#4846]) - the run still records SUCCESS. Only its note records the loss. The collector's own Collection Health tab read that note. The fleet overview, the `get_fleet_overview` MCP tool and the viewer's Overview cards did not, so they showed the collector as Healthy. On its first start after the upgrade, the service rebuilds the hourly collection-health rollup and fills eight days of it in the background. -- **`run_custom_view_panel` runs count in read latency with the web dashboard off** ([#4839]) - the run's timing went to a slot only the web dashboard filled. With the dashboard off (the default), these runs were left out. They are now recorded as composed-panel reads, the same as a panel run from the web dashboard. -- **An alert that no channel delivered is tried again a minute later instead of waiting out its cooldown** ([#4786], [#4804], [#4826], [#4827], [#4828], [#4837]) - A send fails like this when, for example, a webhook answers HTTP 429 or 5xx or times out, or the mail server cannot be reached. The alert is tried again a minute later while its condition holds, and the wait doubles after each failed try (1, 2, 4 minutes and so on) and never passes the alert's cooldown. In Darling this covers the SQL Server high CPU, blocking, blocking wait time, deadlock, poison wait, long-running query, tempdb space, volume free space, version store, file growth, long-running job, failed agent job, database state and forced plan alerts; the PostgreSQL findings, high CPU, deadlock, blocking, long-running query and poison wait alerts; and the repeating self-alerts, such as Collection Stopped, Capture Down, Agent Not Running, Collector Cost Regression and store disk pressure. Lite reports a send that no email or webhook channel received as failed, so its alerts are retried the same way, and the tray notice shows again on each retry. In both apps, "Server Unreachable" and the availability group alerts (replica disconnected, failover, data movement suspended, and in Lite, sync fell behind) are tried again while the server stays down, with re-fire off or on, and so is a Per-event deadlock, blocking or poison wait alert whose sends all failed. A delivered alert is not repeated, and neither are the Restored and Reconnected notices. A custom alert rule has no cooldown, so its wait stops doubling at 15 minutes. A severity change that no channel delivered is sent again the same way, and a resolve goes out only for an alert that was delivered. A deadlock or blocking alert that fails to send no longer uses up its count. A failed agent job is no longer recorded as announced when every channel failed, so a restart before the retry no longer loses it; a crash between a send and that record can send the same failure again. Closing Lite ends a webhook alert post that is still in flight, instead of letting it run out its timeout. -- **A removed server no longer leaves alert state behind** ([#4837]) - an alert check or send could still be running when its server was removed. It then left state behind, and the server inherited that state when it was added again. A stale availability group role could page a failover. A stale "already reported" mark could hold back the server's first alert. In Darling, a stale offline mark sent "Server Restored" on the first connect. A check that finished after the removal could also claim an availability group for the removed server, so the group's other monitored replicas stopped judging it. The removal now drops that state, and a check or alert send that finishes afterwards records nothing. -- **The daily retention purge paces its deletes** ([#4835]) - it deleted rows at full speed, and the store wrote about 6 GB of WAL in 7 minutes. The PostgreSQL checkpoint running at the time took 23.5 seconds to sync, and collection slowed on every server. The purge now waits between batches to hold the store's WAL to half of what its checkpoint settings absorb. The collection log shows the store's WAL during the purge and how long it waited. -- **The Store Checkpointer Pressure alert sees one long checkpoint sync** ([#4835]) - it judged only the hour's average sync per checkpoint. A single 23-second sync among several short ones stayed under the 10-second bar. It now also judges the longest single sync, sampled once a minute. -- **get_store_metrics reports the longest checkpoint sync the alert judges** ([#4835]) - the hour's longest single sync is stored with the hourly checkpointer counters. The tool shows it and judges it against the same 10-second bar, so the tool and the alert agree. -- **Query Store trends no longer read low after a quiet interval** ([#4833]) - Query Store stores no row for an interval with no executions, so the next interval's rate was divided by the gap plus its own length. It now uses the interval's own length, for rows collected after the upgrade. The `get_query_store_duration_trend` description in both apps now describes that rate: its head says only a point with no stored end and no earlier point has null rates, and its guide text says each point is rated over its own stored interval. -- **Editing a server's host in the Darling viewer keeps its favorite star with the server** ([#4831]) - Before, the star stayed behind under the old address and marked any server added there later, and unchecking it in the same edit did not clear it. -- **get_store_metrics no longer reads two days of store growth as one** ([#4830]) - A day whose last snapshot came early in the day, after the service was down, was compared with the next day's last snapshot almost two days later and shown as one day's growth. Such a pair is now left out, and the tool says its times are UTC. -- **Darling and Lite count the I/O anomaly tiles' samples the same way** ([#4820]) - Darling counted a row once for both the read and the write tile, so it counted some read-latency tiles that Lite correctly left out, and the sample count on those tiles differed between the products. Darling now counts read samples and write samples separately, as Lite does. -- **A tile's peak time no longer changes between runs when two samples tie** ([#4820]) - when two samples tied on the peak value, the time shown for the peak was whichever the engine reached first, so it could differ from one run to the next with no change in the data. Both products now show the later of the tied samples, for Lite's CPU tile and for every Darling tile that reports a peak time. A Darling tile's peak time also skips a sample with no value, as the tile's peak value already did. -- **Lite's archive views stay readable while compaction swaps files** ([#4816]) - A query that ran during a compaction, or while a run finished the swap an interrupted run left behind, could find an archive table empty or missing rows for a moment. -- **Lite no longer counts archived rows twice during an archive run** ([#4816]) - a new archive file was visible before its rows were removed from the database, so a query in between counted them twice. The file is now added and the rows removed under one lock. -- **"Recurring at this hour" survives a daylight saving change** ([#4814]) - After the clocks changed, older findings shifted by an hour, so the label went missing for up to three weeks, and a job that had not moved could read as "Maintenance window moved". -- **A nightly job no longer reads as "Maintenance window moved"** ([#4814]) - Rows from other weekdays were compared as if they were the same weekly slot. -- **Reading a PostgreSQL log no longer records a false error when the read starts inside a multi-byte character** ([#4813]) - a first read, or a read after a fallback, starts 4 MB before the end of the log, and when that byte was inside a multi-byte character PostgreSQL refused the whole slice and the cycle logged an error that blamed a planted byte. The read is now repeated in the same cycle from 1, 2 and 3 bytes later, and the error row is written only if all four attempts are refused, with a message that says a split character is possible and that later reads resume from a full line. -- **A byte that is invalid in the database encoding costs one log read per cycle, not four** ([#4813]) - the retry from a later start cannot cure an invalid byte anywhere in the 4 MB window, and it is refused at every start on every cycle. After a cycle that used every start and was refused at each, the collector now makes one read per cycle until a read succeeds, and goes back to retrying after that. The memory is kept in process, so a restart pays one four-read cycle. -- **PostgreSQL error rows under the pgBadger log prefix now carry their user and database** ([#4813]) - a `log_line_prefix` written as `user=%u,db=%d` gave a null user and database on every error row, because only `user@db` was read. Both `user=` and `db=` are read now, wherever they sit in the prefix. -- **The plan-capture readiness read now reports a log prefix the log readers cannot read** ([#4813]) - a `log_line_prefix` with an unbracketed process id (`%m %p`, `%t %p:`, `%t [%p-%l]`) makes the stderr log readers drop every line, and the target looked quiet. A new `log_line_prefix_readable` row says whether the prefix starts with a timestamp and carries `[%p]`. -- **A deadlock report cut at the end of a read waits for its last lines instead of being stored as a fragment** ([#4813]) - a report whose HINT line the read did not reach was stored from the lines the read had, and one cut inside its DETAIL block was stored again under another hash when the next read had it whole; on the RDS log API, which never offers the rest again, only the fragment was stored. The newest report of a self-hosted read with no line after its DETAIL block is now left for the next read, which covers those lines again. On RDS the report is held until the next chunk and stored as it is if it is still unfinished after one more chunk, if its file has ended, or if it is larger than 1 MB. A report that other log lines follow is stored at once. -- **The fleet sweep bands a server outage as No Data instead of Warning** ([#4811]) - While a server could not be reached, its "Collection Stopped" alerts counted as data. The outage then showed as a Warning with an alert count, counted as reported, and hid the stale-collection item. -- **A collector that fails on half or more of its databases now bands Warning** ([#4811]) - A run that skipped half or more of its databases still recorded success, so Collection Health read Healthy with no errors. +- **A shutdown during a managed PostgreSQL tool step is no longer missed** ([#4867]) +- **Rollup reads stop at the window end** ([#4859]) +- **Grid time columns sort by time** ([#4858]) +- **Six Postgres time columns follow the time display mode** ([#4858]) +- **Server times and charts are right across a daylight saving change** ([#4783], [#4829], [#4838], [#4840], [#4841], [#4847], [#4848], [#4855]) +- **Anomaly tiles agree on the window end** ([#4854]) +- **Lite shows a refused capture read as a failure** ([#4853]) +- **A backward clock step no longer pauses collection or delays repeat alerts** ([#4851]) +- **A server edited during its connect no longer runs on the old connection string** ([#4851]) +- **PostgreSQL spike advice names a baseline that measured zero** ([#4850]) +- **Lite's View Block Chain reads the Blocking slicer's window when a report has no event time** ([#4848]) +- **Fleet views show WARNING when half or more of a collector's databases fail** ([#4846]) +- **`run_custom_view_panel` runs count in read latency with the web dashboard off** ([#4839]) +- **An alert that no channel delivered is tried again a minute later instead of waiting out its cooldown** ([#4786], [#4804], [#4826], [#4827], [#4828], [#4837]) +- **A removed server no longer leaves alert state behind** ([#4837]) +- **The daily retention purge paces its deletes** ([#4835]) +- **The Store Checkpointer Pressure alert sees one long checkpoint sync** ([#4835]) +- **get_store_metrics reports the longest checkpoint sync the alert judges** ([#4835]) +- **Query Store trends no longer read low after a quiet interval** ([#4833]) +- **Editing a server's host in the Darling viewer keeps its favorite star with the server** ([#4831]) +- **get_store_metrics no longer reads two days of store growth as one** ([#4830]) +- **Darling and Lite count the I/O anomaly tiles' samples the same way** ([#4820]) +- **A tile's peak time no longer changes between runs when two samples tie** ([#4820]) +- **Lite's archive views stay readable while compaction swaps files** ([#4816]) +- **Lite no longer counts archived rows twice during an archive run** ([#4816]) +- **"Recurring at this hour" survives a daylight saving change** ([#4814]) +- **A nightly job no longer reads as "Maintenance window moved"** ([#4814]) +- **Reading a PostgreSQL log no longer records a false error when the read starts inside a multi-byte character** ([#4813]) +- **A byte that is invalid in the database encoding costs one log read per cycle, not four** ([#4813]) +- **PostgreSQL error rows under the pgBadger log prefix now carry their user and database** ([#4813]) +- **The plan-capture readiness read now reports a log prefix the log readers cannot read** ([#4813]) +- **A deadlock report cut at the end of a read waits for its last lines instead of being stored as a fragment** ([#4813]) +- **The fleet sweep bands a server outage as No Data instead of Warning** ([#4811]) +- **A collector that fails on half or more of its databases now bands Warning** ([#4811]) - **The Darling viewer's Collection Health tab no longer re-reads the store's schema version on every refresh** ([#4811]) -- **Plan-forcing advice says when SQL Server's own recommendation names the proposed plan as the regressed one** ([#4810]) - The plan-force bot's journal now records a blocked decision for that plan instead of a would-force one. Each target in the script now also shows how long ago its plan was last seen. -- **Lite no longer archives the same rows twice after it is stopped in the middle of an archive run** ([#4808]) - If Lite was closed or killed after it wrote an archive file but before it deleted those rows, the next run archived them again, and the archive counted them twice. Leftover partial files from an interrupted run are now removed, and the archive views are rebuilt even when compaction fails. -- **Lite's Query Store repair also covers archive months that compaction split into parts** ([#4808]) - Rows in those part files were never repaired. -- **Darling retries a store that is at its connection limit when the service starts** ([#4806]) - Before, a store that was briefly full at start, after a restart storm or while another application held its connections, stopped collection until someone restarted the service. Other resource errors (disk full, out of memory, a configuration limit) still stop it, because they need an operator. -- **The compose `darling` container reports unhealthy when a startup failure has stopped collection** ([#4806]) - It used to show as running although it never collected. -- **The docs now name the oldest supported builds: SQL Server 2016 SP2 and SQL Server 2017 CU3** ([#4805]) - The query stats and procedure stats collectors read columns that older builds do not have. The docs said SQL Server 2016 and named no service pack. -- **A webhook that never answers no longer holds up alert delivery** ([#4803]) - each webhook post (Teams, Slack, generic and PagerDuty, and the test sends for them) waited up to 30 seconds with no way to cancel it, and a delivery makes those posts one after another. Each post now gives up after 10 seconds and records the channel as failed with "timed out after 10 seconds" as the reason. When the Darling service stops, an alert post in flight is cancelled instead of waited out, and the abandoned delivery writes no history row. Analysis-finding alerts, and every alert in Lite, get the 10-second bound but are not cancelled. -- **Query Store backfill now logs a warning when it cannot read its list of work** ([#4801]) - when the backfill's read of the databases to work on, or of a database's stored floor, failed, both apps logged it only at Debug and stopped filling tails and outage holes with no visible sign. Both apps now log one warning at the first failure of a run of failures, and again on the next failure after a read succeeds. -- **Query Store backfill keeps a slice size that works instead of swinging back to the size that timed out** ([#4801]) - after a timeout the slice halved, but any completed slice sent the server back to the full hour, so a database whose 30-minute slice fit and whose 60-minute slice did not wasted a 60-second read on every other tick. The slice still halves after a timeout, now keeps its size after a slice completes, and widens by one step (never above one hour) after three completed slices in a row. Both apps. -- **PostgreSQL analysis: a configuration setting shown under another finding now carries its own advice** ([#4799]) - A setting that hung off another finding, such as maintenance_work_mem under an autovacuum backlog, was described as "see its card", and only analyze_server shows that card. The viewer, get_analysis_findings and the e-mail showed neither the setting's advice nor its fix. The finding's text now names each such setting with its own headline and adds its fix, so every place that shows the finding shows the advice. -- **The advice for turning autovacuum back on now names the provider's parameter group** ([#4799]) - The advice said only "autovacuum = on in postgresql.conf", which managed PostgreSQL (RDS, Aurora, Azure, Cloud SQL) does not let you edit. It now names the provider's parameter group or server parameters, which apply the change themselves, and keeps the reload for postgresql.conf. -- **A webhook channel that keeps failing no longer goes unnoticed while another channel delivers** ([#4798]) - A Teams, Slack, generic or PagerDuty channel could fail for weeks with nothing but log lines while another channel delivered every alert. A channel that fails three times in a row now raises a "Notification Channel Failing" alert in Darling and a tray notice in Lite, and clears with "Notification Channel Recovered" when it delivers again. Turning a failing channel off closes the alert with an entry that says the channel was turned off. The alert and the notice name the channel and the count and carry no error text, since a webhook error can carry the webhook URL. -- **The configuration change card no longer calls a metric "resolved" when only minutes have passed since the change** ([#4797]) - Until the after-window reaches an hour, a metric that appeared or vanished is shown as not yet comparable. -- **A server that is down when the Darling service starts now gets a "Collection Stopped" alert once the threshold passes** ([#4796]) - the check was skipped until the service had seen the server online, so a server that stayed down across a service restart got no "Collection Stopped" alert, and no reminders, until it came back. Staleness is now judged from the later of the server's last success and the service start, so the alert fires once the staleness window (30 minutes by default) has passed since the start, and its text counts the minutes from the start. A healthy server whose last success predates the restart still does not alert at startup, and a server that reconnects after a restart is judged from the start rather than from its pre-restart rows. -- **Adding a server whose id matches a different server's no longer overwrites it in the Darling viewer, and Lite now refuses to add or edit onto it** ([#4794]) - Two different servers can hash to the same id. In the Darling viewer, Add Server and Add Multiple Servers wrote with an upsert that rewrote the server already holding it: that server stopped being monitored and its history showed under the new one, with no message. Add Server now refuses the add, saves nothing and names the server that holds the id, and adding a server that is already monitored at the same address shows the "already monitored" message instead of rewriting its row. Add Multiple Servers refuses that row, counts it apart from added, skipped and failed, and shows the count in its status text. The `--add-server` totals line now counts collided servers, and the command exits 1 when a server was not added because its id collides. In Lite, both servers were added and then collected into one history, so each tab showed both servers' rows with no message. Lite's Add Server and Edit Server now refuse a server whose id a different server holds and name that server, and adding the same server twice shows the "already monitored" message. Lite's Add Multiple Servers marks such a row "Not added", counts it apart from added, skipped and failed, and the main window's summary shows the count. An edit that keeps its id is still allowed, so a pair saved earlier stays editable. Importing follows the same rule: Lite's Import Settings no longer adds a server whose id a different server holds, and the Darling viewer's migration and Import Settings no longer leave such a server out silently as if it were already monitored. Each refuses it and reports it: Lite's Import Settings message shows the count and its log names the entry and the server that holds the id, and the Darling viewer logs both servers, with its Import Settings message showing how many servers it did not add. -- **`get_store_metrics` no longer reports a gap of several days in the store's size history as one day's growth, and it marks today's partial day as partial** ([#4792]) - The whole-store `daily_growth` labeled the difference between two neighboring daily points with the later day without checking that they were a day apart, so the first day after a stretch with no snapshots carried the whole stretch's growth as a single-day spike, and the per-server ingest rate built on it overstated what onboarding a server costs. Today's point, the latest snapshot of a day still in progress, was shown as a full day. A day is now compared only with the calendar day before it, and a wider pair is left out of the list (a hole in `daily_growth` is missing snapshots, not zero growth). Each point also carries `metric_time` (the snapshot it was read at), `span_days` (always 1) and `partial` (true for today), which makes each point about 74 bytes larger. -- **The store checkpointer alert no longer tells you to raise max_wal_size for every requested checkpoint** ([#4791]) - The informational Store Checkpointer Pressure alert, and the checkpointer note in the MCP store metrics, called any requested checkpoint "WAL-forced" and said the store had written more WAL than max_wal_size allows. PostgreSQL also counts a base backup or a CHECKPOINT statement as requested, and its counters do not say which one happened, so the suggested remedy was sometimes wrong. The alert's text now says "requested checkpoint(s)". The alert detail and the note now list all three causes, and when a requested checkpoint is what fired them, they also point at the log_checkpoints lines that say which and suggest raising max_wal_size only for the WAL cause. The get_store_metrics tool description says the same about its requested field. The alert fires on the same conditions and stays informational. -- **`mute_analysis_finding`, in Darling and in Lite, no longer mutes the pattern on whichever matching server sorts first** ([#4790]) - a `server_name` that matched more than one server (a partial name, or a display name shared by per-database and read-only registrations of one machine) muted the pattern on whichever sorted first and echoed the caller's spelling. Both products now resolve it to exactly one server, Darling the way `remove_server` does: a name that matches more than one server answers `ambiguous` with the candidates and mutes nothing, a name that matches nothing (a blank one included) answers `not_found`, and a successful call reports the resolved server name. `remove_server` resolves the same way: a name that matches one registration's own server name exactly, in the same letter case, picks it even when a sibling shows that name as its display name, while a partial name, a display name or a different letter case that matches several registrations still answers `ambiguous`, and the successful answers of both tools now say which kind of registration was picked (`kind`: plain, read-only or per-database). -- **Repeating a `create_mute_rule` call no longer creates a second identical rule** ([#4790]) - a client retry, from MCP or the web route (`POST /api/mute-rules`), left two identical mute rules. A create that repeats an enabled, unexpired rule's scope, patterns and expiry now inserts nothing and answers `already_exists` with the existing rule's id (HTTP 409 on the web route). A disabled or expired rule does not count, and a different expiry is a different rule. -- **`add_servers` reports every server in the batch when a later entry fails to save, and no longer says "added" for a save that wrote nothing** ([#4787]) - `add_servers` now reports every server in the batch when a later entry fails to save, instead of reporting the whole call as failed after it had already added the earlier ones: the failed entry and the ones after it come back as the new status `not_saved` (counted as failed) and the earlier ones stay `added`. It rejects a literal SQL password or service principal client secret on Linux, where it cannot be encrypted, and points at the `env:` or `file:` reference form. When the save wrote nothing because another server holds the same id, it answers `collides` (or `duplicate` for a concurrent add of the same server) instead of "added". -- **The plan-force bot no longer reads a database missing from the newest automatic-tuning capture as "automatic correction off"** ([#4784]) - it uses that database's last state from the past 24 hours, and blocks the database as unknown when there is none. -- **After a failed state read, the plan-force bot looks at the same plans again after 1 hour instead of holding them for a day** ([#4784]) - the blocked row from a failed read now holds its plan for 1 hour, and every other blocked row keeps the 24-hour cooldown. -- **Web viewer: a page left loading in a hidden or paused tab refreshes normally again** ([#4781]) - A page whose data finished loading while its browser tab was hidden, or while auto-refresh was paused, used to count the whole hidden or paused time as its load time. It then waited 15 minutes before its next refresh and showed "(slow page)". The page now counts its load as finished when its data arrives, and refreshes on its normal schedule. -- **The PostgreSQL plan-regression finding now reports the worst regression when more than 50 statements changed plans in the window** ([#4780]) - the plan-change read kept the 50 lowest query ids, so the worst regression could be dropped, or no regression reported at all when the kept rows had too few calls. The read now keeps the statements the pick would choose from, worst first. -- **A standby that was removed or replaced no longer outranks the live standbys for the rest of the window** ([#4780]) - its last row stayed in the window, so the finding described it in the present tense, kept its synchronous weighting and reported the whole table's span. Live standbys now rank first, and a standby that stopped reporting gets advice that says when it was last seen. -- **A dropped replication slot no longer grades Critical for the rest of the window** ([#4780]) - an inactive, growing slot kept grading Critical from its last row after it was dropped, and its inactive hours kept growing. A slot or database that stopped reporting now grades nothing, ranks behind the ones still reporting, and measures its inactive hours to its last row. -- **The alert history now records whether each notification channel delivered or failed** ([#4779]) - an alert that reached one channel and failed on another was stored as a plain delivery, so a broken channel was invisible while a sibling kept delivering. The route record on each history row now says `delivered`, `failed` or `not attempted` per channel, in both Darling and Lite, and `get_alert_history` returns it as `outcome`. No error text is stored, because a webhook error can name its endpoint URL; `send_error` is unchanged. -- **The alert notebook finds an alert's resolution even when it came late, was dismissed, or sat behind many newer alerts** ([#4778]) - The notebook's status only looked at the first 24 hours after the alert, at most 200 rows, and skipped dismissed rows. A store alert that cleared more than 24 hours later, a Cleared row hidden by "Dismiss all", or a fleet-level alert whose resolution sat behind 200 newer alerts from other servers read "Fired again" or "Unknown" instead of "Resolved at ...". The status now reads the first resolution row and the first later firing of the metric directly, with no 24-hour limit and no row cap, dismissed rows included, and scoped to the alert's server when it has one. -- **A fleet-level store alert with no resolution reads "No resolution recorded" instead of saying collection stopped** ([#4778]) - A store self-alert with no resolution row and no later firing read "Unknown (not collected since ...)" in the alert notebook, which says a collector stopped. Store alerts have no collector, and the process that evaluates them serves the page, so it now reads "No resolution recorded". -- **Darling now sends alert email through notification routes when the default recipient list is blank, instead of treating email as not set up** ([#4777]) - A notification route that named email recipients as its only destination sent nothing when the SMTP settings had a server and a from address but no default recipients, because email counted as set up only with the default list. Email is now set up with a server and a from address, and a route's recipients are enough to send. An alert that no route covers and that has no default recipients is skipped without a failed row or a cooldown, and an alert nothing else delivered is recorded as undelivered. The Send Test Email button still needs the default list. The Settings window's Validate message for a blank default list now says what the list is for. -- **`--configure-network` keeps the web listener's `tls` and `oidc` settings** ([#4775]) - Re-running the wizard for the web listener no longer drops `web.network.tls`, `web.network.oidc` or any other setting it does not ask about, so the dashboard keeps HTTPS and OIDC sign-in after the restart. The MCP and store blocks keep their other settings too, and the wizard prints a `Kept ... from the existing darling.json.` line naming what it kept. -- **A repaired hourly hole no longer leaves a partial day in the daily rollups, and days an earlier repair left short are rebuilt once after the upgrade** ([#4739], [#4763]) - After an hourly hole repair, the daily rollups that already held a bucket for the repaired day were not refreshed again, so a day older than the daily policy's 3-day window stayed partial and became the only copy once the hourly aged out. The repair now force-refreshes those complete days (at most 3 per daily per range), including the day-grain daily behind the interval daily, and the seam repair log line reports the holes still standing. After the upgrade, the service also checks each daily rollup against the hourly data under it, once, and rebuilds any day an earlier hourly repair left short, one day at a time. The repair logs each daily day it rebuilds with the seconds it took, and a day rebuilt after a repaired seam range is no longer rebuilt twice and counted twice in the repair's chained-days count. -- **Darling upgrade no longer says "New build in place." after copying nothing** ([#4762]) - when the staging folder's name contained [ or ], the upgrade script's copy matched nothing and threw nothing, so it reported success over the old build. It now copies the folder by literal path, and stops with a plain message if the installed service executable does not match the new build's after the copy. The installer no longer skips hardening older darling.json backups, or looks up its own files by wildcard, in an install folder with [ or ] in its name. -- **An older Lite refuses to open a data file from a newer version** ([#4753]) - An older Lite pointed at a data folder that a newer Lite had upgraded kept running, and every batch for the 13 tables that gained columns in schema versions 60 to 65 failed with only a log line to show for it. Lite now stops at startup with a message that names the file and both schema versions, and does not write to the file. -- **Lite re-applies its newer columns on every start** ([#4753]) - A data file where one of the columns added in schema versions 60 to 65 failed to apply, or was stamped without it, kept failing that table's collection on every start. Lite now adds any of those columns that are missing on each start, so the file gets it back. A column that still cannot be added is logged as an error naming the table and column, and the next start tries again. -- **After the computer sleeps and resumes, Lite runs each due collector once** ([#4753]) - After a sleep, each collector that was due ran twice about a minute apart, which wasted queries and stored an extra sample per collector. Lite now starts the cycle at the current collection slot after a resume, so each due collector runs once. -- **Two analyze_server calls that overlap no longer give the second one a false all-clear** ([#4742]) - The Darling and Lite MCP servers shared one analysis service, so a second analyze_server call made while the first was still running got "No significant findings" for a server it never analyzed. Each call now runs its own analysis in both products. -- **In Lite, a server that just went down no longer holds a connection slot while its retries wait** ([#4740]) - Each connect attempt now takes a slot and gives it back when the attempt ends, so a server that went down since its last status check no longer holds a slot through four connect timeouts and seven seconds of backoff, and can't stall collection for the other servers that way. -- **The self-hosted PostgreSQL log tail no longer stays on the outgoing log file after a rotation in the same second** ([#4738]) - When a size or age rotation put the old file's last write and the new file's first write in the same second, the tail could pick the old file as current on the stderr, csvlog or jsonlog route, so lines in the new file were not collected until the next line was logged in a later second; it now breaks that tie by file name, so the newer file is read. -- **Store upgrade: copy mode is chosen from the data folder's own volume and a finished size count** ([#4725]) - The pre-upgrade headroom check read the free space of the data directory's drive letter and took a size walk an error had cut short as the size, so a data directory on a folder-mounted volume, or one whose walk failed partway, could be upgraded in copy mode and fill the disk (the store came back on its old major, but was down for the attempt). The free space is now read for the data directory's parent itself, and an unfinished size walk falls back the way too little room does: hard-link mode where the volume supports it, otherwise no upgrade. -- **Store upgrade: hard-link mode removes the pre-upgrade directory even when a settings carry fails, after saving the old `postgresql.conf`** ([#4725]) - In hard-link mode the moved-aside pre-upgrade directory shares its files with the upgraded cluster and is not a rollback copy, but a failure carrying `postgresql.auto.conf` or the operator's `postgresql.conf` lines left it in place for two service starts. It is now removed as soon as the carries are done with it, whether they succeeded or failed. The old `postgresql.conf` holds the operator's lines below the `darling-managed.conf` include and exists nowhere else, so every major upgrade now first copies it beside the data folder as `postgresql.conf.pre-upgrade` (restricted to the service account like `postgresql.auto.conf.pre-upgrade`, covered by `--harden-files`, and kept until a later major upgrade replaces it), and hard-link mode removes the directory only once that copy exists, or when there was no `postgresql.conf` to copy. If the copy cannot be made, the directory is kept with a warning and ages out after two service starts, as before. The warnings for an operator line the new major rejects now name where the original line is kept (the saved copy) instead of the pre-upgrade directory. -- **Store settings migration: a repeated attempt restores the newest backup of `postgresql.conf`** ([#4725]) - A failed migration attempt restored the FIRST attempt's backup, so edits made to `postgresql.conf` between attempts were lost. A new backup is taken when the file changed since the last one, and a failed or resumed attempt restores the newest. -- **Store free-space checks and reports read the data folder's own volume** ([#4725]) - The free-space check before `--backfill-rollups` and the plan dimension compaction, the WAL sizing (`max_wal_size` and `min_wal_size` at every service start), the store host profile (the start-up log, `--check-settings` and the MCP host tool), and the store disk-pressure alert read the size and free space of the data directory's drive letter. A data directory on a volume mounted at a folder was therefore judged by another volume: a backfill or a compaction could start on a volume with no room for it, the WAL ceiling and the reported size and free space came from the wrong disk, and the disk-pressure alert watched a disk the store is not on. On Windows they now ask for the data directory itself, as the upgrade check does. The alert's free figure is now the space available to the service account, as the other reads use, which differs from the volume's total free space only where the account has a disk quota. Where that read fails, each keeps its old answer for an unreadable volume (the verbs refuse, the WAL sizing is skipped and the WAL settings in force stay, the host profile shows a volume that is not ready, the disk-pressure alert gives no signal that check). The filesystem name in the host profile still comes from the drive letter, and other platforms keep the old read. -- **Lite archive compaction no longer loses a month when a promote fails** ([#4718]) - hourly compaction deleted the month's existing parquet file before moving the merged replacement in; a move that failed (a scanner or backup agent holding the fresh file) then deleted the merged copy too and the month was gone, with part files losing both old parts and double-counting the new rows. The swap now sets the existing files aside, moves every merged file in, and deletes inputs only after all of them are in place; a failed or interrupted swap is undone or finished on the next run. -- **The size-triggered Lite reset no longer deletes the database after a failed export** ([#4718]) - when the store hit its size limit and one table's export failed, the reset ran anyway and that table's hot window was lost; a kill mid-export could also leave a truncated file that hid every archived month of the table. Exports now go to temp files, nothing is promoted until every export succeeded, a failure leaves the database and archive untouched and backs off, and a kill between export and reset no longer duplicates the hot window. -- **The tab Refresh button no longer runs collectors during a Lite database reset** ([#4718]) - a reset could delete the database under a Refresh run and lose everything collected until the next restart; the run now registers with the reset gate like the scheduled and tab-open collections. -- **Lite archive views now include compaction's part files** ([#4718]) - a month that compaction split into `_ptNNN` files dropped out of the archive views, and a table with only part files showed no archive at all. -- **Importing a previous Lite install no longer overwrites this install's part files, and imported files now expire with retention** ([#4718]) - an imported part file of the same month and table was compacted over the local one; imported files also never aged out because their prefix hid the date. -- **A failed archive export no longer leaves a partial file on disk** ([#4718]) - When DuckDB failed partway through writing an archive export (out of memory, disk full), the partial `.tmp` file stayed behind, and the size-triggered reset repeated that every 15 minutes. The reset and the hourly archival now delete the partial file when the export fails. -- **Reads of an archive view no longer fail after old archive files expire** ([#4718]) - Expiring a table's last multi-part month (or its last single-file month while part files remained) made every read of that table's history view fail until the next hourly refresh. The views are now rebuilt right after retention deletes files, and after the cleanup of files a killed size-triggered reset left behind. -- **A managed store moved aside by a failed upgrade is no longer replaced by an empty one** ([#4717]) - When an in-place PostgreSQL upgrade could not move the data directory back, the next service start initialized an empty store in its place, wrote a new superuser credential over the old one, and deleted the real store as an expired rollback copy two starts later. A start now refuses to initialize while a `-old-*` or `-upgrade-*` sibling holds a cluster and names the rename to do by hand, and the rollback sweep counts no start until a cluster is back at the data directory. -- **A start after an interrupted store upgrade resumes it instead of refusing every start** ([#4717]) - When the service died between the runtime swap and the upgrade's commit, or the revert was refused, every later start stopped with "the PostgreSQL 17 binaries are not on this host" although they were in `pg-runtime-prev`, and deleting the runtime stamp to force a retry deleted them. The start now finds the store's binaries there, the runtime update never empties `pg-runtime-prev` while the store still needs it, and the refusal's hint names a path a start reads. -- **A failed store upgrade that left no startable store stops the start** ([#4717]) - A failure that could not put the data directory back, or could not revert the runtime, used to let the start go on, into the empty-store initialize above or onto PostgreSQL 18 binaries in front of a PostgreSQL 17 cluster. It now stops with the hand step in the message, and the worker does not retry it. -- **The pre-upgrade rollback copy survives the two service starts it is kept for** ([#4717]) - A start the worker retried in the same process counted as two starts against the copy. The sweep now runs once per service start. -- **PostgreSQL 13 servers read through csvlog are no longer reported as quiet** ([#4714]) - The csvlog parser required exactly 26 columns, but PostgreSQL 13 writes 24 (`leader_pid` and `query_id` arrived in 14), so every PostgreSQL 13 record was rejected. Log events, deadlocks and plan capture came back empty, and the run counted one discard however many records were rejected. The parser now accepts 24 or 26 fields, and a read it cannot use reports how many records it dropped. A PostgreSQL 13 auto_explain capture has no query id, so it is stored as an orphan plan (query id 0) instead of being counted as forged. -- **RDS and Aurora PostgreSQL log reads now collect the lines a log file received before RDS rotated it, and resume where they stopped after a restart** ([#4713]) - Deadlock, log-event and plan-capture reads opened only the newest RDS log file, so whatever the previous file received after the last read was never collected, a new stderr file was read from its last 10,000 lines instead of its first line, and the read position lived only in memory, so a restart re-read just the last 10,000 lines of the newest file. A read now finishes the file it was reading before it moves to the newest one, in the same cycle (at most four reads per cycle), and a new file is read from its first line. Each read saves its position to collect.collector_state once its rows are stored and loads it at start; a saved file RDS no longer lists falls back to the newest file's last 10,000 lines. Files that rotate away entirely between two reads are still not read, but the run now records how many in log_files_skipped_by_rotation, and a missing saved file in log_resume_file_missing, with a sentence on the collection_log row. The read also lists every log file even when the listing is paged (up to 20 pages), so a listing too long for one page can't hide the newest file or the file a saved position names; past 20 pages it uses the files it has and logs a warning, at most once an hour for each instance. -- **Down servers no longer use up the fleet's collection slots, and a command timeout no longer drops a healthy connection** ([#4712]) - A connect attempt against a dead server takes about 15 seconds to fail, and it ran inside the fleet collection gate, so about 22 down servers filled the default gate and healthy servers queued behind them. Connect attempts now run in their own small gate, and the retry delay grows from 60 seconds to about 4 minutes (with jitter) while a server stays down; it resets when the server connects or its definition is edited. A definition edit made while a connect attempt is running is no longer lost: the attempt remembers the definition it used, and a stale attempt installs nothing and lets the next sweep connect with the new definition. Separately, a SQL Server command timeout dropped the server's connection and re-ran the Extended Events setup and on-load snapshots even though the connection was still good, costing a stressed server 75 seconds or more of collection; the service now drops the connection only when a probe on a fresh connection fails. -- **A memory grant that used none of its memory now gets an Excessive Memory Grant finding** ([#4705]) - Rule 9 skipped any plan whose `MaxUsedMemory` was 0, so a grant of 1 GB or more that the query never used, the largest possible waste, got no finding. The parser now records whether the plan carried a `MaxUsedMemory` attribute, and the rule fires for a grant of at least 1 GB that used 0 KB with the message "Granted N MB but the query used none of it." A plan with no `MaxUsedMemory` attribute (an estimated plan, or one with no runtime grant info) still does not fire, and the ratio message and 10x threshold for a grant that used some of its memory are unchanged. -- **Estimated Plan CE Guess names the predicate behind each default guess and follows the plan's CE model version** ([#4705]) - Rule 33 called the 30% guess an equality guess (it is the inequality guess), called 10% and 1% inequality guesses that no predicate produces, never looked for the real equality guess, and ignored the statement's CE model version. It now labels each guess for what produces it, detects the equality guess (the square root of the row count from CE 120, the row count to the power 0.75 under CE 70), and reports a band only when the plan's estimator has it. The warning type, the 100,000-row minimum and the rest of the message are unchanged; the label text changes. -- **Expensive Operator no longer names an exchange operator** ([#4705]) - An exchange (Gather, Distribute or Repartition Streams) spends most of its elapsed time waiting on the operators around it, so Rule 35 could name the exchange while the operator next to it did the work. Rule 35 now skips exchange operators; the operator that did the work, such as a spilling Sort, keeps its warning. The 20% share, the 1,000 ms floor, the warning type and the message text are unchanged. -- **Self-hosted PostgreSQL targets no longer lose the log lines written just before a log rotation** ([#4704]) - The log tail keeps a resume marker per target, finishes the previous log file before reading the newest, and says so on the collection log when a file is gone or the log outgrew the read window. When one read holds more deadlock reports or captured plans than the collector's row limit, the newest are now kept, and the collection log says the limit was hit. -- **A Query Store backfill database that keeps failing no longer blocks the databases after it on the same server** ([#4703]) - The backfill runs at most one slice per server per pass in a fixed database order, so a database whose slice always failed stayed first in line and the databases behind it never got a slice. In Darling and Lite, a database that fails 3 slices in a row is now skipped while any other database on that server has work, one Warning is logged when it starts being skipped, and it is retried only when no other database has work, longest-ago failure first. A completed slice clears its count. The slice window still narrows per server after failed slices, as before. -- **The plan viewer's row label, edge colours and minimap, and analyzer rules 5 and 26, no longer misread operators in a parallel zone** ([#4632], [#4688], [#4698]) - Actual rows in a plan are a total, the estimate is per execution, and the execution count is a real loop count only on the inner side of a Nested Loops join (elsewhere in a parallel zone it is the thread count). The node label now prints the totals against the expected rows, for example "609 of 2,983 (20%)" (on a Nested Loops inner side the expected rows are the estimate times the executions, so "609 of 613 (99%)"), with just enough decimals that the numbers agree with the percentage: a Key Lookup that ran 117 times for 1 row reads "1 of 1.128 (89%)". An operator that returned exactly its estimate used to read "12 of 100 (12%)" at DOP 8 and, from DOP 11, was drawn in the critical colour; it now reads "100 of 100 (100%)" and stays neutral. The edge colours and the minimap follow the same rule: accurate operators in a parallel zone at DOP 11 or more stop drawing Blue, LightBlue or FluoBlue edges, and real misestimates in a parallel zone now show their full tier (a 20x underestimate at DOP 11 draws LightOrange, where it drew no colour before). On a Nested Loops inner side, the edge colour comes from the same ratio as the node's label, so an operator that ran thousands of times no longer gets a worst-misestimate red edge while its label shows the estimate was close. Rule 5 no longer reports a false overestimate on a parallel operator (a DOP 8 join with estimate 2,983 and 609 actual rows used to read "Estimated 2,983 vs Actual 609 (76 rows x 8 executions) - 39x overestimated" and is now silent), and rule 26 now reports "Row goal active: estimate reduced from 1,000 to 100" for a parallel scan that returned 500 rows, where it used to be swallowed. -- **Selecting the plan viewer's "+" tab through UI Automation (screen readers) adds one new sub-tab, not two** ([#4688]) - a UI Automation select on "+" sets focus on the tab and then selects it, and each counted as a click on "+", so one select added two empty "New Plan" sub-tabs in Lite and in the Darling Viewer. The plan viewer now treats the pair as one gesture and re-selects the sub-tab it just added. A mouse click or keyboard selection of "+" still adds one tab, and two separate selections still add two. -- **The Darling Viewer's server list is no longer a solid white box when the store is unavailable** ([#4685]) - While the store is unavailable the sidebar server list is disabled, and the stock list template painted it white in every theme, out of place next to the themed sidebar. Each theme now has its own list template: a disabled list keeps its themed background and border and dims instead. The same applies to the tag list in Manage Tags, which is disabled on a read-only seat. Enabled lists render as before. -- **Custom tab headers and the status-bar collector text now use readable, theme-following ink** ([#4682]) - In Lite, a selected server tab or Plan Viewer tab, and in Lite and the Darling Viewer a selected plan sub-tab, drew its label in the page text colour on the accent fill (1.99:1 on Dark, 2.71:1 on Cool Breeze); it now uses the theme's on-accent ink. In both apps, the status bar's "Collectors: N OK / erroring" text kept the previous theme's colour after a live theme switch until the next 30 second tick; it now follows the switch. In Lite, "Logging: BROKEN" uses the theme's critical text colour instead of a fixed red that was under 4.5:1 on every theme. -- **Web dashboard: a slow notebook or Custom View panel is no longer re-run while its previous read is still running** ([#4671]) - Composed panels read through a request the page's in-flight guard did not count, so a periodic refresh could fire a panel again while its last read was still running on the store. Panel reads are now counted like every other page read, so the page waits for them and the new slow-page back-off measures them. -- **Custom Views: window-total Query Store measures are no longer labelled "(ratio)"** ([#4664]) - "Query Store total CPU time" and "Query Store total duration" showed "(ratio)" in the measure pickers although they divide by nothing; each is a window total. The suffix now appears only on measures that are ratios. -- **Cool Breeze's warning text now reads clearly on the plan viewer's properties panel** ([#4658]) - In Lite, the Darling Viewer and the Dashboard, warning-tier text in the Cool Breeze theme (the missing-index impact percentage and per-thread skew on the plan viewer's properties panel) was a shade too light to meet the accessibility contrast guideline there. The warning color is now slightly darker by default, so that text meets the guideline on the panel and on the theme's cards, plan nodes and status bar. -- **Darling: the daily digests keep their time of day** ([#4656]) - The collector-cost digest, the fleet-sweep daily rollup and the analysis singles digest were due 24 hours after their last send and checked on an hourly tick that itself slid, so each arrived up to an hour later than the day before. Each now keeps a daily slot, and a late tick no longer moves the next day's. -- **Darling Viewer: the Plan Viewer opens when the viewer has no configuration or can't reach the store** ([#4649]) - The failure message now covers only the content area. Open Plan Viewer, View Log, Open Log Folder and About stay usable; the entries that need the store are disabled. -- **Custom Views AVG panels read from a rollup match raw to the last digit** ([#4647]) - The rollup route divided in floating point after rounding the sum, so for very large sums it could differ from raw's average by one unit in the last place. -- **Darling Viewer: restarting as administrator during an upgrade keeps its configuration** ([#4646]) - The restarted viewer read its own `--upgrade-takeover` flag as the path to darling.json and showed "darling.json not found"; it now reads its arguments the way `--test` does and passes the first launch's arguments on. -- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - Each collector's next run was scheduled from when its pass started (Darling) or waited a full minute after the pass's work (Lite), so late starts accumulated: busy Darling stores ran 1-minute collectors about every 71 seconds and lost about 15% of per-minute samples. Both now keep a fixed grid and skip, rather than replay, a slot missed during a stall. Stores that were drifting collect correspondingly more data per day: up to about 20% more for the per-minute tables. -- **The plan viewer's minimap now draws the first time you open it** ([#4643]) - Opening the minimap on a freshly loaded plan tab used to show only the "Minimap" header with nothing below it, until you dragged its resize grip or closed and reopened it. It now draws the plan overview immediately. -- **Double-clicking a minimap node now centers it correctly** ([#4643]) - Double-clicking a node in the minimap to zoom to it used to leave the node off to the side once the properties panel opened, by as much as 200 pixels. It now centers in the space that's actually left after the properties panel opens. -- **Jumping from a plan warning to its operator now centers the operator** ([#4643]) - Clicking a warning header's link to jump to the operator it came from used to leave that operator off to one side, because the properties panel opening alongside it narrowed the view after the centering had already happened. It now centers in the space that's actually left once the panel opens. -- **Copy and paste no longer freeze the window for up to 9 seconds when another app holds the clipboard** ([#4634]) - In Lite, the Darling Viewer and the Dashboard, a copy or paste that found the clipboard busy tried 8 times, and each try could take about a second, so the window stopped responding for up to about 9 seconds. It now tries twice and gives up after about 2 seconds. -- **get_store_metrics no longer reports retired store objects as a failing sweep** ([#4633]) - The inventory counted every row left from an older sweep as a sweep that "is not completing", and pointed at a Warning line that does not exist. On an upgraded store those rows belong to objects the product retired, such as the superseded baselines and the frozen rollups' jobs. It now checks whether each object still exists. Retired objects appear in their own `dropped_objects` list with the time of their last row. Only an object that still exists is reported as a sweep gap, with the service-log lines that say why. The compression line also explains why `collection_health_hourly` is uncompressed instead of listing it as DISABLED. -- **The Runtime Summary no longer says a query used "100%" of a memory grant it never got** ([#4632]) - When a query's memory grant was zero, the plan viewer now says "No memory grant" instead of a fabricated "0 KB granted, 0 KB used (100%)". -- **Plan viewer orange text now reads clearly in the Light theme** ([#4632]) - In Lite and the Darling Viewer, the warning badge, missing-index impact percentage, per-thread skew text, and the node cost/elapsed/CPU/row-estimate text used a fixed orange that was too pale to read on a white background; they now use theme-aware colours that stay readable in both Light and Dark. -- **Collector status text in the status bar now reads clearly in the Light theme** ([#4632]) - When collectors were erroring or capture was down, the status bar text used a fixed orange that was too pale to read on a white background; it now uses the same theme-aware colour the plan viewer uses, readable in both Light and Dark. -- **The repro script declares each parameter once** ([#4626]) - When a batch's plan lists the same parameter, or an auto-parameterized `@0`/`@1`, for more than one statement, the repro script declared it once per statement and failed to run. Each name is now declared once; a name the statements give different types is left out with a warning, and a warning says when the statements' compiled values differ. Matches PerformanceStudio. -- **Collection health no longer calls an idle activity-only collector regressed** ([#4625]) - `waiting_tasks`, `query_snapshots`, `running_jobs`, `job_history`, `procedure_stats`, `pg_lock_stats` and `pg_session_states` store rows only while the target is busy, so three empty runs in a row is normal for them, and working collectors showed WARNING. They are now flagged as stopped only after 72 hours without a row. Errors, denials and staleness are still flagged at once. Every row flagged as regressed now carries the sentence that explains it, including the default `get_collection_health` rows, and the web Collection Health table has a Regression column. -- **The daily purge of the per-interval Query Store tables no longer scans each table in full** ([#4615]) - The two tables get an index on the column the purge and the Query Store read gate filter on, so a purge with nothing to delete no longer costs minutes on a large store (measured: a cold-cache no-op purge dropped from ~4.1s to ~0.6ms on a 4M-row table). -- **A rare deadlock between a chunk drop and the alert pass's database-state check no longer fails that pass** ([#4612]) - The alert pass retries its database-state statements once when PostgreSQL picks them as a deadlock victim, the way the daily purge already retries its chunk drop. -- **Copying from Lite or the Darling Viewer no longer crashes when another program holds the clipboard** ([#4600]) - Every remaining unguarded clipboard write (recommendation copy/AI-prompt buttons, MCP command/URL copy, grid/row/cell copy, chart image copy, alert detail T-SQL copy, sign-in device-code copy) now retries briefly instead of throwing when another process is holding the clipboard. -- **The plan viewer no longer crashes when another program is holding the clipboard, and "Copy Query Text" now hands back the full query on a truncated single-statement plan** ([#4593]) - Copying anything from the plan viewer, blocking chain, deadlock graph, or a results grid used to crash the app if the Windows clipboard was briefly locked by another program; copies now fail quietly instead. Separately, "Copy Query Text" on a single-statement plan whose text hit SQL Server's 4,000-character cap now returns the full query the plan was captured from, instead of a copy cut off mid-word — for the Query Store and Active Queries plan sources that pass the original query text. -- **`get_ag_health` keeps its fleet-wide answer within the 32 KB MCP budget** ([#4568]) - The fleet-wide default page now fills most-severe-first by measured size instead of a fixed 11 groups. On a real fleet whose groups carry many databases, those 11 groups came to about twice the budget. `limit` still caps the page, and `groups_truncated` says whether the size budget or the limit cut it. -- **Plan analysis: the repro script matches PerformanceStudio's hardening** ([#4567]) - Reproduction scripts built from a plan now drop, with a header warning, a parameter whose plan-supplied name or data type is not a plain identifier or type, and use a placeholder for a compiled value that is not a safe literal. Every value written into the script's header comment is escaped so it cannot end the comment, and the `USE [database]` line is left out when the database name contains a control character. Parameters named `@0`, `@1`, … from simple and forced parameterization keep working. -- **A cancelled analysis, comparison, or collection-cycle read now propagates instead of returning an empty or fallback result** ([#4562]) - A cancelled `get_analysis_facts` or `compare_analysis` MCP call, or a shutdown mid-collection-cycle, used to come back looking like a clean empty result or an ordinary read failure; all now surface the caller's own cancellation. -- **Lite's MCP analysis tools stop reading when the client cancels the request** ([#4561]) - A cancelled `get_analysis_facts`, `compare_analysis` or `audit_config` request, and the config-change attribution behind it, now stops reading DuckDB and returns as cancelled, instead of reading to the end and logging an error. Darling's analysis tools already did this. -- **Plan analysis stops when its caller cancels** ([#4560]) - The MCP plan tools stop parsing and analysing a plan when the client cancels the request, and the Darling and Lite analysis passes stop on shutdown instead of finishing a large plan first. -- **Plan analysis now looks inside a procedure, function or cursor body** ([#4557]) - The plan viewer and the `analyze_plan_xml` MCP tool skipped every statement inside a stored procedure or user-defined function call, and a cursor's own sub-plan was never read at all. An `EXEC ` plan analyzed as a single statement with no findings, no cost, and no benefit score for the work actually happening in the body. -- **Plan analysis: the non-SARGable predicate check now knows which table a function, conversion or `ISNULL`/`COALESCE` call is wrapping, so it stops flagging a Nested Loops outer reference or a parameter-side conversion, recognizes `LIKE` as a comparison, and now also catches a function or conversion on an unaliased table variable's own column** ([#4554]) - Each previously produced a Non-SARGable Predicate warning for a predicate that could actually seek (or, for the table-variable case, missed a real one), and pointed at the wrong cause. -- **The rollup coverage check no longer writes about 170 MB of temp files every five minutes on a large store** ([#4553]) - Finding a rollup's oldest bucket sorts every compressed batch of its oldest chunk. The check now re-measures a rollup only when its oldest chunk changes, and reuses the last measurement otherwise. -- **Plan analysis now scores each finding's benefit, and the plan viewer and MCP plan tools show it** ([#4552]) - The benefit scorer was never run, so no finding had a benefit value. Findings are now ordered by their estimated benefit. The viewer's headers read "— up to X% benefit", and the MCP plan tools report `max_benefit_percent`. This turns on the Serial Plan and Bare Scan benefit estimates. -- **A deeply nested execution plan no longer crashes the Darling service, the MCP plan tools or the plan viewer** ([#4551]) - Plans nested deeper than about 80–120 operators overflowed the stack and ended the process that parsed them. Parsing now runs on its own thread with a large enough stack, stops cleanly at 1,000 levels, and rejects plan XML over 16 MB. -- **Plan analysis: adaptive-join memory grants, redundant UDF findings, and culture-dependent percentages** ([#4548]) - The Excessive Memory Grant finding now notes when an adaptive join ran as Nested Loops, so the unused grant isn't mistaken for a separate problem. Rule 6's Scalar UDF finding no longer duplicates a Serial Plan finding that already names the same UDF as the reason a plan runs serially. Three warning messages that reported a percentage now format it the same way regardless of the machine's locale. -- **Plan analysis: an operator's reported self-time no longer includes the coordinator thread's wall-clock time or double-counts a batch-mode or Compute Scalar child's time, in either a parallel or a serial plan** ([#4547]) - the "Operator time" text and the severity of plan findings now reflect the operator that actually did the work, not an operator that happened to sit above a batch subtree, a Compute Scalar pass-through, or near the top of a parallel branch. -- **The Join OR Clause plan-analysis finding no longer fires on a parameterized `IN` list** ([#4544]) - A query such as `WHERE t.A IN (@p1, @p2)` on an indexed column builds a dynamic seek with the same operator shape as a real join OR. The finding now also requires a lookup branch that reads a value from another input. -- **Plan analysis no longer flags an unexecuted operator as a row estimate mismatch, and stops recommending a rewrite for the engine's own table-valued functions (`STRING_SPLIT`, `OPENJSON`, `GENERATE_SERIES`, DMVs/DMFs)** ([#4542]) - Rule 5 previously warned about a 0-row estimate mismatch on any operator whose branch never ran; it now requires `ActualExecutions > 0`. Rule 23 previously warned on every table-valued function operator; it now skips one whose object has neither a database nor a schema, which is how the engine's own functions appear. -- **The store no longer compresses every heavy table at once after midnight** ([#4541]) - The nine largest hypertables each become eligible for compression at their own hour (1 to 9 hours after the usual one day), so the nightly compression pass no longer times out collector statements. Existing stores pick up the new delays on their next start. -- **Plan analysis rules for `MAXDOP 1`, `RECOMPILE`, `OPTIMIZE FOR UNKNOWN`, `NOT IN`, and row-goal causes ignore hints and keywords written inside a comment or a string literal** ([#4540]) - A hint or keyword sitting in a `--`/`/* */` comment or inside a quoted string no longer counts as code, so these rules no longer fire on text that isn't actually part of the query, and no longer miss a real hint hidden behind one. -- **A managed PostgreSQL or a config load that takes more than two minutes to start no longer leaves Darling running without collecting** ([#4538]) - The sustained start-up retry from [#4509] now also covers the bundled PostgreSQL's own start and, for failures already treated as transient, loading `darling.json`. While that retry runs, `/api/ping` and the status detail say it is a sustained retry, with the interval, instead of reporting an attempt count past the cap. -- **After a long store outage at start, Darling now keeps retrying and starts collecting when the store is back** ([#4509]) - Once the two-minute startup retry budget for a recoverable store connection or migration failure ran out, Darling stood down and never collected again until the service was restarted, even though the service itself kept running. It now keeps retrying, more slowly, until the store is reachable again. -- **After a SQL Agent job-history identity reset (a reseed, a restore or a failover), Darling and Lite re-read the recent history once instead of on every collection** ([#4496]) - the watermark read the highest ID ever stored, which a reset leaves above every new ID. One store collected each run about 13 times. -- **A gap of one hour in the collection-health rollup no longer makes the Viewer, web and MCP health reads scan seven days of raw collection log** ([#4494]) - the missing hours are read raw and the rest still comes from the rollup. A store measured the raw path at 6.6 s against 184 ms. -- **Lite's perfmon chart and `get_perfmon_trend` also set aside a one-sample Wait Statistics spike and say how many** ([#4492]). -- **A one-sample spike in a Wait Statistics counter no longer flattens the perfmon chart** ([#4490]) - SQL Server occasionally reports a cumulative-sized value in a per-second instance for a single sample. The Viewer's perfmon chart and `get_perfmon_trend` now set such a sample aside and say how many, and the stored value is unchanged. -- **Lite's Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4488]). -- **`query_store` no longer reads as "produced then stopped" between Query Store intervals** ([#4483]) - it runs every 5 minutes, but its source advances once per interval (up to a day). It's flagged only after more than a day plus 15 minutes with nothing new. -- **The Availability Groups tab and `get_ag_health`'s `distinct_ag_count` no longer count differently-owned AGs that share a name as one group** ([#4481]) - e.g. every Amazon RDS Multi-AZ instance's internal `RDSAG0`. An AG monitored from both its primary and a secondary still counts once. -- **Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4481]). -- **Recommendations say "queries", not "querys"** ([#4481]). -- **Plan analysis now reads the query plan inside an IF condition, and the query and plan hashes of statements that carry several plans** ([#4470]) - an `IF EXISTS (SELECT …)` condition's operators and missing-index suggestions were dropped, and a `MULTIPLE PLAN` statement came back with no hashes. -- **Upgrading a busy store no longer stops partway and asks for a re-run when the service's process takes a few extra seconds to exit** ([#4467]) - the upgrade script now waits up to two minutes for it before refusing. +- **Plan-forcing advice says when SQL Server's own recommendation names the proposed plan as the regressed one** ([#4810]) +- **Lite no longer archives the same rows twice after it is stopped in the middle of an archive run** ([#4808]) +- **Lite's Query Store repair also covers archive months that compaction split into parts** ([#4808]) +- **Darling retries a store that is at its connection limit when the service starts** ([#4806]) +- **The compose `darling` container reports unhealthy when a startup failure has stopped collection** ([#4806]) +- **The docs now name the oldest supported builds: SQL Server 2016 SP2 and SQL Server 2017 CU3** ([#4805]) +- **A webhook that never answers no longer holds up alert delivery** ([#4803]) +- **Query Store backfill now logs a warning when it cannot read its list of work** ([#4801]) +- **Query Store backfill keeps a slice size that works instead of swinging back to the size that timed out** ([#4801]) +- **PostgreSQL analysis: a configuration setting shown under another finding now carries its own advice** ([#4799]) +- **The advice for turning autovacuum back on now names the provider's parameter group** ([#4799]) +- **A webhook channel that keeps failing no longer goes unnoticed while another channel delivers** ([#4798]) +- **The configuration change card no longer calls a metric "resolved" when only minutes have passed since the change** ([#4797]) +- **A server that is down when the Darling service starts now gets a "Collection Stopped" alert once the threshold passes** ([#4796]) +- **Adding a server whose id matches a different server's no longer overwrites it in the Darling viewer, and Lite now refuses to add or edit onto it** ([#4794]) +- **`get_store_metrics` no longer reports a gap of several days in the store's size history as one day's growth, and it marks today's partial day as partial** ([#4792]) +- **The store checkpointer alert no longer tells you to raise max_wal_size for every requested checkpoint** ([#4791]) +- **`mute_analysis_finding`, in Darling and in Lite, no longer mutes the pattern on whichever matching server sorts first** ([#4790]) +- **Repeating a `create_mute_rule` call no longer creates a second identical rule** ([#4790]) +- **`add_servers` reports every server in the batch when a later entry fails to save, and no longer says "added" for a save that wrote nothing** ([#4787]) +- **The plan-force bot no longer reads a database missing from the newest automatic-tuning capture as "automatic correction off"** ([#4784]) +- **After a failed state read, the plan-force bot looks at the same plans again after 1 hour instead of holding them for a day** ([#4784]) +- **Web viewer: a page left loading in a hidden or paused tab refreshes normally again** ([#4781]) +- **The PostgreSQL plan-regression finding now reports the worst regression when more than 50 statements changed plans in the window** ([#4780]) +- **A standby that was removed or replaced no longer outranks the live standbys for the rest of the window** ([#4780]) +- **A dropped replication slot no longer grades Critical for the rest of the window** ([#4780]) +- **The alert history now records whether each notification channel delivered or failed** ([#4779]) +- **The alert notebook finds an alert's resolution even when it came late, was dismissed, or sat behind many newer alerts** ([#4778]) +- **A fleet-level store alert with no resolution reads "No resolution recorded" instead of saying collection stopped** ([#4778]) +- **Darling now sends alert email through notification routes when the default recipient list is blank, instead of treating email as not set up** ([#4777]) +- **`--configure-network` keeps the web listener's `tls` and `oidc` settings** ([#4775]) +- **A repaired hourly hole no longer leaves a partial day in the daily rollups, and days an earlier repair left short are rebuilt once after the upgrade** ([#4739], [#4763]) +- **Darling upgrade no longer says "New build in place." after copying nothing** ([#4762]) +- **An older Lite refuses to open a data file from a newer version** ([#4753]) +- **Lite re-applies its newer columns on every start** ([#4753]) +- **After the computer sleeps and resumes, Lite runs each due collector once** ([#4753]) +- **Two analyze_server calls that overlap no longer give the second one a false all-clear** ([#4742]) +- **In Lite, a server that just went down no longer holds a connection slot while its retries wait** ([#4740]) +- **The self-hosted PostgreSQL log tail no longer stays on the outgoing log file after a rotation in the same second** ([#4738]) +- **Store upgrade: copy mode is chosen from the data folder's own volume and a finished size count** ([#4725]) +- **Store upgrade: hard-link mode removes the pre-upgrade directory even when a settings carry fails, after saving the old `postgresql.conf`** ([#4725]) +- **Store settings migration: a repeated attempt restores the newest backup of `postgresql.conf`** ([#4725]) +- **Store free-space checks and reports read the data folder's own volume** ([#4725]) +- **Lite archive compaction no longer loses a month when a promote fails** ([#4718]) +- **The size-triggered Lite reset no longer deletes the database after a failed export** ([#4718]) +- **The tab Refresh button no longer runs collectors during a Lite database reset** ([#4718]) +- **Lite archive views now include compaction's part files** ([#4718]) +- **Importing a previous Lite install no longer overwrites this install's part files, and imported files now expire with retention** ([#4718]) +- **A failed archive export no longer leaves a partial file on disk** ([#4718]) +- **Reads of an archive view no longer fail after old archive files expire** ([#4718]) +- **A managed store moved aside by a failed upgrade is no longer replaced by an empty one** ([#4717]) +- **A start after an interrupted store upgrade resumes it instead of refusing every start** ([#4717]) +- **A failed store upgrade that left no startable store stops the start** ([#4717]) +- **The pre-upgrade rollback copy survives the two service starts it is kept for** ([#4717]) +- **PostgreSQL 13 servers read through csvlog are no longer reported as quiet** ([#4714]) +- **RDS and Aurora PostgreSQL log reads now collect the lines a log file received before RDS rotated it, and resume where they stopped after a restart** ([#4713]) +- **Down servers no longer use up the fleet's collection slots, and a command timeout no longer drops a healthy connection** ([#4712]) +- **A memory grant that used none of its memory now gets an Excessive Memory Grant finding** ([#4705]) +- **Estimated Plan CE Guess names the predicate behind each default guess and follows the plan's CE model version** ([#4705]) +- **Expensive Operator no longer names an exchange operator** ([#4705]) +- **Self-hosted PostgreSQL targets no longer lose the log lines written just before a log rotation** ([#4704]) +- **A Query Store backfill database that keeps failing no longer blocks the databases after it on the same server** ([#4703]) +- **The plan viewer's row label, edge colours and minimap, and analyzer rules 5 and 26, no longer misread operators in a parallel zone** ([#4632], [#4688], [#4698]) +- **Selecting the plan viewer's "+" tab through UI Automation (screen readers) adds one new sub-tab, not two** ([#4688]) +- **The Darling Viewer's server list is no longer a solid white box when the store is unavailable** ([#4685]) +- **Custom tab headers and the status-bar collector text now use readable, theme-following ink** ([#4682]) +- **Web dashboard: a slow notebook or Custom View panel is no longer re-run while its previous read is still running** ([#4671]) +- **Custom Views: window-total Query Store measures are no longer labelled "(ratio)"** ([#4664]) +- **Cool Breeze's warning text now reads clearly on the plan viewer's properties panel** ([#4658]) +- **Darling: the daily digests keep their time of day** ([#4656]) +- **Darling Viewer: the Plan Viewer opens when the viewer has no configuration or can't reach the store** ([#4649]) +- **Custom Views AVG panels read from a rollup match raw to the last digit** ([#4647]) +- **Darling Viewer: restarting as administrator during an upgrade keeps its configuration** ([#4646]) +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) +- **The plan viewer's minimap now draws the first time you open it** ([#4643]) +- **Double-clicking a minimap node now centers it correctly** ([#4643]) +- **Jumping from a plan warning to its operator now centers the operator** ([#4643]) +- **Copy and paste no longer freeze the window for up to 9 seconds when another app holds the clipboard** ([#4634]) +- **get_store_metrics no longer reports retired store objects as a failing sweep** ([#4633]) +- **The Runtime Summary no longer says a query used "100%" of a memory grant it never got** ([#4632]) +- **Plan viewer orange text now reads clearly in the Light theme** ([#4632]) +- **Collector status text in the status bar now reads clearly in the Light theme** ([#4632]) +- **The repro script declares each parameter once** ([#4626]) +- **Collection health no longer calls an idle activity-only collector regressed** ([#4625]) +- **The daily purge of the per-interval Query Store tables no longer scans each table in full** ([#4615]) +- **A rare deadlock between a chunk drop and the alert pass's database-state check no longer fails that pass** ([#4612]) +- **Copying from Lite or the Darling Viewer no longer crashes when another program holds the clipboard** ([#4600]) +- **The plan viewer no longer crashes when another program is holding the clipboard, and "Copy Query Text" now hands back the full query on a truncated single-statement plan** ([#4593]) +- **`get_ag_health` keeps its fleet-wide answer within the 32 KB MCP budget** ([#4568]) +- **Plan analysis: the repro script matches PerformanceStudio's hardening** ([#4567]) +- **A cancelled analysis, comparison, or collection-cycle read now propagates instead of returning an empty or fallback result** ([#4562]) +- **Lite's MCP analysis tools stop reading when the client cancels the request** ([#4561]) +- **Plan analysis stops when its caller cancels** ([#4560]) +- **Plan analysis now looks inside a procedure, function or cursor body** ([#4557]) +- **Plan analysis: the non-SARGable predicate check now knows which table a function, conversion or `ISNULL`/`COALESCE` call is wrapping, so it stops flagging a Nested Loops outer reference or a parameter-side conversion, recognizes `LIKE` as a comparison, and now also catches a function or conversion on an unaliased table variable's own column** ([#4554]) +- **The rollup coverage check no longer writes about 170 MB of temp files every five minutes on a large store** ([#4553]) +- **Plan analysis now scores each finding's benefit, and the plan viewer and MCP plan tools show it** ([#4552]) +- **A deeply nested execution plan no longer crashes the Darling service, the MCP plan tools or the plan viewer** ([#4551]) +- **Plan analysis: adaptive-join memory grants, redundant UDF findings, and culture-dependent percentages** ([#4548]) +- **Plan analysis: an operator's reported self-time no longer includes the coordinator thread's wall-clock time or double-counts a batch-mode or Compute Scalar child's time, in either a parallel or a serial plan** ([#4547]) +- **The Join OR Clause plan-analysis finding no longer fires on a parameterized `IN` list** ([#4544]) +- **Plan analysis no longer flags an unexecuted operator as a row estimate mismatch, and stops recommending a rewrite for the engine's own table-valued functions (`STRING_SPLIT`, `OPENJSON`, `GENERATE_SERIES`, DMVs/DMFs)** ([#4542]) +- **The store no longer compresses every heavy table at once after midnight** ([#4541]) +- **Plan analysis rules for `MAXDOP 1`, `RECOMPILE`, `OPTIMIZE FOR UNKNOWN`, `NOT IN`, and row-goal causes ignore hints and keywords written inside a comment or a string literal** ([#4540]) +- **A managed PostgreSQL or a config load that takes more than two minutes to start no longer leaves Darling running without collecting** ([#4538], [#4509]) +- **After a long store outage at start, Darling now keeps retrying and starts collecting when the store is back** ([#4509]) +- **After a SQL Agent job-history identity reset (a reseed, a restore or a failover), Darling and Lite re-read the recent history once instead of on every collection** ([#4496]) +- **A gap of one hour in the collection-health rollup no longer makes the Viewer, web and MCP health reads scan seven days of raw collection log** ([#4494]) +- **Lite's perfmon chart and `get_perfmon_trend` also set aside a one-sample Wait Statistics spike and say how many** ([#4492]) +- **A one-sample spike in a Wait Statistics counter no longer flattens the perfmon chart** ([#4490]) +- **Lite's Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4488]) +- **`query_store` no longer reads as "produced then stopped" between Query Store intervals** ([#4483]) +- **The Availability Groups tab and `get_ag_health`'s `distinct_ag_count` no longer count differently-owned AGs that share a name as one group** ([#4481]) +- **Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4481]) +- **Recommendations say "queries", not "querys"** ([#4481]) +- **Plan analysis now reads the query plan inside an IF condition, and the query and plan hashes of statements that carry several plans** ([#4470]) +- **Upgrading a busy store no longer stops partway and asks for a re-run when the service's process takes a few extra seconds to exit** ([#4467]) - **Stores that expose the managed PostgreSQL on the network re-verify a settings file left unstamped by a hand edit or an interrupted start, instead of reporting a failure on every start** ([#4465]) -- **Stores that expose the managed PostgreSQL on the network now finish the settings-file migration, instead of restoring the previous file and logging a warning on every start** ([#4464]) - the command-line `listen_addresses` outranks the file, so the check no longer compares keys the command line owns. -- **The daily chunk-interval adjustment now shrinks a busy table's chunks on stores that hold more than 1,000 chunks in total** ([#4458]) - its 1,000-chunk limit counted every table's chunks on the store, so a store past 1,000 in total held every table at 24 hours however far over its memory budget it was; the limit now applies to each table's own chunk count at the smaller size, and each held table and each run's store total and budget are logged at Information. -- **Severe-error rows from system_health now carry their database id, and no longer list errors below severity 16 or the two routine connection-error numbers sp_HealthParser ignores** ([#4455]) - the database id was read from the wrong part of the captured event and always came back empty, and the unfiltered view could show errors the proc's own report never would. -- **A managed PostgreSQL 17 store whose settings carried an old 2 GB maintenance_work_mem starts again after the move to darling-managed.conf** ([#4444]) - a carried value from before the PostgreSQL 17 memory cap is now capped the same way a freshly derived one already was, so `postgres -C` no longer rejects it on start. +- **Stores that expose the managed PostgreSQL on the network now finish the settings-file migration, instead of restoring the previous file and logging a warning on every start** ([#4464]) +- **The daily chunk-interval adjustment now shrinks a busy table's chunks on stores that hold more than 1,000 chunks in total** ([#4458]) +- **Severe-error rows from system_health now carry their database id, and no longer list errors below severity 16 or the two routine connection-error numbers sp_HealthParser ignores** ([#4455]) +- **A managed PostgreSQL 17 store whose settings carried an old 2 GB maintenance_work_mem starts again after the move to darling-managed.conf** ([#4444]) - **After a long outage across an upgrade, repaired hourly query statistics also reach the daily rollup, so the hourly tier's retention isn't held** ([#4439]) - **PostgreSQL statement statistics count a re-created statement entry's work since it was re-created, instead of under-counting it; on PostgreSQL 16, where the entry's creation time isn't available, such a row is recorded as unknown** ([#4435]) - **Wait statistics on servers where a scheduled job clears them are counted from each clear instead of being recorded as unknown; only the work between the last collection and the clear stays unknown** ([#4434]) - **The raw purge gate judges each rollup against the rows that rollup can hold, so an hour of CPU-unknown query statistics at the floor can't hold the purge forever** ([#4432]) - **Query statistics record a restarted cached plan's executions, duration and CPU since the restart in full, instead of under-counting them; a restart the collector cannot place in time is recorded as unknown rather than estimated** ([#4431]) -- **After an outage across an upgrade, the raw purge resumes within the hour on a running store, with no second restart** ([#4430]) - a legacy/successor seam an outage opens across an upgrade used to require a second full service start before the raw purge gate would release; the hourly retention tick now closes that seam on its own. +- **After an outage across an upgrade, the raw purge resumes within the hour on a running store, with no second restart** ([#4430]) - **The daily retention sweep no longer drops raw query statistics over a hole no rollup holds; the gated service-triggered purge owns those tables, and purge_now reports what it held** ([#4429]) -- **Query statistics no longer record a false zero CPU when only the CPU counter's delta is unknowable; those rows keep their executions and duration** ([#4423]) - a `query_stats` row whose CPU (worker time) counter reset or was seen for the first time, while its execution-count or elapsed-time counters had a real delta in the same pass, previously wrote CPU as a false 0 over a fabricated zero interval — which then caused the row's real executions and duration to be dropped by the interval-honest filter along with the fake CPU. That row now records CPU as unknown (NULL) and keeps its real interval, executions, and duration. A CPU counter that is genuinely unchanged over a real measured interval still records 0, unchanged. -- **FinOps no longer reports a database as idle when its only recent samples were a plan's first sighting** ([#4417]) - idle-database detection now counts a recent last-execution time as activity, instead of deciding on the summed execution count alone (#4394). -- **Alert notebook: the collector-freshness check now counts only successful collection runs** ([#4416]) - it previously treated a collector's own failed runs as proof it was still fresh, used no read timeout, and always logged a zero elapsed time on failure. It also now recognizes AG and Server Unreachable/Restored recovery pairs when resolving a notebook's status. -- **`get_store_host` now honours request cancellation** ([#4412]) - an abandoned or superseded call to `get_store_host` kept its store-host gather running to the tool's own fixed deadline instead of stopping when the caller went away; the gather now also observes the request's own cancellation, and a cancelled gather is never cached. -- **Web reads honour request cancellation for 2 more trend charts and 3 analysis tools** ([#4411]) - `get_file_io_trend`, `get_perfmon_trend`, `compare_analysis`, `get_analysis_facts` and `get_analysis_findings` kept running their store reads (and, for the analysis tools, the inference engine's fact collection and scoring) to completion after a web request was abandoned. They now take a cancellation token and stop when the client disconnects. -- **Web reads for PostgreSQL index bloat, column stats, CPU utilization, log events and logging audit now honour request cancellation** ([#4409]) - an abandoned web request for one of these five reads previously ran its underlying store query to completion instead of stopping; each now threads the request's cancellation token through every store call. -- **The settings redactor no longer masks a short value whole on its first call** ([#4408]) - its patterns are warmed once at start-up, so a first-use compile cost can't count against the match time bound. -- **darling-managed.conf is rewritten only when its settings change** ([#4407]) - a change in a header display field, such as the data volume's free space crossing a GiB boundary, no longer rewrites the file or re-verifies it. -- **Stop re-holding the raw retention purge for a healthy store whose successor rollup hasn't run its first refresh yet** ([#4406]) - An upgrade with no outage was reporting the raw purge's safety gate as unsafe while a freshly-added rollup's history was still empty, even though no row was actually at risk. The gate's fallback probe now stops one refresh-window short of the current time, matching how far the rollup's own first refresh is expected to reach. -- **Carry an operator's own `postgresql.conf` lines below the `darling-managed.conf` include across a major PostgreSQL upgrade** ([#4405]) - previously only `postgresql.auto.conf` (`ALTER SYSTEM`) settings survived a major upgrade; a hand-edited line below the include stayed behind in the retained old data directory. Each carried line is now probed against the new binaries and skipped (never fatal) if rejected. -- **Web reads honour request cancellation (10 more tools)** ([#4402]) - `get_store_query_stats`, `get_store_metrics`, `get_store_log`, `get_collector_stall_probes`, `get_plan_xml`, `get_oversized_plan_backlog`, `get_fleet_overview`, `get_sweep_reports`, `get_collector_cost` and `get_pg_blocking` kept running their store query to completion after a `/api/read` client disconnected or timed out, because their dispatch entries and tool methods never threaded the request's `CancellationToken` through to the query. Each now takes the token and passes it to every store call, so an abandoned request stops promptly instead of finishing unread. +- **Query statistics no longer record a false zero CPU when only the CPU counter's delta is unknowable; those rows keep their executions and duration** ([#4423]) +- **FinOps no longer reports a database as idle when its only recent samples were a plan's first sighting** ([#4417]) +- **Alert notebook: the collector-freshness check now counts only successful collection runs** ([#4416]) +- **`get_store_host` now honours request cancellation** ([#4412]) +- **Web reads honour request cancellation for 2 more trend charts and 3 analysis tools** ([#4411]) +- **Web reads for PostgreSQL index bloat, column stats, CPU utilization, log events and logging audit now honour request cancellation** ([#4409]) +- **The settings redactor no longer masks a short value whole on its first call** ([#4408]) +- **darling-managed.conf is rewritten only when its settings change** ([#4407]) +- **Stop re-holding the raw retention purge for a healthy store whose successor rollup hasn't run its first refresh yet** ([#4406]) +- **Carry an operator's own `postgresql.conf` lines below the `darling-managed.conf` include across a major PostgreSQL upgrade** ([#4405]) +- **Web reads honour request cancellation (10 more tools)** ([#4402]) - **Fixed a raw-purge gate that could hold history forever, and a repair -- **Web reads honour request cancellation (11 more SQL Server tools)** ([#4393]) - `get_session_stats`, `get_waiting_tasks`, `get_cpu_scheduler_pressure`, `get_plan_cache_bloat`, `get_latch_stats`, `get_spinlock_stats`, `get_memory_trend`, `get_default_trace_events`, `get_running_jobs`, `get_pvs_stats`, and `get_ag_health` now take a `CancellationToken` and pass it down to every store call, so an abandoned `/api/read` request stops its query instead of running to completion. Removed all from `CancellationAllowlist`. -- **The PostgreSQL settings redactor has a bounded matching time** ([#4392]) - Each redaction pattern runs under a time bound. A value that reaches it is masked whole, and the warning names only the setting. -- **An armed raw-retention purge no longer runs when PostgreSQL starts, before the service can hold it** ([#4391]) - After a long enough outage, TimescaleDB's own scheduler could run the `query_stats`, `procedure_stats` or `query_store_stats` retention job the moment PostgreSQL came up, dropping raw history that no rollup had materialized yet. These three jobs are now never scheduled on TimescaleDB's runner. The service runs the purge itself, from its hourly evaluation only, and only after it measures coverage itself, confirms the hole repair finished cleanly since the current PostgreSQL start, and finds no hole in the range it would drop. A new **Raw Purge Over Horizon** alert says why a purge didn't run, or that the purge trigger has stopped. The first start after the upgrade still runs the old armed job once. -- **PostgreSQL web reads now honour request cancellation** ([#4390]) - `get_pg_xmin_horizon`, `get_pg_wraparound_risk`, `get_pg_session_states`, `get_pg_replication_stats`, `get_pg_predicate_stats`, `get_pg_kernel_stats`, `get_pg_io_stats`, `get_pg_index_usage`, `get_pg_database_stats` and `get_pg_autovacuum_health` ran every store call to completion even after the web caller disconnected. Each now takes a `CancellationToken` and passes it to every store call, so an abandoned request stops its query instead of running to completion. -- **PostgreSQL-target MCP reads now cancel on client disconnect** ([#4388]) - nine PostgreSQL-target read tools (`get_pg_deadlocks`, `get_pg_deadlock_detail`, `get_pg_wait_stats`, `get_pg_wait_sampling`, `get_pg_replication_slots`, `get_pg_top_queries`, `get_pg_table_bloat`, `get_pg_plans`, `get_pg_plan_capture_readiness`) ran to completion even after the requesting client disconnected. Each now takes a `CancellationToken` threaded to every store call and is dropped from the web-read cancellation allowlist. -- **Web reads now honour request cancellation for 15 more MCP tools** ([#4387]) - `get_cpu_utilization`, `get_wait_stats`, `get_wait_types`, `get_wait_trend`, `get_memory_stats`, `get_memory_clerks`, `get_file_io_stats`, `get_tempdb_trend`, `get_perfmon_stats`, `get_query_store_top`, `list_servers`, `get_collection_health`, `get_collection_log`, `get_current_waits_trend` and `get_blocking_stats` used to run their store query to completion even after the web viewer's request was aborted; each now takes a `CancellationToken` threaded to every store call, so an abandoned request stops promptly. -- **Web reads honour request cancellation for Alerts, Memory Grants and Health MCP tools** ([#4386]) - `get_alert_history`, `get_alert_settings`, `get_mute_rules`, `get_notification_routes`, `get_resource_semaphore`, `get_memory_grants`, `get_memory_pressure_events`, `get_server_summary`, `get_daily_summary` and `get_daily_summary_range` previously ran their store query to completion even after an abandoned web request; they now take a `CancellationToken` and pass it through every store call. -- **Threaded cancellation through 10 PostgreSQL-target web reads** ([#4373]) - get_pg_buffer_usage, get_pg_extensions, get_pg_lock_stats, get_pg_server_config, get_pg_server_config_changes, get_pg_write_stats, get_pg_database_trend, get_pg_io_trend, get_pg_query_duration_trend and get_pg_wait_trend ran their store queries to completion after a web request was abandoned; each tool now takes a CancellationToken and passes it to every store call, and is removed from the /api/read cancellation allowlist. -- **Web reads for object-stats and config-history now honor request cancellation** ([#4372]) - get_database_sizes, get_index_usage, get_object_locking, get_table_index_sizes, get_database_config_changes, get_database_scoped_config, get_server_config_changes and get_trace_flag_changes ran their store query to completion even after a web caller abandoned the request; all eight now take a CancellationToken threaded through every store call and are removed from the cancellation allowlist. -- **Deprecated Dashboard's XE ring-buffer collectors no longer reshred unchanged data** ([#4371]) - `install/22_collect_blocked_processes.sql` and `install/24_collect_deadlock_xml.sql` converted the whole Extended Events ring buffer to XML and shredded it on every scheduled run, even when nothing new had arrived since the last cycle. Both now read the ring buffer target's own delivered-event counter first and skip the conversion when it hasn't changed, matching the fix #4212 shipped for Darling and Lite. Applies to existing installs still running the deprecated Dashboard's SQL Agent collectors; the rows each collector stores are unchanged. A no-change collector run (median of 5, on a filled ring buffer) went from 150 ms to 35 ms for blocked-process and from 56 ms to 28 ms for deadlock. -- **Bucketed the memory-grant and TempDB usage viewer trend charts** ([#4364]) - The memory-grant overlay, Memory Grants chart, and TempDB usage chart (Darling and Lite) each returned one row per collection over a 7-day window. On a 7-day seed at each collector's cadence, the memory-grant overlay went from 10,080 to 1,008 rows, the Memory Grants chart from 20,160 to 2,016, and TempDB usage from 10,080 to 1,008. All three now bucket to the chart's point budget the same way the CPU, wait, and file-I/O trend charts already do, averaging gauges and summing true deltas per bucket, with no change to what the series measures. -- **Bucketed the blocking-trend charts' lock-wait, waiting-task, and blocked-session reads** ([#4362]) - the Blocking Trends and Current Waits charts read one row per collection at wide windows, unlike the other trend charts #4353 and #4340 already bucketed. On a 7-day seed at the 1-minute cadence, lock waits went from 20,160 to 2,016 rows, waiting tasks from 30,240 to 3,024, and blocked sessions from 20,160 to 2,016, on both products. Blocked sessions is now averaged per collection within each bucket, so its value no longer grows with the bucket width. -- **Bucketed the CPU scheduler, session stats, and plan cache trend reads** ([#4361]) - These three reads returned one row per collection with no cap, unlike the file I/O, memory, wait stats, and other trend reads #4234 already fixed. On a 7-day seed at each collector's cadence, CPU scheduler pressure went from 10,080 to 1,008 rows, and Sessions and Plan cache each from 2,016 to 1,008. All three now bucket to the same width ladder the other trend charts use, averaging each gauge per bucket and (for Session Stats) carrying forward the newest collection's application/host attribution rather than blending it. -- **Blocking and deadlock web reads now cancel with the request** ([#4203]) - the seven blocking/deadlock tools behind the web viewer's Blocking page (blocked process XML, blocking, blocking trend, deadlock detail, deadlock trend, deadlocks, lock wait trend) kept running their store queries after a browser navigated away or a request was abandoned. Each now takes a cancellation token and passes it through every store call, so an abandoned request actually stops. -- **Health Parser web reads now cancel with the browser request** ([#4359]) - the nine `get_health_parser_*` `/api/read` handlers ran their Postgres queries to completion even after the browser tab closed or the request was aborted; they now thread `RequestAborted` through every store call so an abandoned read stops promptly. -- **Four Performance-Trends web reads now stop their store query when the request is abandoned** ([#4357]) - `get_query_trend`, `get_query_duration_trend`, `get_procedure_duration_trend` and `get_query_store_duration_trend` used to keep running their store query after a web caller gave up or navigated away; they now observe the request's cancellation all the way down to Npgsql. -- **A slow first-run database create no longer fails Darling's Postgres bootstrap** ([#4352]) - The managed store's first-run `CREATE DATABASE` was retried up to 6 times inside the same 10 second window used for the post-start connection probe. Because a timed-out `CREATE DATABASE` is cancelled and rolled back, every retry re-copied the template database from scratch under the same 10 second budget, so a copy that took longer than 10 seconds failed outright no matter how many retries ran. The create now runs once, on a 60 second budget, outside that retry. -- **Passwords and other secrets in stored PostgreSQL settings are now redacted** ([#4351]) - The config collector stored `pg_settings` and per-database/per-role override values verbatim, including secrets a `pg_monitor`-only monitoring role can read but should not retain in plain text, such as a standby's `primary_conninfo` replication password or a backup tool's key/token in `archive_command`/`restore_command`; new collections now mask the secret, and existing stored rows are scrubbed in place, in batches, and the scrub completes at any settings cadence; a target that fails is retried on the next start. Non-secret password-policy settings (`rds.accepted_password_auth_method`, `rds.restrict_password_commands`, `passwordcheck.min_password_length`) are no longer masked. "Keep the rest of the value" is not true for every case: `ssl_passphrase_command` and a dotted extension setting naming a secret are masked whole. Rotate any password or key that was ever stored this way: the scrub changes the store's current rows only, not copies made before it ran. Upgrade every service that writes to a store - a service still on an old build keeps storing plaintext after the scrub's marker is set, and nothing re-runs it. -- **Eight Queries-tab reads in the web viewer stop their store query when you leave the page** ([#4350]) - get_active_queries, get_plan_corrections, get_query_heatmap, get_query_store_clutter, get_top_queries_by_cpu, get_top_procedures_by_cpu, get_query_store_regressions and get_long_query_completions used to run their store query to the end after the browser gave up on the request. They now stop when the request is abandoned. The tab's duration trends and Query Store top list still run to the end; later PRs convert them. -- **Configuration-tab reads in the web viewer stop their store query when you leave the page** ([#4347]) - Leaving the Configuration tab, or an audit_config read, before it finished left its store query running to the end for a caller who was gone. Those six reads now cancel when the browser abandons the request. The viewer's other reads still run to the end; follow-up PRs convert them. -- **PostgreSQL `pending_restart` can now be trusted after a reload, on Windows targets** ([#4345]) - `pg_settings.pending_restart` is backend-local, so on Windows, where the collector's reconnect-every-cycle model always sees a brand new backend, a setting that had actually been changed and reloaded but still needed a restart could read `false` forever. Unix targets never had this gap: there, the postmaster itself applies the reload and every backend it forks inherits the flag, so `pg_settings` alone was already correct. The collector now also checks `pg_file_settings` on Windows targets, which is read from the file rather than a connection's own state, when the monitoring role can read it (two grants: `SELECT` on the view and `EXECUTE` on `pg_show_all_file_settings()`). `get_pg_server_config` and `get_pg_logging_audit` note when a Windows target's role cannot read it, and say what the two grants expose, so an operator can weigh the trade before granting them; a non-Windows target is untouched and never asked to widen its role for this. -- **Heal the Postgres v8 hardware-sizing block on stores resized before the #4225 fix shipped** ([#4342]) - A managed store whose hardware had not changed since its last hardware-sizing rewrite never re-triggered the heal, so a store that already carried duplicate sizing blocks, or a block written before `work_mem` rejoined the formula, stayed on stale settings even after upgrading past the earlier fix. The heal now also runs when the conf carries more than one sizing block, or when the newest block's content no longer matches what the current build would write. -- **Fleet Sweeps reports an error instead of "no sweeps" when its store read fails** ([#4328]) - A failed read for the sweep timeline, a sweep's verdicts, its would-have-paged ledger, or the watch-item worklist used to log the failure and silently answer an empty list, so the web page showed its normal "No sweeps in this span" empty state and the `get_sweep_reports` MCP tool answered an empty or silently incomplete document instead of reporting that the read failed. Both surfaces now answer the failure: the web page shows its error strip, and the tool answers its usual error status. +- **Web reads honour request cancellation (11 more SQL Server tools)** ([#4393]) +- **The PostgreSQL settings redactor has a bounded matching time** ([#4392]) +- **An armed raw-retention purge no longer runs when PostgreSQL starts, before the service can hold it** ([#4391]) +- **PostgreSQL web reads now honour request cancellation** ([#4390]) +- **PostgreSQL-target MCP reads now cancel on client disconnect** ([#4388]) +- **Web reads now honour request cancellation for 15 more MCP tools** ([#4387]) +- **Web reads honour request cancellation for Alerts, Memory Grants and Health MCP tools** ([#4386]) +- **Threaded cancellation through 10 PostgreSQL-target web reads** ([#4373]) +- **Web reads for object-stats and config-history now honor request cancellation** ([#4372]) +- **Deprecated Dashboard's XE ring-buffer collectors no longer reshred unchanged data** ([#4371]) +- **Bucketed the memory-grant and TempDB usage viewer trend charts** ([#4364]) +- **Bucketed the blocking-trend charts' lock-wait, waiting-task, and blocked-session reads** ([#4362]) +- **Bucketed the CPU scheduler, session stats, and plan cache trend reads** ([#4361]) +- **Blocking and deadlock web reads now cancel with the request** ([#4203]) +- **Health Parser web reads now cancel with the browser request** ([#4359]) +- **Four Performance-Trends web reads now stop their store query when the request is abandoned** ([#4357]) +- **A slow first-run database create no longer fails Darling's Postgres bootstrap** ([#4352]) +- **Passwords and other secrets in stored PostgreSQL settings are now redacted** ([#4351]) +- **Eight Queries-tab reads in the web viewer stop their store query when you leave the page** ([#4350]) +- **Configuration-tab reads in the web viewer stop their store query when you leave the page** ([#4347]) +- **PostgreSQL `pending_restart` can now be trusted after a reload, on Windows targets** ([#4345]) +- **Heal the Postgres v8 hardware-sizing block on stores resized before the #4225 fix shipped** ([#4342]) +- **Fleet Sweeps reports an error instead of "no sweeps" when its store read fails** ([#4328]) - **Lite Overview baseline bands used the wrong hour under a custom time range on a server not on UTC** -- **Dashboard query comparison grids and Server Trends baseline bands now use the server's local time** ([#4321]) - Under a preset time range (not a custom one), the Query Stats, Proc Stats and Query Store "Compare to" grids, and the Server Trends baseline bands, built their current time window from the Dashboard machine's clock in UTC instead of the monitored SQL Server's own local time. On a server not running in UTC, this shifted the comparison grids' "current" window and picked the wrong hour-of-day/day-of-week baseline bucket, by the server's UTC offset. Fixed to use the server's local time, matching the Server Trends ghost-line fix in [#4317]. -- **`get_collection_health`'s default reply now fits the MCP response budget** ([#4319]) - A collector row that -- **Dashboard Overview ghost line reads the right hours outside UTC** ([#4317]) - Under a preset time range, the -- **The Query Store activity slicer reads less history on each refresh** ([#4311]) - The slicer read one extra day of Query Store history below its window, as a margin for clock skew. The margin is now one hour. For the last 24 hours, it now reads 25 hours of history instead of 48. -- **Lite's Overview ghost line reads the right hours outside UTC** ([#4309]) - Under a preset time range, -- **Availability Groups tab no longer freezes the UI every 30 seconds** ([#4308]) - The Darling viewer's and Lite's Availability Groups tabs rebuilt every card and every per-database grid from scratch on every refresh. In the Darling viewer, that blocked the UI thread for over 2.5 seconds on a 42-AG fleet, even when nothing had changed. Refreshes now update existing cards in place, skip entirely when the data has not changed, and only render the cards that are actually on screen. -- **The Daily Summary calendar and `get_daily_summary_range` cache closed days for an hour** ([#4307]) - The WPF Daily Summary calendar (every 1-minute refresh) and `get_daily_summary_range` (the web Overview tab and MCP clients) recomputed every day in the displayed range on every poll, even though days before today do not change. A refresh now recomputes only today (and briefly yesterday, for a late collector run) and reuses the rest from a one-hour cache. A row that lands late for a closed day -- an outage catch-up, a backfill -- can take up to an hour to show, where it showed immediately before; an explicit `as_of` timestamp still always reads live. The cache holds at most 1,024 ranges, and drops entries older than an hour the next time it computes a range. -- **Query Store backfill's candidate check no longer reads old compressed chunks, and no longer drops a hole on a database that goes quiet** ([#4306]) - The backfill's candidate-database scan read across all of raw retention on every check, which decompressed chunks outside the backfill window: measured at 206 ms and over 21,000 buffers per check on a heavy server. It is now bounded at the backfill's own horizon (1.7 ms and 792 buffers in the design measurement). The per-database floor lookup now stops at the first row at or before that horizon instead of taking the minimum over every row. A database that stopped sending Query Store data while a repair "hole" was still open for it used to age out of the backfill scan and never get serviced. It now stays in scope until the hole is filled or expires. Both Lite and the Darling service get the change. -- **The Darling viewer's Wait Stats and Perfmon trend charts read time buckets, not every collection** ([#4304]) - Both charts read every collection in the window on each refresh: for 20 wait types over 7 days at a 1-minute cadence, that was about 170,000 rows. They now read buckets sized to the chart's point budget, which cut the rows returned about tenfold for a 7-day window in the measurement. A bucket's rate is its summed wait (or counter delta) over its summed collection interval. When the budget covers every collection, the chart still gets each raw point at its own timestamp. The wait-type and counter pickers ran a full-window DISTINCT on every 1-minute refresh; they now reuse the list for up to 15 minutes for the same server and window. -- **The Darling viewer's Active Queries grid and wait drill-down no longer load every snapshot's plan XML up front** ([#4303]) - -- **Lite's Queries-tab comparisons use the grid's time window** ([#4302]) - On a server not on UTC, the "Compare to" baseline on the Queries tab read a window shifted by the server's offset. That covers the Top Queries, Top Procedures and Query Store grids. It happened under a custom date range or after a slicer drag. Comparisons now read the same UTC window as the grid beside them. One behavior changes on purpose. After a slicer drag, the baseline is the dragged window shifted back by a day or a week, not the whole preset range. -- **Active Queries and wait drill-down no longer load every plan's XML just to show the grid** ([#4297]) - -- **The query heatmap loads much faster on large windows** ([#4295]) - The heatmap read resolved the query text of every row in the window, then kept one row per cell. Now it resolves the preview text only for the row that each cell shows. The cells, counts, top queries and preview text do not change. On a seeded window of 180,000 rows over 24 hours, the read went from 2,035 ms to 242 ms. -- **Less write-ahead log from the query, procedure and Query Store history tables** ([#4294]) - Five indexes on these tables wrote close to a quarter of the store's write-ahead log. They were read only a few times in several days. They are now dropped. Each feature that read them was timed without its index and stays well within its time limit. -- **Web viewer no longer shows raw error text for failed requests** ([#4293]) - Several pages and API routes answered a failed request with the underlying exception's own text, which could include a PostgreSQL SQLSTATE and message or a store's host and port: saving or deleting a Custom View, an alert rule or a mute rule (including turning a mute rule on or off), running a Custom View panel, the two fleet-sweep reads, a server lookup that could not read the server registry, and the triage page's notes and per-section cards. These now answer a fixed, generic message; the real text still goes to the service log so an operator can see what failed. A statement timeout now answers with a "took too long" message and the right status code in each of these places, matching what other reads already did. The one exception is a Custom View panel's own query error (a syntax error, a missing column, a bad value, or its own statement timeout), which still shows the database's message so the author can fix the panel. -- **Empty legacy baseline aggregates now drop instead of staying forever** ([#4292]) - On a store where nothing ever fed the old `perfmon_baseline` or `wait_stats_baseline` aggregate, both it and its replacement stayed empty. The empty replacement has no oldest bucket, so the old aggregate's cleanup rule never passed. Now an old aggregate that holds no rows drops on the next start, with its refresh, retention and compression jobs. -- **CPU and I/O-latency baselines recompute once a day, not every hour** ([#4291]) - Darling and Lite recomputed these two anomaly baselines every hour. Each time, they scanned 30 days of raw rows. The I/O-latency scan alone spilled about 50 MB to temp. They now recompute once per UTC day, and their 30-day window ends at midnight UTC. A 30-day baseline barely moves within a day. A failed compute still retries within the hour. -- **Fewer needless writes to the Darling store's plan and text tables** ([#4288]) - A plan or text seen again within the hour still cost a row lock and a WAL record. PostgreSQL locks the row before it checks the freshness rule. On production stores, that was 12 to 23 percent of all WAL. The upsert now skips a fresh row before it takes any lock. Separately, the touch that keeps Query Store plan and text rows from expiring re-stamped each row every 6 hours. It now waits 12 hours, which halves those writes. Rows are kept just as long as before. -- **Managed store: less WAL, from compressed full-page images** ([#4287]) - Most of a managed store's WAL was full-page images, written without compression. Every managed store now sets `wal_compression = lz4` on its next service start. In a test burst, that cut WAL by about a quarter. A longer checkpoint interval cuts WAL further, but it can slow checkpoint syncs past the store's own alert bar. So it waits for a production measurement. Bring-your-own PostgreSQL stores do not change. -- **Web failure handling: log batches, bad requests and error text** ([#4286]) - A route cut inside a character made Darling's service log drop its whole 5-second batch. The viewer's, Lite's and the Dashboard's log files had the same bug for any text with a broken character. A malformed or oversized request, or a client that dropped the connection, cost a 500 and an Error line. It now gets its own status and no Error line. A line break in exception text started what looked like a second entry in the service log. Each line is now cleaned before it is written. The read dispatcher and the fleet sweep reads answered some failures with raw exception text, such as a connection error that names the store's host. They now answer with a fixed message and log the detail. Darling's web and MCP hosts now always run as Production, so a stray Development setting on the machine cannot turn on the developer error page. -- **Time-based reads no longer shift on a store outside UTC** ([#4285]) - Every timestamp in the Darling store holds UTC, but a bring-your-own store keeps the session time zone its owner set. Reads that compare those timestamps with the current time shifted by the zone's offset. Their window was wider or narrower than asked, with no error. Every store connection that the service, the CLI and the desktop viewer open now sets its session time zone to UTC. Managed stores already set UTC in their `postgresql.conf`. The service and the viewer also keep a connection-string setting that has an empty value, such as `Password=''`, when they add their own settings. Before, they dropped it, and Npgsql then used the `PGPASSWORD` environment variable or a password file if either one was there. -- **Web viewer timeouts now show a message and get logged** ([#4281]) - A read that ran past the store's timeout used to show a blank error. The service log had nothing, so a timeout looked the same as a bug. Now the page says "The store took too long to answer this read. Try again in a moment." Other failures show a short generic message. For both, the service log records the route, how long the read ran and what kind of failure it was. -- **A major store upgrade keeps your ALTER SYSTEM settings** ([#4280]) - A major PostgreSQL upgrade of the managed store used to drop every `ALTER SYSTEM` setting. A raised `shared_buffers`, for example, went back to the default with no warning. The upgrade now checks each setting against the new version, test-starts the new store with the settings it accepts, and keeps them if that start works. A setting the new version rejects is left out with a warning that names it. If the test start fails, the store starts on its defaults instead, and a warning names each setting it dropped. The logs name settings but never show their values. The original file is kept as `postgresql.auto.conf.pre-upgrade` next to the data directory, so a dropped setting can be re-applied by hand. -- **Lite says when a query window was cut short** ([#4279]) - Three MCP tools read raw tables with no rollup fallback: `get_top_queries_by_cpu`, `get_top_procedures_by_cpu` and `get_query_store_top`. Lite keeps those tables 30 days by default, and a user can lower that per collector. So a long window was read from much less history, with nothing to say so. Each tool now returns `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note` when the window was cut short. The three grids show "Showing since" and the effective start above the grid in the same case, after a time-range change or a slicer drag. On Lite and Darling alike, each tool's short description now explains `window_truncated`. The false line that said Lite always reads the full window is gone. -- **Top-CPU reads disclose a short window** ([#4278]) - Two MCP tools read raw tables that the store purges at 4 days with the rollups on. They are `get_top_queries_by_cpu` and `get_top_procedures_by_cpu`. A longer window came back short, and `hours_back` came back unchanged. Both tools now return `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note`, like `get_query_store_top`. The desktop viewer's Top Queries, Top Procedures and Query Store grids show "Showing since" and the effective start in the same case. The web viewer shows the same note on those panels. On the hourly tier, `window_truncated` and `effective_start` come from a per-server check of where the rollup starts. When the window ends past the rollup's materialization ceiling, the note says nothing after it was read, or that the end edge is not verified when the ceiling is unknown. -- **`get_query_store_top` stays under the MCP response-size budget** ([#4198]): The default call returned about 48 KB, over the 32 KB limit some MCP clients enforce. `query_text` is now a 400-character preview by default. A new `full_text` argument returns the whole statement. A new `query_text_truncated` flag on each row says whether the text was cut. The web viewer is unchanged and still shows up to 2,000 characters. -- **`describe_custom_view_catalog` stays under the MCP response budget** ([#4198]): The Custom Views compose catalog returned 98 KB by default, three times the budget. It now returns a compact, source-grouped list by default (name, purpose, aggregate/unit vocabulary only). A new `source` argument drills into one source's full detail. A new `full_detail` argument returns the complete catalog as before. The web Custom Views editor is unaffected: it reads the full catalog through its own endpoint. -- **MCP `get_collection_health` caps its response size** ([#4198]): A default call on a busy SQL Server fleet reached 41,669 bytes, over the 32 KB limit. Healthy collectors with nothing to report now compact to a shorter row by default. Any failing, stale, stopped, erroring, denied, or regressed collector keeps every field. A new `full_detail` argument restores every field on request. The web dashboard and Custom Views are unaffected. -- **MCP `get_blocking` (Darling) and `get_blocked_process_reports` (Lite) cap their response size** ([#4198]): A default call measured 89,096 bytes on a 30-row test seed, over the 32 KB limit. The default row limit drops from 30 to 15. The blocked and blocking SQL text come back as a 150-character preview instead of a 2,000-character cut, and each has its own `*_truncated` flag. A new `full_text` option returns both texts whole. On Darling, a call with `dedup_key` names one incident, so it always gets the whole text. The web viewer's Blocking table and Custom Views keep 30 rows and the 2,000-character text. -- **MCP get_collection_log stays under the response-size budget by default** ([#4198]) - -- **`get_query_store_regressions` default calls stayed under the MCP response budget** ([#4198]). The -- **get_pg_io_trend's default call now fits the MCP response budget** ([#4263]): The default 24-hour call -- **`get_active_queries` stays under its response-size budget by default** ([#4261]) - A default call on a busy server returned well over the 32 KB target. The number of fields per row and an uncapped query text preview were the cause. The default page size is now 25 rows (was 50). Query text now previews to 500 characters with a `query_text_truncated` flag. A new `full_text` argument opts back into the whole text. The web viewer's Active Queries tab keeps its pre-existing 2,000-character preview. -- **get_index_usage's default answer now fits the response budget** ([#4260]) - A default call, with no `limit` argument, always returned up to 200 rows regardless of width. That measured over 69 KB on a busy server, large enough for an MCP client to refuse it outright. The default `limit` is now 75 on both Darling and Lite. An explicit `limit` still returns exactly what was asked for. -- **`get_query_heatmap` default call stays under the MCP response budget** ([#4259]): A default call returned -- **`get_object_locking` default response stays under the MCP budget** ([#4258]): Before this fix, the tool returned up to 200 locking rows with no row limit. On a busy server it pushed 71 KB, and some MCP clients refused the response. It now returns 75 rows by default, highest contention first. It reports `truncated`/`objects_returned` when there are more. Pass `limit` for more rows, up to 1000. -- **`get_plan_corrections` default call stays under the MCP response budget** ([#4198]): A default call returned nearly 100 KB on a busy server. Each row carries 20+ fields and the query text ran to 2,000 characters. The text preview is now 150 characters. Each row gets a `query_text_truncated` flag and a `full_text` opt-in. The default row limit dropped from 50 to 25. -- **Job History loads faster and stops polling every 30 seconds** ([#4256]): The tab used a window function -- **Availability Group reads: bounded the newest-snapshot lookup** ([#4228]). All five AG reads used an -- **`get_deadlock_detail` no longer returns oversized deadlock graphs by default** ([#4254]) - The tool's `deadlock_graph_xml` field could push a default call past 100 KB, because each graph runs tens of kilobytes and the tool did not cap that field's size. It now previews each graph to 2000 characters by default and marks it `deadlock_graph_xml_truncated: true`. A new `full_graph` argument returns the whole graph. A `dedup_key` call, naming one incident, always returns it in full. -- **Database Sizes and Storage Growth load without a multi-chunk planning tax** ([#4252]): The latest snapshot reads had no bound on collection time. PostgreSQL had to plan a step for every retained chunk before running each read. Each read now resolves the snapshot timestamp in a separate step first. The main read then skips chunks it does not need. Clock skew between reader and collector does not drop the latest snapshot. -- **Alert triage links now skip only a disabled dashboard, and email carries one too** ([#4230]) - the per-alert triage-page link (`web.publicBaseUrl`) used to go out even when the dashboard was off, and the web host rejected every request naming the DNS host that setting suggested using. The link is now omitted only when the dashboard is disabled. The web host accepts that configured host. Alert email now carries the same link the other channels already did, in both the HTML and plain-text bodies. -- **PLAN_REGRESSION no longer deduplicates the whole raw Query Store slice every pass** ([#4208]). On a store ingesting many servers' Query Store data, the plan-regression check was the single heaviest statement in the store. It spent most of its time sorting and spilling the server's entire raw Query Store history to temp files. This adds store schema rung V143, the `collect.query_store_interval_latest` table, holding only each interval's latest snapshot. The check now reads that table and falls back to the old full read only when coverage is incomplete for a server. Findings are unchanged: the same regressions, the same snapshots. -- **Force-plan bot no longer acts on a best plan older than 4 days** ([#4208]). The unattended force-plan bot now gates on `ForcePlanBotPolicy.MaxBestPlanAgeDays` = 4. A target whose best plan has not been seen in more than 4 days is blocked with reason `best_plan_stale`. This prevents a force on a plan the server evicted. The gate value is pinned by `ForcePlanBotPolicyTests`. -- **`audit_config` no longer runs the full analysis pass** ([#4206]). It read a full ~30-family collection, detector and scorer pass just to answer 8 point-in-time configuration facts, measured at 7-15 seconds per call. It now runs only the specific family reads those 8 facts come from. The facts and recommendations returned are unchanged. -- **`get_query_store_regressions`' comparison baseline is now a fixed 7 days** ([#4206]). The baseline used to be every Query Store capture the store retained before the requested window. Both cost and the comparison period grew with retention. It is now a fixed 7-day lookback ending at the window's start, reported as `baseline_start` and `baseline_end` in the response. A regression against something that changed more than 7 days before the window is no longer caught. A store retaining less than 7 days is unaffected. Performance Monitor Lite's own copy of this same tool had the same unbounded baseline and is fixed the same way. -- **`get_pg_cpu_utilization` now returns bucketed points instead of one row per minute** ([#4206]). A wide window (a week, or longer with the V136 host-memory columns) returned several megabytes per call. It now buckets to a point budget the same way the rest of the trend family does. It averages CPU/ACU per bucket while keeping each bucket's peak. The worst (not average) memory-pressure sample per bucket is kept, so a brief spike is not smoothed away. -- **The desktop viewer's Query Store Regressions grid had the same unbounded-baseline shape as `get_query_store_regressions` and is now bounded the same way** ([#4206]). It was a third, separate copy of the defect, in the WPF app rather than the MCP surface, with its own 7-day fixed lookback. -- **The deadlock and plan-capture log patterns only offer a report whose ERROR: is the line's own label** ([#4042]) - A crafted SQL statement that echoed "ERROR: deadlock detected" plus a tab-continued DETAIL line matched the deadlock pattern through to the line's real process-id bracket. Measured end to end this forgery stored nothing, because the log assembler already takes a report's label from the line it actually came from, and new tests pin that for both the SQL and C# copies of the pattern. Both copies are narrowed anyway, matching the rule behind them exactly: the gap before ERROR: and DETAIL: can no longer cross another field's label, and the managed log-prefix family's gap to the process-id bracket can no longer slide past the real bracket into a statement's text (the same fix #4016 made for plan capture). Fewer forged lines are offered as candidates at all. -- **Plan capture keeps working under a custom log prefix with fields before the process id** ([#4016]) - Plan capture required exactly one token between the timestamp and the process-id bracket in log_line_prefix. A self-hosted prefix with more than one field there (for example '%m %u@%d [%p] %Q ') matched nothing, so those stores silently stopped capturing plans. The gap before the process id now allows any number of fields, as long as none of them is itself a bracket, so a forged log line behind the real bracket still cannot be read as a plan. -- **Trace flag reads no longer hide every enabled flag after an ordinary run** ([#4032]) - get_trace_flags, the web viewer's Trace Flags grid, and Lite's equivalent compared the newest captured row's timestamp against the newest successful run's timestamp, but Darling stamps a run's collection-log row when the run ENDS, after its capture rows are written - so that comparison read false after every ordinary run and hid every enabled flag. All three reads now keep the newest capture unless the newest successful run explicitly captured zero rows (which means every flag is off); a failed run, or one with no row count, keeps the reading from before this fix. -- **The fleet card's collection-health figures no longer reread a week of raw log rows on every call** ([#3911]) - The seven-day fleet-wide collection-health read decompressed six of its seven days of collection_log on every call. It now reads from a new hourly rollup instead, cutting the read down to the buckets it needs. The fleet card's numbers are unchanged; only how they are produced is faster. -- **The per-server collection-health summary stops leaking memory and stops going stale on a fleet with more than one active caller** ([#3900]) - The health memo keyed its cache on the window's start time, which two calls a few seconds apart would each compute freshly, so the cache never hit in production and grew without bound as more distinct start times accumulated. It now keys on the window's length, so calls asking the same question in different moments share one cached answer and old entries age out. -- **A collector that produced then stopped no longer reads healthy with zero rows** ([#3889]) - Collection health banding keyed a regressed collector's WARNING floor on the collector's STATUS word rather than on whether it was actually producing output, so a collector whose query still ran and still returned SUCCESS - just with zero rows, after previously producing rows - kept reading HEALTHY indefinitely. On one production server this hid a stopped collector for up to two weeks and over 1,900 consecutive zero-row successes. Banding now also watches for a productive collector's output falling to zero for three or more consecutive runs, and reports it as regressed. A collector whose normal resting state is zero rows (an event capture with nothing to report) is unaffected. -- **job_history collection survives an msdb reseed** ([#3886]) - The collector deduped job-history rows against a stored high-water mark taken from the target's job-history identity column. A maintenance window that purges msdb's job history also resets that identity to a lower value, so the stored watermark (in the millions) outlived the identity it was taken from (back in the thousands), and the collector's filter matched nothing from then on - forever, on that server, with no error. The watermark now yields to a bounded time window whenever the target's current identity max falls below the stored watermark, the regression is logged once, and job history collection self-heals on its next run without intervention. -- **The compression-stuck self-alert no longer pages on a healthy job's own run instant** ([#3588]) - TimescaleDB's job_stats view assembles job_status from pg_stat_activity and next_start from the background-worker job-stat row, so for a moment at both edges of every healthy run one read sees the same shape as a genuinely dead job (next_start = -infinity while the schedule still reads Scheduled). A production store paged on exactly that, 53 ms into a 63 ms run that went on to succeed. The check now re-reads five seconds after a -infinity trip and only reports the job if the trip still holds; a failed confirmation defers judgement to the next hourly check rather than paging. The hourly check itself is now snapped to :30 past the minute instead of drifting a few seconds later each time, keeping it off the fixed-schedule policies' own :00 run instants. -- **pg_deadlocks reads a self-hosted target's csvlog file, closing the same forged-line hole #4124 closed for pg_log_events** ([#4136]) - pg_deadlocks only read stderr-format log text. A target with csvlog but not stderr in log_destination produced no deadlock rows at all. A target with both was open to the same forged-line risk #4124 describes for pg_log_events. A failed login can plant a newline into a logged name. Unquoted stderr text turns that newline into a fake extra line. pg_deadlocks now parses the target's own .csv file as CSV when log_destination includes csvlog, the same forger-safe, whole-record join #4124 built. A planted newline now stays inside its own quoted field instead of becoming a fake deadlock. This change leaves pg_log_events and plan capture as they were. #4137 covers plan capture. -- **pg_plan_capture reads a self-hosted target's csvlog file** ([#4137]) - pg_plan_capture only read auto_explain plans from stderr-format log text. A self-hosted target with csvlog but not stderr in log_destination captured no plans. pg_plan_capture now reads the target's own .csv file when log_destination includes csvlog, through the same whole-record CSV parser #4124 built. It takes the query id from csvlog's own query_id column. The stderr route is unchanged. -- **Darling's daily retention purge no longer holds up collection** ([#4133]) - The purge ran inside the loop that starts each server's collection, and the loop waited for it to finish. A slow purge, 346 to 400 seconds on a large store, stalled collection for every server for that long. The purge now runs in the background, and a new purge never starts while one is still running. -- **Lite's get_index_usage no longer hides active indexes behind a silent cap** ([#4131]) - This MCP tool capped at 200 rows server-wide, with no way to ask about one database, no way to raise the cap, and no sign when rows were cut. Since unused indexes always sort first, a server with many unused indexes in one database could fill the whole answer with them, hiding every active index elsewhere, with a result that looked identical to a collection failure. It now takes a database_name filter and a limit, and reports matching_index_count and truncated so a short answer is never mistaken for an empty one. Darling's twin tool has worked this way since #2636. On Lite, Darling and the Dashboard, indexes of the same size now sort by name, so a capped answer keeps the same rows from one call to the next. An index with no recorded size, and a heap's missing index name, now sort last on all three products; Darling used to put an index with no size first. -- **pg_log_events reads a self-hosted target's csvlog file, closing a forged-line hole** ([#4124]) - Before this change, pg_log_events only read stderr-format log text. A target with csvlog but not stderr in log_destination produced no log events at all. A target with both was open to a forged line. A failed login plants a newline into a logged user or database name before authentication runs. Stderr text has no quoting, so the planted newline becomes a second, fake log line. pg_log_events now parses the target's own .csv file as CSV when log_destination includes csvlog. A planted newline inside a quoted field stays inside that field, never becoming an event of its own. Deadlocks, plan capture and the RDS route are unchanged. -- **Two install-lock tests pass on a non-elevated machine** ([#4111]) - After #4090, two `DarlingInstallLocationTests` tests failed on every non-elevated local run. There the lock cannot create `pg-runtime-prev\`, as designed, and the tests read that directory's ACL anyway. The tests now check the elevated and the non-elevated outcome separately. The elevated checks that CI runs are unchanged, and no product behavior changed. -- **MCP tool schemas no longer list an internal service as a parameter** ([#4110]) - A race in .NET reflection sometimes put a service the app supplies itself, such as the PostgreSQL connection, into tools/list as a tool parameter. It happened when two threads built the same tool's schema at once. Tool schemas now leave out every parameter whose type is a registered service. -- **Log reads through pg_read_binary_file now decode text in the database's own encoding** ([#4106]) - This route used to decode every PostgreSQL log tail as UTF-8. It now uses the connected database's server_encoding: every LATIN and ISO_8859 variant, WIN866, WIN874, WIN1250 to WIN1258, KOI8R, KOI8U, EUC_JP, EUC_CN, EUC_KR, UTF8 and SQL_ASCII. A database in one of those encodings no longer has to fall back to the text route, where one bad byte can stop the read. -- **Store Checkpointer Pressure no longer fires all the time on a healthy store** ([#4096]) - The alert compared the checkpoint sync time summed over the whole interval against a limit meant for one checkpoint. A store whose checkpoints each took a few seconds to sync breached it every hour. It now judges the average sync time per checkpoint, and a checkpoint forced by WAL volume still fires it. The alert and get_store_metrics now report the checkpoint count and the average. This adds store schema rung V140, the checkpoints_timed column on store_metrics. -- **A planted line in a PostgreSQL server's log can no longer stop plan capture** ([#4089]) - A client that fails to log in with a crafted name can put text into a PostgreSQL target's server log. A fake plan-capture line with an out-of-range query id or duration used to fail the whole read. That hid every real plan in the log tail. Darling now skips that line, counts it (forged_captures_skipped), and reads the real plans. On the pg_read_binary_file route, the deadlock and plan-capture readers also skip their pattern search when the tail holds no line they look for. -- **A Lite Query Store test that never ran now runs** ([#4084]) - The test that checks that the module filter runs after interval dedup had no [Fact] attribute, so xUnit never ran it. It now runs and passes. No product behavior changed. -- **A PostgreSQL log in a non-UTC zone no longer reports a deadlock problem on the log events collector** ([#4070]) - When log_timezone is not UTC, the log events and deadlock collectors store nothing from the server log and record why. That message said "deadlock reports" and "NOT 'no deadlocks were detected'" on both collectors. It now names the log, says that the log is not empty, and still tells you to set log_timezone = 'UTC'. -- **The install and upgrade scripts name each account once in a refusal** ([#4069]) - A folder made under `C:\` inherits two entries for `BUILTIN\Users`. One allows appending data, and one allows writing it. The [#4050] refusal listed `BUILTIN\Users` twice for the same folder. It now lists each group or account once for each folder. -- **One bad byte from a failed login no longer blinds the three PostgreSQL log readers, and RDS and Aurora targets get the time-zone fix too** ([#4051]) - A client that fails to log in with a crafted role or database name plants one invalid character in the server log. That character used to stop deadlock capture, plan capture and log-event collection from reading the server log until it aged out. Grant the monitoring role EXECUTE on `pg_read_binary_file`. Then, on a UTF8 or SQL_ASCII database, Darling reads the log in a way that tolerates the bad character. On other encodings, the error message says that the grant does not help there. While that grant is missing, Darling reminds you once a day. RDS and Aurora targets whose `log_timezone` is UTC now skip a planted line that is stamped in another zone, instead of refusing the whole read. Self-hosted targets already did this. -- **Darling's install and upgrade scripts refuse a folder that ordinary users can already write to** ([#4050]) - When you extract the zip into a folder made directly under `C:\`, the folder inherits write access for every signed-in user. The #4038 lock stops writes only from the moment that it runs, so it could never catch a binary that was swapped before then. `install-darling.ps1` and `upgrade-darling.ps1` now check every file in the tree, and the existing install, before they change anything. They name who can write to the tree, and each folder that they cannot look inside. Then they refuse, unless you pass `-AcceptWritableExtraction` for a deliberate dev loop. An upgrade copies its zip to an administrators-only folder and verifies the zip there before it extracts anything. Every doc and message now names `C:\Program Files\PerformanceMonitorDarling` as the install folder. This includes the refusal for a folder inside a user profile, which used to send people to a folder that this check refuses. -- **A planted log line in another time zone no longer stops a PostgreSQL server's log events and deadlocks from being read** ([#4049]) - Before this fix, one line stamped in a zone other than UTC anywhere in the log tail made Darling refuse every log-event and deadlock read of that server, for as long as the line stayed in the window. Any client that can reach the port can put such a line there with one failed login, because %u and %d in log_line_prefix echo the requested role and database names unescaped. Now the self-hosted readers check the server's own log_timezone in the same query. When it is UTC, a line in another zone cannot be the server's own: it is skipped and counted on the collection log row, with a note naming log_timezone and #4046, and the read goes on. A server whose log_timezone really is another zone is still refused, as before. RDS and Aurora read the log through the AWS API, cannot check the setting, and are unchanged. Plan capture never read the zone and was not affected. A failed login whose role name carries a byte that is not valid UTF-8 still makes the server's pg_read_file fail for the whole window, under any prefix. [#4051] in this release covers that when the monitoring role has EXECUTE on `pg_read_binary_file`. -- **PostgreSQL servers whose log prefix puts fields before the pid now show their log events and deadlocks, and a client's port is no longer stored as an event's SQLSTATE** ([#4047]) - Under a log_line_prefix such as '%m %u@%d [%p] ', the log reader matched no line, so the server stored no log events and no deadlocks and looked quiet. It now reads fields between the zone and the pid, and it still takes the pid from the first bracket and the label from the line itself, so text inside a statement cannot open an event. The self-hosted deadlock read also stopped missing reports under '%t' prefixes (pgBadger's recommended one) and colon-delimited prefixes. Under any prefix with %r, the RDS default among them, the client's five-digit port was read as the event's SQLSTATE, often one in the resource or system-error classes. Now the port inside %r is ignored. A bare five-digit %l, %x or %v in the prefix can still be read as a SQLSTATE. Telling those apart from %e needs the target's own log_line_prefix. -- **On Windows the log-hash key is refused if anyone beyond SYSTEM, Administrators and the service account holds any right to it, and it is checked and read through one held file handle** ([#4044]) - The key was trusted through the check it shares with the credential files. That check refuses only a file Users, Authenticated Users or Everyone can read, so INTERACTIVE, Domain Users or a single named user with read access passed it, and so did an account that could write the key or change its permissions. That account could plant a key of its own or grant itself the read, and then test guesses against the stored log hashes. The key is now held to an allowlist of the three accounts the service writes, for every right. It is opened once in a way nobody else can rename, replace or write while it is open, and it is refused if it is a link or has a second name. Its owner and permissions are checked through that same handle, and the read is capped at 1 KB. When a key is refused, log events stop being collected and the refusal names the accounts to remove. -- **A PostgreSQL server that logs only to CSV is reported by name instead of looking quiet** ([#4040]) - With log_destination set to csvlog, PostgreSQL still leaves a small stale stderr-format file in its log directory, and the plan, deadlock and log-event collectors read that file every cycle and reported a server with nothing to say. They now check log_destination itself and report that it has no stderr output, with the one-line fix (add stderr and reload, no restart needed). -- **Install and upgrade lock the Darling install folder, so an ordinary local user can no longer replace the service's binaries** ([#4038]) - The documented install location, a folder made directly under C:\, inherits write access for ordinary local users from the drive root. On Windows client editions that is Modify for every authenticated user, so any local user could replace the service exe, a DLL, or the bundled postgres.exe and have their code run as the service account. install-darling.ps1 now locks the folder before anything runs from it: it stops the folder inheriting, removes the broad groups, makes Administrators the owner, closes any write grant a user left on a file of their own, and grants back read and execute to Users and Modify to the service account only. upgrade-darling.ps1 applies the same lock as soon as the service stops, so an existing install is closed at its next upgrade, and anything that stays open is named with the command that fixes it. -- **The hourly re-mask of PostgreSQL deadlock data stored before #4005 now runs without a log-hash key, covers finding alerts, and never leaves a raw report hash behind** ([#4036]) - a service with no usable log-hash key (an untrusted key directory or ACL, an unreadable key file, or DPAPI after the service moved machines) skipped the whole re-mask, so raw SQL literals stayed in deadlock reports, alerts and findings for their full retention. Now everything is re-masked and only re-keying an alert whose report is gone waits for a key. Analysis finding alerts sent before #4005 kept a raw report hash and the raw victim statement in their stored detail, which the Viewer's alert detail showed. They are rewritten from the finding, or withheld once the finding is gone. A finding whose deadlock fact sits behind its root is rewritten too. An alert missed by the pass is keyed rather than keeping its raw hash, a stage that gives up is retried a day later instead of waiting for a restart, a page cut short by the hourly budget, or a row moved by a dismissal or VACUUM FULL, can no longer end a walk early with a row still raw, and with a log-hash key no raw report hash is sent to the store as a query parameter, where log_min_duration_statement would copy it into the store's own log. An alert is never cut from its report by the order the pass rewrites them in, and a finding alert is rewritten only from the analysis run it was sent for, never from a later run of the same story. Each hourly pass works through pages until its 60-second budget. On a test table of 120,000 compressed rows (20,000 reports, each seen 6 times), one pass rewrote about 5,500 reports. The whole table took about 4 passes. Once every row was rewritten, a walk of the whole table took 2.7 seconds. The README says precisely what is rewritten: pg_log_events rows from before #4020 keep their old hash until their 30-day retention drops them. -- **On compose, a log-hash key or role password planted in a credentials directory that was open to other users is discarded instead of trusted, `--harden-files` no longer follows a junction or a hard link, and the Viewer's always-empty Statement Fingerprint column is gone** ([#4031]) - Each file the service read judged the credentials directory on its own, and role provisioning set the directory owner-only before the log-hash key loaded, so a key planted while a bind-mounted directory was world-writable was trusted and kept, letting whoever planted it test guesses against the stored log hashes. Worse, a start that closed the directory but never provisioned (a store that was down, or a crash) left a planted admin password for the next start to re-assert on the admin role. Now whichever check first finds the directory open to other users' writes removes the role passwords and the key there and then, logs it as an error, and new ones are generated. The first `pg_log_events` run after a replaced key says so on its Collection Log row. Every credential name is tried, so a directory planted at one name no longer shields the files at the others. A directory with something in it is left alone, the credentials directory stays owner-only, and that start uses nothing in it and names each path to remove. Run one service per credentials volume (on Kubernetes, `strategy: Recreate`). `--harden-files` now covers the log-hash key, refuses (exit 1) any target reached through a junction or symbolic link, or a file with a second name (a hard link), instead of rewriting whatever it points at, checks every folder on the path when darling.json sits at a volume root, and only touches `darling-keys` on a bring-your-own install, where it is the key's directory. A directory left where the key's temporary file goes is now named as the reason instead of "it did not exist". The PostgreSQL log grid no longer shows a Statement Fingerprint column that could never fill, and the key is flushed to disk before it is renamed into place. -- **Trace flags could show a flag as enabled days or weeks after it, and every other flag, was turned off** ([#4030]) - get_trace_flags, the web viewer's Trace Flags grid, and Lite's equivalent all read the newest trace_flags row to decide what is currently set. A capture that finds every flag off writes no row at all, so the read silently fell back to an older capture that still had a flag on. Both surfaces now also check the trace_flags collector's newest successful run in the collection log, so a capture that found nothing on is recognized as current and reports no flags instead of a stale one. -- **On-load collectors could read HEALTHY forever even after their daily reschedule silently broke** ([#4029]) - server_config, database_config, database_scoped_config, trace_flags and server_properties are on-load collectors: they capture on every connect, and since #3929/#3930 also recapture once a day. Collection health banding still exempted them from every staleness check, so a daily reschedule that quietly stopped firing kept reading HEALTHY as long as its historical runs were all successes. These five collectors now band on the same STOPPED/FAILING/STALE ladder as any other collector, at their daily cadence, on the collection health grid, the fleet overview and the get_collection_health tool. -- **The PostgreSQL log tail could pick the csvlog or jsonlog file instead of the real log** ([#4025]) - On a target logging to both stderr and csvlog or jsonlog, the shared reader behind plan capture, deadlock capture and log events picked whichever file had the newer timestamp, and a csvlog or jsonlog file could win the tie. Its contents do not look like an ordinary log line, so the cycle read nothing and reported the target as quiet instead of naming the real file it needed. The tail now always reads the real log file, and a target with no such file gets a clear, named result instead of a silent miss. -- **PostgreSQL deadlock reports, deadlock alerts and analysis findings stored before the SQL normalization are rewritten in place** ([#4022]) - Since the deadlock SQL was normalized, every read showed older data normalized, but the stored rows kept their raw queries and a hash over the raw report: deadlock reports for their 90 days, deadlock alerts fired before the fix in the alert history, and analysis findings in their deadlock drill-down for 30 days, all readable by any role with a direct SELECT such as the MCP login. The service now rewrites them in small hourly slices. Each report takes the text every read already showed and the current identity, so its sightings group with newer ones. Each alert takes the incident the live alert builds today, and each finding takes what its read already showed. Only rows still raw are touched, a second pass changes nothing, and no store migration is needed. -- **PostgreSQL log events are identified by hashes keyed with a per-store secret, so a store reader can no longer test guesses at the values a log line hid** ([#4020]) - `pg_log_events` stored `raw_line_hash` and `statement_fingerprint` as plain SHA-256 over text a store reader can mostly rebuild, so anyone who could read the rows could test candidate values offline. A review recovered a four-digit PIN in 6 ms. Both are now HMAC-SHA-256 under a 32-byte key the service generates once and keeps outside the store: DPAPI-protected beside the managed credentials, in the `darling-credentials` volume on compose, and in `darling-keys` beside `darling.json` on bring-your-own, owner-only in each case. The service never replaces an existing key. If the key file cannot be trusted or read, log-event collection stops with an error that names the file and says how to fix it or delete it to rotate. No tool or web view returns either hash any more (`statement_fingerprint` left `get_pg_log_events` and the log tab). Rows stored before the upgrade keep their old hashes until retention drops them, so each log entry still in the overlap window is stored once more, and each statement's fingerprint changes once. -- **Plan capture could be spoofed by a statement's own author** ([#4015]) - Plan capture matched auto_explain's plan header anywhere in the server log, not just at the start of a real log line. PostgreSQL echoes a rejected statement back verbatim after a syntax error, so a user who could run SQL on a monitored target could write a fake header into their own query text and have it read back as a real captured plan, attached to any query id and duration they chose. Both the plan parser and the self-hosted collector's SQL now require a genuine log-line prefix immediately before the header, so only PostgreSQL's own auto_explain output can produce a stored plan. -- **PostgreSQL deadlock reports store and show their SQL normalized, and no read returns a hash of the raw report** ([#4013]) - The deadlock collector stored each report's queries and the victim's statement exactly as PostgreSQL wrote them, literals included, and get_pg_deadlocks, get_pg_deadlock_detail, the web and desktop viewers, the deadlock alert's email and webhook bodies, and the analysis drill-down returned them that way. Every query is now put through the same normalizer as the log events before it is stored: each literal becomes ?, and a query cut inside a literal is withheld. Every read also normalizes reports stored before this change, including stored analysis findings. The report hash, which could be used to test guesses at the hidden values, is now computed over the normalized report, and an older report is named by its time and process ID instead. A logged statement that quoted a deadlock message is no longer stored as a deadlock, and the graph panel now shows the newest reports first. -- **Analysis passes stop recomputing every 30-day baseline on every pass** ([#4011]) - Each scheduled analysis pass built its baselines from scratch. That meant 9 to 12 thirty-day store reads per server per pass, and on a 31-day test store they were 76 to 94 percent of a pass's time. `analyze_server` and `compare_analysis` then read the same baselines again. The Darling service now keeps one shared set of computed baselines for its scheduled passes, its MCP server and its web dashboard, so a baseline is read from the store once per analysis hour between them. A second pass in the same hour read none. On the test store, a PostgreSQL target's pass fell from about a second to between 36 and 301 ms. Only successful reads are shared, so one caller's timeout cannot hide another caller's baselines. The baseline window now ends on the analysis hour instead of the analysis minute, which is what makes a shared baseline identical to a fresh one. Lite gets the same fix for its scheduler, MCP server, Recommendations tab and overview charts. -- **CPU scheduler readings no longer flicker between two answers when a collection lands on a duplicate timestamp** ([#4010]) - A run-overlap or clock-resolution collision could occasionally store two different cpu_scheduler_stats snapshots under one collection_time. Every reader that shows the current scheduler reading, the fleet card's Threads chip, get_cpu_scheduler_pressure, the CPU Scheduler viewer tab and overview, and the RUNNABLE_TASKS analysis fact, picked between the two snapshots with no tiebreak, so the value could change from one refresh to the next with nothing actually changing on the server. Collections are now stamped so this cannot happen going forward, and every affected reader in both Darling and Lite breaks a tie deterministically, correcting reads of rows already stored this way. -- **The rest of the trend family now buckets to a point budget instead of returning every collection** ([#4007]) - get_wait_trend, get_cpu_utilization, get_tempdb_trend, get_memory_trend, get_perfmon_trend and get_pg_query_duration_trend used to return one point per collection, so a week of one-minute data ran from 160 KB up to 2 MB depending on the tool. They now bucket to the same roughly 200-point budget the file I/O, lock wait and duration trends already used, with an optional bucket_minutes to ask for a specific width. A week of get_tempdb_trend is now under 50 KB by default instead of nearly 2 MB, with the same shape of change across the other five. get_memory_trend's memory-grant figures also switched from matching the nearest grant snapshot within 30 seconds to averaging every grant snapshot inside a point's bucket, which answers correctly for a bucket that spans several snapshots instead of picking one arbitrarily. -- **get_pg_io_trend's automatic subject choice no longer scans the whole window in order** ([#4003]) - Calling get_pg_io_trend without a backend type or context asked it to sort every pg_io_stats row in the window before picking which one to follow, which took nearly 4 seconds over a week on a busy TimescaleDB store. It now reads each candidate's starting and ending values instead, which answers in a fraction of a second and still falls back to the exact original method whenever a counter reset could make that shortcut wrong. The chart it draws does not change. -- **Custom alert rules now evaluate on the Linux compose store** ([#4002]) - On the compose distribution, a user could author custom alert rules in the web dashboard, but they were never evaluated and never fired, since the evaluator only ever built its metric-reading pool from a managed Windows store's credential. The evaluator now reads with the compose store's least-privilege viewer role, which [#3983] set up for the web dashboard. Its rules now fire like any other. A bring-your-own store is unaffected: its rules still do not fire, since its viewer role does not have the resolve function the evaluator needs. -- **On-load config collectors recapture daily, so a long-lived connection keeps fresh config facts and a cleared trace flag actually clears** ([#4001]) - server_config, database_config, database_scoped_config, trace_flags and server_properties captured once per connect and never again while the connection stayed healthy. A server connected for more than 30 days lost its only capture to the 30-day retention purge, so CONFIG_*, DB_CONFIG, TRACE_FLAGS and the config audit had nothing to read until the next reconnect. Separately, TRACE_FLAGS took each trace flag's latest row across all retained history with no time bound. DBCC TRACESTATUS(-1) lists only flags that are currently on, so a flag turned off never got another row to supersede its stale ON one, and it kept reporting as enabled for up to 30 days after being turned off. Both SKUs now also re-run the on-load collectors on a daily cadence, in addition to on connect, so a long-lived connection's snapshot never gets close to aging out of retention. TRACE_FLAGS now reads the newest capture inside that same daily-aware window (about two days at the shipped cadence), so a flag turned off drops out at the next daily capture. When every flag is off, a capture writes nothing, and the window bounds the fallback to the capture before it. An operator's own schedule override for any of these collectors is unaffected. -- **get_store_metrics reads each store object's newest sample through an index instead of sorting a year of rows** ([#3998]) - The store-metrics latest read took each object's newest row with a DISTINCT ON over the whole `collect.store_metrics` table. The table keeps 400 days of hourly sweeps, and the only index was on the time column, so every call sorted every retained row: 7.8 seconds and a sort spilling to disk at full retention on a CI-sized store, and growing for over a year after a store is created. The read now steps from one object to the next through a new `(object_kind, object_name, metric_time DESC)` index and takes each object's newest row directly. The answers are identical, and the same read at full scale takes 19 ms. -- **list_servers and the per-server summary tools no longer plan a store's whole collection history to find one timestamp** ([#3995]) - list_servers, the Overview summary card, and the get_server_summary tool each read a server's newest collection with a query shape that forced TimescaleDB to plan every retained day of history before returning an answer that takes a fraction of a millisecond to compute. These reads now use the same fast per-server lookup the sidebar's freshness indicator already used, so a store that has run for months answers just as quickly as a brand new one. Answers are unchanged: a server that has gone dark still reports correctly. -- **PostgreSQL config and logging-audit tools no longer plan a year of chunks to read one row** ([#3992]) - get_pg_server_config, get_pg_logging_audit and the PostgreSQL config panel read the newest configuration snapshot with no lower bound, so on a store that had run for months TimescaleDB spent seconds planning every retained daily chunk before returning an answer that took milliseconds to compute. These reads now bound the same way the collector's own config reads already did, planning only the last day's chunks and falling back to the full history only for a target whose collector was dark for a while. Answers are unchanged. -- **A store with no readable server-log directory keeps its hourly collector-cost flush** ([#3985]) - The store-log capture's own catch kept its failure from stopping the hourly tick. But Npgsql closes the connection outright on the capture's error, so the re-mask and the collector-cost flush that ran next on that connection failed with "Connection is not open". That happened every hour on a store with no log directory, which is the Linux compose store's shape, and `get_collector_cost` never got a row there. The connection is now reopened before either runs. A capture the store will never allow (no log directory, or a login without the log read) now warns once per process instead of every hour, and `get_store_log` still reports the gap. Separately, the sizing pass gets its own narrow catch, so the next statement a store permanently rejects there can no longer take the store-log census and the collector-cost flush down with it. -- **Lite's daily summary starts its retention horizon where Lite's history actually starts** ([#3984]) - `get_daily_summary` and `get_daily_summary_range` put the retention horizon on the archive cutoff day, three months back. The archive cleanup deletes a whole month's file once that month falls before the cutoff, so the days between the cutoff and the next month start were already gone. Those days were judged as retained with no data instead of purged, and `retention_horizon` read up to a month earlier than the data really goes. The horizon is now the first month start the cleanup keeps, the same instant the Overview freshness band uses since [#3975]. -- **The web dashboard and the MCP server no longer connect to a compose or bring-your-own store as its owner** ([#3983]) - Outside managed mode both hosts used `postgres.connectionString`, the collection login, which owns the store. So a web session or an MCP token-holder there had none of the `viewer`/`mcp` roles' protections: no secret-column carve over the SMTP password, webhook URLs and stored server passwords, no narrow write grants, and no `statement_timeout` backstop. The README said they had all three. Three changes follow Erik's ruling on #3914. First, the Linux compose store provisions the `admin`, `viewer` and `mcp` roles itself, the way a managed store does, and the two hosts connect as `viewer` and `mcp`. The service recognizes that store as its own because its login is the store's bootstrap superuser (`POSTGRES_USER`) and the cluster holds no other database, so nothing needs configuring and an existing compose deployment gets the roles on its first start with the new image. The generated passwords are one owner-only file per role in a new `darling-credentials` volume. The roles carry their own marker, `darling-compose`, so the service never re-keys a role `provision-roles.sql` created; a same-named role it did not create is left alone. When a start does not provision the roles (a refusal, a failure, or a collector that stopped first), each surface keeps its role with the credential an earlier start wrote, and falls back to the owner, with the reason, only when there is none. Every start also switches off the roles' widening attributes and revokes any role membership granted to them. Second, a bring-your-own store gets two optional settings, `postgres.webConnectionString` and `postgres.mcpConnectionString`, in the same forms as `connectionString`. Left unset, a surface connects as the owner and the service warns at startup that it gives up the carve, the narrow write grants and the backstop. `provision-roles.sql` now creates the `mcp` role too, with managed's grants and carve, and gives `viewer` the `custom_alert_rules` write it was missing, so the web rule editor works when pointed at it. Third, a fresh managed or compose store let the MCP tools read the continuous aggregates only after a restart, because they are created after provisioning and `mcp` had no default read on `collect`; it now has one, SELECT on `collect` only. The README, `get_store_query_stats` and the instructions now describe the owner-identity behavior accurately. -- **A fresh store's fleet overview and web Fleet page work before the collection-health aggregate materializes** ([#3981]) - On every new TimescaleDB store, `get_fleet_overview` answered "Out of range of DateTime" and `/api/fleet` returned a bare 500, so the web dashboard's Fleet Overview and sidebar were broken until `collection_health_hourly` had materialized something. That meant until collection had rows and an hourly refresh had covered them, because a refresh over an empty log leaves the aggregate unmaterialized. The reader guarded the aggregate's watermark with `isfinite()`, expecting "nothing materialized" to read `-infinity`. TimescaleDB reports the minimum finite timestamp (4714 BC) instead, and Npgsql cannot hold that as a date. A watermark earlier than 2000 now reads as nothing materialized, so the collection-health half is read in full from the log, as designed. A guard read the client cannot convert now falls back to the raw scan instead of failing the overview. -- **Latest-value lookbacks follow the collector's cadence, and the PostgreSQL target's config reads stop planning every retained snapshot** ([#3980]) - [#3931] bounded the analysis latest-value reads to a day, but collector cadences are editable. A database-size, memory-clerk or plan-cache collector scheduled daily or slower lost its facts from 24 hours after each sample until its next run, so the findings built on them resolved and re-fired. The lookback is now a day or twice the collector's actual interval, whichever is longer. The interval comes from the same schedule rule the collector runs by: Darling's per-server and fleet-wide overrides, Lite's schedules, the Dashboard's `config.collection_schedule`. A collector set to run only on connect anchors on its newest capture however old. Every default cadence is under twelve hours, so nothing changes until someone slows a collector down. Separately, the PostgreSQL target's five reads of the newest `pg_server_config` snapshot had no lower bound. A year in, TimescaleDB planned all 366 one-day chunks: 4.0 to 8.3 seconds of planning per read, four of them on every analysis pass. They now read the last day first and fall back to every retained snapshot only when that finds nothing, so every answer is unchanged. -- **The top-CPU drill-down resolves statement text for the five queries it prints, not for every plan-cache row in the window** ([#3979]) - The drill-down behind CPU_SQL_PERCENT and CPU_SPIKE findings projected query_text inside its window. On Darling, v_query_stats resolves that column from the fleet's query-text dimension for every row, so the read looked up and sorted the whole window's text to print five. It now ranks and cuts to five without the text, then reads the same MAX over the same rows for the five that print. A group with a NULL key reads NULL-safe, because GROUP BY groups NULLs and equality cannot match them. Lite runs the same SQL, byte-identical by pin, and the frozen Dashboard mirrors it; its MAX over every window row's compressed statement drops from 1,140-1,360 ms to 32-47 ms on a 72K-row window. On a rig with a 400K-text dimension and a 72K-row window, Darling's read goes from 260.6 ms to 132.2 ms. Output is identical in all three SKUs against an old-SQL oracle, NULL keys and trap rows included. -- **A server dark past the collection log's retention reads Offline everywhere, not "Awaiting first collection"** ([#3975]) - [#3966] fixed this on the fleet card. `list_servers`, the viewer's sidebar dot and Overview card, and Lite's Overview card still read "no collection found" as "never collected". `collection_log` keeps 60 days and Lite's archive keeps three months, so a decommissioned server left enabled read Offline until its last row aged out, then turned amber: "Awaiting first collection" on Darling, and "Never" with "No collection has ever landed for this server" on Lite. One shared rule now bands a server with no collection in view by when it was registered. A server registered before the earliest instant the read can see is Offline; one registered since then is still awaiting its first collection. Lite's horizon is the first month start its archive cleanup keeps, because the cleanup deletes a month's file whole. -- **The service's start-up hole scan no longer reads every aggregate's whole materialization and source table** ([#3972]) - At every start the service scans each of its 23 continuous aggregates for materialization holes (#3731), and the scan's two per-bucket checks ran as joins: one read the aggregate's entire materialization, and the other read the entire source table once for every bucket with nothing materialized, which after an outage is every outage hour. On DARLING01 the wait-stats baseline's check wrote all 9.8 million wait_stats rows to disk and read them four times, 4.5 seconds for one aggregate. Each check now runs once per bucket as an index lookup, and finds exactly the same holes. One start's scans across all 23 aggregates went from 5.9 s to 75 ms there. -- **The trend tools answer in time buckets sized to the window: a day of `get_file_io_trend` is 34 KB, not 1.4 MB** ([#3968]) - `get_file_io_trend`, `get_lock_wait_trend`, `get_query_duration_trend`, `get_procedure_duration_trend`, `get_pg_io_trend` and `get_pg_database_trend` returned every collection in the window, so an answer grew with the window and the collection cadence: a default day of file I/O on a monitored SQL Server 2022 was 12,500 points and 1.4 MB, and a week 9.8 MB. Each now gathers its collections into buckets sized to keep the answer near 200 points (a day is ten-minute points, a week hourly), the same way on Lite and Darling; `bucket_minutes` asks for another width up to a per-tool cap that keeps the largest answer under 256 KB, and a width out of range or over the cap is refused with the width that fits. Counts are summed and rates and ratios recomputed from each bucket's sums, never averaged; every point keeps its worst single collection as a peak, so a spike survives; and the answer says what a point is (`bucket`, `bucket_minutes`, `aggregate_note`). `get_file_io_trend` charts each database's data and log files as two lines ranked by I/O stall, folding everything past the top five into one `(other)` line, and `database_name` charts one database file by file; it used to list tempdb's files under one name, indistinguishably. `get_lock_wait_trend` charts the whole lock family as one series with a legend of the types that waited, where it returned a row per type per collection, mostly zeros. On the PostgreSQL pair `point_count` now counts buckets and `interval_count` the intervals it used to count. The web viewer charts the same reads at a larger point budget, and `get_query_heatmap`'s `bucket_minutes` and `metric` refusals now carry the `invalid` status and the parameter name. -- **A server dark for more than two days reads Offline on the fleet card, not "Awaiting first collection"** ([#3966]) - The web fleet page and `get_fleet_overview` look back 48 hours for each server's newest collection. A server silent for longer fell out of that read and was banded as if it had never collected: an amber "Awaiting first collection", counted under Warning, with the same words in Needs attention. The WPF viewer called the same server Offline. The window stays, because planning the read over every retained `collection_log` chunk on every call is the cost it exists to avoid. The read now also returns each enabled server's registration instant from the registry. A server registered before the window with nothing in it reads Offline and counts in `offline_count`. One registered inside it that has not collected yet still reads awaiting. The web card's Offline status line shows how long ago the last collection was, or "no recent collection", instead of a time of day that read as today. -- **A restart's shutdown checkpoint no longer counts toward checkpoint write and sync time either** ([#3964]) - The shutdown checkpoint's own write and sync work lands in the same counters as the live checkpoints', and nothing can separate the two, so an interval that spans a PostgreSQL restart is now judged on neither arm. Store Checkpointer Pressure neither fires nor resolves on it, even when the shutdown sync is slow, and get_store_metrics reports the interval as status Restarted with no delta. PG_CHECKPOINT_PRESSURE leaves restart intervals out of its write, sync and checkpoint-buffer figures as well as the requested count, and get_pg_write_stats returns checkpoint write time, sync time and checkpoint buffers as null for a window that holds a restart. The cost is one skipped interval after a restart; the next interval is judged normally. -- **PostgreSQL config change history reports per-database and per-role overrides being set, changed and reset** ([#3957]) - `get_pg_server_config_changes` and its web twin said nothing about `ALTER DATABASE ... SET` or `ALTER ROLE ... SET`. The override rows V138 added to `pg_server_config` had to be kept out of the server-wide change read, and even a per-scope comparison could only see an existing override's value move, never one being set or reset. A second read now compares each pair of consecutive snapshots for every database and role scope. An override that appears reads `set`, one that disappears reads `reset`, and a moved value reads `changed`. Overrides already present when the store first captured them are the baseline and are not reported as set. The server-wide rows, their order and their payload shape are unchanged, and a page with no scoped rows is byte-identical to before. -- **The plan-regression drill-down no longer re-deduplicates the whole Query Store slice, and the parameter-sensitivity drill-down stops resolving text for rows it never prints** ([#3956]) - Every analysis pass that raised a PLAN_REGRESSION finding ran the fact's 14-day Query Store deduplication twice: once for the fact, and again in the drill-down that lists its top five. Those five are the head of the ranking the fact had just computed. The fact now records the queries it reported on the pass, and the drill-down deduplicates only those queries' rows. It reads the whole slice, as before, when the fact did not run, failed or found nothing. Lite and the Dashboard do the same. On a rig seeded to the production funnel (4.15M raw rows per server), the drill-down went from 27.1 s to 0.41 s, and on DARLING01 from 194 ms to 2.1 ms, with md5-identical output. The parameter-sensitivity drill-down read v_query_stats, which joins the fleet's query-text dimension for every row in the window and carries the text through its sort. It now resolves text for the five rows it prints: 520 ms to 165 ms on the rig. The Dashboard's twin carried each row's compressed statement through the same sort, and it now does the same. PlanRegressionSql's own cost needs a storage change, proposed in [#3953]. -- **A PostgreSQL restart no longer raises a false Store Checkpointer Pressure warning or reads as a WAL-forced checkpoint on a monitored server** ([#3955]) - PostgreSQL counts a shutdown checkpoint as a requested checkpoint and keeps the count across the restart, so every service restart that stopped the store fired Store Checkpointer Pressure as WAL-forced checkpoints, and a monitored server's restart read as WAL pressure in PG_CHECKPOINT_PRESSURE and get_pg_write_stats. Every checkpointer sample now records the server's postmaster start time (store schema V139), so an interval that spans a restart is recognised and no longer counted as a requested checkpoint. get_store_metrics and get_pg_write_stats report postmaster_restarted and postmaster_start_time so the gap is explained rather than hidden. -- **Log masking fails closed: a DETAIL or CONTEXT is read as SQL only where PostgreSQL writes SQL, a value cut before its close is masked to the end, and `get_store_query_stats` masks a raw text `pg_stat_statements` kept** ([#3952]) - A fourth review of [#3920] found values still reaching the viewer and mcp roles through the store's own log and every PostgreSQL target's `get_pg_log_events`. The DETAIL and CONTEXT masking split at any line shaped like `Process N:` or `SQL statement "`, a value's own lines included, which kept a literal's middle as identifiers and cut a key tuple or failing row away from the close its mask needed; now a DETAIL is SQL only in a deadlock report (a `Process N:` line starts a query only for one of the deadlock's own processes, and only once the query before it reads to its end), a crash report or a logged EXECUTE's `prepare:`, and a CONTEXT frame is SQL only where a frame can start. A pasted value that reads as an identifier to PostgreSQL (a no-break space, full-width digits) is masked, every prose value shape masks to the end when its close never arrived, a field over 64 KB is withheld and a hostile field can no longer stall capture (one key-tuple pattern took minutes on 90 KB), and `get_store_query_stats` masks the statement text `pg_stat_statements` stores raw when an entry is evicted or reset mid-statement. Covered by the reviewer's inputs as regression tests, timing pins for the hostile shapes, and a live test that forces the raw text into `pg_stat_statements`. -- **The web server page's Overview tab no longer waits on the daily summary** ([#3950]) - On the largest production store the two daily-summary reads were 26 of the Overview tab's 28 seconds, and one of them ran into the `viewer` role's 15 s timeout. The month read was slow in its query count, not in its raw sources. The check that names a day the rollup never materialized (#3653) ran as a join over the server's whole query history, rescanned once per day of the window and spilled to disk, and the distinct-query count sorted every rollup row of the month. Each check now runs once per day as an index lookup and the count is hashed, with identical results on every tier. On one busy server's seeded data the month read went from 3.3 s to 0.19 s and a 120-day read from 12.4 s to 0.16 s. The rollup-coverage lookup took 1.7 s or more in production and ran on every call. It is now cached for five minutes, concurrent reads share one lookup, and a failed lookup is retried rather than routed on. The tab's today tile now comes from the same read as the month grid, so the page runs one daily-summary query instead of two, and the tile's unique-query count matches the grid's last row. -- **The fleet overview reads each server's newest sample instead of every retained row, and the web viewer asks for it once per refresh instead of twice** ([#3947]) - Every `get_fleet_overview` call and every `/api/fleet` request behind the web sidebar, fleet page and server page read its four "latest value per server" metrics (CPU, memory, memory-grant pressure, worker threads) with a `DISTINCT ON (server_id)` or a `MAX` joined back over the whole table. That read decompressed and sorted every retained row to keep one per server. It also counted blocking and deadlocks bounded only on the event's own timestamp, which no chunk is partitioned on, so a one-hour count opened every retained chunk. Both grew with servers × retained days, and one overview took 12.3 s cold on a 43-server store. Each newest-row read is now one `LATERAL ... LIMIT 1` probe per registry server, which TimescaleDB's ordered ChunkAppend stops in the newest chunk; PostgreSQL targets, which never write those tables, are skipped. The incident counts carry a `collection_time` floor one chunk before the window, which keeps every row the window wants because a row is collected after its event. The 48-hour last-collection read is a per-server probe too. On DARLING01 the sub-reads went from 1,317 ms and 26,836 buffers to 32 ms and 182, returning identical rows. The web viewer's sidebar and page each fetched `/api/fleet` on every 60-second tick, doubling the cost per open tab; they now share one in-flight request. The WPF viewer's copies get the same fixes (its sidebar freshness read was a `GROUP BY` over every retained `collection_log` row on every refresh, 303 ms to 13 ms on DARLING01), as do `get_server_summary`'s windowed counts, and Lite's Overview card reads its newest CPU, memory and last collection from the hot table before falling back to the archive. -- **A PostgreSQL target's analysis reads its statements' own baselines once per metric, not once per statement** ([#3946]) - The bad-actor share detector and the plan-regression detector asked for each candidate statement's hour-of-week baseline one at a time, and each ask read the server's whole 30-day `pg_statement_stats` slice (the table's only index is (server_id, collection_time), so the statement predicate is a heap filter; the share arm also re-summed the same per-collection total each time). A cold pass paid five share reads plus one per flipped statement, and on the production PostgreSQL store that was about 70 % of a cold `analyze_server`. Each detector now asks once for its whole candidate set: the keyed arm makes the per-statement arm's own read with one filter per statement and runs the unchanged robust scaffold once per statement over it, so every statement's buckets are the ones its own read produced (identical tiers, counts, medians and MADs; means and standard deviations to float8 summation order). On DARLING01's PostgreSQL target the five share reads (920–1,053 ms) became one (409–466 ms), and on a 4.3M-row compressed month the share read halved and the mean fell by a third. The per-statement scaffold is the floor that remains; scheduled passes never reusing the baseline cache is tracked separately (#3941). -- **`get_store_metrics` answers with a bounded summary instead of every store object's daily series** ([#3942]) - The tool returned every store object's latest row and its daily series on every call. The object count is fixed by the schema (about 250: 72 hypertables, 25 continuous aggregates, 146 background jobs), not by the fleet, so the default answer was about 1.9 MB on every production store. That is around 500k tokens, more than an MCP client's context, and it was 1,246 KB on the dogfood store. The default is now the store-level blocks (inventory, retention, job_history, checkpointer, and the whole-store daily growth with the per-server ingest rate) plus three ranked lists bounded by `limit` (default 10): the largest objects, the fastest-growing, and the background jobs, failing ones first and then those closest to their cadence. Each row carries its change over the window in place of its series. `object_kind` lists one kind, and an exact `object_name` returns that object's daily series. On the dogfood store's own rows the default answer drops from 1,246 KB to 19 KB. Wire change: `daily` is gone from the default response, `objects` is a bounded page, and job rows no longer carry the byte fields, which were always null. The store alerts' triage page gains a background-jobs section. -- **Managed role provisioning never sends a role's password in a statement** ([#3940]) - Every service start sent all three login roles' plaintext passwords in `CREATE ROLE` / `ALTER ROLE ... PASSWORD`, and any surface that records statement text could keep them: an operator-created role with a managed role's name made provisioning fail on every start, and the store's own log then wrote the whole batch, passwords included, where the viewer role reads it for 400 days. Provisioning now sends each role's SCRAM-SHA-256 verifier, computed client-side (PostgreSQL stores a verifier as-is, which is what psql's `\password` does), and only for a role whose stored verifier no longer accepts its credential file, so a steady-state start sends none. `tools/provision-roles.sql` recommends a verifier or `\password` for a store you run yourself. -- **A store without TimescaleDB re-runs its store-object convergence every hour, not only at restart** ([#3932]) - #3817 made the service re-run its store-object convergence hourly (the baseline views, the store's statement statistics, the composer's covering indexes), but the hourly pass sat inside the tick's TimescaleDB gate, so on a plain-PostgreSQL store, a supported configuration, a dropped fallback view or an extension a DBA created by hand waited for the next restart. The hourly pass now runs on every store shape and skips only the steps that need TimescaleDB, the same ones the start path gates. -- **Analysis latest-value reads look back a day instead of scanning a server's whole history, and stop counting dropped databases** ([#3931]) - The database-size, autogrowth, disk-space, memory-clerk, plan-cache and memory facts, and the autogrowth drill-down, took each series' newest row with no lower time bound. So every analysis pass numbered every row the server had retained, and TimescaleDB could exclude no chunk. On the largest field store `DatabaseSizeSql` alone was about a tenth of `analyze_server`. On Lite the archive views could skip no parquet row group. The answers were wrong too: "latest ever" kept a dropped database's files in `DATABASE_TOTAL_SIZE_MB` and in the autogrowth drill-down until retention aged them out. The seven reads now bind a lower bound one day before the window's end, in Darling, Lite and the Dashboard, so a series with no sample in that day yields no fact rather than a stale one. `DB_CONFIG` anchors on the newest capture, as its drill-down already did, which drops the dropped databases it was still counting. -- **A store upgrade that fails before its commit point puts the old cluster back as it found it, and only claims a revert that happened** ([#3927]) - In hard-link mode pg_upgrade renames the old cluster's `global/pg_control` once linking starts, and a failure after that point left a store that could not start on either runtime while the log said the pre-upgrade data directory was never modified. The failure and shutdown paths now rename it back before reverting the runtime, and log CRITICAL with the exact rename when they cannot. The runtime revert refuses while a PostgreSQL server is still running on the data directory instead of moving its binaries out from under it, and a revert whose second move fails puts the first one back instead of leaving no runtime at all. A directory swap that could not undo itself is moved back too, so the next start can no longer initialize an empty store over the real one. The failure outcome and the Failed self-alert now say only what was actually put back, and name the manual step before the next restart when something was not. -- **Log text keeps no literal: the store's own log and every PostgreSQL target's log events mask the SQL inside DETAIL and CONTEXT, every retained store-log entry is masked, and the statement reader shows only normalized DML** ([#3920]) - Two further reviews of [#3915] found text still leaking to the viewer and mcp roles. The store-log sweep kept `statement_timeout`, `lock_timeout`, `deadlock` and `unclassified` entries as the server wrote them, so an ERROR's `STATEMENT:` line carried whatever the failed statement did, a DBA's `ALTER ROLE ... PASSWORD` literal included, for 400 days. Both log surfaces masked a deadlock's `Process N:` queries, a crashed process's query and a PL/pgSQL `SQL statement "..."` context as prose, which keeps bare numbers and dollar-quoted strings, so a monitored server's deadlock kept both sessions' values in `get_pg_log_events`. Every retained entry now has its values masked, with statements and the SQL inside DETAIL and CONTEXT going through a single-pass SQL lexer that masks every literal spelling and withholds text it cannot read to its end, a backslash before a quote that reads two ways included. Rows stored before this build are re-masked in bounded hourly slices, and both readers mask on the way out. `get_store_query_stats` shows statement text only for normalized DML that opens with no comment (every other statement keeps its timings and reads as withheld), which closes comment-split role DDL, a DML keyword hidden in a leading comment, connection strings, and a `SELECT ... INTO` on a pre-16 store that tracks utility statements; its advice about `pg_read_all_stats` now says what that grant opens. The managed store's conf reading de-escapes values the way PostgreSQL does (an include directory ending in a backslash was dropped from the preload merge), reports a preload list PostgreSQL rejects as an Error rather than as fine, and bounds its include walk. Covered by the reviewers' leak cases as regression tests, the statement patterns judged by PostgreSQL's own regex engine, and live tests of the reader and of the re-mask pass on a migrated store. -- **The store's hourly self-metrics sweep works again on TimescaleDB 2.29 and later** ([#3918]) - TimescaleDB 2.29.0 rebuilt its chunk catalog and dropped the two name columns the sweep's catch-all census joined on, so on 2.29+ that statement failed every hour with 42703. The store-size series stopped, the store-log census and collector-cost flush on the same tick stopped with it, and `get_store_metrics` silently lost its `largest_unenumerated` list. That was live on the Linux compose image, which runs 2.30.1, and it blocked the bundle bump ([#3908]). The census now reads the public `timescaledb_information.chunks` view, whose columns keep their names across the rewrite, so one statement serves 2.28.1 and 2.29+ stores with no version check. It also excludes each chunk's compressed relation through `compression_settings.compress_relid`, because from 2.29.0 compressed data is no longer a chunk catalog row, and without that the system row would count it a second time (34.8 MB of a 129 MB test store). Verified on 2.28.1, a fresh 2.30.1, a 2.28.1 store upgraded in place, and a store whose extension update never ran: in each, the sweep's rows add up to the database's relation total to the byte. -- **The bundled store moves to TimescaleDB 2.30.1, which closes GHSA-hcfx-29v5-2rcw, and a store's extension now moves before the store opens instead of under a live store** ([#3908]) - Every release since 3.2 shipped TimescaleDB 2.28.1, which that advisory covers, and the update path could not move an existing store off it. The old post-start `ALTER EXTENSION` ran on a store that the web host, MCP host, Viewer seats and the job scheduler were already connected to. Once the extension moved, every session that had loaded the old library failed its next statement, and the update's own pre-step killed running jobs, which then sat in crash backoff for up to an hour. Now, when the runtime ships a newer TimescaleDB, the service starts the store on a private loopback port with background workers off, runs the update as the first statement of its own session, verifies it, stops the store, and only then starts it normally. Nothing else can connect in that window. The runtime carries the 2.28.1 libraries beside 2.30.1, so nothing ever has to be reverted. A store whose update fails still opens on its own version, and a Critical `Store Runtime Upgrade` alert names the reason; the update is retried on the next start. A PostgreSQL 17 store's pg_upgrade restores its extension as it is, and the update follows once the upgrade commits, so a failure there can no longer cost the rollback copy. The store's version is recorded in `darling-timescaledb.version` in the data directory, and the service refuses to swap in a package that has no libraries for it, which is what a rollback past this release would otherwise do. Releases 3.3 through 3.8 keep this runtime if you roll back to one (the service keeps `pg-runtime.stamp` pinned to the package they shipped). Verified on real servers: a 2.28.1 store with compressed hypertables and continuous aggregates moves to 2.30.1 with every row intact, stamped and unstamped. A package missing the update script leaves the store on 2.28.1, running and collecting, with no runtime reverted. A server left on the update's private port by a killed service is stopped at the next start instead of being adopted. -- **A runtime update no longer stops the store from starting when the previous runtime's folder cannot be cleared** ([#3919]) - A runtime update deletes what the last one left in `pg-runtime-prev` before rescuing the current runtime into it, and that delete sat outside the guard that turns a failed rescue into a skipped update. A file held open under the folder, by an antivirus scan or a shell sitting in it, threw out of startup and the store did not start that time. This release moves the bundled runtime to PostgreSQL 18.6 ([#3906]), so every host takes that path on its first start. Clearing or re-creating the folder now fails the way the rescue does: a warning naming the folder and the error, no swap this start, the live runtime left alone, and a retry on the next start. -- **A store still on PostgreSQL 17 no longer fails to start on a host with 40 GB of RAM or more** ([#3909]) - The managed store's memory sizing derived `maintenance_work_mem = 2048MB` on large hosts. PostgreSQL 17 on Windows accepts at most 2097151 kB, one kB less, and refuses to start over it. PostgreSQL 18 accepts the value, which is why current stores never showed it. A store still on 17 got those blocks after a failed upgrade to 18 reverted. From then on it could not start, and a later release could not upgrade it either, because the upgrade's first step starts the old cluster. The cap is now 2047 MB. A store on 17 whose conf is already over the limit gets a corrective line before anything starts it. A command-line override does not help, because 17 still validates the file. An over-limit value set with `ALTER SYSTEM` is reported with the fix, since nothing appended to postgresql.conf can override it. -- **The store's statement statistics, reviewed before release: the ALTER SYSTEM advice no longer bricks the store, and the reader's filter can no longer be switched off** ([#3915]) - #3899's first version ([#3904]) merged before its adversarial review finished, and the review found four serious faults. The v13 warning told an operator to pass the whole preload list to `ALTER SYSTEM` as ONE literal, which `shared_preload_libraries` stores as a single library name, so the store would not start again; the fix is now written one quoted literal per library, and a list stored that way is reported as an Error with a remedy that works while the store is down. The reader functions' body is parsed at call time under the caller's settings, so one `SET standard_conforming_strings = off` from any grantee turned the backslash filter into letters and returned recorded role passwords; both functions now pin the setting, and the pattern has no backslash. The `slow_statement` store-log class kept any role's raw duration lines, bind-parameter DETAIL included, where the viewer and mcp roles read them; it now keeps the statement with comments stripped, every literal masked (the shared log redactor gains dollar-quoted and `E''` strings) and DETAIL dropped, one row per statement however often it ran. And the setup probe failed at plan time for any store owner that is not a superuser; it now reads whether the module is loaded from `pg_settings`, which any role can. The same pass makes `get_store_query_stats` answer `precondition` from the catalog for each setup state (including an extension older than 1.8, which `pg_upgrade` leaves in place, and a dropped one), return query ids as strings, rename `entries_evicted` to `eviction_passes`, and say what its figures leave out; derives the viewer and mcp slow-statement line from a third of their `statement_timeout`; follows include directives in the v13 merge and checks the preload line in force on every start; scopes the scrub to the store's own database; and corrects the role identities and the hourly-cadence claims. Nothing public shipped the first version (nightlies build from main). Covered by unit tests for each fix and live tests on the bundled runtime, including the `standard_conforming_strings` bypass attempt and a non-superuser store owner. -- **The bundled PostgreSQL moves to 18.6, and the self-contained .NET runtime to 10.0.12, closing published CVEs in both** ([#3906]) - A security review of 3.8.0 flagged two things. First, the Darling store runtime was on PostgreSQL 18.4, one release behind 18.6, which fixes 23 CVEs in it. Second, Lite's builds (zip, Setup and Portable) and the Darling Viewer's Setup and Portable builds carried a `Microsoft.DiaSymReader.Native` affected by CVE-2026-69439, CVE-2026-71328 and CVE-2026-69522. Those are heap overflows in PDB parsing, fixed in .NET 10.0.12. That runtime is whatever the SDK packs into a self-contained build. `global.json` pinned SDK 10.0.302 with `latestPatch`, which never leaves the 3xx feature band, and Microsoft stopped servicing that band at 10.0.303 (runtime 10.0.11). Dependabot had moved the `Microsoft.Extensions.*` packages to 10.0.12, but it never touches the SDK. The SDK is now 10.0.401, and Dependabot's `dotnet-sdk` updates keep it current. A pin test makes each of those pull requests move the Darling container's SDK line with it. Existing Darling installs pick up the new PostgreSQL on upgrade: same data directory, no pg_upgrade. A host whose runtime predates stamping is now compared on the full PostgreSQL version rather than the major alone, so a readable 18.4 is no longer adopted as the 18.6 package. The nightly now runs that same-major upgrade on a real store built on the previous release's runtime, stamped and unstamped. A weekly `Runtime currency` workflow fails when a newer PostgreSQL minor for the pinned major is out, or when a TimescaleDB advisory covers the pinned version. An advisory already tracked by an issue is reported as a warning until the change that clears it. TimescaleDB stays at 2.28.1 for now. Testing the bump on real data showed that the store upgrade cannot yet move an existing store's extension to a new version, and would have left every upgraded store's database failing. That fix, and the bump, are [#3908]. -- **Each generated store TLS root certificate carries a unique per-generation name** ([#3557]) - Windows caches every root a viewer's TLS stack ever sees into the user's intermediate-CA store, one per certificate rotation; with all rotations sharing one name, that cache eventually breaks certificate chain building outright on long-running viewer machines. Distinct names per rotation mean the pile can never form. -- **The by-CPU tools now actually rank by CPU** ([#3523]) - get_top_queries_by_cpu and get_top_procedures_by_cpu ordered by summed elapsed time in both SKUs, so on a wait-bound server the real CPU consumers could be missing from the page entirely - and attributed_cpu_ratio read as "hidden CPU" when it actually meant "wrong sort key". Every ranking site now orders by worker time, including the over-fetch cut that could drop a CPU-heavy query before the final sort ever saw it. The viewer's Duration grids keep their elapsed ranking, which is what they promise. -- **analyze_server no longer answers "all metrics are within normal ranges" when the analysis window collected nothing** ([#3524]) - The analysis gate passes on lifetime history, so a server whose collection died still reached the all-clear path with an empty window. Both SKUs' analysis services now flag the zero-facts window and analyze_server returns the "unavailable" envelope pointing at get_collection_health; the genuine all-clear (facts collected, zero findings) is unchanged. -- **The Performance Calendar, daily summary, and fleet sweep band deadlocks as a measured per-hour rate, not any-deadlock-is-Critical** ([#3525]) - The shared daily classifier routed the Deadlocks signal through the Overview card's store-backed rate tiers (#3368, V120) with each surface's real window as the denominator, so one deadlock no longer paints a calendar day red, sweep verdicts stop scaling with the cadence knob, sub-hour spans fall to Warning instead of a multiplied rate, and the day tooltip/reasons report the rate beside the count. The still-forming day clamps its window to the elapsed portion, so an active storm bands on its true in-progress rate instead of diluting against hours that have not happened yet. -- **Perfmon rates are honest per-second values in analysis** ([#3527]) - The PERFMON_*_SEC facts, the batch-request anomaly window, and both SKUs' batch-request baselines read the per-collection-interval delta as if per-second (60-300x overstatement); every read now divides by the measured sample_interval_seconds (Darling's baseline derives it from collection-time gaps, since the continuous aggregate stores no interval), and interval-0 rows - where no delta was knowable - are skipped instead of read as rates. -- **Floor the SQL count thresholds, give Store Disk Pressure a GB floor, and count measured metrics in the fleet Healthy label** ([#3528]) - The SQL Server deadlock and blocking count thresholds now floor at 1 on read like their PostgreSQL twins, so a store row hand-edited to 0 can't fire on a quiet server; Store Disk Pressure gains a self_alerts.disk_free_warn_gb floor (default 50, 0 disables) so a large store volume at a low percent stops paging CRITICAL with hundreds of GB of runway; and fleet cards carry measured_metric_count/metric_count so a Healthy label built off one measured metric of six says so ("1 of 6 measured" on the web fleet page). -- **get_memory_trend stops reporting granted memory as a hardcoded zero** ([#3529]) - The MCP payload shipped a literal total_granted_mb = 0.0 on both SKUs, steering agents away from memory grants during grant-pressure investigations. The field became an explicit null with the envelope naming get_memory_grants as the grants series' source, and both tool descriptions stopped promising granted memory. -- **Lite's Query Store time slicer reads physical reads from its own column** ([#3530]) - The reader mapped both read fields to the logical-reads ordinal and never read the SELECT's total_physical_reads column, so the physical aggregate was computed and dropped. Pinned with a test whose fixture rows carry distinct values per I/O column. -- **LCK_M_IS advice carries the same RCSI caveats as its LCK_M_S twin** ([#3531]) - The intent-shared-lock advice handed out the READ_COMMITTED_SNAPSHOT ALTER with no caveats. Both lock twins now name the brief exclusive lock the ALTER takes, the tempdb version-store cost, and the test-on-a-copy warning for NOLOCK-dependent code. -- **Collector schedules refuse cadences that would fabricate quiet** ([#3532]) - Delta-family collectors (wait/latch/spinlock/query/procedure/file I/O/memory-grant/perfmon stats, and the PostgreSQL wait/statement collectors) now cap at 30 minutes in both Lite's and Darling's schedule editors, with the store-side resolver ignoring out-of-policy rows: past the shared 60-minute delta gap policy every cycle re-baselined and recorded zeros forever, so the charts flatlined green precisely because collection stopped measuring. -- **get_pg_plans finds the plan you asked for, not just the plans in the top page** ([#3533]) - the queryid filter ran client-side over a fetched top-duration page: the reader had no query_id predicate, so the tool pulled the top limit x 10 shapes by total time and filtered them in C#, which made any plan ranked below that page unfindable at every window size - and the filtered-empty branch then told the caller capture was working, the plan was never captured, and the statement was "not the query to look at", while the plan sat in the store. The predicate now runs in the store's SQL over every capture in the window, the over-fetch is gone, and the miss text says what was actually searched and what a miss can mean, with get_pg_top_queries and get_pg_plan_capture_readiness cross-references. The web dashboard's read dispatch already passed query_id through, so it gains the server-side search with no wiring change. -- **get_pg_autovacuum_health classifies severity from the same axis it ranks by** ([#3534]) - The reader ranks tables by GREATEST(dead ratio, insert ratio) but severity only read the dead side, so an append-only worst_table ten times past its insert-vacuum threshold reported "ok"; severity now comes from the worse of the two ratios, the insert-side ratio is published as insert_threshold_ratio, a one-sample window reports growth as unknown instead of "flat" (with first_seen_at showing the window), and the page-scoped summary counts carry the sibling limit_reached flag. -- **get_pg_replication_slots headlines the worst-classified slot and never spells unknown WAL growth as stable** ([#3535]) - worst_slot was picked by retained size, so an active 45 GB keeping-pace slot ("ok") outranked an inactive growing orphan ("critical_orphan_filling_disk"); slots now rank by severity with size only breaking ties, growth is null when either endpoint is the collector's -1 sentinel or the window holds one sample, new unknown-growth severities say so explicitly, and raw retained_wal_bytes nulls the sentinel like its _gb sibling. -- **get_pg_io_stats no longer renders track_io_timing=off as an impossibly fast disk** ([#3536]) - track_io_timing is OFF by default in PostgreSQL, so on a stock server the read and write time counters are never populated - and this read divided the zeros out to 0.000 ms latencies while its trend sibling had shipped the honest contract all along. The single-window read now mirrors that contract exactly: the setting is read from the collected pg_server_config bounded by the window's end (inferred from the window's data when never collected, with io_timing_source saying which), io_timing_tracked and timing_note are published, and every time-derived figure is null when untracked rather than zero, while the operation counts, hit ratios and byte figures stand untouched. The new busiest_basis field states which key decided the "busiest" ranking. -- **The PostgreSQL xmin-horizon alert catches rotating holders and stops firing on single observations** ([#3537]) - The persistence gate gains a horizon arm that fires when the horizon sits past the age threshold in a majority of the window's real captures (counted from the collector's own collection_log runs) regardless of who holds it, naming the rotating-holder pattern under a stable dedup subject; a minimum-observations floor stops the first holder after quiet hours from reading 1-of-1 as chronic. -- **QueryStore slicer's physical-reads sort plots the physical series** ([#3547]) - Sorting the Query Store grid by physical reads relabeled the slicer but kept plotting logical reads, and the selected-row overlay had no physical series to draw at all. Bars and overlay both plot the real physical-reads aggregate now. -- **get_memory_trend joins the grants series so total_granted_mb carries real data** ([#3548]) - Completing #3529's honest null: both SKUs join the memory-grant series the viewers already chart into the trend payload, matching each memory point to the nearest grants snapshot within 30 seconds. A snapshot measuring nothing granted is a genuine 0.0, an uncovered point stays null, and the granted_note appears only when there is a gap to explain. -- **Viewer Recommendations tabs stop saying "All clear" when the analysis window collected nothing** ([#3551]) - Both viewers only branched on the insufficient-data message, so a server whose collection died still rendered the all-clear on a zero-finding read. Lite's Generate now consumes the analysis service's window-empty state directly; the Darling service persists it into the analysis-state marker (false-with-a-message, no schema change) so the viewer's read and Generate now doors both render a "nothing was measured - check Collection Health" notice. The genuine all-clear (facts measured, zero findings) is unchanged. -- **Viewer pass for the Store Disk Pressure GB floor and fleet measured-metric qualifier** ([#3563]) - The Settings window can now edit the Store Disk Pressure warning's GB floor (V126, 0 disables) next to its percent sibling, and the WPF fleet card's band label carries the web fleet page's "N of M measured" qualifier when a band folded over unmeasured metrics, so an Unknown-heavy server no longer reads as an unqualified green. -- **Deprecated Dashboard analysis reads perfmon counters as true per-second rates** ([#3561]) - The Dashboard's analysis facts, batch-request anomaly window, and batch-request baseline read the per-collection-interval perfmon delta as if it were per-second, overstating by 60-300x at common cadences; all three now divide by the row's measured sample interval and skip rows with no knowable delta, matching the Lite/Darling fix in #3560. -- **Sorting the Procedures or Query Store grid by physical reads plots the physical series, in both apps** ([#3556]) - In Lite and the Darling viewer, the Procedures grid's physical-reads sort plotted the logical aggregate under a physical label, and the Query Store slicer labeled execution-weighted slice totals "Avg". The Darling viewer's Query Store grid also still carried the original #3547 physical/logical swap, and none of its grids re-projected a selected row's overlay when the sort metric changed, so the bars and the overlay could show different metrics. Both apps now plot the series the sorted column names, label slice totals as totals, and keep the overlay on the bars' metric - pinned by distinct-per-column reader tests and source-text pins over the sorting handlers in both apps. -- **The Locking & Contention grid names the table as schema.table** ([#3576]) - On Azure SQL DB and anywhere per-tenant schemas are the pattern, the same table name lives in several schemas, so the grid's bare table name made `dbo.Orders` and `archive.Orders` read as one object. The Table column now shows the qualified name, and sorting, filtering, and CSV export all treat it as one string. Mirrored in the Darling viewer and the deprecated Dashboard, and the Darling viewer's PostgreSQL Index Usage grid, which had the same gap, names its tables the same way. -- **Extreme, corroborated anomaly findings can now cross the notify floor, so the baseline engine is no longer notification-inert at shipped settings** ([#3526]) - every `ANOMALY_*` ramp saturates its base at 1.0, the Layer-3 tuning-class cap held the final at 1.49, no amplifier arm existed, and the shipped `notify_severity` is 1.5 - so a 20σ session spike beside a 15σ batch-request spike at 3am could never page unless THREADPOOL/SOS/RESOURCE_SEMAPHORE happened to co-fire; the product's best per-server-calibrated statistics were structurally its quietest. The shared `FactScorer` gains a second, per-fact escape for `ANOMALY_*` only: a deviation at 3x the cutoff the fact fired at (10.5σ on the 3.5σ robust path, 15σ heavy-tail, 6σ classical, 3x the absolute bar on the never-blind fallback path, bounded at the 25σ display cap; never for `is_new` profiles or the ratio/count families) leaves the cap on its own evidence, and a new anomaly co-fire amplifier arm (sibling anomaly families and measured absolute facts at the bars their own arms use) carries an extreme anomaly with two corroborators to 1.6. Routine 2-4σ saturation still caps at 1.49, a lone extreme anomaly scores its 1.0 base, one corroborator reaches 1.3, and CXPACKET's cap and the impact-peer escape are untouched. Lite + Darling (+ the deprecated Dashboard via the shared scorer). -- **`get_store_metrics`' `job_history` block now says whose eyes its rows are visible to, and proves rows exist where it can** ([#3574]) - `recording: true` was a GUC echo: `timescaledb_information.job_history` shows a row only to members of the job's owner role or the database owner, while `jobs` and `job_stats` show every role everything, so a least-privilege role could list all 110 jobs and read an empty history on a store recording perfectly - which cost a real postmortem. The block now evaluates the view's own predicate for its reader (`reader_role`, `visibility`), counts the rows it actually sees over a fixed 24-hour window beside the jobs `job_stats` says ran, and names the contradiction - recording on, reader admitted, jobs ran, zero rows - as a finding. In managed mode the MCP host reads as the `mcp` role the view filters out, and the block says so rather than reporting a zero it produced by construction. Darling only. -- **The forced-plan-failures alert read no longer walks the whole fleet's two-hour slice of Query Store rows to find one server's** ([#3573]) - the read's own composite index was in the store all along, and the planner priced it out because server ids interleave physically across collection passes, so every 30-second pass re-read the entire fleet window per server and cold excursions crossed the 10-second deadline as the table grew from 6 GB to 23 GB. A covering index over exactly the read's columns makes it an Index Only Scan over one server's rows (50 buffers against 1,514 on the rig, 11x fewer pages measured live), applied at startup like the composer's indexes. The deadline does not move. -- **The viewer's tray Snooze now silences the toast itself** ([#3570]) - Snoozing or silencing an alert from the Darling viewer wrote the mute rule and then waited for the background service to reload its own cache and flag the next alert muted before the tray went quiet; when that reload was slow or failed, the rule sat in Manage Mute Rules while the toasts kept coming. The viewer now applies its own mute rules to the tray on the very next poll, the same way Lite always has in-process, and the status bar says what stops now (the tray) and what the service applies within 15 s (email/webhook). A snooze that could not be saved is now reported in the status bar instead of only logged. -- **The compression-stuck self-alert no longer pages on a healthy job's run instant** ([#3575]) - TimescaleDB's job_stats view reads job_status from pg_stat_activity and next_start from the job-stat row, so for a few milliseconds at either edge of every run it reports the dead-job shape (next_start = -infinity, not Running); a production store paged on exactly that, 53 ms into a 63 ms run that succeeded. The check now re-reads five seconds after a -infinity trip and reports the job only if it persists, and its hourly sample is pinned to :30 past the minute, off the :MM:00 instants the compression policies fire on. Re-arm and escalation semantics and the six-hour hung-run bound are unchanged. -- **Text on an accent fill gets a measured ink in every theme, and the FinOps row marks become theme brushes Dark can actually see** ([#3577]) - The selected tab on Cool Breeze read 2.71:1 because the TabItem's selected-state Foreground never reached the header text (the app-level implicit TextBlock style out-ranked it); the header presenter now shadows that style and a per-theme `AccentForegroundBrush` is the ink on every accent fill (5.39:1 on Cool Breeze, 7.52:1 on Dark, unchanged on Light), applied to tabs, highlighted combo items, accent buttons, the calendar and Dark's grid selection. The "Mark Done / To Do / Do Not Do" row tints move from three fixed 20% overlays (1.2-1.4:1 against Dark's rows) into theme brushes, with Dark's built from its own status colors at 2.9-3.1:1 while row text holds AA. -- **The duration-trend trio routes by retention tier and says what it served, so a 7-day request no longer returns 4 days labelled quiet** ([#3541] A2) - get_query_duration_trend and get_procedure_duration_trend read raw query_stats / procedure_stats only, whose rows a TimescaleDB store drops at four days, while hours_back accepts 168 — a 7-day request came back as 4 days under a label saying 7, and when nothing survived the empty branch called the window "genuinely quiet — widen hours_back", which is false (dropped, not absent) and harmful (widening cannot help). Both now route through the ladder get_query_trend already uses (age → availability → materialized coverage) onto the hourly rollups, dividing by the bucket width instead of a LAG, and every sibling — the Query Store one included — publishes `source`, `effective_start`, `effective_hours_back`, `truncated`, `bucket` and `aggregate_note` on the data path and the empty one, with the empty branch naming an unserved head and `--backfill-rollups` where widening cannot help. get_query_trend gains the availability and coverage rungs (it answered 42P01 on plain PostgreSQL past four days). Lite's twins, get_query_trend included, publish the same block with Lite's truth (raw, per-collection); `value` gains its named twin `elapsed_ms_per_second` on both SKUs. -- **Analysis facts divide by the time the collector actually observed, and a window with a hole in it says so** ([#3538] A2) - Every wait fraction, blocking rate and deadlock rate divided by the nominal window, so collector downtime deflated severity in proportion to the data lost: a CXPACKET storm at a true 25% read as 6% with the collector down three of four hours, and nothing consulted collection health. Both SKUs now stamp observed coverage from the wait_stats collection series (real LAG intervals, an interval past the delta gap policy credited as zero, first row clipped to the window) and divide by it; an unobserved window emits no rate fact and composes with the #3524 unavailable envelope even when point-in-time config facts exist. Below 70% coverage a COLLECTION_GAP context fact carries the fraction and largest gap, and analyze_server, get_analysis_facts and compare_analysis carry a coverage block and a partial-coverage caveat. -- **SQL Server's Poison Wait alert measures accumulated starvation over a ten-minute window like its PostgreSQL twin, so one slow wait no longer pages and a THREADPOOL storm no longer sleeps** ([#3539] A4) - the alert judged ONE collector delta's average ms per wait against a 500 ms bar, presence-flat CRITICAL: a single 600 ms wait paged, and ten thousand 50 ms THREADPOOL waits - 500 seconds of worker starvation a minute - never moved the average. The PostgreSQL edition had fired on TOTAL accumulated wait over a rolling ten-minute window since [#2711], graded WARNING at one backend continuously stuck (600 s) and CRITICAL at ten, under the same alert name, switch and mute key - so one mute rule meant two things. Both SKUs' reads now SUM every wait_stats delta per poison type over the window (no completed-task filter, no row cap, no threshold in the read), a shared PoisonWaitEvaluator grades the sum against constants the PostgreSQL evaluator now aliases rather than duplicates, and the message shape mirrors PostgreSQL's clause for clause. Measured first on one production store class (43 SQL Server primaries, four days, 24,757 server-ten-minute buckets): the worst bucket anywhere held 5,795 ms of THREADPOOL - 0.0097 average waiters, ~100x under the WARNING bar, the same order as the PostgreSQL research's 160x - while the old trigger's near-misses showed both wrong shapes (single rows at 247 ms over 2 tasks; a 703-task row averaging 8 ms). The clear arm now needs an observed window: a collector that stops delivering holds the alert open instead of announcing "Cleared" on silence. The `poison wait threshold (ms)` setting stays persisted and reported but is no longer consulted; both Settings windows say so and disable the box. -- **Six MCP pages now say what bounded them, so a limited page stops passing for a complete answer** ([#3541]) - `get_blocking`/`get_blocked_process_reports`, `get_deadlocks`/`get_deadlock_detail`/`get_blocked_process_xml`, `get_alert_history`, `get_long_query_completions`, `get_plan_corrections`, `get_waiting_tasks` and `get_wait_stats` carried a hidden reader cap (`LIMIT 200`/`50`/`500`, or none) under a tool that advertised `limit`, took `limit` off the top, and published the capped count as `total_*` - so an agent read a 200-row page of a 5,000-event window as the window, and "widen hours_back" could never help because the cap was on rows. One pattern on both SKUs, the one [#3287] established: the cap binds to the caller's `limit` as a SQL parameter, the read fetches `limit + 1` and reports `truncated` only when the extra row existed, the page publishes `oldest_returned_*`/`newest_returned_*` and its `order`, and every page count is `*_returned`. `get_alert_history` now states and measures its `dismissed = FALSE` filter (`dismissed_excluded`, `dismissed_excluded_count`) and takes `include_dismissed`; the dedup_key fingerprint scan on `get_blocking`/`get_deadlocks` honours [#2159]'s whole-window promise up to a stated 2,000-row ceiling (`rows_examined`, `scan_truncated`); Lite's `get_long_query_completions` now keeps the window's SLOWEST like Darling instead of the newest 200 re-ranked, which could omit the slowest run entirely. -- **The four naked delta families store the interval their deltas accrued over, so a restart's fabricated zero reads as unknowable instead of 0.00 ms/sec** ([#3540]) - wait_stats, file_io_stats, latch_stats and spinlock_stats discarded the calculator's measured interval at the write, so its (0, 0) "no delta knowable" marker could not survive and every per-second reader LAG-divided a restart's zero into a confident 0.00 (file-I/O latency rendered "0.00 ms" mid-restart; the wait-rate window counted the restart as a sample). Darling V127 / Lite v60 add sample_interval_seconds to all four (perfmon_stats and query_stats already had it); the collectors write the minimum over each row's delta groups; every reader treats a stored 0 as NULL (the point is absent, MCP fields are null), a NULL as a pre-upgrade row that keeps its LAG-derived interval, and a measured value as the divisor. The wait_stats_baseline continuous aggregate still sums the restart zero - the documented follow-up is a new aggregate, since a rebuild would forfeit 35 days of baseline history. -- **Blocking and CPU health bands are rates over the window they were measured in, tiered from 14 days of fleet blocking and CPU data** ([#3539] A2/A3/A8d) - `BlockingSeverity` banded a raw count over a caller-chosen 1–168 h window (`count >= 5 → Critical`), so five blocked-process reports were Critical at a week's read and Healthy at an hour's; the daily classifier reddened a cell on six hot CPU samples or eleven blocking events whatever the span (a 15-minute sweep or a 24-hour day — 5.9% and 5.1% of measured server-days), and on a single collection ERROR row. Blocking now bands reports per hour (Warning 5/hr, Critical 20/hr — the tiers sit at the top of the measured quiet mode and the foot of the storm mode, with the 60 s block a rate-independent Critical), the calendar/sweep delegate to that band over their own window, the high-CPU bar scales with the window (an excursion-scale minimum of 6 below ~5 h, a sustained-heat 30 per day above), collection errors band as a share of the window's runs against the collector-health classifier's own 20% bar at its Warning tier, and the collector dot grades one failing collector of forty apart from forty of forty. Cards, calendar tooltips, sweep evidence and the MCP day tools disclose the rate or share they banded on. -- **get_store_metrics stops answering for 38% of the store: continuous aggregates and the named plain tables join the inventory, every sweep is reconciled against pg_database_size, and the block says its own coverage** ([#3582]) - On the largest production store the inventory accounted for 159 GiB of 415 GiB, because timescaledb_information.hypertables never lists a materialization and the walk never named collect.query_store_text and its siblings. The hourly sweep now writes one continuous_aggregate row per aggregate (sized through its materialization, under its view name), three table rows, and two catch-all rows (other / system), and the tool reconciles one sweep's rows against that sweep's pg_database_size, states enumerated and attributed coverage with the residual and a reconciled verdict, and names the largest un-enumerated relations live. Each aggregate object carries compression_enabled and its refresh/compression/retention policy job ids read from the catalog. The same sweep persists the owner's own job_history count so the managed-mode block (#3574) is a measurement rather than a GUC echo, and the GUC-off note no longer claims an empty view — failed runs are written regardless. -- **The twenty continuous aggregates join the compression ladder** ([#3581]) - Every raw hypertable compressed since the archival tier existed; no continuous aggregate ever did, and on the largest production store the twenty materializations were 235 GiB of a 415 GiB database — an uncompressed rollup of a 9x-compressed source is larger than the source. An idempotent startup ensure now enables columnar compression on each materialization (segmentby server_id, orderby bucket) and attaches a once-a-day policy whose compress_after is derived from the tier's refresh window plus one raw chunk (2 days for hourly-refreshed aggregates, 4 for the dailies), so a refresh never decompresses what a policy just compressed. The jobs run off the hourly phase grid, one aggregate per hour at :35Z, and on an existing store the first runs are staged one aggregate per night, largest first, in the schedule itself; a fresh store gets all twenty at once. -- **PostgreSQL MCP percents name their denominator, so a three-row page stops summing to 100% of everything** ([#3541] A7) - `get_pg_top_queries`, `get_pg_wait_stats`, `get_pg_wait_sampling`, `get_pg_kernel_stats` and `get_pg_io_stats` divided every row by the sum of the rows they had fetched and published it as `pct_of_total_*` beside a `total_*` that was the same page sum, so at `limit = 3` the three shares summed to 100% by construction and read as "these three are everything"; `get_pg_top_queries` compounded it with a literal `LIMIT 50` under `Take(limit)`. Each reader now computes the window's total on the SAME statement as its rows - a `SUM(...) OVER ()` over the grouped result, evaluated before `LIMIT`, so it cannot drift from them and costs no second read - and each tool fetches `limit + 1`, observes `truncated`, publishes the window figure as `total_*`, the page's own sum as `returned_*`, the ratio once as `returned_pct_of_total`, and says in its description which denominator its shares use. Executing the statements against live PostgreSQL 18 also found that `get_pg_kernel_stats` had never been ranked by CPU: its `ORDER BY 3 + 4 DESC` is an expression PostgreSQL folds to a constant and drops, so every page was the alphabetically-first series; it now sorts by the named differenced columns, and the Viewer's kernel grid inherits the fix. A cross-SKU census over every paged tool body pins the rule, with `get_pg_database_stats`' disclosed page-summed totals as its one stated allowance. -- **Every delta family is seeded from the store at service start, and the series-age rescue finally has passes to read, so a restart no longer fabricates one interval of quiet for six families** ([#3540] A4) - both hosts' restart seeders covered four of the ten delta families, so `latch_stats`, `spinlock_stats`, `procedure_stats`, `query_stats` and the PostgreSQL wait/statement pair re-baselined on every restart and deploy and stored one interval of fabricated quiet each time - and the per-group pass window that the #2235 recompiled-plan credit reads was never seeded at all, so that credit was inert on exactly the post-restart pass it exists for. Every family a host monitors now restores its keys (latest row per key inside the 15-minute window via `DISTINCT ON` for the collectors that do not write every key every pass; the bounded latest-collection probe for the rest) and its pass window from the same read, under a per-family guard so one slow or missing table cannot cost the others their continuity; `query_stats` restores its pass window only, because its delta key carries statement offsets the store does not persist (a rung, tracked on #3540). `ClearServer` is wired into Lite's server-removal cleanup and Darling's reconcile-remove branch, so a remove-and-re-add inside the gap policy's hour starts from a first pass instead of subtracting another server's counters. A census in Lite.Tests reads both hosts' seeders against the calculator's family list and each collector's own delta-group names, so an eleventh family cannot ship unseeded. -- **MCP write tools report what happened** ([#3541] A14) - `add_servers` counted a `collides` refusal in no counter, so a collided server went unmonitored under `failed: 0`; every status now maps to exactly one of `added / skipped / collided / failed`, which sum to a new `requested`. `remove_server` no longer deletes the first partial match of an ambiguous name - it refuses with the candidates listed and honors a partial only when unique. `update_custom_view` and `update_custom_alert_rule` share one vocabulary (omitted = unchanged, empty string = cleared; the view tool used to clear on omission). `mute_analysis_finding` on both SKUs reports `registered` and `matched_now`, says `muted_unmatched` for a hash no stored finding carries, and surfaces a swallowed store failure instead of `muted`. The instruction table stops denying the Entra modes #3484 accepted, and `/api/read/get_alert_history` gains the `include_dismissed` parameter. -- **The scorer's wait thresholds carry their measurement: WRITELOG stops saturating on a third of routine windows, deadlocks grade 5/hr apart from 90/hr, and the absolute gates scale with the hours actually observed** ([#3538] A5/A7) - Every `GetWaitThresholds` entry now names its lineage against the 43-server dogfood read (1,075 server-4h-windows) or says "unmeasured", and a census pins that. WRITELOG's inherited (0.10, null) saturated base 1.0 on 339 of 1,075 windows (31.5%) and is re-derived to (0.25, 0.50); DEADLOCKS adopts the alerting layer's measured (5, 20) instead of saturating at the WARNING entry; the 0.01-saturating waits ramp to (0.01, 0.10); HADR_SYNC_COMMIT - the fleet's second-largest wait, previously invisible to the engine - gains an entry, evidence-gated advice that names synchronous commit as a durability policy (never "switch to async"), and graph edges to and from WRITELOG; PREEMPTIVE_OS_QUERYREGISTRY is an explicit no-threshold entry with its fleet-uniform measurement. THREADPOOL (>= 15 min per observed hour + 1 s avg) and PAGELATCH_UP (> 10 s per observed hour, the ported source's own hourly bar) now divide by observed time, so hours_back no longer changes the verdict on an unchanged server. The five CALIBRATE ON SQL2025/HAMMERDB markers are replaced with what the fleet pass did and did not measure. -- **Analysis pages with long compound stories now reach Slack instead of dying with invalid_attachments** ([#3612]) - The Slack builder rendered every structured detail without ever counting blocks, and a five-fact plan-regression story — the highest-severity compound finding the product makes — carries enough drill-down and incident items to cross Slack's 50-block message limit; three such pages were lost across two builds. Details are now budgeted the way #3493 budgeted the prose: head and footer costed first, the longest leading run of details kept, the rest dropped with one omission item naming what was dropped and where the full page lives. Bodies split under their heading through the same splitter and fields cap at Slack's 2,000-character field limit as hygiene; every page that fit before renders byte-identically. -- **Continuous-aggregate materializations are chunked at one raw chunk, like every raw table** ([#3620]) - TimescaleDB sizes a rollup's chunks at ten times the raw table's interval, so every aggregate carried 10-day chunks: the 7-day interval tier held up to 17 days and compression could not reach the newest ten days of any rollup. The startup ensure that compresses the aggregates now holds each materialization at the raw chunk width, derived from the one constant so the tiers cannot drift apart. Existing wide chunks age out on their own schedule, so short rollups tighten to their designed hold over about two weeks rather than overnight. -- **The PostgreSQL first-target runbook stops denying three capabilities that ship** ([#3608]) - §12 and step 9 said plan capture, blocking chains and configurable alert thresholds did not exist; all three do. Step 9 now lays out all eight PostgreSQL alert families in two groups — the three Tier 0 predictors, which carry no knob by decision, and the five shared-name alerts, two of which have their own PostgreSQL count thresholds (`pgDeadlockCountThreshold`, `pgBlockingCountThreshold`, #3444) — and §12 points each struck denial at the step that carries it. Same-vintage drift in the README's "not yet" sentence, the blocking design note's "not started" header, and the runbook's schema version (v114 → v127) corrected in the same pass. -- **Slack text cuts land on whole characters, not UTF-16 indexes** ([#3622]) - The six places the Slack builder cuts text to a limit — the prose hard split and omission fragment, the detail heading, the field label and value, and the omitted-headings list — cut by UTF-16 index, so an emoji or accented letter astride a limit reached the reader as a replacement glyph the value never held, the hard split showed two of them and no emoji, and a cut field's "N more characters" counted code units. Every cut now lands on a whole character through one helper, falling back to a code-point boundary only when a single character is wider than the whole limit, and the field's omitted count is in characters the reader can count. -- **A not-yet-valid web TLS certificate now raises the self-alert instead of reading as healthy** ([#3517]) - a `web.network.tls` certificate whose `NotBefore` was still ahead at service start (a skewed clock, or one issued for a future rotation) is refused and the LAN dashboard binds loopback-only, but the #3514 self-alert derived everything from `NotAfter` and saw a far-out expiry. The web host now carries its refusal verdict to the sweep, which fires the same `Web TLS Certificate Expiring` family at Critical — same key and mute scope — naming the validity window, the loopback-only consequence, and the restart the host needs to re-decide. -- **Light and Cool Breeze status colors read against their own page, and text on a status fill gets a theme ink** ([#3609]) - Light's Warning and Info and Cool Breeze's Warning were under the 3:1 marker floor against their page (2.47, 2.32 and 2.09:1) — the new Settings contrast readout painted the stock palette red. Re-derived to clear 4.5:1 on the page and the card, and a new StatusForegroundBrush carries the text on the Recommendations severity badge and the viewer's alert badges, which had hard-coded inks (the viewer's White was 1.41:1 on Dark's amber). Dark is unchanged. -- **Forced Plan Failing fires once per observation, not once per cooldown** ([#3579]) - The adapter now returns the collection that produced the rise and the engine remembers which one it already reported, so a plan whose force failed once produces one card instead of one per cooldown until the next collection lands (six cards for one event on a production store). A plan failing across successive collections still re-fires per collection; recovery is unchanged. -- **The compression dead-job alert now says what a -infinity row is on the store's TimescaleDB** ([#3591]) - Below TimescaleDB 2.26.4 the sentence "the scheduler will never run it again" stands and the job is re-armed once as before. From 2.26.4 on (upstream #9360) a persistent -infinity is a crashed run in the scheduler's own crash backoff; the alert says so, and the service no longer re-arms it — measured on 2.28.1, alter_job against a job in crash backoff resets the backoff rather than shortening it and would have posted a false Recovered. Such a row is logged on first sight and pages Critical only if the scheduler's retry has not cleared it an hour later. -- **Every delta family now stores the interval its deltas accrued over, and query_stats stores the statement offsets its delta key is made of** ([#3540], Darling V128 / Lite v61) - V127 dressed four of the naked delta families; this dresses the last four (`procedure_stats`, `memory_grant_stats`, `pg_wait_stats`, `pg_statement_stats`), so the calculator's (0, 0) "no delta knowable" marker reaches the store from all ten and the procedure duration trend, the per-statement PostgreSQL trend and `get_resource_semaphore` stop reading a restart as 0.00 ms/sec, 0.00 calls/sec or a quiet semaphore. `query_stats` gains `statement_start_offset` / `statement_end_offset` (byte offsets into the batch text, `-1` = end of batch, stored verbatim), so both hosts' restart seeds rebuild that family's delta key from the store instead of restoring only its pass window; pre-upgrade rows (NULL offsets) still feed the pass window and seed no fabricated key. The census's still-naked list and the seeding census's pass-window-only set are both empty and asserted so. -- **The File Growth threshold means one thing — megabytes per hour — at every surface that shows it** ([#3539] A8c) - The rise knob was compared against the raw growth inside the lookback window while the lookback was a second knob clamped 5–1440 minutes, so the same 10 GB bar meant 10 GB per five minutes on one store and per day on another. The knob is now a rate averaged over the lookback (`rate × lookback / 60`, byte-identical on the shipped 60-minute default); both Settings rows, both preview lines, the alert's threshold line (rate, window, and the bar in MB), the card and both MCP descriptions say "MB/hr averaged over the lookback" in one shared phrase a nine-surface census holds. Key, column and stored value unchanged. -- **Story confidence measures corroboration instead of path length, and the nightly rebuild's three cards become one incident that names the job** ([#3538] A6/A9) - `confidence` was (n-1)/n over the story path with a lone symptom at 1.0, so the least-evidenced finding ranked highest under an evidence name. It is now 0.20 for the fired symptom plus up to 0.48 for the share of the root fact's amplifier checks that matched and up to 0.32 for chain depth; both SKUs publish `confidence_basis`, define the term, label pre-change rows `path-shape (pre-#3538)` by their provably-disjoint value shape (no schema change), and name an anomaly fact's baseline trustworthiness `baseline_confidence`. Three symptom → RUNNING_JOBS graph edges (SCH_M, IO_WRITE_LATENCY_MS, WRITELOG), gated on the job having fired, fold a maintenance window into one incident whose advice names the long-running job's overrun. -- **The daily digest and sweep rollup no longer re-announce on a service restart** ([#3580]) - Both once-a-day gates lived in process memory, so the first tick after any start delivered both documents again; on one install night three restarts produced six re-posts among ~23 channel posts. The gate now stamps delivered-today in the store's existing state table (no migration) and reads it back after a start, while a delivery the channel reported failed writes nothing, so the next tick still retries it. -- **compare_analysis bands each delta by the server's own dispersion and folds one cause into one row, so same-hour-yesterday noise stops reading as a verdict** ([#3538] A3) - The tool compared one window against one and banded every key by its severity delta on a flat ±0.1 dead-band, so a saturated ladder's doubling read "stable", a trace wait's slope read "worse", one I/O stall was six worse keys, and plan-cache hash churn inflated new/resolved counts. Both SKUs now share one `ComparisonBanding`: keys with a same-unit per-server baseline (CPU %, read latency, connections) are banded in that hour's robust sigma (`delta_sigma`, `band_source: "baseline"`); every other key changes status only when the value moved ≥ 25% of the larger side AND sits ≥ 0.25 up its own severity ladder; `BAD_ACTOR_*` appearances are `plan_cache_churn`; rows carry a physical-cause `family` with one family row per cause; the rules are stated in `band_rules`, every verdict row flags `coverage_caveat` when a side was partly observed, and the description says what "worse" cannot mean at N=1 vs N=1. -- **A server nothing has banded yet is Unknown, not Healthy, and the alert-history grids show the severity the alert fired at instead of the colour its name implies** ([#3539]) - A collector dot with zero banded collectors read Healthy, and an online server on which not one metric was measured folded to Healthy and counted in the fleet's healthy mass with "0 of 6 measured" as its only tell; both now read Unknown, and the nothing-measured card bands Warning like a server awaiting its first collection, with the reason "no metric measured yet" on every surface. Both Alert History grids classified a row by its metric NAME, so a Warning-graded Poison Wait rendered red and a Critical-graded low-disk fire amber; the alert's fired severity is now persisted in the row's context JSON on both SKUs (no schema change) and every grid, both SKUs' get_alert_history (severity + severity_source) and the web alerts page render it, falling back to the name only for rows that predate it. -- **Every latest-snapshot MCP read says when it was captured, and no tool accepts a window it does not read** ([#3541] A10) - Latest-snapshot reads (memory stats/clerks, file I/O, perfmon, the on-connect configuration family, plan cache, scheduler) answered with the newest row a store held and nothing saying when; two memory-grant tools took hours_back and read only the newest row in it, so a grant storm three hours ago was invisible. Every such read now publishes captured_at (anchored ones age_seconds against as_of); get_resource_semaphore/get_memory_grants read the window (peak waiters and when, summed timeout/forced deltas) beside the stamped snapshot; get_cpu_scheduler_pressure has one (server_name, hours_back, as_of) contract on both SKUs and Lite publishes its verdict; get_server_summary names its three clocks; the latch band names the interval it came from. Census-pinned on both SKUs. -- **PostgreSQL servers get a measured deadlock band from their own counters, their Long-Running Query alert skips maintenance like SQL Server's does, and every one-sided alert says why it is one-sided** ([#3539]) - The fleet card's deadlock dot read Unknown on every PostgreSQL target while the store held the server's own `pg_stat_database.deadlocks` counter. Both fleet surfaces now difference that counter per database (reset-clamped, summed) and band it through the same per-hour tiers as SQL Server's graph count, measured only where a difference was actually taken; the coverage block counts those servers as read and names the instrument. The PostgreSQL Long-Running Query read gains the noise opt-outs SQL Server's has had (autovacuum/walsender, VACUUM/ANALYZE/REINDEX/CLUSTER, pg_dump-family on the shared backups switch, excludedDatabases), and the Darling README gains an engine-coverage table stating why each remaining one-sided alert and band is one-sided. -- **Database File Growth's rise arm fires once per hourly observation, not once per cooldown** ([#3636]) - The rise gate reads a stored delta between two collections of a collector that runs hourly, and re-fired on every 5-minute cooldown against the same two rows — up to twelve cards per growth event. Both SKUs' reads now return the newest sample's collection_time as the observation's identity, and the engine remembers per (server, database, file) which observation the rise arm last fired on and declines to re-fire it regardless of cooldown; a file still growing across successive hourly collections re-fires per collection, and the level gate (file ≥ X% of volume) re-fires on the cooldown exactly as before. #3579's mechanism, one condition over. -- **The daily summary stops painting purged months green, and every MCP filter is part of the query** ([#3541] A9/A13) - The daily aggregate's day spine outlived the signals it banded: the seven per-signal tables purge at 30 days, the collection log at 60 and the alert log at 90, so for every day in between the spine still had the day while deadlocks, blocking, CPU and memory had all been dropped and each `COALESCE`d to a MEASURED zero - which bands Healthy - and a 366-day `get_daily_summary_range` painted the purged months green. Both SKUs now decide each day from one shared `DailySummaryRetention.StateFor`: the reader's effective retention horizon (Darling: the shortest fleet-effective signal retention, so an operator-shortened retention moves it; Lite: its archive horizon; wall-clock deliberately, because a backdated `as_of` cannot un-purge a table), a `signal_sources_present` count so "the tables no longer hold it" is never said of a held row, and #3596's `collection_runs`. Days read `collected` / `purged` (NoData, never Healthy) / `past_horizon` (rows survive, verdict withheld) / `no_run_record` (disclosure only), the range publishes `retention_horizon` and the counts, and `summary_date` is ISO-only. On the filter side `parallel_only`/`min_dop` are a HAVING floor before the CPU ordering and cap instead of a `.Where` over an already-cut page, `get_active_queries` pushes `database_name`/`blocking_only` into SQL, counts the filtered population with `COUNT(*) OVER ()`, joins the paged dialect and never strips a head blocker a row in the same capture names (`blocker_not_shown` says `not_captured` / `filtered` / `past_page` otherwise), three uncapped reads refuse a non-positive `hours_back` instead of `Math.Abs`-ing it, and `get_analysis_facts` validates `source` against `FactScorer.KnownSources` (fifteen, pinned to every literal) and refuses with the whole set. -- **Zero is a measurement: health parsers say whether their source was ever seen, a regression with no baseline stays null, and the first point of a differenced trend is no longer a fabricated 0** ([#3541] A12) - Eight of the nine `get_health_parser_*` tools answered a dead system_health session with the same `empty` a healthy hour earns; every one now carries `source_observed` / `last_captured_at` and a nothing-ever-captured store answers `unavailable`. `get_query_store_regressions` keeps a NULL percent null (a 0 baseline has no ratio) with the reason under `undefined_percents`; the duration trends publish the window's first collection with null rates and `unrated_points` instead of 0.0; `get_pg_xmin_horizon` divides by every capture in the window (the alert evaluator's own denominator); `get_pvs_stats` reports a measured 0 MB as 0.00% with `pvs_measured`; `get_table_index_sizes` derives growth only from baselines the store holds, with `history_days_available` and `growth_over_available_history_*`. -- **The interval-hourly Query Store refresh stops paying twelve index inserts per re-materialized row for eleven indexes nothing reads, and the capture-down alert read stops decompressing a server's whole collection log to learn two statuses** ([#3597]) - Measured on a TimescaleDB rig: a refresh recomputes exactly the hour-buckets any write dirtied, so a single backdated row re-materializes the whole fleet's hour, and each of those rows carried eleven per-column group indexes on the dedup materialization that no reader uses. The aggregate is now created without them and existing stores drop them at startup under a lock timeout that yields to a refresh in flight. The capture-down self-alert read, the heaviest statement on the alert pass, now asks each collector for its newest row through the partition column and stops at the newest chunk. -- **Top CPU Queries reads as one record per query on Slack, not seven fields interleaved across a two-column grid** ([#3644]) - A drill-down's rows now travel as records beside their flat fields, and Slack renders each as a bold summary line over its SQL in a code block, packed into as few sections as fit. The five-fact analysis page's fixed items cost 20 blocks instead of 33, so thirteen incidents fit where six did and the three pages #3612 could only deliver by dropping incidents now deliver whole. Email and Teams render the same compact list; every payload that carries no record array is byte-identical. -- **Top Cpu Queries' Max Dop is the newest plan's reading, with the cross-plan maximum kept as a dated history** ([#3648]) - The High CPU card's drill-down (and the bad-actor detail) reported MAX(max_dop) grouped by query_hash, which folded every cached plan's lifetime high-water mark into one provenance-free number: a MAXDOP-1 instance whose stored plan was serial read 16 and drove a tuning recommendation that had to be retracted. max_dop is now the newest plan's DOP; max_dop_any_plan, max_dop_any_plan_last_seen, plan_count and a dop_note sentence carry the history beside it, and an unknown reading is null rather than 0. Both SKUs, byte-identical SQL. -- **The force-plan remediation said "eligible, no blockers" for plans automatic plan correction already owned, had failed to force, or had withdrawn** ([#3652]) - The verdict now reads the store's forcing and APC state at read time — `query_store_stats` (is_forced_plan, plan_forcing_type, force_failure_count) and `plan_correction` (recommendation state/reason, last-good plan, FORCE_LAST_GOOD_PLAN enablement) — and adds five named blockers with evidence and snapshot time: `apc_owns_it`, `already_forced`, `forcing_failed_on_this_plan`, `apc_withdrew_it`, `apc_resolved_differently`. When APC is on for the database the target carries `apc_mode: on` and a guidance sentence ("the engine is Verifying via plan N; intervene only if it reverts or expires"), and whenever the state could not be read the target says so in `state_note` rather than reading as eligible by silence. Both SKUs; the in-app arming gate disarms on the new blockers unchanged. -- **A Claude review that posted nothing no longer finishes green** ([#3650]) - the reviewer's allowlist forbade every read tool the prompt invited, so swallowed runs read denials ≈ turns and ended without a verdict. Read-only tools (Read, Grep, Glob, git diff/log/show) join the allowlist; the job now fails itself when no non-empty-bodied claude[bot] review was submitted since the run's start, with the transcript's result block in the log and the transcript retained seven days as an artifact. -- **The deprecated Dashboard mirrors five of the brains-review honesty fixes in its own idiom** ([#3653]) - The frozen Full-edition Dashboard (bug-fix support) said the same five untrue things the shipping SKUs fixed today: `get_blocking` / `get_deadlocks` / `get_alert_history` published a capped page count as a total (now `*_returned` + `truncated`, with the reader's fixed cap named as `limit_applied_by_reader`); the Poison Wait alert paged on one slow wait's average and slept through a THREADPOOL storm (now accumulated over the ten-minute window and graded on the shared `PoisonWaitEvaluator` bars, clearing only on an observed quiet window; the ms preference is retired but round-trips); `mute_analysis_finding` answered "muted" for any hash (now `registered` / `matched_now` / `muted_unmatched`); an online server with no collector banded was a green "OK" (now Unknown / `--`); and the Perfmon per-second rate was integer division (now fractional on the read). The anomaly detector's "calibrate on the lab box" markers now state what the fleet pass measured and that it never reached the Dashboard tier. The wait-fact nominal-window divisor stays declined per the issue. -- **Six small honesty riders from the brains-review residue** ([#3653]) - `poison_wait.threshold_ms` (both SKUs) now carries `threshold_ms_note` saying #3593 retired it, and Darling's `update_alert_settings` stores it with a `warnings[]` entry instead of pretending it tunes anything; `get_pg_server_config` publishes `captured_at` and joins the latest-snapshot census the `GetCurrent*Async` name had kept it out of; Lite's `get_latch_stats` / `get_spinlock_stats` bind their hidden `LIMIT 20` to the caller's `limit` and report `*_returned` / `truncated` (the grid keeps its 20 by name); a no-server census fails any reader on either SKU whose `ORDER BY` is an integer expression PostgreSQL/DuckDB would fold to a constant (zero hits today); V79/V122 rung docs name the PRs that superseded them; Lite's `analyze_server` recommends next reads for `HADR_SYNC_COMMIT`. -- **The PostgreSQL poison-wait host holds on silence like the SQL Server engine does, and three presence-flat alerts grade their severity from the bars the health bands already measured** ([#3653]) - The PG Poison Wait host announced "Cleared" the moment its read came back empty — collector silence read as recovery. Because `pg_wait_stats` skips idle events (#2694), the rows cannot witness their own absence, so the read now carries the collector's own `collection_log` run count over the same window and the host clears only on an observed window (the #3593 contract, ported). Deadlocks Detected grades Warning/Critical on the #3368 rate tiers (Darling's V120 knob honoured via `IAlertEngineSettings.DeadlockRateThresholds`; Lite the shipped pair), High CPU grades Critical at the CPU health band's 95% bar, tempdb Space fires an explicit Warning with no Critical tier (no measured bar exists to cite) — so history grids, `get_alert_history` and every channel render the tier the alert fired at instead of the colour its name implies. -- **The Darling viewer's trend charts and calendar tell the same truth the MCP tools learned today** ([#3653]) - The Performance Trends tab read the raw tier only, so a 7-day chart on a TimescaleDB store plotted the 4 days raw still held under an axis that said 7; the query-duration, procedure-duration and execution-count charts now route by retention tier through the same ladder and hourly SQL the MCP trend tools use (moved to Storage as `DurationTrendRouting`, pinned equal on both sides) and each chart titles itself with the tier it served from and a truncation note when the store no longer holds the window's head. The viewer's trend SQL no longer fabricates a 0 for the first differenced point; an unrated point is skipped, not plotted or interpolated. The Performance Calendar judges every day against the store's retention horizon with the one `DailySummaryRetention` decision the MCP reader makes (`DailySummaryHorizon`, Storage; the purge's retention constants and fleet rule move down and the service aliases them), so a purged day is grey, not green, and its tooltip says why - on both SKUs. The PVS top-5 trend no longer plots an unmeasured size as 0 MB (Lite's `get_pvs_trend` carries it as null with `pvs_measured`). -- **`get_pg_server_config` counted the page and called it the server** ([#3653]) - `non_default_count` was a count over the rows fetched, so a limit below the number of chosen settings reported the limit as a fact about the snapshot, and `truncated` was inferred from a full page — always up on the default view. The count is now the snapshot's, computed on the row statement above the cap; the page's own count is `non_default_returned`; the `include_defaults` filter is in the statement so `truncated` is about the population asked for; and the three sibling pages in the same file observe truncation off a `limit + 1` fetch. -- **The four PostgreSQL host alerts fire with the tier they earned instead of no tier at all** ([#3653]) - High CPU, Deadlocks Detected, Blocking Detected and Long-Running Query on a PostgreSQL target passed no severity, so the history grids, get_alert_history and every channel coloured them by name after #3635. CPU now grades on the CPU health band's own classifier (Critical at 95% of the configured ACU ceiling), deadlocks on the shared rate grader against the store's deadlock tiers, blocking and long-running query as an explicit Warning with the missing measured bar named. Rows written before this keep their by-name colour. -- **Darling's `get_pvs_stats` trend drew an unmeasured pass as 0 MB** ([#3653]) - a collection on which the DMV reported no PVS size for a database was published as a real zero in the top-5 series, a cliff in a series that had none. The point is now null with `pvs_measured` beside it, the same two keys Lite's twin has carried since #3666; a measured 0 MB is still a zero. -- **The Query Store duration chart now says what served it and where the rollup's floor cut the window** ([#3653]) - The viewer's fourth Performance Trends chart plotted what the corrected Query Store rollup had materialized under an axis spanning the requested window, with no title; it now carries the sibling charts' disclosure — the route word the MCP tool publishes, the grain seam, and a "data begins" clause only when the rollup's measured floor sits above the requested start. The MCP trend reader's tier ladder and hourly SQL became aliases of the Storage definitions rather than pinned-equal copies, so the tool and the viewer cannot drift. -- **The analysis pass no longer says "collection appears to have stopped … NOT an all-clear" for a window the coverage witness proves the collector observed** ([#3653]) - The empty-window rule in both analysis services tested `facts.Count == 0` before it tested the coverage witness, so an observed window that simply produced no fact wore the dead-collector envelope: `unavailable` with a pointer at collection health from `analyze_server`, and the Viewer's dead-collector marker from the scheduled pass. The rule now gates on `ObservedDurationMs <= 0` alone; an observed window with no facts runs the pass and reads `empty` at its stated coverage, with one Information line naming that coverage for the scheduled pass. -- **The PostgreSQL analysis vocabulary absorbs what six content lanes reported back** ([#3542]) - Two `pg_config` facts were inert by construction: `autovacuum = off` and `maintenance_work_mem` had no scorer arm, so they scored 0 and no co-fire could lift them; `autovacuum = off` is now a 0.9 posture fact and `maintenance_work_mem` is evidence-gated on the backlog the way `work_mem` is on the spill. The connection ceiling subtracts PostgreSQL 16's `reserved_connections`, edges can name "the bad actor" through a stable `PG_BAD_ACTOR` alias the graph resolves to the window's heaviest statement, and a bad actor's next reads lead with `get_pg_query_duration_trend`. -- **A target that restarted, failed over or was re-pointed no longer keeps subtracting from the old instance's counters** ([#3653]) - Every delta family subtracted from a baseline cached under the server_id with nothing checking the readings came from the same instance; a failover to a busier replica stored `new total − old baseline` as one interval's work. Both hosts now detect an identity epoch on a read they already make — `sqlserver_start_time`/`@@SERVERNAME` for SQL Server, `pg_stat_statements_info.stats_reset` for the PostgreSQL statements family — compared against the pair persisted in collector_state, forget the affected baselines before subtracting, mark the run's collection_log note (`identity_epoch_changes=1`) and log old→new at Information; Darling's same-id reconnect on a definition edit forgets its baselines too. -- **A quiet hour no longer halves the next hour's Query Store rate** ([#3653]) - the rollup-routed Query Store duration trend rated every point over the gap to the previous EMITTED point, so a corrected-hourly bucket with no rows made its neighbour's denominator 7,200 seconds and published half its true rate; each point class now carries its own denominator - a rollup bucket its bucket width (and is therefore always rated, first bucket included), a raw Query Store interval its spacing (the store holds no interval length for it, said on the CTE). Both the MCP tool and the viewer read one builder. -- **The query-stats trends read the interval the store has, on both SKUs** ([#3653]) - `query_stats` has carried `sample_interval_seconds` from the start, yet the query-duration and execution-count trends (Darling viewer, Lite) LAG-recomputed it from row spacing and divided a restart row's fabricated 0 into a confident 0.00 ms/sec; they now read it three-state like the procedure trends have since V128 - stored interval, 0 = unrated, LAG only for a pre-upgrade collection - through one Storage builder. The MCP reader's own raw query-stats const is the named one-line follow-up. -- **Compose delta aggregates exclude the restart marker** ([#3653]) - every raw-tier SUM/AVG/MIN/MAX over a delta column on one of the ten interval-carrying families now carries its own `FILTER (WHERE sample_interval_seconds IS DISTINCT FROM 0)`, so a restart's (0, 0) marker is no longer averaged in as a measured zero or reported as the window's minimum; gauges, overlays, ratios, COUNT(*), Query Store and the rollup route are untouched. -- **`mute_analysis_finding` stops writing the hash as the path and stops registering the same mute twice, `remove_server` can remove a server that never connected, and eight MCP descriptions stop saying what the code does not do** ([#3653]) - The mute registry write is one guarded `INSERT … WHERE NOT EXISTS … RETURNING` on both SKUs: idempotent per (scope, hash), the `story_path` column names the chain resolved from the retained findings (the hash only as a disclosed placeholder), and the payload says `registered` / `already_muted` / `story_path` truthfully. `remove_server` resolves against `config_monitored_servers` — the table it deletes from — so a definition that never connected is removable, with `ever_connected` and `matched_in` disclosed. Descriptions fixed: `audit_config` (no edition branch exists; PostgreSQL targets are refused and redirected), Lite `get_cpu_utilization` (one ring-buffer record per minute; 15 s is Azure's `dm_db_resource_stats`), the plan tools (`top_operators` publishes its cap/count/truncation and its ranking basis; `missing_indexes` carries a labelled statement-scoped impact and column lists, no paste-ready DDL), `get_ag_health` (lag not banded, lag 0 while suspended, stale last snapshot), the duration-trend catalogue line, and `get_resource_semaphore` row order now matches across SKUs. -- **The web server page labelled page sums as totals, drew one instant as a trend, and four tools called their capture time by another name** ([#3653]) - `get_pg_database_stats` now computes `total_temp_files` / `total_temp_bytes` / `total_deadlocks`, `database_count`, a cluster-wide `cache_hit_pct` and the reset flag as window aggregates on the same statement as its rows, publishes the page's own figures as `returned_*` / `databases_returned` / `cache_hit_pct_of_returned`, observes `truncated` off a `limit + 1` fetch instead of inferring `limit_reached`, and the A7 census's one stated allowance is gone; `get_pg_io_stats` spells its page count `combinations_returned` like every other paged tool. The Memory Grants line chart drew `grants[]` — one instant, every row at the same stamp — under a window caption; it and the Resource Semaphore table are now two tables per read, the `window[]` aggregates (peak waiters and when, peak granted, floor of available, timeouts and forced grants across the window) first and the newest snapshot second, labelled as a moment. `get_database_sizes`, `get_running_jobs`, `get_server_properties` and `get_session_stats` stamp `captured_at` on both SKUs and join the latest-is-a-time roster; the `StampedUnderCollectionTime` allowance is deleted. -- **The wait and perfmon anomaly baselines stop counting every restart's fabricated zero as a quiet sample** ([#3653]) - Interval-honest successor aggregates (`sample_interval_seconds IS DISTINCT FROM 0` baked in, the measured interval carried) replace the legacy pair in place; the provider reads whichever supply covers its window, divides by the stored interval and applies the `LAG > N` heuristic only to pre-column rows, and the legacy pair retires by a self-executing coverage condition about five days after the release. The startup baseline backfill now fires on the first start (its gate read coverage through the real-time view), and a Daily-routed Performance Calendar answers the days its rollup has not reached from raw instead of printing `unique_queries = 0`. -- **Three PostgreSQL pages stop guessing truncation from a full page, and four of the eleven payload rules stop being sentences** ([#3653]) - `get_pg_deadlocks`, `get_pg_plan_capture_readiness` and `get_pg_index_bloat` published `truncated = rows.Count >= limit`, and the two that withhold their summaries on that flag withheld them for pages that were the whole set; `get_pg_plans` cut at `limit` and said nothing. All four now fetch `limit + 1` and observe through one shared `McpHelpers.BoundPage`, the page census sweeps the inference across every tool body on both SKUs instead of a roster (which is why it missed these), and `McpPayloadContractCensusTests` pins errors-one-shape, refuse-what-you-cannot-honor and name-is-truth as far as a census honestly can, with the one-vocabulary inventories (14 truncation dialects, 8 severity spellings, two error shapes) as exact rosters for the lane that collapses them. -- **The MCP query-duration trend still divided a restart's zero into 0.00 after the viewer stopped, and two sentences that #3695/#3696 made false** ([#3653]) - `get_query_duration_trend`'s raw route now reads `query_stats.sample_interval_seconds` three-state through the same Storage builder the viewer runs (`DarlingTrendReader.QueryDurationTrendSql` and both `ProcedureDurationTrendSql` consts are aliases of `DurationTrendRouting`), so a restart collection is unrated instead of a confident 0.00 ms/sec and a measured pass is no longer halved by a LAG spanning it. The trend trio's descriptions say which points are rated over what (rollup buckets over their width, first bucket included; raw points over the stored interval or, lacking one, the LAG). `get_cpu_utilization`'s Darling note ports Lite's corrected cadences (one ring-buffer record per minute on-prem; 15 s is Azure's `sys.dm_db_resource_stats`), pinned byte-identical across SKUs. -- **The perfmon chart plotted deltas under a "Value" label with the divisor sitting unused on the row, and a latch/spinlock restart read as zero** ([#3653]) - both viewers now shape every perfmon series through the stored `sample_interval_seconds` via one shared `DeltaSeriesShaping`: a counter whose name ends in `/sec` plots per second (a name proxy until the `cntr_type` rung lands, its mis-classes named), every other counter plots its raw delta under a legend and axis that say so, and a restart's (0, 0) is a line break, not a trough. Both latch/spinlock snapshot grids render the (0, 0) marker as "—" with an Interval (sec) column saying "restart / first sample", and Lite's `get_latch_stats` / `get_spinlock_stats` publish null, not 0, for it. The gap clause was already landed by #1944's cadence rule; this adds the restart-at-normal-cadence break it could not see. -- **One payload said NoData and No Data, and the page cut had five names** ([#3653]) - get_daily_summary / get_daily_summary_range publish overall_health and health_band from one enum token on both SKUs; four PostgreSQL tools, the autovacuum run history and get_analysis_findings stop inferring a cut from a full page and fetch one past their cap through McpHelpers.BoundPage, publishing truncated and *_returned; McpPayloadContractCensusTests classifies every cut key and severity-word literal by what it is (six of #3699's eight "severity spellings" were other vocabularies) and fails a retired or unclassified spelling by name. McpHelpers.ValidateDaysBack adopts the five inline days_back refusals and list_servers goes through FormatError; FormatError's wire shape awaits ruling Q11. -- **Five families subtracted from the old instance once before anyone noticed it had changed, and Aurora's wait counters had no one watching for a restart at all** ([#3653]) - #3694's only SQL Server identity carrier was `cpu_utilization`, tenth in the schedule, so on the pass where a restart, failover or re-point first became visible wait_stats, latch_stats, spinlock_stats, query_stats and procedure_stats each subtracted the new instance's counters from the dead instance's baseline once and then ate a second (0, 0) re-baseline pass. `WaitStatsCollector`, first in the order on both hosts, now carries the identity pair (`sqlserver_start_time`, `@@SERVERNAME`) as a second result set observed after the rows are read and before anything subtracts, so every SQL Server delta family re-baselines against nothing on the epoch pass; the CPU carrier stays as the fallback for an operator who disables wait_stats, and `ServerEpoch` remembers per calculator and per server the identity it last forgot to, so two carriers seeing one epoch forget once. `PgWaitStatsCollector` carries `pg_postmaster_start_time()` as its own epoch (a clean restart zeroes `aurora_stat_system_waits()` while leaving `pg_stat_statements_info.stats_reset` continuous) and forgets only the wait groups. Both census rosters (`FamiliesThatSubtractOnceBeforeTheCarrier`, `FamiliesWithoutAnEpochCarrier`) are empty and asserted empty. No Azure SQL DB epoch (#3694's ruling stands); the marker is still the run's `collection_log` note plus `collector_state`, not rendered. -- **Lite's plan-cache trend descriptions rated every point over the gap since the previous one, the shared unrated_note named one of two unrated reasons, and the latch/spinlock restart row was spelled two ways across SKUs** ([#3653]) - Lite's `get_query_duration_trend` / `get_procedure_duration_trend` descriptions and instructions row now carry the three-state rule (stored interval; a restart's 0 is unrated; LAG only where no interval was stored). The trio's `unrated_note` names both the stored-0 restart and the first-in-window LAG in one sentence, byte-identical on both SKUs. `get_latch_stats` / `get_spinlock_stats` publish the unknowable row one way on both SKUs — per-second rates null, `interval_seconds` null beside them, the latest delta null — with Lite gaining `interval_seconds` and the per-second pair, Darling's latch nulling `severity` and the banded-from delta instead of a LOW from a zero nobody measured, and Darling's spinlock query returning the interval its null rates lacked. -- **Fifteen rate arms spelled "unknowable" as 0 behind a guard that happened to hide it** ([#3653]) - Every `CASE WHEN interval > 0 THEN delta / interval` that fell back to `ELSE 0` — the file-I/O throughput trend on both SKUs, nine LAG-differenced PostgreSQL trend rates, and the two wait-ms/sec baseline arms — now ends at `END`, so a collection with no interval to rate over yields NULL rather than a measured 0.00; the PostgreSQL trend readers and `get_pg_*_trend` carry that null instead of reading it back as 0, and `evictions_per_second` follows. Two of the fifteen were live: two collections landing in one second on a pre-column store rated a 0 ms/sec sample into the wait baseline (mean 66.7 where the rated collections say 100), so the baseline's row filter also takes Lite's `interval_sec > 0` before the restart LAG. Both census rosters are empty and asserted empty. -- **A falling gauge read as a counter reset because the store did not know it was a gauge** ([#3653]) - `perfmon_stats` gains `cntr_type` (Darling V132 / Lite v62), so the collector writes a gauge such as Total Server Memory (KB) as its level with no delta instead of differencing it like Batch Requests/sec and storing the (0, 0) "counter reset" marker when the level fell. Both viewers' perfmon charts plot a gauge as its value, a rate per second and everything else as its per-interval delta, classified by the stored type with the `/sec` name proxy kept only for rows written before the rung; both SKUs' `get_perfmon_stats` / `get_perfmon_trend` publish `cntr_type` and `counter_kind` and null a gauge's `delta_value`. The ten Wait Statistics "Average wait time (ms)" instances are PERF_AVERAGE_BULK numerators whose average needs a base row this store does not join — stated, not fixed. -- **A maintenance job's own sub-threshold anomalies fold onto the job's incident and name the job** ([#3704]) - #3632's three maintenance edges (SCH_M, IO_WRITE_LATENCY_MS, WRITELOG → RUNNING_JOBS, gated on the job having fired) were keyed on the regular symptom facts, and AnomalyIncidentReconciler folded an ANOMALY_* story only onto a regular story carrying its family — so four one-fact anomalies during one server's 116-minute index-maintenance job paged separately and never said the job's name. A maintenance-family anomaly's fold-target set now includes any story carrying RUNNING_JOBS (the same fired-gate, seen through the story set; no new graph edge), and its frozen Investigation gains one sentence naming the job from the fact's ObjectName (#3693). Non-maintenance anomalies stay solo, as #3632 ruled. -- **PostgreSQL baselines survive a shortened retention, and pg_cpu carries the CPU dispersion floor** ([#3691]) - The four `pg_*` raw hypertables the PostgreSQL-target baselines read directly were user-editable and unfloored, so a 7-day retention would have silently switched every PostgreSQL anomaly detector off; the purge now floors them at the 30-day baseline window, the detector's own minimum-history gate, exactly as #1757 floored `cpu_utilization` / `file_io_stats`. `BaselineMath.AbsStdDevFloorFor` gives `pg_cpu` (percent of the capacity ceiling) the 5-point floor SQL Server CPU carries, by unit parity, so a flat month of ACU utilisation no longer manufactures a display-capped z-score on a one-point wobble. -- **`compare_analysis` sigma-bands the PostgreSQL baselined metrics** ([#3691]) - On a PostgreSQL target the tool banded a 10 → 60 tps move "stable" (absolute rule; `PG_TPS` sits at ladder 0 by design) in the window the detector called 25σ, because only SQL Server keys were mapped to baselines. `PG_TPS`, `PG_CONNECTION_SATURATION` (on its peak session count, never the fraction), `PG_DEADLOCK_RATE` and `PG_CPU_PERCENT` (capacity unit only) now band against their own `pg_*` hour-of-week buckets; the `plan_cache_churn` note speaks the engine of the facts. SQL Server output is byte-identical. -- **`get_analysis_facts` now runs the anomaly detector on both engines** ([#3691]) - the read the tool sold as "every observation the engine sees" was collector + scorer only on Lite and Darling alike, so it never showed an ANOMALY_* / ANOMALY_PG_* fact and the detector's gate metadata (deviation_sigma, fire_threshold, baseline_samples, threshold_lineage) was reachable only through a finding that had already crossed the severity floor. The resolved engine's detector now runs between collector and scorer over the same window, gated on the coverage witness like the pass, so anomaly facts arrive scored with their metadata — including the ones that fired but stayed under the finding floor. Descriptions and instructions say so on both SKUs. -- **Full-edition `perfmon_stats.cntr_value_per_second` divided as an integer, so every counter under one event per second read 0/sec** ([#3653]) - The computed column is now `cntr_value_delta * 1.0 / NULLIF(sample_interval_seconds, 0)` (numeric(33,12)) in `install/02` and `06`, and `06` converges an existing install idempotently, guarded on `sys.computed_columns` by the column's integer type rather than its rewritten definition text. `report.daily_summary_v2`'s throughput rows stop averaging truncated zeros; the Dashboard's read was already fixed in #3658, this is the schema half. -- **The write family tells Aurora the truth** ([#3691]) - On aurora-postgres, PG_CHECKPOINT_PRESSURE and CONFIG_PG_MAX_WAL_SIZE were a permanent measured 0 and a forever-0.4 advisory about a knob the engine never consults (fifty clusters: sixty synthetic timed checkpoints an hour, requested share 0). Both are now emitted `not_applicable` with the shape and reason in metadata, score 0, root nothing, and say what Aurora does instead. Where the engine reports WAL, PG_WAL_VOLUME_SHIFT states the window's mean/peak bytes/s (or why it cannot) and ANOMALY_PG_WAL_VOLUME grades the peak against the server's own hour-of-week baseline, lifting and folding onto the checkpoint incident it leads. -- **Three hourly rollups counted every restart's fabricated zero as a sample, and a service outage longer than a day left a two-hour hole under a floor that said covered** ([#3653]) - `query_stats_interval_hourly`, `procedure_stats_interval_hourly` and `query_stats_db_interval_hourly` carry the collector's knowability verdict in their WHERE and the measured interval summed, every hourly-tier reader takes them where they reach as far as the legacy, and the refresh phase grid re-derived itself around them (heaviest refresh at :18, watch line 900 s). At service start every continuous aggregate is scanned for bucket ranges its source holds rows for and it never materialized, and each is closed with one refresh over exactly its bounds — no policy window widened. -- **The PostgreSQL engine absorbs what the v2 lanes reported back** ([#3691]) - Shortening PostgreSQL retention no longer starves the I/O-latency and WAL-volume detectors (both tables floored at the 30-day window). The I/O-latency baseline is built at a quarter-hour grain with a 250-read floor, so it is judged against this hour of the week rather than collapsing to the hour of the day. A slot-retention or replication-lag finding is now lifted by a fired WAL-volume anomaly (the co-fire had read a fact that could never fire), a Lock wait walks to the idle-in-transaction holder behind it, and the idle finding's next reads include the xmin-horizon and blocking tools. compare_analysis says which PostgreSQL keys are baseline-banded. Wave-3 stubs for the blocking family (lane 17). -- **`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. -- **`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. -- **`provision-roles.sql` stops at a role-name collision** ([#4809]) - When a role the script would create (`admin`, `viewer` or `mcp`) already exists without Darling's `darling-managed` marker, psql stops there with exit status 3 and leaves that role as it was. A caller's own `ON_ERROR_STOP` setting is kept. The README's psql command now passes `-X`, so an operator's psqlrc can't change the run, and asks for psql 10 or later. -- **Command-line verbs that open the store report an unusable store setting instead of crashing** ([#4809]) - Every verb that opens the store (`--validate-config`, `--check-settings`, the MCP and web endpoint verbs, `--add-server`, `--backfill-rollups` and the others) now exits 1 with a clear message when the store connection string can't be used. A managed store's unreadable credential, a DPAPI failure included, is reported as that. -- **Azure SQL Database and Managed Instance servers show their platform, not a SQL Server year** ([#4870]) - An Azure SQL Database showed as "SQL Server 2014". The MCP `list_servers` tool, the Viewer's server list and the Add-server test now say "Azure SQL Database" or "Azure SQL Managed Instance". Other servers keep their label. -- **Lite's MCP plan tools say Lite keeps no plans** ([#4871]) - They said a plan "may have been evicted from the plan cache", but Lite never stores plans. `analyze_query_plan`, `analyze_procedure_plan` and `get_plan_xml` now answer `not_collected`, say so, and point to `analyze_plan_xml`, and Lite's `analyze_server` next-step hints suggest `analyze_plan_xml` too. -- **Lite's MCP tools and FinOps inventory read the collected server properties** ([#4872]) - Lite looked up the edition and FinOps figures in a table that is never filled. On Azure SQL Database, 15 MCP tools answered `empty` or "may not have run yet" instead of `not_collected`, and the Server Inventory never showed average CPU, storage, idle database count or provisioning status. Both now read the collected server properties. `audit_config` names editions correctly in Lite and Darling. A server with no CPU sample in the last 24 hours shows no provisioning verdict, where it read as 0% CPU and over-provisioned. -- **Alert History's expanded rows show their labels** ([#4873]) - Blocking and incident details in Alert History showed bare values, with their labels pushed out of sight. Each value now shows its label, and each item's heading sits on its own row. -- **The server health starter dashboard can be created again, server pages show display names, and count charts use whole numbers** ([#4874]) - Creating the "Server health at a glance" dashboard failed, server pages showed registry keys instead of display names, and count axes repeated labels. -- **Darling stores Query Store text and plans for Azure SQL Database** ([#4875]) - On Azure SQL Database, Darling stored Query Store rows with no statement text and no plan, so plan analysis reported the plan as unavailable and blamed the database's capture mode. Darling now fetches the text and plan for each database it reads, and the missing-plan message also covers a plan that hasn't been collected yet. -- **Azure SQL Database no longer shows the host's hardware as its own** ([#4876], [#4882]) - On Azure SQL Database, the web's Server Properties, `get_server_properties`, the server inventory and FinOps showed the host machine's memory, sockets, cores per socket and hyperthread ratio as if they were the database's. Those now read n/a, with a note that they describe the host, and the service objective is shown. Logical CPUs still show, as the database's own scheduler count. -- **FinOps stops advising shrinks without CPU data, or VM and memory changes on Azure SQL Database** ([#4877]) - A server with no CPU sample in the window read as 0% CPU and was told to cut cores. It now gets no CPU or VM right-sizing advice. On Azure SQL Database, VM and memory right-sizing advice no longer appears, since a database's memory comes with its service objective and can't be resized on its own. CPU advice still applies there. -- **File I/O shows real file sizes on Azure SQL Database, and no size for a Hyperscale log** ([#4878]) - On Azure SQL Database, File I/O now takes each file's size from the database's own file list, so a Hyperscale data file shows its real size instead of a fraction of a megabyte. A Hyperscale log file lives in the log service, so it shows "n/a (log service)" with no size, and no size total counts it. Both apps. SQL Server and Managed Instance are unchanged. -- **Web panels show the history their read keeps when the Range asks for more** ([#4881]) - With the web server page's Range at "last 30 days", a panel whose read keeps only 7 days showed a "pick a shorter range" notice and no data. It now shows the last 7 days, says so, and its chart spans those days. Saved views behave the same way. In the view editor, Save and Auto-detect work for such a panel. -- **Azure SQL Database figures use the database's own vCores and memory limit** ([#4879]) - On Azure SQL Database, CPU share in top queries and top procedures is now measured against the database's vCores, so a 1-vCore database no longer shows half its real share. The FinOps Utilization card's CPU count shows the vCores too. A DTU-model database or an elastic pool names no vCores, so there the count and the share read n/a instead of using the host's count. The card's memory figure is captioned "Memory limit", since it is the database's own limit and not physical RAM. Both apps. -- **A Hyperscale log file no longer counts as ~1 TB of database storage** ([#4880]) - On Azure SQL Database Hyperscale the log lives in the log service, but its file reported about 1 TB, which inflated Database Sizes and the FinOps storage totals. It now reads "n/a (log service)" and stays out of every allocated total, in Lite, the Darling Viewer and the web, and `get_database_sizes` returns no size for it, with a note. Storage Growth leaves it out of the earlier sums too, so a database's older rows don't show up as a sudden shrink. -- **Wait names with a trailing space are trimmed, and two Hyperscale timer waits are ignored** ([#4884]) - Four wait names come back from SQL Server with a trailing space: EXTERNAL_GOVERNANCE_ATTR_SYNC_BACKGROUND, EDC_DOPP_LOCK, EDC_DOPP_BACKGROUND and SQP_STATS_REPORTING. An ignore entry or a lookup by the clean name never matched them. Both apps now trim the name as they read it. The first sample under the trimmed name starts fresh, so the upgrade shows no spike, and rows stored with the space stay until retention removes them. RBIO_COMM_RETRY and SQP_STATS_REPORTING, fixed-interval timers on Hyperscale, join the default ignore list for Darling and for new Lite installs. An existing Lite install keeps its own list. REMOTE_BLOCK_IO stays visible. -- **Lite no longer stores events twice, or loses its settings, after its 512 MB archive-and-reset** ([#4887]) - When the database passed 512 MB, Lite archived it to Parquet and reset it. The next collection then stored recent deadlocks, blocked-process reports, long queries and CPU and memory-pressure samples a second time, and re-read default trace and job history from the start. After the next restart, alerts that had already been sent could fire again, and a restart during an alert's cooldown could send it again. The reset also lost the user's analysis mutes, server tags and tag assignments. On a store created by an older version, it could fail to restore saved alert state or swap two of its timestamps. Lite now carries on from where it stopped across the reset, and keeps its alert, collector and user settings. Copies that an earlier reset stored now count once: blocked process reports, long query completions and system_health events show and count once ([#4918]), and deadlock copies are removed or counted once ([#4910]). Copied CPU and memory-pressure samples are not removed. -- **Perfmon rate counters show a per-second rate** ([#4883]) - The web Perfmon Counters grid showed a rate counter's stored value, which is a running total since the counter started, so Batch Requests/sec could read 11,641. The grid now shows the rate under "Per second" and the running total under "Total since counter start", and the trend chart below it plots rate counters per second. A small rate no longer reads as 0: one deadlock in 300 seconds shows 0.0033 a second. `get_perfmon_stats` and `get_perfmon_trend` add a `per_second` field for rate counters, in Lite and in Darling. -- **On Azure SQL Database, empty tabs say their collector doesn't run there, and the page file and memory state read n/a** ([#4888]) - Default Trace said there were no events in the window, CPU Scheduler showed nothing, and the ten System Events tabs fed by the system_health session said there were no events. None of those collectors runs on Azure SQL Database, and each tab now says so, in Lite and the Darling Viewer. Memory > Overview showed the page file as 0 MB and the memory state as "Available", values the collector stores because it has no source for them there. Both now read n/a in both apps and on the web, and `get_memory_stats` returns the state as null with a note. Lite's `get_blocked_process_reports` labels each row's source ("blocked-process-report" or "DMV snapshot"), as Darling's `get_blocking` does. -- **Lite keeps its saved settings through a crash during the archive-and-reset, and no longer double-counts an interrupted one** ([#4889]) - When Lite archived and reset its database, it copied the settings it keeps (mute rules, dismissed archive alerts, and, with #4887, alert state and server tags) to a temporary folder and put them back after the reset. A crash, a forced restart or an end-task between those two steps lost them silently. The copy now lives in the archive folder behind a marker, and the next start puts the settings back before anything reads them. While a restore is pending, those settings are read-only, so a change can't be undone at the next start. Changes made to them while the reset was starting are no longer lost either, which happened on every reset. A reset interrupted before the database was replaced no longer leaves its archive files counting history twice. A mute-rule edit or snooze that couldn't be saved is now reported as not saved, instead of taking effect until the next restart. -- **Azure SQL Database shows its own CPU count and calls its memory a limit** ([#4882]) - On Azure SQL Database, Logical CPUs show again in Server Properties, the server inventory and `get_server_properties`, as the database's own scheduler count. Memory, sockets, cores per socket and hyperthread ratio stay blank, because they describe the host. The Memory tabs in Lite, the Darling Viewer and the web, and the ready-made memory dashboard, label the totals "Memory limit" and "Available under limit", and `get_memory_stats` adds a note that the total is the database's limit, so use near 100% is normal. FinOps says "vCores" beside the CPU count and in CPU right-sizing advice, and shows Worker Threads in use as n/a when it wasn't collected, instead of 0. The plan viewer's Server Context card shows vCores and no host memory. On every edition, the FinOps health score now leaves out the CPU term when the window has no CPU sample, where it used to score a full 100. -- **Other databases on an Azure SQL Database server show their allocated size, with used space beside it** ([#4890]) - Database Sizes showed each other database's used space as its size, so a Hyperscale database read 119 MB with 10,240 MB allocated. Each now shows its allocated size as the total and its used space beside it. Its log size reads n/a in the Database Sizes grids, the web table and `get_database_sizes`, because the server doesn't report it, and Storage Growth and the Allocated vs Used chart say when a database's log isn't counted. At upgrade, the stored size of these databases jumps from used to allocated. Storage Growth and the file growth alert leave the older rows out, so the jump isn't read as growth, and these databases show no past size until new history builds up. A used size that wasn't read is reported as null, not 0. -- **On Azure SQL Database, an unknown volume is no longer reported as 0 MB free** ([#4892]) - Azure SQL Database doesn't expose the volume under a database file, so none is collected. Lite's `get_database_sizes` reported that as an empty mount point with 0 MB total and 0 MB free, which reads as a full volume. It now returns null for all three, as Darling does. The file-growth alert in both apps shows the free space and the file's share of the volume as n/a instead of 0.0 GB and 0%, and the FinOps grids show n/a for an unknown volume. -- **A new Azure SQL Database Hyperscale database no longer raises a wait-profile anomaly on every analysis window for its first three days** ([#4893]) - Until a server has three days of history, the wait-profile anomaly fires on a fixed bar of 250 ms of waiting per second. On Hyperscale, REMOTE_BLOCK_IO alone runs at about 1,000 ms/s on an idle database, so every window fired. On Azure SQL Database that bar now leaves REMOTE_BLOCK_IO out of the rate it tests. The wait is still collected, charted and counted in the reported rate, and SQL Server, Managed Instance and any server with an established baseline are judged as before. -- **Lite's FinOps advice, High Impact Queries and the SQL Server Agent check read archived data too** ([#4921]) - After Lite's 512 MB archive step, these saw only the data collected since then. The reserved-capacity, long-running-jobs and storage-latency advice judged their 7-day windows on hours of data, High Impact Queries showed only recent activity for any range, and a stopped SQL Server Agent read as never having run, as it also did 7 days after Agent last ran. They now read the archived rows too. -- **Lite keeps its learned database states, and its database state alerts stay right, after the 512 MB archive step** ([#4917]) - After Lite archived its data at 512 MB, or after a week with no database state rows for a server, the database state alert check read an empty table: it deleted every learned baseline and treated every database as recovered, so state alerts repeated or were lost. The editor also listed no databases, so their overrides couldn't be seen or changed. The check, the editor and the re-baseline button now read archived snapshots too. With fewer than two snapshots, or with data more than 7 days old, the check makes no decision: it doesn't fire, resolve or forget anything until the server collects again. -- **The Darling Viewer and Lite no longer close with an error when you check or uncheck a picker item** ([#4920]) - Checking or unchecking an item in the Wait Types, Memory Clerks or Perfmon Counters picker re-sorted the list inside the checkbox event, which WPF can reject with "Cannot modify the Visual children for this node because a tree walk is in progress", closing the app. The re-sort and chart update now run just after the event, once per burst of changes, and only when the selection changed. -- **A new server no longer reports that a collector never ran, or that it's AWS RDS, before the collector is due** ([#4915]) - Until a collector was due, `get_running_jobs` in Lite and Darling said the collector was switched off or that the server was AWS RDS. A collector is due at the server's first collection, plus its default interval, plus 10 minutes: 15 minutes for Running Jobs. Before then, it now says the collector hasn't run yet, names when the server started and last collected and how often the collector runs by default, and returns `status` `unavailable` instead of `precondition`, which matters to an MCP client that branches on it. The empty-tab notes in Lite, the Darling Viewer and both database state editors say the same. Once a collector is overdue, the never-ran note returns, and the Running Jobs note names AWS RDS as a possible cause, not a certain one. -- **Silencing one of several databases that share a display name no longer silences the others, and their alerts no longer share a dedup key** ([#4908]) - Darling and the Viewer matched a whole-server silence by display name, and a database added with no display name shows its host, so two databases on one Azure SQL Database server shared one silence. A silence now keys on the server's store id. Existing silences keep exactly the effect they had, and Unsilence keeps silenced any other server an older silence covered. Alerts from a server that shares its display name with another registration now carry the store id in their dedup key; every other server keeps its key and its open incidents. -- **Blocking and deadlock counts for a time window agree everywhere, counted by when each event happened** ([#4909], [#4913]) - Grids, slicers, trends, severity graphs, the daily summary, the MCP reads, analysis findings, drill-downs and anomaly checks counted events by when they were collected, while the Overview and fleet cards counted them by when they happened, so one window could show different counts in different places. All of them now count by when the event happened, in both apps: an event from before the window that was collected inside it no longer counts, and one collected late still counts in the window it happened in. Alerts still pick up events by when they were collected, so a late-collected event still alerts. On PostgreSQL targets, a deadlock with no timestamp is counted by when it was collected. -- **Collection Health no longer makes a collector's latest counts look like a total for every run** ([#4914]) - Collection Health showed a collector's newest counts followed by "(all N runs)", so a quiet cycle read as "nothing stored in 174 runs" beside a grid of stored rows. The counts now read "latest run: ..." when every run recorded counts, and "latest noted run: ... (k of N runs)" otherwise, in both apps' health grids and in `get_collection_health` in both MCP servers. -- **An Azure SQL Database logical server monitored at master stores each deadlock once, and loses none** ([#4900], [#4910]) - The server-wide deadlock read keyed its cutoff on rows stored under `master`, but it stores each deadlock under the database it happened in, so every run re-read the last 10 minutes and stored the same deadlocks again, up to 10 times. A deadlock that both a database's own read and the server-wide read returned was also stored twice. Each read now keeps its own cutoff and re-reads 10 minutes behind it, so a late event is still stored, and a deadlock already stored (same server, time and exact graph) isn't stored again. A deadlock only a database's own read saw can no longer be skipped. Copies stored by earlier versions are removed once at startup, and Lite's archived copies are counted once. -- **On Azure SQL Database, a monitored master no longer repeats the blocking and deadlock alerts and findings of databases you also monitor on their own** ([#4894], [#4906]) - A target on a logical server's master database collects blocked-process reports and deadlocks for every database on the server, so each event for a database you also monitor as its own target alerted twice. Master now skips those databases' events (read-only-intent targets don't count as monitored) and still alerts on events for databases that aren't monitored on their own. Its analysis does the same: the blocking, blocking-chain and deadlock findings, their drill-down evidence, the anomaly counts and `analyze_server` leave out events of databases monitored on their own. With excluded databases configured, the blocking count now follows the same Extended Events preference as the unfiltered count instead of coming out higher. `get_deadlocks` names each deadlock's database in both apps. -- **Lite's Recommendations tab says there isn't enough data yet for a newly added server, instead of "All clear"** ([#4901]) - The tab showed "All clear" for a server with less than the 24 hours of history the analysis needs, because its refresh never checked how much history there was; only the Generate button did. It now shows the same not-enough-data message as the Darling Viewer. -- **FinOps no longer gives an Azure SQL Database logical server's master database a provisioning verdict or right-sizing advice** ([#4896]) - A target on a logical server's master database was rated over-provisioned and offered CPU, memory and VM right-sizing advice, though master has no service objective to resize. Both apps now show its provisioning as N/A, in the card, the 7-day trend and Server Inventory, and give it no right-sizing advice. User databases on Azure SQL Database, and SQL Server and Managed Instance, are judged as before. -- **FinOps picks up a server added while the app is open** ([#4898]) - Lite's Database Sizes and Storage Growth grids stayed empty for a newly added server until the app restarted. They now reload when the tab is shown again if their last load came back empty or failed. The Darling Viewer's FinOps server picker now lists servers added after the Viewer started. -- **FinOps right-sizing advice says how much data it's based on, and no longer advises "reduce from 4 GB to 4 GB"** ([#4905]) - The CPU, memory and storage right-sizing texts said "over the last 7 days" even on two hours of data. They now give the number of samples and the span they cover, for example "16 samples over 3 hours", up to 7 days. Memory advice is skipped when the recommended size, as shown, equals the current size, and idle-database advice waits until there are 7 days of query statistics. Both apps. -- **The Darling Viewer says when Azure SQL Database doesn't collect a tab's data, instead of showing an empty grid** ([#4904]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, the two change grids and Memory Pressure Events showed an empty grid or chart. They now say the data isn't collected there, and the database state editor says so in its status line. On AWS RDS, Running Jobs says the same. The FinOps Logical CPUs header explains that the count can differ from the vCores you pay for, and the Memory Overview shows an N/A memory model as n/a. -- **Databases on one Azure SQL Database server no longer get mixed up** ([#4899]) - In Lite, double-clicking an Overview card opens that card's own database, and each card keeps its own silenced bell. Import Settings in Lite and the Viewer no longer skips every database after the first on one server. When a server name matches several servers, on one host or across hosts, the MCP read tools in Lite and Darling list the matches instead of answering with the first, and a full name from the list picks one. The Viewer's `--open-server` link opens a server only when exactly one has that name, and says so when several do. -- **Lite says why a tab is empty when its collector doesn't run on Azure SQL Database** ([#4903]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, Memory Pressure Events, the two configuration change grids and the Database State window showed an empty grid or chart. They now say the collector doesn't run there. On AWS RDS, Running Jobs says the same and no longer asks you to grant msdb access where no grant can help. On any engine, a tab now also says when its collector has never run for a server that is collecting other data. The FinOps Logical CPUs column has a tooltip that explains the count, and Memory Model shows n/a instead of N/A. -- **Optimized locking is read on Azure SQL Database, and a flag that couldn't be read shows as unknown, not off** ([#4907]) - Azure SQL Database reports major version 12, so the optimized-locking flag was never collected there, and every config view and `get_database_config` showed it as off. It's now collected there, and a flag that couldn't be read shows as unknown (null in MCP). When optimized locking is on, Locking & Contention and `get_object_locking` say that their per-index counters don't count transaction-ID lock waits, including when they have no rows. The upgrade doesn't record a false config change for the flag. -- **Storage Growth shows n/a, not 0, when there's no earlier size to compare** ([#4902]) - A database with no size row 7 or 30 days back, a server whose collection stopped more than a window ago, and a table in the per-table drill with no earlier sample all showed 0 growth, rate and percent in Lite and the Viewer. They now show n/a. The daily rate also divides by the real number of days between the two snapshots, instead of 7 or 30. +- **Dashboard query comparison grids and Server Trends baseline bands now use the server's local time** ([#4321], [#4317]) +- **`get_collection_health`'s default reply now fits the MCP response budget** ([#4319]) +- **Dashboard Overview ghost line reads the right hours outside UTC** ([#4317]) +- **The Query Store activity slicer reads less history on each refresh** ([#4311]) +- **Lite's Overview ghost line reads the right hours outside UTC** ([#4309]) +- **Availability Groups tab no longer freezes the UI every 30 seconds** ([#4308]) +- **The Daily Summary calendar and `get_daily_summary_range` cache closed days for an hour** ([#4307]) +- **Query Store backfill's candidate check no longer reads old compressed chunks, and no longer drops a hole on a database that goes quiet** ([#4306]) +- **The Darling viewer's Wait Stats and Perfmon trend charts read time buckets, not every collection** ([#4304]) +- **The Darling viewer's Active Queries grid and wait drill-down no longer load every snapshot's plan XML up front** ([#4303]) +- **Lite's Queries-tab comparisons use the grid's time window** ([#4302]) +- **Active Queries and wait drill-down no longer load every plan's XML just to show the grid** ([#4297]) +- **The query heatmap loads much faster on large windows** ([#4295]) +- **Less write-ahead log from the query, procedure and Query Store history tables** ([#4294]) +- **Web viewer no longer shows raw error text for failed requests** ([#4293]) +- **Empty legacy baseline aggregates now drop instead of staying forever** ([#4292]) +- **CPU and I/O-latency baselines recompute once a day, not every hour** ([#4291]) +- **Fewer needless writes to the Darling store's plan and text tables** ([#4288]) +- **Managed store: less WAL, from compressed full-page images** ([#4287]) +- **Web failure handling: log batches, bad requests and error text** ([#4286]) +- **Time-based reads no longer shift on a store outside UTC** ([#4285]) +- **Web viewer timeouts now show a message and get logged** ([#4281]) +- **A major store upgrade keeps your ALTER SYSTEM settings** ([#4280]) +- **Lite says when a query window was cut short** ([#4279]) +- **Top-CPU reads disclose a short window** ([#4278]) +- **`get_query_store_top` stays under the MCP response-size budget** ([#4198]) +- **`describe_custom_view_catalog` stays under the MCP response budget** ([#4198]) +- **MCP `get_collection_health` caps its response size** ([#4198]) +- **MCP `get_blocking` (Darling) and `get_blocked_process_reports` (Lite) cap their response size** ([#4198]) +- **MCP get_collection_log stays under the response-size budget by default** ([#4198]) +- **`get_query_store_regressions` default calls stayed under the MCP response budget** ([#4198]) +- **get_pg_io_trend's default call now fits the MCP response budget** ([#4263]) +- **`get_active_queries` stays under its response-size budget by default** ([#4261]) +- **get_index_usage's default answer now fits the response budget** ([#4260]) +- **`get_query_heatmap` default call stays under the MCP response budget** ([#4259]) +- **`get_object_locking` default response stays under the MCP budget** ([#4258]) +- **`get_plan_corrections` default call stays under the MCP response budget** ([#4198]) +- **Job History loads faster and stops polling every 30 seconds** ([#4256]) +- **Availability Group reads: bounded the newest-snapshot lookup** ([#4228]) +- **`get_deadlock_detail` no longer returns oversized deadlock graphs by default** ([#4254]) +- **Database Sizes and Storage Growth load without a multi-chunk planning tax** ([#4252]) +- **Alert triage links now skip only a disabled dashboard, and email carries one too** ([#4230]) +- **PLAN_REGRESSION no longer deduplicates the whole raw Query Store slice every pass** ([#4208]) +- **Force-plan bot no longer acts on a best plan older than 4 days** ([#4208]) +- **`audit_config` no longer runs the full analysis pass** ([#4206]) +- **`get_query_store_regressions`' comparison baseline is now a fixed 7 days** ([#4206]) +- **`get_pg_cpu_utilization` now returns bucketed points instead of one row per minute** ([#4206]) +- **The desktop viewer's Query Store Regressions grid had the same unbounded-baseline shape as `get_query_store_regressions` and is now bounded the same way** ([#4206]) +- **The deadlock and plan-capture log patterns only offer a report whose ERROR: is the line's own label** ([#4042]) +- **Plan capture keeps working under a custom log prefix with fields before the process id** ([#4016]) +- **Trace flag reads no longer hide every enabled flag after an ordinary run** ([#4032]) +- **The fleet card's collection-health figures no longer reread a week of raw log rows on every call** ([#3911]) +- **The per-server collection-health summary stops leaking memory and stops going stale on a fleet with more than one active caller** ([#3900]) +- **A collector that produced then stopped no longer reads healthy with zero rows** ([#3889]) +- **job_history collection survives an msdb reseed** ([#3886]) +- **The compression-stuck self-alert no longer pages on a healthy job's own run instant** ([#3588]) +- **pg_deadlocks reads a self-hosted target's csvlog file, closing the same forged-line hole #4124 closed for pg_log_events** ([#4136]) +- **pg_plan_capture reads a self-hosted target's csvlog file** ([#4137]) +- **Darling's daily retention purge no longer holds up collection** ([#4133]) +- **Lite's get_index_usage no longer hides active indexes behind a silent cap** ([#4131]) +- **pg_log_events reads a self-hosted target's csvlog file, closing a forged-line hole** ([#4124]) +- **Two install-lock tests pass on a non-elevated machine** ([#4111]) +- **MCP tool schemas no longer list an internal service as a parameter** ([#4110]) +- **Log reads through pg_read_binary_file now decode text in the database's own encoding** ([#4106]) +- **Store Checkpointer Pressure no longer fires all the time on a healthy store** ([#4096]) +- **A planted line in a PostgreSQL server's log can no longer stop plan capture** ([#4089]) +- **A Lite Query Store test that never ran now runs** ([#4084]) +- **A PostgreSQL log in a non-UTC zone no longer reports a deadlock problem on the log events collector** ([#4070]) +- **The install and upgrade scripts name each account once in a refusal** ([#4069], [#4050]) +- **One bad byte from a failed login no longer blinds the three PostgreSQL log readers, and RDS and Aurora targets get the time-zone fix too** ([#4051]) +- **Darling's install and upgrade scripts refuse a folder that ordinary users can already write to** ([#4050]) +- **A planted log line in another time zone no longer stops a PostgreSQL server's log events and deadlocks from being read** ([#4049], [#4051]) +- **PostgreSQL servers whose log prefix puts fields before the pid now show their log events and deadlocks, and a client's port is no longer stored as an event's SQLSTATE** ([#4047]) +- **On Windows the log-hash key is refused if anyone beyond SYSTEM, Administrators and the service account holds any right to it, and it is checked and read through one held file handle** ([#4044]) +- **A PostgreSQL server that logs only to CSV is reported by name instead of looking quiet** ([#4040]) +- **Install and upgrade lock the Darling install folder, so an ordinary local user can no longer replace the service's binaries** ([#4038]) +- **The hourly re-mask of PostgreSQL deadlock data stored before #4005 now runs without a log-hash key, covers finding alerts, and never leaves a raw report hash behind** ([#4036]) +- **On compose, a log-hash key or role password planted in a credentials directory that was open to other users is discarded instead of trusted, `--harden-files` no longer follows a junction or a hard link, and the Viewer's always-empty Statement Fingerprint column is gone** ([#4031]) +- **Trace flags could show a flag as enabled days or weeks after it, and every other flag, was turned off** ([#4030]) +- **On-load collectors could read HEALTHY forever even after their daily reschedule silently broke** ([#4029]) +- **The PostgreSQL log tail could pick the csvlog or jsonlog file instead of the real log** ([#4025]) +- **PostgreSQL deadlock reports, deadlock alerts and analysis findings stored before the SQL normalization are rewritten in place** ([#4022]) +- **PostgreSQL log events are identified by hashes keyed with a per-store secret, so a store reader can no longer test guesses at the values a log line hid** ([#4020]) +- **Plan capture could be spoofed by a statement's own author** ([#4015]) +- **PostgreSQL deadlock reports store and show their SQL normalized, and no read returns a hash of the raw report** ([#4013]) +- **Analysis passes stop recomputing every 30-day baseline on every pass** ([#4011]) +- **CPU scheduler readings no longer flicker between two answers when a collection lands on a duplicate timestamp** ([#4010]) +- **The rest of the trend family now buckets to a point budget instead of returning every collection** ([#4007]) +- **get_pg_io_trend's automatic subject choice no longer scans the whole window in order** ([#4003]) +- **Custom alert rules now evaluate on the Linux compose store** ([#4002], [#3983]) +- **On-load config collectors recapture daily, so a long-lived connection keeps fresh config facts and a cleared trace flag actually clears** ([#4001]) +- **get_store_metrics reads each store object's newest sample through an index instead of sorting a year of rows** ([#3998]) +- **list_servers and the per-server summary tools no longer plan a store's whole collection history to find one timestamp** ([#3995]) +- **PostgreSQL config and logging-audit tools no longer plan a year of chunks to read one row** ([#3992]) +- **A store with no readable server-log directory keeps its hourly collector-cost flush** ([#3985]) +- **Lite's daily summary starts its retention horizon where Lite's history actually starts** ([#3984], [#3975]) +- **The web dashboard and the MCP server no longer connect to a compose or bring-your-own store as its owner** ([#3983]) +- **A fresh store's fleet overview and web Fleet page work before the collection-health aggregate materializes** ([#3981]) +- **Latest-value lookbacks follow the collector's cadence, and the PostgreSQL target's config reads stop planning every retained snapshot** ([#3980], [#3931]) +- **The top-CPU drill-down resolves statement text for the five queries it prints, not for every plan-cache row in the window** ([#3979]) +- **A server dark past the collection log's retention reads Offline everywhere, not "Awaiting first collection"** ([#3975], [#3966]) +- **The service's start-up hole scan no longer reads every aggregate's whole materialization and source table** ([#3972]) +- **The trend tools answer in time buckets sized to the window: a day of `get_file_io_trend` is 34 KB, not 1.4 MB** ([#3968]) +- **A server dark for more than two days reads Offline on the fleet card, not "Awaiting first collection"** ([#3966]) +- **A restart's shutdown checkpoint no longer counts toward checkpoint write and sync time either** ([#3964]) +- **PostgreSQL config change history reports per-database and per-role overrides being set, changed and reset** ([#3957]) +- **The plan-regression drill-down no longer re-deduplicates the whole Query Store slice, and the parameter-sensitivity drill-down stops resolving text for rows it never prints** ([#3956], [#3953]) +- **A PostgreSQL restart no longer raises a false Store Checkpointer Pressure warning or reads as a WAL-forced checkpoint on a monitored server** ([#3955]) +- **Log masking fails closed: a DETAIL or CONTEXT is read as SQL only where PostgreSQL writes SQL, a value cut before its close is masked to the end, and `get_store_query_stats` masks a raw text `pg_stat_statements` kept** ([#3952], [#3920]) +- **The web server page's Overview tab no longer waits on the daily summary** ([#3950]) +- **The fleet overview reads each server's newest sample instead of every retained row, and the web viewer asks for it once per refresh instead of twice** ([#3947]) +- **A PostgreSQL target's analysis reads its statements' own baselines once per metric, not once per statement** ([#3946]) +- **`get_store_metrics` answers with a bounded summary instead of every store object's daily series** ([#3942]) +- **Managed role provisioning never sends a role's password in a statement** ([#3940]) +- **A store without TimescaleDB re-runs its store-object convergence every hour, not only at restart** ([#3932]) +- **Analysis latest-value reads look back a day instead of scanning a server's whole history, and stop counting dropped databases** ([#3931]) +- **A store upgrade that fails before its commit point puts the old cluster back as it found it, and only claims a revert that happened** ([#3927]) +- **Log text keeps no literal: the store's own log and every PostgreSQL target's log events mask the SQL inside DETAIL and CONTEXT, every retained store-log entry is masked, and the statement reader shows only normalized DML** ([#3920], [#3915]) +- **The store's hourly self-metrics sweep works again on TimescaleDB 2.29 and later** ([#3918], [#3908]) +- **The bundled store moves to TimescaleDB 2.30.1, which closes GHSA-hcfx-29v5-2rcw, and a store's extension now moves before the store opens instead of under a live store** ([#3908]) +- **A runtime update no longer stops the store from starting when the previous runtime's folder cannot be cleared** ([#3919], [#3906]) +- **A store still on PostgreSQL 17 no longer fails to start on a host with 40 GB of RAM or more** ([#3909]) +- **The store's statement statistics, reviewed before release: the ALTER SYSTEM advice no longer bricks the store, and the reader's filter can no longer be switched off** ([#3915], [#3904]) +- **The bundled PostgreSQL moves to 18.6, and the self-contained .NET runtime to 10.0.12, closing published CVEs in both** ([#3906], [#3908]) +- **Each generated store TLS root certificate carries a unique per-generation name** ([#3557]) +- **The by-CPU tools now actually rank by CPU** ([#3523]) +- **analyze_server no longer answers "all metrics are within normal ranges" when the analysis window collected nothing** ([#3524]) +- **The Performance Calendar, daily summary, and fleet sweep band deadlocks as a measured per-hour rate, not any-deadlock-is-Critical** ([#3525]) +- **Perfmon rates are honest per-second values in analysis** ([#3527]) +- **Floor the SQL count thresholds, give Store Disk Pressure a GB floor, and count measured metrics in the fleet Healthy label** ([#3528]) +- **get_memory_trend stops reporting granted memory as a hardcoded zero** ([#3529]) +- **Lite's Query Store time slicer reads physical reads from its own column** ([#3530]) +- **LCK_M_IS advice carries the same RCSI caveats as its LCK_M_S twin** ([#3531]) +- **Collector schedules refuse cadences that would fabricate quiet** ([#3532]) +- **get_pg_plans finds the plan you asked for, not just the plans in the top page** ([#3533]) +- **get_pg_autovacuum_health classifies severity from the same axis it ranks by** ([#3534]) +- **get_pg_replication_slots headlines the worst-classified slot and never spells unknown WAL growth as stable** ([#3535]) +- **get_pg_io_stats no longer renders track_io_timing=off as an impossibly fast disk** ([#3536]) +- **The PostgreSQL xmin-horizon alert catches rotating holders and stops firing on single observations** ([#3537]) +- **QueryStore slicer's physical-reads sort plots the physical series** ([#3547]) +- **get_memory_trend joins the grants series so total_granted_mb carries real data** ([#3548]) +- **Viewer Recommendations tabs stop saying "All clear" when the analysis window collected nothing** ([#3551]) +- **Viewer pass for the Store Disk Pressure GB floor and fleet measured-metric qualifier** ([#3563]) +- **Deprecated Dashboard analysis reads perfmon counters as true per-second rates** ([#3561]) +- **Sorting the Procedures or Query Store grid by physical reads plots the physical series, in both apps** ([#3556]) +- **The Locking & Contention grid names the table as schema.table** ([#3576]) +- **Extreme, corroborated anomaly findings can now cross the notify floor, so the baseline engine is no longer notification-inert at shipped settings** ([#3526]) +- **`get_store_metrics`' `job_history` block now says whose eyes its rows are visible to, and proves rows exist where it can** ([#3574]) +- **The forced-plan-failures alert read no longer walks the whole fleet's two-hour slice of Query Store rows to find one server's** ([#3573]) +- **The viewer's tray Snooze now silences the toast itself** ([#3570]) +- **The compression-stuck self-alert no longer pages on a healthy job's run instant** ([#3575]) +- **Text on an accent fill gets a measured ink in every theme, and the FinOps row marks become theme brushes Dark can actually see** ([#3577]) +- **The duration-trend trio routes by retention tier and says what it served, so a 7-day request no longer returns 4 days labelled quiet** ([#3541]) +- **Analysis facts divide by the time the collector actually observed, and a window with a hole in it says so** ([#3538]) +- **SQL Server's Poison Wait alert measures accumulated starvation over a ten-minute window like its PostgreSQL twin, so one slow wait no longer pages and a THREADPOOL storm no longer sleeps** ([#3539], [#2711]) +- **Six MCP pages now say what bounded them, so a limited page stops passing for a complete answer** ([#3541], [#3287], [#2159]) +- **The four naked delta families store the interval their deltas accrued over, so a restart's fabricated zero reads as unknowable instead of 0.00 ms/sec** ([#3540]) +- **Blocking and CPU health bands are rates over the window they were measured in, tiered from 14 days of fleet blocking and CPU data** ([#3539]) +- **get_store_metrics stops answering for 38% of the store: continuous aggregates and the named plain tables join the inventory, every sweep is reconciled against pg_database_size, and the block says its own coverage** ([#3582]) +- **The twenty continuous aggregates join the compression ladder** ([#3581]) +- **PostgreSQL MCP percents name their denominator, so a three-row page stops summing to 100% of everything** ([#3541]) +- **Every delta family is seeded from the store at service start, and the series-age rescue finally has passes to read, so a restart no longer fabricates one interval of quiet for six families** ([#3540]) +- **MCP write tools report what happened** ([#3541]) +- **The scorer's wait thresholds carry their measurement: WRITELOG stops saturating on a third of routine windows, deadlocks grade 5/hr apart from 90/hr, and the absolute gates scale with the hours actually observed** ([#3538]) +- **Analysis pages with long compound stories now reach Slack instead of dying with invalid_attachments** ([#3612]) +- **Continuous-aggregate materializations are chunked at one raw chunk, like every raw table** ([#3620]) +- **The PostgreSQL first-target runbook stops denying three capabilities that ship** ([#3608]) +- **Slack text cuts land on whole characters, not UTF-16 indexes** ([#3622]) +- **A not-yet-valid web TLS certificate now raises the self-alert instead of reading as healthy** ([#3517]) +- **Light and Cool Breeze status colors read against their own page, and text on a status fill gets a theme ink** ([#3609]) +- **Forced Plan Failing fires once per observation, not once per cooldown** ([#3579]) +- **The compression dead-job alert now says what a -infinity row is on the store's TimescaleDB** ([#3591]) +- **Every delta family now stores the interval its deltas accrued over, and query_stats stores the statement offsets its delta key is made of** ([#3540]) +- **The File Growth threshold means one thing — megabytes per hour — at every surface that shows it** ([#3539]) +- **Story confidence measures corroboration instead of path length, and the nightly rebuild's three cards become one incident that names the job** ([#3538]) +- **The daily digest and sweep rollup no longer re-announce on a service restart** ([#3580]) +- **compare_analysis bands each delta by the server's own dispersion and folds one cause into one row, so same-hour-yesterday noise stops reading as a verdict** ([#3538]) +- **A server nothing has banded yet is Unknown, not Healthy, and the alert-history grids show the severity the alert fired at instead of the colour its name implies** ([#3539]) +- **Every latest-snapshot MCP read says when it was captured, and no tool accepts a window it does not read** ([#3541]) +- **PostgreSQL servers get a measured deadlock band from their own counters, their Long-Running Query alert skips maintenance like SQL Server's does, and every one-sided alert says why it is one-sided** ([#3539]) +- **Database File Growth's rise arm fires once per hourly observation, not once per cooldown** ([#3636]) +- **The daily summary stops painting purged months green, and every MCP filter is part of the query** ([#3541]) +- **Zero is a measurement: health parsers say whether their source was ever seen, a regression with no baseline stays null, and the first point of a differenced trend is no longer a fabricated 0** ([#3541]) +- **The interval-hourly Query Store refresh stops paying twelve index inserts per re-materialized row for eleven indexes nothing reads, and the capture-down alert read stops decompressing a server's whole collection log to learn two statuses** ([#3597]) +- **Top CPU Queries reads as one record per query on Slack, not seven fields interleaved across a two-column grid** ([#3644]) +- **Top Cpu Queries' Max Dop is the newest plan's reading, with the cross-plan maximum kept as a dated history** ([#3648]) +- **The force-plan remediation said "eligible, no blockers" for plans automatic plan correction already owned, had failed to force, or had withdrawn** ([#3652]) +- **A Claude review that posted nothing no longer finishes green** ([#3650]) +- **The deprecated Dashboard mirrors five of the brains-review honesty fixes in its own idiom** ([#3653]) +- **Six small honesty riders from the brains-review residue** ([#3653]) +- **The PostgreSQL poison-wait host holds on silence like the SQL Server engine does, and three presence-flat alerts grade their severity from the bars the health bands already measured** ([#3653]) +- **The Darling viewer's trend charts and calendar tell the same truth the MCP tools learned today** ([#3653]) +- **`get_pg_server_config` counted the page and called it the server** ([#3653]) +- **The four PostgreSQL host alerts fire with the tier they earned instead of no tier at all** ([#3653]) +- **Darling's `get_pvs_stats` trend drew an unmeasured pass as 0 MB** ([#3653]) +- **The Query Store duration chart now says what served it and where the rollup's floor cut the window** ([#3653]) +- **The analysis pass no longer says "collection appears to have stopped … NOT an all-clear" for a window the coverage witness proves the collector observed** ([#3653]) +- **The PostgreSQL analysis vocabulary absorbs what six content lanes reported back** ([#3542]) +- **A target that restarted, failed over or was re-pointed no longer keeps subtracting from the old instance's counters** ([#3653]) +- **A quiet hour no longer halves the next hour's Query Store rate** ([#3653]) +- **The query-stats trends read the interval the store has, on both SKUs** ([#3653]) +- **Compose delta aggregates exclude the restart marker** ([#3653]) +- **`mute_analysis_finding` stops writing the hash as the path and stops registering the same mute twice, `remove_server` can remove a server that never connected, and eight MCP descriptions stop saying what the code does not do** ([#3653]) +- **The web server page labelled page sums as totals, drew one instant as a trend, and four tools called their capture time by another name** ([#3653]) +- **The wait and perfmon anomaly baselines stop counting every restart's fabricated zero as a quiet sample** ([#3653]) +- **Three PostgreSQL pages stop guessing truncation from a full page, and four of the eleven payload rules stop being sentences** ([#3653]) +- **The MCP query-duration trend still divided a restart's zero into 0.00 after the viewer stopped, and two sentences that #3695/#3696 made false** ([#3653]) +- **The perfmon chart plotted deltas under a "Value" label with the divisor sitting unused on the row, and a latch/spinlock restart read as zero** ([#3653]) +- **One payload said NoData and No Data, and the page cut had five names** ([#3653]) +- **Five families subtracted from the old instance once before anyone noticed it had changed, and Aurora's wait counters had no one watching for a restart at all** ([#3653]) +- **Lite's plan-cache trend descriptions rated every point over the gap since the previous one, the shared unrated_note named one of two unrated reasons, and the latch/spinlock restart row was spelled two ways across SKUs** ([#3653]) +- **Fifteen rate arms spelled "unknowable" as 0 behind a guard that happened to hide it** ([#3653]) +- **A falling gauge read as a counter reset because the store did not know it was a gauge** ([#3653]) +- **A maintenance job's own sub-threshold anomalies fold onto the job's incident and name the job** ([#3704]) +- **PostgreSQL baselines survive a shortened retention, and pg_cpu carries the CPU dispersion floor** ([#3691]) +- **`compare_analysis` sigma-bands the PostgreSQL baselined metrics** ([#3691]) +- **`get_analysis_facts` now runs the anomaly detector on both engines** ([#3691]) +- **Full-edition `perfmon_stats.cntr_value_per_second` divided as an integer, so every counter under one event per second read 0/sec** ([#3653]) +- **The write family tells Aurora the truth** ([#3691]) +- **Three hourly rollups counted every restart's fabricated zero as a sample, and a service outage longer than a day left a two-hour hole under a floor that said covered** ([#3653]) +- **The PostgreSQL engine absorbs what the v2 lanes reported back** ([#3691]) +- **`get_fleet_overview` runs its collection-health rollup once per minute per host, however many overview calls race** ([#3735]) +- **`compare_analysis` sigma-bands the v2 PostgreSQL baselined metrics, and the write family has one definition of "WAL tracked"** ([#3691]) +- **Hour-of-week baselines key on the target's local clock, not UTC** ([#3653]) +- **PostgreSQL targets key their hour-of-week baselines on their own clock** ([#3691]) +- **The long-query completion XE session could never be created on Azure SQL DB** ([#3753]) +- **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], [#3754]) +- **A pass whose fact families could not be read says so, on both SKUs** ([#3691]) +- **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]) +- **The PostgreSQL Long-Running Query twin honours the program/login opt-out knob** ([#3743]) +- **The materialization hole scan reports on every start** ([#3756]) +- **The Long-Running Query alert applies `excludedDatabases` ahead of the row cap on both SQL Server SKUs** ([#3742]) +- **The CPU alert gate identifies a sample by equality, not order, and keys on the stored UTC instant** ([#3744]) +- **query_store_health collects per database on Azure SQL DB** ([#3764]) +- **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]) +- **PostgreSQL connection saturation now divides the real population by the ceiling** ([#3691]) +- **The rollup-routed daily calendar prints NULL, not 0, for a day the tier never materialized, and names it** ([#3653]) +- **The CPU collector's watermark and dedup key on the UTC twin where the store has it, with the frame stated** ([#3778]) +- **A quiet PostgreSQL pool is graded from numbackends alone, and the Aurora wait-profile advice names the window mean** ([#3691]) +- **The trend family's window floor is `window_truncated`, not the page dialect's `truncated`** ([#3653]) +- **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]) +- **Four census pins the V137 wave outran** +- **The plan tools stopped saying "no CREATE INDEX text — a hint, not a design"** ([#3805]) +- **pg_statement_stats runs again on PostgreSQL clusters whose pg_stat_statements is below 1.9 or installed outside public** ([#3818]) +- **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]) +- **The PostgreSQL engine absorbs what waves 4–5 reported back, and the stock load storm can now page** ([#3691]) +- **Two counts nothing re-derived turned dev red on three checks** +- **The companion-object remedy told twenty-three clusters to UPDATE an extension none of them had** ([#3830]) +- **A collector that STOPPED producing read as one that never produced** ([#3819]) +- **TimescaleDB availability was decided once, by a probe whose failures last a minute** ([#3815]) +- **`PG_XMIN_HOLD` grades the horizon's persistence, not one winner's** ([#3691]) +- **Store job self-heal covers every policy family, and a held retention policy is never mistaken for a dead one** ([#3816]) +- **A live store test stops racing the statistics collector** +- **A month of zeros is the strongest baseline there is, not the absence of one** ([#3691]) +- **A configuration lever hanging off a diagnostic chain is attached to that finding instead of orphaned into a card of its own** ([#3691]) +- **Darling's Entra service-principal connections can find their authentication provider** ([#3838]) +- **Every button in every theme recognizes its access key again** ([#3835]) +- **Store self-alert triage pages stop rendering "Could not resolve server" for every metric added after #2768** ([#3833]) +- **`get_collection_health` per server no longer races the store's write bands with an unmemoized 7-day scan** ([#3856]) +- **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]) +- **An argument a tool does not declare is refused by name instead of silently dropped, on both SKUs, from one filter** ([#3870]) +- **`checkpoint_timeout` says `not_applicable` in the FACT on Aurora, not just at the tool that renders it** ([#3868]) +- **FinOps Locking & Contention stops showing databases that were renamed away** ([#3876]) +- **Darling's four object-locking reads stop showing databases that were renamed away** ([#3878]) +- **The pin that held the defect as intended behavior is renamed, which is why this was its own issue.** +- **A census caught what no pin was watching for, and its roster grew rather than shrank.** +- **`provision-roles.sql` stops at a role-name collision** ([#4809]) +- **Command-line verbs that open the store report an unusable store setting instead of crashing** ([#4809]) +- **Azure SQL Database and Managed Instance servers show their platform, not a SQL Server year** ([#4870]) +- **Lite's MCP plan tools say Lite keeps no plans** ([#4871]) +- **Lite's MCP tools and FinOps inventory read the collected server properties** ([#4872]) +- **Alert History's expanded rows show their labels** ([#4873]) +- **The server health starter dashboard can be created again, server pages show display names, and count charts use whole numbers** ([#4874]) +- **Darling stores Query Store text and plans for Azure SQL Database** ([#4875]) +- **Azure SQL Database no longer shows the host's hardware as its own** ([#4876], [#4882]) +- **FinOps stops advising shrinks without CPU data, or VM and memory changes on Azure SQL Database** ([#4877]) +- **File I/O shows real file sizes on Azure SQL Database, and no size for a Hyperscale log** ([#4878]) +- **Web panels show the history their read keeps when the Range asks for more** ([#4881]) +- **Azure SQL Database figures use the database's own vCores and memory limit** ([#4879]) +- **A Hyperscale log file no longer counts as ~1 TB of database storage** ([#4880]) +- **Wait names with a trailing space are trimmed, and two Hyperscale timer waits are ignored** ([#4884]) +- **Lite no longer stores events twice, or loses its settings, after its 512 MB archive-and-reset** ([#4887], [#4918], [#4910]) +- **Perfmon rate counters show a per-second rate** ([#4883]) +- **On Azure SQL Database, empty tabs say their collector doesn't run there, and the page file and memory state read n/a** ([#4888]) +- **Lite keeps its saved settings through a crash during the archive-and-reset, and no longer double-counts an interrupted one** ([#4889]) +- **Azure SQL Database shows its own CPU count and calls its memory a limit** ([#4882]) +- **Other databases on an Azure SQL Database server show their allocated size, with used space beside it** ([#4890]) +- **On Azure SQL Database, an unknown volume is no longer reported as 0 MB free** ([#4892]) +- **A new Azure SQL Database Hyperscale database no longer raises a wait-profile anomaly on every analysis window for its first three days** ([#4893]) +- **Lite's FinOps advice, High Impact Queries and the SQL Server Agent check read archived data too** ([#4921]) +- **Lite keeps its learned database states, and its database state alerts stay right, after the 512 MB archive step** ([#4917]) +- **The Darling Viewer and Lite no longer close with an error when you check or uncheck a picker item** ([#4920]) +- **A new server no longer reports that a collector never ran, or that it's AWS RDS, before the collector is due** ([#4915]) +- **Silencing one of several databases that share a display name no longer silences the others, and their alerts no longer share a dedup key** ([#4908]) +- **Blocking and deadlock counts for a time window agree everywhere, counted by when each event happened** ([#4909], [#4913]) +- **Collection Health no longer makes a collector's latest counts look like a total for every run** ([#4914]) +- **An Azure SQL Database logical server monitored at master stores each deadlock once, and loses none** ([#4900], [#4910]) +- **On Azure SQL Database, a monitored master no longer repeats the blocking and deadlock alerts and findings of databases you also monitor on their own** ([#4894], [#4906]) +- **Lite's Recommendations tab says there isn't enough data yet for a newly added server, instead of "All clear"** ([#4901]) +- **FinOps no longer gives an Azure SQL Database logical server's master database a provisioning verdict or right-sizing advice** ([#4896]) +- **FinOps picks up a server added while the app is open** ([#4898]) +- **FinOps right-sizing advice says how much data it's based on, and no longer advises "reduce from 4 GB to 4 GB"** ([#4905]) +- **The Darling Viewer says when Azure SQL Database doesn't collect a tab's data, instead of showing an empty grid** ([#4904]) +- **Databases on one Azure SQL Database server no longer get mixed up** ([#4899]) +- **Lite says why a tab is empty when its collector doesn't run on Azure SQL Database** ([#4903]) +- **Optimized locking is read on Azure SQL Database, and a flag that couldn't be read shows as unknown, not off** ([#4907]) +- **Storage Growth shows n/a, not 0, when there's no earlier size to compare** ([#4902]) ### Security -- **Scrubbed legacy plan-force-action audit text** ([#4384]) - a one-time startup pass rewrites audit lines written by older builds to the same safe form the read path already applies; every other field and row is left untouched. -- **Collected PostgreSQL statement text applies the same sensitive-statement filter as the store's own statements** ([#4383]) - matching text is withheld before storage, and a one-time job rewrites rows stored earlier. -- **Stored PostgreSQL setting values are redacted in more shapes, and the one-time scrub resumes a large server-day after a restart** ([#4380]). -- **Plan-force journal reads no longer return pre-#4326 exception text** ([#4363]) - Both plan-force journal reads now replace exception text written before #4326 with a fixed sentence; evidence lines written after #4326 are returned unchanged. -- **Stopped `/api/ping` and the analysis notes from echoing raw exception text** ([#4326]) - `/api/ping`'s +- **Scrubbed legacy plan-force-action audit text** ([#4384]) +- **Collected PostgreSQL statement text applies the same sensitive-statement filter as the store's own statements** ([#4383]) +- **Stored PostgreSQL setting values are redacted in more shapes, and the one-time scrub resumes a large server-day after a restart** ([#4380]) +- **Plan-force journal reads no longer return pre-#4326 exception text** ([#4363]) +- **Stopped `/api/ping` and the analysis notes from echoing raw exception text** ([#4326]) ## [3.8.0] - 2026-09-17 diff --git a/docs/changelog/3.9.md b/docs/changelog/3.9.md new file mode 100644 index 0000000000..bce27b44d6 --- /dev/null +++ b/docs/changelog/3.9.md @@ -0,0 +1,1370 @@ +# PerformanceMonitor 3.9.0 + +The full changelog entries for 3.9.0. [CHANGELOG.md](../../CHANGELOG.md) carries the +compacted index for every version, this one included, and is where `[Unreleased]` is written. + +## [3.9.0] - 2026-10-01 + +### Important + +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - After upgrading, 1-minute collectors run every 60 s instead of drifting to about 70 s on large fleets, so per-minute data and store growth rise by up to ~20% compared with 3.8. + +- **Upgrading from 3.8 runs the Darling store migrations V126 through V157 on the service's first start** - the ones that touch existing data were measured at 43-server fleet scale to finish in about a second or less each (the largest, V150's two indexes over the collection log and job history). V157 adds a nullable `server_id` column to `config.config_mute_rules`. Adding a nullable column with no default is a metadata-only change in PostgreSQL, so it takes no time on a store of any size. V126 through V156 ran on production monitoring stores during the 3.9 pre-release builds, and V157 ran there at the release-candidate install, with no install stalled by a migration, so no maintenance window is needed. + +### Added + +- **`--drop-xe-sessions`** ([#4852]) - a command-line verb that drops the Extended Events sessions a removed server left behind. Run it just before removing the server. `--dry-run` lists them. `--print-sql` prints guarded statements to run by hand when the server is no longer configured. +- **Collection Falling Behind self-alert** ([#4851]) - it fires when the fleet collection gate skips at least 5% of the slots due in the last hour. At least 20 slots must be skipped too. It resolves after a full hour under 1%. An hourly log line gives the slots run and skipped, how long collection waited for a gate slot, and the gate width. +- **PostgreSQL targets: a finding when pg_stat_statements keeps evicting statements** ([#4680]) - When a target's pg_stat_statements module has had to drop its least-used entries in at least 3 of the last 6 hours, analysis reports it, says Darling's statement totals can under-report, and recommends raising pg_stat_statements.max (a restart, or on RDS and Aurora a parameter-group change and a reboot). It never fires where the eviction count is unknown. +- **Per-rule plan analyzer overrides** ([#4602]) - `darling.json`'s (Darling) and `settings.json`'s (Lite) new optional `analyzer` section can disable a specific plan-analysis rule or override its severity, e.g. `"analyzer": { "rules": { "disabled": [20] } }` hides Local Variables findings. Applies to the MCP plan tools, the drill-down views, and the plan viewer window. +- **Plan viewer: a Server Context card** ([#4614]) - The Plan Insights strip now opens with a Server Context card, as in PerformanceStudio's desktop viewer. It shows the server a plan belongs to: its name, edition and version, CPUs and memory, MAXDOP, cost threshold for parallelism, max server memory, and the plan's database with its compatibility level, from what the collector has stored for that server. +- **Plan viewer: a Parameters card** ([#4604]) - The Plan Insights strip now includes a Parameters card, listing each statement parameter's data type, compiled value and runtime value, and flagging a runtime value that differs from its compiled value as possible parameter sniffing. +- **Plan viewer minimap** ([#4596]) - The plan viewer's toolbar has a "Minimap" toggle that opens a scaled-down overview of the whole plan, with a box showing the current scroll position and a click-to-center shortcut. +- **Plan analysis flags a possible Standard Edition batch-mode DOP limit, and marks legacy findings** ([#4585]) - A plan that ran at DOP 2 with batch-mode operators gets a Standard Edition DOP Limitation finding (Info until the server's edition is known). Findings from rules that predate the benefit-scoring framework carry `is_legacy` in the MCP plan output and a [legacy] tag in the plan viewer. +- **Plan viewer: a finding's header links to the operator it came from** ([#4559]) - Plan-level and per-operator warnings that know which operator they came from now show a small arrow in their header; clicking it selects and scrolls to that operator. +- **The MCP plan tools report which operator each finding came from** ([#4556]) - Every plan analysis finding now carries the node IDs of the operators it came from, empty for findings with no single operator responsible (such as high compile CPU). Carried in `origin_node_ids` in the MCP plan tools' JSON output. +- **Plan analysis turns a plan's wait statistics into findings, and gives external and preemptive waits a real benefit estimate** ([#4555]) - When an actual plan carries wait statistics, each significant wait type becomes a "Wait: " finding with a description of what the wait means and a severity from its estimated benefit. External and preemptive waits, which the engine spends outside its own scheduler, get their own benefit formula instead of being folded into operator time. +- **Plan analysis now flags an operator that takes a large share of a statement's run time even when no other rule has advice for it** ([#4550]) - A new "Expensive Operator" finding fires when a single operator's own time is at least 20% of a statement that ran 1 second or longer, so a big chunk of runtime no longer disappears from the findings just because nothing specific was wrong with it. +- **Plan analysis warns on dynamic cursors and on cursors declared without `LOCAL`, and "Scan With Predicate" names a dynamic cursor when it is the likely cause** ([#4549]) - A dynamic cursor sees data changes between fetches, which blocks many index uses. A cursor declared without `LOCAL` defaults to global scope. A declaration inside a comment or a string does not count. +- **Plan analysis flags a query whose text was cut off by SQL Server's showplan limit** ([#4548]) - When a statement's copy of its query text hit SQL Server's roughly 4,000-character cap when the plan was captured, the analysis now says so instead of leaving the reader to work out why re-running or formatting that text fails. +- **Plan analysis: added the "Bare Scan" finding for a full-table or full-clustered-index scan with no predicate** ([#4545]) - A Clustered Index Scan or heap Table Scan with no predicate now gets a covering-index or columnstore suggestion depending on its output width. +- **Plan analysis now marks which findings are SQL Server's own warnings and which are inferences, and duplicate missing-index suggestions are no longer merged across different databases** ([#4543]) - `PlanWarning.Source` says whether a plan warning came from the engine's own `` element or from the analyzer; the plan viewer tags the engine's with `[SQL Server]` and the MCP plan tools carry it as a `source` field. Rule 30's duplicate-index-suggestion check now keys on database as well as schema and table, so same-named tables in different databases are no longer reported as duplicates of each other. +- **get_read_latency reports how long the web dashboard's and MCP server's reads take: p50, p95 and p99 per read over a chosen window, with timeout counts** ([#4454]) - the data comes from hourly histograms the service records; the percentiles are bucket upper-bound estimates; the web and MCP store sessions now show their own application_name. +- **Self-monitoring alerts (Collection Stopped, Capture Down, Collector Cost Regression) open a notebook with the server's collection health and the collector's log and cost** ([#4437]) +- **Analysis-finding alerts open a notebook with that finding's summary and evidence** ([#4436]) +- **Custom-rule alerts open a notebook that charts the rule's own measure with its threshold or band** ([#4433]) +- **Poison Wait alerts open an authored notebook: top waits on both engines, waiting tasks, resource-semaphore/memory-grant detail when the wait is RESOURCE_SEMAPHORE, and a trend bound to the firing wait type.** ([#4424]) +- **Server Unreachable/Restored and the Agent-job alerts (Failed Agent Job, Long-Running Job, Agent Not Running) now open an authored notebook instead of the mechanical section-list fallback, and the collection-log web read can filter by status.** ([#4422]) +- **High CPU alerts open an authored notebook: SQL Server and PostgreSQL CPU timelines, top queries/procedures by CPU, and scheduler pressure, instead of the mechanical read list.** ([#4420]) +- **PostgreSQL Wraparound Risk, Vacuum Horizon Blocked and Replication Slot Retention alerts open an authored notebook: their own drill-down reads and a 24h trend panel, instead of the mechanical fallback section list.** ([#4419]) +- **Long-Running Query and Forced Plan Failing alerts open an authored notebook: active/completed queries and a completion-duration timeline for Long-Running Query, plan corrections and a corrections timeline for Forced Plan Failing.** ([#4418]) +- **Authored Blocking and Deadlocks alert-notebook templates** ([#4395]) - `/api/alert-notebook` now returns a forensic, multi-cell layout for Blocking Detected, Blocking Wait Time, and Deadlocks Detected instead of the flat mechanical read list every other alert type gets: a blocked-process-reports or deadlocks timeline with a cross-annotation, ranked breakdowns by object/database/lock-mode, and the existing header/status/drill-down reads, all bound to the alert's own window and database. +- **Aurora per-query peak memory as a context fact** ([#4370]) - PostgreSQL-target top-statement findings now state a statement's peak executor memory (Aurora's `aurora_stat_statements()` only) as context when available, alongside its share of window time; it never changes a finding's severity, rank, or whether it fires, and reads NULL rather than 0 off Aurora. +- **Alert-notebook read-only render on `#/triage`** ([#4368]) - the alert deep link can now render the bound notebook document returned by `/api/alert-notebook` (server, status, and forensic read cells for the firing), read-only with no fleet scope picker; falls back to the existing triage assembly when the endpoint isn't present. +- **Notebook `read` cell type** ([#4367]) - Notebooks can now include a `read` cell (`{type:"read", read, params, viz, title}`), validated by the same rules as a dashboard's v1 read panel and rendered through the shared panel renderer. Those shared rules now also check a read panel's `params` on save, for dashboards as well, so a saved dashboard panel with a malformed `params` object is rejected the next time it is saved. +- **Alert-notebook binding endpoint** ([#4366]) - added `GET /api/alert-notebook`, which turns an alert link into a bound, read-only notebook definition (a dedup-matched alert, a four-arm live status, and a mechanical per-metric read cell list), the server half of the alert-to-notebook MVP (#4222). +- **A shell-level pause/resume control for the web viewer's auto-refresh** ([#4365]) - the 60s refresh loop previously only paused automatically while a browser tab was hidden. Added a button in the sidebar chrome, present on every page, that lets the operator pause and resume the tick directly; the paused state persists across reloads. Resuming runs one refresh immediately. Also added the alert-notebook triage deep-link route to the existing poll-skip guard so the periodic tick does not re-render it. +- **The store host profile now reports its cloud instance type** ([#4330]) - `get_store_host`, `--check-settings` and the store host web panel now show the EC2 instance type or Azure VM size of the machine the Darling service runs on. For a managed store, or a store on the same machine, that is the store's own host. A short, bounded probe of the cloud metadata endpoint reads it, as the metadata service reports it, and the panel says "not detected" off the cloud or when the probe finds nothing. +- **Store host visibility: an MCP read and a web panel** ([#4282]) - The managed PostgreSQL store's own host +- **`--check-settings` reports whether a managed store's sizing still matches this host** ([#4271]) - a new CLI verb prints the host and store facts (RAM, CPUs, PostgreSQL/TimescaleDB versions, store size, buffer hit ratio, uncompressed TimescaleDB chunk bytes against RAM) and a verdict for each of the eight sizing-relevant settings: matches, stale after a hardware change, operator override, or not managed. `--json` prints the same facts for scripting. Separate exit codes for a config error, an unreachable store, and a stale setting let an install or upgrade script gate on the outcome that matters to it. +- **`--validate-config` (`--test-connection`) no longer fails a healthy store over a stale entry in darling.json** ([#4271]) - once the store is reachable, this now probes its own registry of monitored servers instead of the config file's first-bootstrap seed list. A server that is only in the file (never registered, or since removed from the registry) is now a warning, not a failure. A store that cannot be reached still falls back to the file's list, and says so on the console. This closes the false failure reported on a 42-server production store whose darling.json still listed two long-removed servers. +- **Darling's MCP host now serves a /core endpoint alongside /** ([#4121]) - / keeps serving every Darling MCP tool, unchanged. /core serves a fixed 74-tool subset: the four tools a fresh conversation starts from (list_servers, get_fleet_overview, analyze_server, get_tool_guide) plus every tool the analysis engine's next_tools recommendations can point at. /core sits behind the exact same Host, bearer-token and CIDR checks as /, and a tool outside the subset fails the same way an unknown tool name would. A /core session's shared instructions now lead with a short note. The note says /core serves 74 tools, and that the tool count and tool notes after it describe the full set on /. It also says a tool outside /core fails as an unknown tool, though get_tool_guide can still describe it. Along the way, fixed eight next_tools entries that recommended get_blocked_process_reports, a tool Darling has never had (Darling's name is get_blocking), so those findings always pointed at a call that failed. +- **get_resource_semaphore also returns interval_seconds** ([#4103]) - On Darling and Lite, get_resource_semaphore now returns interval_seconds beside sample_interval_seconds. It carries the sample interval under the name get_latch_stats and get_spinlock_stats already use, and it is null when the interval cannot be known. sample_interval_seconds stays for existing readers. +- **get_query_store_top takes module_name, so one stored procedure's Query Store history can be read without widening top** ([#4057], contributed by @kendra-little) - the read ranked the whole window before capping it, so a procedure an investigation named but whose queries sat outside the top N could not be reached at all. The filter is part of the query on both SKUs. It matches the exact, case-sensitive, schema-qualified name the collector records (the full_name get_top_procedures_by_cpu returns, Adhoc for ad-hoc statements), and it applies after the #1841 interval dedup and before the ranking and the cap. Every row now carries module_name, beside the execution_type #4060 added, and the two filters compose. A filter that matches nothing answers empty only when the same read without the filters has rows, and the message names both filters. On Darling, a module miss also carries effective_start, effective_hours_back and window_truncated as hints. Otherwise the read answers as an unfiltered one would. +- **The store names its own slow queries: `get_store_query_stats` ranks the monitoring store's SQL by cost and by the role that ran it** ([#3899], hardened before release by [#3915]) - Field reports that the web viewer and MCP tools were slow could not be traced to a query from anything the product recorded: the store loaded only TimescaleDB and logged no statement durations. The managed store now preloads `pg_stat_statements` through a new v13 conf block that MERGES it into the effective `shared_preload_libraries` list (includes followed), so an operator's own libraries survive, and turns `pg_stat_statements.track_utility` off, because provisioning's `ALTER ROLE ... PASSWORD` literals are otherwise recorded verbatim (measured on the bundled PostgreSQL 18.4). Every start then checks which preload assignment is in force and logs the exact fix when an `ALTER SYSTEM` override, a later line, or an edit the block overrides leaves the library out; the `ALTER SYSTEM` fix is written one quoted literal per library, since a single literal holding the list is stored as one library name and the store will not start. A store-object convergence step, run at every start and hourly on a TimescaleDB store, creates the extension and two SECURITY DEFINER readers (pinned `search_path` and `standard_conforming_strings`, revoked from PUBLIC) granted to the admin, viewer and mcp roles. The readers refuse every statement whose text can carry a credential (role, user-mapping, subscription or server DDL, or a `PASSWORD` literal), with a backslash-free pattern a caller's string mode cannot switch off, and the step scrubs such statements from this database's entries and warns once if utility tracking is on. `get_store_query_stats` (MCP, and the `/api/read` mirror) ranks statements by total, mean or max time, calls, rows or disk reads, attributes each to its role with each role's share of the recorded time, and returns query ids as strings. It says what the figures leave out: `COPY` ingest while utility tracking is off, statements whose text the store owner may not read (and the `pg_read_all_stats` grant that fixes it), and a compose or bring-your-own store's web and MCP hosts, which connect as the owner ([#3914]). It answers `precondition` with the remedy, from the catalog, when the module is missing, not loaded, older than 1.8, or not granted, and a 1.8 install gets the ranking without the reset stamp. The viewer and mcp roles also log any statement past a third of their `statement_timeout` (5 s at the default), re-asserted with the timeout on a reload, with bind parameters off; the store-log sweep keeps those under `slow_statement`, one row per statement with comments stripped, every literal masked and parameter lines dropped, whichever role's statement it was. The Linux compose store gets the same preload on its command line, and `provision-roles.sql` carries the bring-your-own steps, including utility tracking off for its own session. Covered by unit tests for the merge, parse, include and coverage checks, the version gates, the redaction and the precondition answers, and live tests on the bundled runtime proving that a role password never reaches the reader (even with `standard_conforming_strings` off), that statements are attributed per role and normalized, that the scrub removes a password recorded with tracking forced on, that a non-superuser store owner can run the setup, and that an extension walked up from 1.7 is gated and then served. +- **Maintain your own theme colors, per theme, with a reset to default** ([#3577]) - Settings gains a Colors section beneath the theme drop-down in both Lite and the Darling viewer: twelve palette colors of the theme on screen (backgrounds, text, accent and its ink, alternating row, the four status colors), each with a swatch, hex, an HSV picker and the measured WCAG contrast ratio against the surface it renders on, color-coded at 4.5:1 and 3:1 - a warning, never a gate. Apply writes a per-user theme-overrides.json beside settings.json (the viewer's beside viewer-settings.json, local to the machine) and re-applies live; Reset to default returns that one theme to its shipped palette; Open file hands you the JSON, and saved edits apply on their own. A bad file, key or value is a logged warning and the stock theme, never a crash. +- **A PostgreSQL target with every logging setting off no longer looks identical to an instrumented one** ([#3607]) - `get_pg_logging_audit` judges log_min_duration_statement, log_lock_waits, log_temp_files, log_autovacuum_min_duration, log_checkpoints and log_connections/log_disconnections from the stored configuration snapshot, setting by setting, with what each unlocks, the recommended value and its cost, and the remedy in the hosting flavour's own syntax (ALTER SYSTEM plus a reload, or a parameter group where rds.* parameters prove RDS/Aurora). It sits beside `get_pg_plan_capture_readiness`, whose auto_explain facets it lists but never re-judges, so target onboarding has one "is this target telling us everything it could" answer. +- **A stock PostgreSQL target without pg_wait_sampling now has a wait profile instead of an empty chart** ([#3604]) - pg_wait_sampling grows a service-side arm that polls pg_stat_activity once a second for a 30-second window every five minutes and accumulates the tallies itself when the extension is absent, so the three PostgreSQL wait tiers (Aurora native › extension › service sampler) are one connect-time decision with exactly one instrument per target. get_pg_wait_stats, get_pg_wait_sampling and the Viewer disclose instrument: engine_cumulative | extension_sampled | service_sampled, with the floor caveat on the service tier. Aurora is gated off pg_wait_sampling (it cannot preload the module) and is pointed at pg_wait_stats instead. No migration. +- **PostgreSQL's server log is read by a classifier, not by two regexes** ([#3601]) - Darling now tails the same log the deadlock and plan readers tail — `pg_read_file` self-hosted, the RDS log API on Aurora/RDS — and classifies every line into families: `error` (WARNING or worse), `connection`, `lock_wait`, plus `temp_file`/`autovacuum`/`checkpoint` recognised for the structured tables #3602/#3603 add. Events land in `collect.pg_log_events` (V129, 30-day retention) with `message`/`detail`/`context` redacted by the plan parser's own patterns and the statement never stored, only fingerprinted; `get_pg_log_events` reads them with `family`/`min_severity` filters and the honest page contract. The three log readers now share one tailer (`PgServerLogTail`) instead of three copies. +- **The log said what the spill cost and what the vacuum cost; the store kept the sentence and threw away the number** ([#3602], [#3603]) - Two parser families on the log-event pipeline lift the figures out of the prose: a `temp_file` event carries the spilled file's exact bytes beside the fingerprint of the statement that spilled, and an `autovacuum` event carries the run's relation, duration, pages, tuples, buffers and WAL, on V130 columns of `pg_log_events` rather than sibling tables. `get_pg_log_events` publishes them where the line carried them; `get_pg_autovacuum_health` gains `recent_runs` per table, so "is it keeping up" and "what does each run cost" answer from one place. Line shapes pinned per PostgreSQL 16/17/18 from the server source. +- **Alert families route to their own channels** ([#3598]) - Every alert used to fan out to every configured channel from one install-time row, so self-monitor alerts, scheduled reports, job failures and performance pages interleaved in one stream and the reader did the routing in their head. A sparse `config_notification_routes` table (V131) layers over that row: a route names a family (`self-monitor`, `reports`, `agent-jobs`, `performance` — a closed taxonomy every alert maps into, census-pinned) or an exact metric, and carries a destination per channel; resolution runs once per firing after cooldown — exact name, then the firing a recovery pairs with, then family, then the parent's default — per channel, so an empty column inherits and a store with zero routes behaves byte-for-byte as before. The delivery ledger records which route matched, recoveries land where their firing did, the viewer gains a Routes grid, `get_notification_routes` / `set_notification_route` / `delete_notification_route` expose it to agents, and routes hot-reload through the same beacon mute rules use. +- **PostgreSQL targets enter the analysis pipeline** ([#3542] v1 plumbing) - The scheduled pass and every MCP analysis tool used to skip a PostgreSQL target behind an engine tombstone ("does not apply … use the get_pg_* reads"), because the pipeline read SQL Server tables and would have sat at "0 hours, still collecting" forever. The analysis service now holds two engine component sets and picks one PER CALL from the registry's `engine_kind` (two of its construction sites are singletons shared by every server, so the constructor could not be told); a PostgreSQL pass measures its 24-hour gate, its coverage witness and its baseline gate on `pg_database_stats`, scores a `pg_`-prefixed fact vocabulary declared once before any row persists, and clears the tombstone row on its first real pass. Every shared switch (scorer, advisory roots, graph, advice, anomaly reconciler, tool recommendations) gained exactly one delegating `pg_` arm so the nine content lanes build in parallel without touching shared files; `audit_config` answers `not_collected` for a PostgreSQL target instead of "the config collector may not have run yet". The SQL Server pass is byte-identical. No schema, no content. Rider (#3653/#3616): `HADR_SYNC_COMMIT` findings on Darling now carry next_tools (`get_wait_trend`, `get_ag_health`, `get_perfmon_trend`, `get_file_io_stats`), the pair of Lite's #3659. +- **A PostgreSQL target's durability posture is stated, not inferred** ([#3542] lane 8) - The analysis pass read nothing about `fsync`, `full_page_writes` or `synchronous_commit`, so a cluster running with fsync off analysed exactly like one running safe. Three `pg_posture` facts now come off the newest `pg_server_config` snapshot: fsync/full_page_writes off is a CRITICAL policy card naming the corruption trade, synchronous_commit off a 0.4 advisory naming the acknowledged-then-lost commit window, and Aurora's platform-managed pair is present, marked managed and ungraded. No amplifier, graph edge or optimisation word can reach a posture fact — pinned in source and at runtime (D6). +- **A PostgreSQL analysis pass now names the statement** ([#3542] lane 7) - A PostgreSQL target's stories ended at a server-level symptom and never said which statement. `PG_BAD_ACTOR_` facts from `pg_statement_stats` stored deltas now carry one shape's share of the window's total execution time (denominator over the whole window, never the page), its calls/sec over the span its deltas accrued and mean/max ms; the scorer grades the share behind an idle-window gate with every bar declared unmeasured (`threshold_lineage = 0`); the card states the figures, both levers with their counter-objectives and the queryid re-key caveat; the drill-down carries the normalised text, its hash and the per-database breakdown. +- **The two PostgreSQL knobs learn to speak** ([#3542] lane 2) - The analysis pass had nothing to say about `shared_buffers` and `max_wal_size`, the two settings the OtterTune field study found carry 75–95% of measured tuning value. Both are now cut from the latest `pg_server_config` snapshot: at their shipped defaults (128 MB, the line `initdb` writes; 1 GB) they root a 0.4 ADVISORY card and never an incident on their own, and reach the incident line only when the engine's own workload signal co-fires — `PG_CHECKPOINT_PRESSURE` (requested-dominant checkpoints from `pg_write_stats` deltas, with WAL bytes per interval) or `PG_BUFFER_CACHE_PRESSURE` (a composite of hit ratio, bgwriter and, on PostgreSQL 16+, `pg_io_stats` evictions, each arm carrying its own evidence and honesty flag: `evictions_tracked` below 16, `hit_ratio_suppressed` on Aurora where the storage layer answers reads). Every bar carries lineage — defaults engine-defined, ramps declared unmeasured with the calibrating read named — and the advice states the measured share, the value on the host, both levers and each lever's counter-objective. A `PgSettingValue` helper normalises PostgreSQL's unit zoo (8kB pages, kB/MB/GB, ms/s/min, -1 sentinels) once. +- **A PostgreSQL target's analysis pass gains its vacuum family, graded on the same bars the Tier-0 alerts page on** ([#3542]) - `PG_AUTOVACUUM_BACKLOG` names the worst table persistently past its own autovacuum trigger line with the ratio to that line, the dead-tuple slope over the run and whether autovacuum ran and lost (cumulative counts differenced, never summed); `PG_WRAPAROUND_TREND` grades XID and MultiXact separately through the alert evaluator's four arms and adds a time-to-wall estimate with an explicit not-computable branch; `PG_XMIN_HOLD` grades the alert's identity arm and names the fix per holder kind. The wraparound/xmin/slot constants move to one shared `PostgresOutagePredictorThresholds` that both the alert evaluator and the analysis scorer reference, pinned so the surface that pages and the surface that narrates cannot disagree; the three facts chain into one story with value-stated advice that never suggests disabling autovacuum. +- **A PostgreSQL pool near its connection ceiling is graded as the outage it is** ([#3542]) - A PostgreSQL target's analysis pass had no session fact: a pool at 96 of 97 usable slots — one deploy from `FATAL: too many clients already` — produced an empty verdict at full coverage. `PG_CONNECTION_SATURATION` now grades the window's peak session count from `pg_session_states` against the engine's own line, `max_connections − superuser_reserved_connections` (read off the config facts, never re-read), scoring zero below 0.8 and 1.0 at 0.9 with `threshold_lineage = 0`; the card states the division with all three numbers, the peak capture's active / idle-in-transaction / other breakdown, and both levers — a pooler or a higher ceiling — with what each costs. When the monitoring login lacks `pg_read_all_stats` and most stored rows are redacted, `PG_MONITORING_PERMISSIONS` says so instead of a ratio built on blank rows. +- **A PostgreSQL analysis pass now names temp-file spill and gates work_mem on it** ([#3542]) - PG_TEMP_SPILL grades spilled bytes per second of observed time from the reset-aware pg_database_stats difference (a pg_stat_reset() mid-window is clamped and reported), names the database that spilled the most, and leads a story to CONFIG_PG_WORK_MEM, which scores 0 without that evidence and reaches the incident line only beside it; the drill-down lists the statements that wrote the most temp blocks and the advice states the host's own work_mem × max_connections arithmetic. The same read emits PG_TPS (with a half-window trend) and PG_DEADLOCK_RATE from the engine's counter on the alert band's measured tiers, saying how many the log captured beside how many the engine counted. +- **A PostgreSQL analysis pass reads the wait profile — measured on Aurora, estimated on stock, and says which** ([#3542]) - Lock, LWLock, IO and IPC rollups with the Lock:relation, LWLock:WALWrite, IO:DataFileRead and IO:WALSync standouts, each a fraction of the wait source's own observed time. Aurora's pg_wait_stats deltas are summed under the three-state interval (a restart collection is not a sample); a stock target's pg_wait_sampling counts × profile_period are read only when the Aurora table is empty and every such fact carries is_sampled and its resolution, with advice that says "estimated from sampling" and never "spent". Bars are unmeasured and say so; a rollup yields to its fired standout so one wait is graded once; WAL waits chain into checkpoint pressure, data-file reads into buffer-cache pressure, and Lock waits mesh with connection saturation. Lock advice names PostgreSQL's levers, not the SQL Server isolation remedy. +- **A PostgreSQL target learns its own normal** ([#3542] lane 9) - A PostgreSQL analysis pass had no baseline and no anomaly detector, so a 6× throughput surge, a tripled connection pool or a serverless instance pinned at its configured ceiling was indistinguishable from a quiet Tuesday - and had the anomalies existed, they would have scored 0 and never left the 1.49 cap (#3584's defect, again). Five baselines over the pg_* raw hypertables (TPS and deadlocks/hour off the reset-aware per-database difference, the capture's total_sessions, the Aurora all-types wait rate with CPU excluded, percent of the configured ACU ceiling - never raw cpu_percent) and five detectors through the shared AnomalyGate writing the metadata the shared ramp and extremity escape read; a PostgreSQL ratio ramp with no sentinel for a first occurrence; load-family co-fires confirmed only by a measured capacity reading; PG_CPU_PERCENT graded only when capacity was measured; advice in PostgreSQL nouns. Every unmeasured bar carries its lineage and threshold_lineage = 0. Stock PostgreSQL's sampled waits get no anomaly baseline in v1. +- **The measurement contract had ten rules and two tests** ([#3653]) - The contract #3540 stated in one sentence is now a numbered list in `Lite.Tests/MeasurementContractCensusTests` (4 and 7 keep their tests' numbers; 9–10 are left empty because the review's enumeration is not on the record), and rules 1, 2, 3 and 6 are censuses over both SKUs' sources with positive controls and population floors: no reader divides by a stored interval except through NULLIF, no rate assumes a cadence, exactly two carriers observe an epoch and every forget site is named, every per-second alias is a quotient. Rule 5 is rostered against the real continuous-aggregate definitions — the #3698 successors carry the interval predicate; the superseded pair and three hourly rollups do not — and rule 8 waits, pinned, on the `cntr_type` rung. +- **v2 plumbing for the PostgreSQL-target engine, and the wait-profile anomaly now folds onto its wait and can page** ([#3691]) - The I/O, replication and bloat families exist as stubs behind one delegating arm per shared switch, with the v2 vocabulary declared once so lanes 11–15 never touch a shared file. `ANOMALY_PG_WAIT_PROFILE` stopped sitting one hundredth under the page line: it folds onto the wait card its dominant contributor names and leaves the 1.49 cap on the same three readings as its SQL Server twin, anchored on its own firing multiple. +- **Schema 133: the PostgreSQL saturation numerator and the sampler's duty cycle are stored** ([#3691]) - `pg_database_stats` gains `numbackends` (the client backends connected per database at the instant of the read, a level, never differenced) and `pg_wait_sampling` gains `sampled_ms` (the milliseconds each five-minute collection actually observed - 30,000 from the service-side sampler, NULL from the extension arm that watches the whole interval), because "count / max_connections" had only an exception-capture count to divide and "samples × period / interval" understated the sampler arm ~10× with nothing in the row saying so. Written by the collectors from this rung; read by nothing yet. Lite stores no `pg_*` table, so no DuckDB bump. +- **The pull-request review learns the repository's traps and stops answering LGTM by default** ([#3710]) - The bot review had read several hundred pull requests and posted LGTM on very nearly all of them; every defect it missed was later found by behaviour, not by reading. Three structural causes, three fixes: a `.github/REVIEW-TRAPS.md` of the repository's recurring defect shapes, each citing the pull request that bit, which the review must consult and name; a blind first phase that reads the diff and its callers before it is allowed the author's account, then reports where the two diverge; and a structured verdict — every claim in the body VERIFIED, UNVERIFIED or REFUTED, the three riskiest lines and what pins each, a machine-readable ledger line — without which the run fails, so a bare LGTM is no longer a valid review. A paths filter sends analysis, collectors, storage, service, alerting and notification changes to a full-tier Opus pass with the 1M context window and everything else to a lighter Sonnet pass; the verdict contract is identical either way. Lands dark under the workflow-drift rule; the first live run is the first pull request after the release sync. +- **A server configuration change now has a consequence the engine states — `CONFIG_CHANGED` compares the ±4 h around it and says what moved, or that nothing did** ([#3653]) - The analysis engine graded the current value of seven `sp_configure` settings and never asked whether a change had an effect; that join lived in the operator's head between `get_server_config_changes` and `compare_analysis`. Both SKUs now emit one Information-level `CONFIG_CHANGED` finding per change event observed inside the pass window, running `ComparePeriodsAsync` over the four hours before the observation and the (honestly clamped) four hours after, banded by the same dispersion rules as `compare_analysis`, with the setting, old → new, and the moved metrics — or the sentence that none moved — frozen into the finding. Because `server_config` is captured on connect, the finding says "first observed", states the span the real change landed in, and never claims to be a causal test; database-config and trace-flag changes are the next slice. +- **PostgreSQL deadlock cards carry the captured exemplars, grouped by shape and ranked by recurrence** ([#3691]) - The card said "the engine counted N; M were captured from the log" and stopped. The drill-down now reads pg_deadlocks for the window, groups reports into shapes (participants, lock modes, resources — deadlock_hash identifies one report, not a shape), carries the top three with bounded statement and graph text, reuses the counter the card was graded on, and re-freezes the advice with the value-stated sentence and the ordering lever. Zero capture beside a non-zero counter names the logging-posture settings instead of showing an empty list. +- **The PostgreSQL bloat family grades fourteen-day GROWTH behind a size floor, never a spot percentage** ([#3691]) - `bloat_pct_estimate` read 71–99.8 % on most of the measured fleet's small heaps while their fourteen-day growth was zero bytes, so a percentage-graded finding would have paged everywhere and argued for VACUUM FULL on a Tuesday. `PG_BLOAT_TREND` (hourly `pg_table_bloat_stats`) and `PG_INDEX_BLOAT_TREND` (daily `pg_index_bloat`) now grade the estimate's growth across a fourteen-day lookback — 256 MiB and 25 % of the earlier value, 1 GiB critical, 64 MiB floor, all measured on the dogfood fleet — exclude `estimate_unavailable` and skipped rows outright, name the top three objects, state their own sample counts, and chain onto a same-table `PG_AUTOVACUUM_BACKLOG` as its damage. Withheld estimates are facts that say why, never zero bloat. +- **A chain that fired every Tuesday at the same hour was rated a fresh incident each week and nobody was told; the pass now labels it "recurring at this hour" at unchanged severity, and a weekly Agent job whose slot slid gets "maintenance window moved"** ([#3653]) - Ruling Q3: label, not discount. After the anomaly fold and before the finding is persisted, one store read of the prior three weeks (on the target's clock via `server_properties.utc_offset_minutes`, UTC disclosed when absent) lets `RecurrenceLabeler` append one sentence to the frozen advice of every chain that fired in the same hour×weekday slot for three consecutive weeks, and one naming the job and both slots to every story tied to a fired `RUNNING_JOBS` whose slot moved since last week. Severity is bit-identical with and without the label; both `get_analysis_findings` twins publish `recurring_at_this_hour`, `recurrence_weeks` and `maintenance_window_moved`. +- **PostgreSQL read latency is now a graded fact, and the pass says why when it cannot know** ([#3691]) - `PG_IO_READ_LATENCY_MS` states milliseconds per data-file read from `pg_stat_io`, graded against bars measured on the dogfood fleet's Aurora storage (10 / 30 ms, population named), with `ANOMALY_PG_IO_LATENCY` when an hour departs this server's own routine. With `track_io_timing` off the pass reports the reads it counted and that none were timed — never 0.000 ms — and on a pre-16 major it says `pg_stat_io` is absent; write latency is stated, not graded. +- **Replication lag and slot retention stories for the PostgreSQL-target engine** ([#3691]) - A PostgreSQL operator's agent now hears whether a standby is behind or FALLING behind and at which stage (sent / write / flush / replay), whether a replication slot is filling the disk or has already lost the WAL its consumer needs, and whether a slot's horizon is what holds vacuum back — three facts, one chain into PG_XMIN_HOLD, and the replay-lag anomaly against the server's own hour-of-week baseline. Every shared bar is the Tier-0 slot alert's own by reference; bytes are graded and NULL replay_lag_ms is tolerated; the drift multiple is unmeasured (n = 1). +- **The CPU sample's UTC instant and the server's time-zone id are now stored, so UTC-window readers stop deriving an offset that is an hour wrong across DST** ([#3653]) - `cpu_utilization_stats.sample_time` is the monitored server's LOCAL wall clock, and every reader that aligned it against UTC derived the offset per batch or from the single collected `utc_offset_minutes`, placing the samples nearest a DST transition an hour wrong. Darling V134 / Lite v63 add `sample_time_utc` beside the unchanged local stamp (the same instant off `SYSUTCDATETIME()`), which the viewer, MCP `get_cpu_utilization` and the Lite CPU window now prefer, and `server_properties.time_zone_id` (`CURRENT_TIMEZONE_ID()`, SQL Server 2022+ / Azure SQL; NULL elsewhere) beside the offset that could not say which side of a transition an instant fell on. Nullable, no backfill: the offset a server had at a past sample's instant is exactly what the store never recorded. +- **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 `log_lock_waits` lines (count, longest, relation), counting each wait once, even when PostgreSQL 18 logs it again while it goes on, and each line once, even when the log is read again ([#4886]) 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], [#4809]) - `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. They exit 0 on success, 1 for bad arguments or configuration, and 2 when the store can't be reached or refuses the login. +- **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. +- **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 + +- **The managed store sets `random_page_cost = 1.1`** ([#4863]) - the managed PostgreSQL store now renders `random_page_cost = 1.1`, a value suited to SSD storage, in place of PostgreSQL's default of 4, which prices a random page read at four sequential ones. The planner now picks index and bitmap scans that the default priced out. Measured on a production store over an hour at each value, back to back, total statement time was 2.3% lower at 1.1, with some statements faster and a few slower. A store upgrading from 3.8 moves its settings into the managed file at the upgrade start and gets the line there, and the value is in force from the service's next start after that. A `random_page_cost` set with `ALTER SYSTEM` still wins, and one already set in `postgresql.conf` when the store upgrades is carried into the managed file unchanged. +- **Per-server Query Store reads fetch fewer rows** ([#4861]) - This covers the Queries grid, MCP's Query Store top read and the Trends Query Store chart. Each filtered one server's rows of the per-interval table by collection time only, which no index held. So it fetched every stored row of that server. Each read now also bounds first_execution_time, which the table's unique key holds, so older rows are dropped before they are fetched. Results do not change. On a large store, a day-long MCP read went from 3.1 s to 0.6 s. +- **SQL Server blocking and deadlock baselines count the hours collection covered** ([#4853]) - each hour-of-week's mean now divides by the days collection ran in that hour. It used to divide by the days that had events. A covered hour with no blocking or deadlocks is a measured zero, so a spike into it says the baseline measured zero instead of "first occurrence". This needs at least one captured event in the 30 days, so a server that cannot capture the events keeps no baseline. Hours with occasional events get lower means. More hours are trusted, and a trusted hour must also pass the rate multiple, so those hours alert less often. An hour whose events cluster on a few days can alert at a lower event rate than before. These baselines are now computed once per UTC day, like the CPU and I/O latency baselines. Events earlier on the current day are not part of the baseline. +- **The plan viewer's Runtime Summary lists CE model above Optimization, with Early abort under it** ([#4849]) - this matches PerformanceStudio. The Early abort label is indented when an Optimization row is shown. +- **Purge Now runs in the background and is paced like the daily purge** ([#4835]) - the command ran the whole purge before it answered, so every other command waited behind it. Its deletes were not paced, which slows collection on every server the way the daily purge did. It now answers at once with "started", or "already running" when another purge holds the slot. When the purge finishes, its totals and each raw table's result are written to the collection log under (fleet), which `get_collection_log` reads, and the viewer shows the totals. Update viewer seats along with the service: a viewer from an earlier release reads the new answer as 0 rows purged. +- **get_pg_deadlocks explains an empty answer more completely** ([#4832]) - The tool's text now names the log line prefix check beside the message language check (as does the empty answer of get_pg_deadlock_detail), and says the RDS read position is saved, so a restart resumes where the last read stopped. +- **Darling reads a quiet database's watermark from its cache instead of from the store every cycle** ([#4818]) - A database whose newest row was recent but had no new batch since the cache was seeded missed the cache on every cycle, at about 30 ms a time. +- **Query Store rows now record when each interval ended, in both apps' stores** ([#4802]) - The Query Store stats in Darling and Lite gain an `interval_end_time_utc` column next to the interval's start time. Rows collected before the upgrade leave it empty. +- **Query Store backfill: the per-tick database list no longer walks the newest chunk's index** ([#4703]) - every backfill tick listed a server's databases with a read bounded at the backfill horizon. Inside the chunk that holds the horizon that bound can only filter, so the read walked the chunk's index entry by entry, and it grew as the chunk filled. On a store monitoring 43 servers, with the horizon 20 minutes before the end of its chunk, one round of these reads cost 495,218 buffers and 560 ms (up to 24,457 buffers and 44 ms for one server). The read now starts at that chunk's start, taken from the TimescaleDB catalog, and the same round cost 1,815 buffers and 5.3 ms. On plain PostgreSQL the list comes from a walk of the index, one seek per database. A quiet database whose newest rows are in that chunk but older than the horizon is now marked done at once, so if it comes back after those rows leave raw retention, its first-contact history is not backfilled. A recorded outage gap is still backfilled. +- **Query Store views over windows longer than the raw tier now show the full window from the interval table, and say how far back it reaches** ([#4700]) - The Queries grid, the get_query_store_top MCP tool and Compose Query Store panels read the per-interval table below the raw tier's floor, down to the exact point where it provably holds the same rows raw held. The MCP tool reports history_source and effective_start, and its note says which bound set the start. +- **Analyzer wording for Nested Loops outer sides and row estimate mismatches now counts rows the way the plan viewer does** ([#4698]) - Rule 16's Nested Loops outer-side detail now prints the total actual rows when the outer input is not on a Nested Loops inner side, for example "actual 100,000 (1000x underestimate)" where it used to print "actual 12,500 (125x underestimate)" at DOP 8. Rule 5's "(N rows x M executions)" text now appears only on a Nested Loops inner side. +- **PostgreSQL targets: the top-queries views say when pg_stat_statements evicted entries during the window** ([#4680]) - Darling now records each target's pg_stat_statements eviction count (`pg_stat_statements_info.dealloc`) with its statement statistics. When the module had to drop its least-used entries in the window, `get_pg_top_queries`, the Darling Viewer and the web dashboard's Top Query Shapes say so and that the totals can under-report, and name pg_stat_statements.max as the fix; where the info view is absent the count is reported as unknown rather than zero. +- **Web dashboard: each notebook and Custom View has its own auto-refresh setting, notebooks start with it off, and slow pages back off** ([#4671]) - A labelled "Auto-refresh" control on each saved view and notebook (Off, 1, 5 or 15 minutes) is saved with the definition; notebooks default to Off and Custom Views to 5 minutes, and the fleet and server pages keep refreshing every minute. The header button now pauses all auto-refresh. A page whose last render took more than half its interval waits at least four times that render (up to 15 minutes) before refreshing again, and says when it will. +- **Query Store collection: each database's watermark comes from the store only when a cached value can't be proven current** ([#4669]) - The collector read `MAX(last_execution_time)` for every database on every cycle; on one production store that was about 6,900 s of store time and 112 million blocks read in four days. The value is now cached per server and database, advanced only after a batch commits and dropped on any fault, reconnect or backfill write, and used only while the row that set it is still inside the read's three-hour floor, so every cycle collects from exactly the same point as before, and re-read from the store at least hourly. +- **Alert pass: the forced-plan failure check reads the store only when its answer can have changed** ([#4667]) - Between Query Store collections every pass re-read two hours of one server's Query Store rows to reach the same answer; on one production store that was the second-largest statement, about 27,700 s of store time in four days. A one-row probe now decides, every Query Store write clears the saved answer, and the previous answer is reused otherwise (less any plan whose older collection has left the window), so alerts fire exactly as before. +- **Query Store collection: the orphaned per-database state cleanup runs at most once an hour per server** ([#4665]) - It ran three deletes after every Query Store cycle to catch the rare dropped database; on one production store that was about 5,600 s of store time in four days. It now runs on the first cycle after a start and then hourly, in Darling and Lite; a failed run is still retried on the next cycle. +- **The Darling Viewer's Query Store trend chart and `get_query_store_duration_trend` no longer re-scan the hourly rollup's oldest and newest hour on every load** ([#4618]) - They take the rollup's range from the coverage the service already caches, instead of a fresh `min`/`max` read over the rollup on every call. +- **Custom Views Query Store panels over a recent window read the per-interval table instead of re-sorting raw snapshots** ([#4617]) - A Query Store panel of 12 hours or more, whose window the store's per-interval table fully covers, now reads that table, with the same numbers, instead of deduplicating every raw snapshot in the window. On a large fleet that dedupe spilled gigabytes of temporary files and could run to the 60-second read timeout. +- **`get_store_metrics` reports the per-interval Query Store tables by name** ([#4616]) - Their size and growth get their own daily rows instead of being counted in "other", so a stalled purge on them shows up. +- **Darling Viewer and MCP store reads can no longer spill unbounded temporary files** ([#4610]) - The viewer and mcp store roles now carry a temp_file_limit, so a Custom Views panel that would have written gigabytes of temporary files fails at once with a message naming the limit, instead of running to the 60-second statement timeout and slowing the collector's writes. +- **Plan viewer minimap: resize, double-click zoom, and accuracy-coloured edges** ([#4603]) - The plan viewer's minimap panel can now be resized and remembers its size across plans, double-clicking a minimap node zooms to and selects it, and minimap edges pick up the same over/underestimate colouring as the main canvas. +- **Rule 38 can now flag a Standard Edition DOP limit as a Warning** ([#4601]) - Plan analysis reads each server's collected edition and MAXDOP wherever it analyzes a stored plan (the MCP plan tools, the drill-downs, and the Darling Viewer and Lite plan viewers). A plan that ran at DOP 2 with batch-mode operators on a Standard Edition server with MAXDOP above 2 now gets a Warning; it stays Info when the edition isn't known. +- **Plan viewer: one neutral card design for the insights strip** ([#4599]) - Runtime Summary, Missing Index Suggestions, and Wait Stats now share one neutral surface with a thin per-card accent edge instead of a full-color tinted background, and an empty card (for example, no missing index suggestions) shows a dimmed, muted state instead of a loud tinted block. +- **The plan viewer's Wait Stats rows show each wait's potential benefit and never clip** ([#4595]) - As in PerformanceStudio's desktop viewer, each wait row gains an "up to N%" benefit column taken from the plan's matching wait finding, the name and duration columns take the spare width with an ellipsis and a tooltip, and the bar and benefit columns size to their content so the percentage is never cut off. +- **Plan viewer costs are formatted as in PerformanceStudio** ([#4592]) - Costs in the properties panel and node tooltips show a trimmed, thousands-separated number instead of six raw decimal places. The sub-millisecond duration format is ported too, but the viewer's statement times are whole milliseconds today, so nothing shows it yet. +- **The plan viewer's Wait Stats header shows the total wait time and wait-type count on hover** ([#4591]) - Matches the desktop viewer's tooltip behavior; no visible layout change otherwise. +- **The plan viewer's runtime summary card matches PerformanceStudio's** ([#4590]) - It's titled "Predicted Runtime" for an estimated-only plan, rows are reordered (Elapsed, CPU:Elapsed, DOP, CPU, Compile, Memory grant, Optimization, CE model), the memory grant row is colored by utilization (red over 100% used, orange when any operator spilled or utilization is moderate-low, red when utilization is very low) with a "⚠ spill" tag when any operator in the plan spilled, and compile time is always shown. +- **The plan viewer's properties panel can be filtered and copied, and keeps its width** ([#4588]) - The panel now has a filter box, a copy menu with "Copy value" / "Copy name and value" / "Copy all properties", and remembers the width you drag it to for the session. +- **The plan viewer rolls per-thread stats into one collapsed breakdown** ([#4587]) - For an actual parallel plan, the per-thread stats in each properties section collapse into one "Per-thread breakdown (N threads)" section, as in PerformanceStudio, with a skew note in its header when the work is unbalanced, instead of an inline row per thread per metric. +- **The plan viewer colours actual-plan edges by how far actual rows diverged from the estimate** ([#4586]) - As in PerformanceStudio, an edge turns orange to red when the operator returned far more rows than estimated and blue when it returned far fewer, in three tiers each way, beyond a divergence limit that defaults to 10 and can be set in the settings file of Lite and the Darling Viewer. Estimated plans keep the plain edge colour. +- **Wait-category colours use PerformanceStudio's contrast-checked palette** ([#4583]) - Wait-category chart colours in the plan viewer and Lite's wait charts now use a laid-out, contrast-checked palette instead of individually picked colours, and three colours that fell short of readable contrast against the dark chart background are fixed. +- **Plan analysis drops three rules that PerformanceStudio removed** ([#4565]) - CTE Multiple References, Ineffective Parallelism and Parallel Wait Bottleneck are no longer reported. They guessed at what the runtime stats and wait stats already show. The plan viewer's runtime summary shows a CPU:Elapsed ratio instead, with external-wait time left out of CPU, as PerformanceStudio does. +- **Dependencies: Velopack to 1.2.158, with the release packer moved to match** ([#4563]) - The Lite and Darling Viewer installers and self-updater move from Velopack 1.2.0 to 1.2.158, the `vpk` tool that packs each release moves with it, and every lock file the bump reaches is regenerated. +- **The store writes much less WAL refreshing its Query Store rollups** ([#4506]) - store rung V152 drops the rollups' automatically created group indexes that no reader uses, and keeps the time and server indexes the reads need. +- **The store writes less WAL maintaining its query plan and text dimensions** ([#4502]) - a plan or query text that keeps being seen now refreshes its `last_seen` at most every 6 hours instead of every hour, so there are up to 6× fewer of these non-HOT updates. Retention is unchanged: the dimension prune's 2-day margin still covers the guard. +- **The store's own PostgreSQL log now names the application behind each line** ([#4501]) - Managed stores gain a new configuration block that adds the connecting application's name to each log line, alongside the existing timestamp and process id. This makes it possible to tell which of the service's own connections (or another client) wrote a given line. Both log readers refuse a line whose application name would make it read as a different kind of message (for example, a log line recorded as an error), instead of recording it. Reading RDS and Aurora logs is unchanged. +- **Darling and Lite now record each Availability Group's `group_id`, so two monitored secondaries of one AG count as one group even without its primary** ([#4495]) - store rung V151 adds the column. Rows collected before it fall back to matching by name and replica. +- **The Viewer's Job History reads each server's newest runs through an index instead of sorting the whole fleet's window** ([#4493]) - it shows the same rows in the same order, including a server whose registry entry has since been removed. +- **The service's startup watermark read looks up each collector's newest run through a new index instead of scanning the recent `collection_log` chunks** ([#4489]) - store rung V150 also adds a per-server `job_history` index for the Viewer's Job History. +- **Darling's service, Viewer, CLI and store-upgrade connections now name themselves in `application_name`** ([#4486]) - as the web and MCP pools already did (now also on a configured or owner-fallback connection), so `pg_stat_activity` and a store log with `%a` in `log_line_prefix` show which surface ran a statement. A bring-your-own connection string's own application name is kept. +- **The Viewer's Overview runs its fleet collection-health read once per refresh however many server cards load at once, and the status bar measures the store's size at most every 5 minutes** ([#4482]) - in a measured session the Overview issued that read 40 times in 4.5 minutes, and the size walk ran on every refresh. +- **The startup watermark read no longer walks every compressed `collection_log` chunk in retention** ([#4480]) - it reads only the last two days, which is all the schedule seed needs. +- **`get_ag_health` returns at most 11 Availability Group views by default, the least healthy first, and says when more exist** ([#4474]) - a fleet-wide call on a large fleet returned hundreds of kilobytes; scope by `server_name` or raise `limit` for the rest. +- **The Query Store stores write less WAL keeping their plan and text maps current (a quarter to a third less per touch on a test store)** ([#4472]) - the liveness touch now updates rows in place instead of writing a new row version and index entry each time; the two `last_seen` indexes are dropped (store migration V149), and their retention prune reads each table once per run. +- **Scheduler issues now report SQL Server CPU, other-process CPU, idle CPU, memory utilization, page faults and working-set change from each scheduler-monitor sample, flagged the way sp_HealthParser flags them** ([#4456]) - the old view read scheduler fields that event never carries, so every row came back empty apart from its time; Darling and Lite now read the fields the event does carry, and a sample is significant when SQL Server's CPU is at least 90%, other processes use at least 50%, or memory utilization is at most 50%. +- **The store now gives the web dashboard's and MCP server's reads up to 60 s before cancelling them, instead of 15 s** ([#4447]) - existing stores still at the shipped 15 s default move to 60 s through store schema rung V147, and an operator-set value other than 15 is left alone. Reads over 5 s are still written to the store's log. The desktop viewer's reads and the shared storage-layer readers keep their own 15 s and 30 s client limits for now. Bring-your-own stores re-run `tools/provision-roles.sql` to pick up the new value. +- **The managed store checkpoints every 15 minutes instead of 5, cutting write-ahead log volume** ([#4426]) - a new marker block ships `checkpoint_timeout = 15min`, after a trial on one store kept the checkpoint sync phase far under the checkpointer's own sync-phase self-alert. +- **Report alerts link to their own page: the Fleet Sweep Rollup opens the sweeps page, and the digests carry no link** ([#4421]) +- **`get_top_procedures_by_cpu` and the Top Procedures grid now route to the hourly rollup once raw ages past its retention window, instead of returning nothing** ([#4413]) - Mirrors the routing already shipped for `get_top_queries_by_cpu`; the payload discloses which tier answered, and the columns the hourly rollup lacks (`object_type`, the handles, the I/O totals and the min/max extremes) are null, not 0. +- **Sized the Linux compose store's background-worker slots and `work_mem` from the product's own +- **Cache the server-scoped watermark read across a runner's lifetime, cutting repeated `MAX()` reads against `job_history`, `default_trace_events`, `system_health_events`, and `memory_pressure_events` to one seed per (server, collector) pair instead of one per collection cycle** ([#4399]) +- **Top-N-by-CPU queries now route to the hourly rollup once raw's retention has dropped the window, instead of returning empty** ([#4396]) - `get_top_queries_by_cpu` (MCP tool, Storage reader, and Viewer) degrades to the hourly continuous aggregate for a window older than raw's floor and discloses the precision loss (`tier_used`, `precision_note`) rather than silently returning nothing. The raw-only filters (`min_dop`, `parallel_only`, `group_by=host_object`) keep the read on raw, and when raw holds nothing in the window the answer is status `empty` with `window_truncated` set. On the hourly tier, the columns the rollup lacks (plan hash and handle, DOP, reads, writes, physical reads, rows, spills, `avg_reads`, `is_parallel`, `distinct_texts` and the min/max CPU and elapsed times) are null, not 0, and `sql_handle` is returned. The read counts no bucket past the rollup's materialization ceiling, and `cpu_attribution` divides by the span the rollup served. +- **The Performance Trends Query Store duration chart reads the interval table for windows of 48 hours or more** ([#4382]) - the table measured faster than raw from 48 hours (361 ms vs 423 ms at 48 h; 374 ms vs 1,045 ms at 7 days) and returns exactly raw's points; shorter windows stay on raw. The interval-table gate also reads raw for any window that still holds legacy rows without an interval start. +- **The Darling viewer's TempDB file I/O trend now buckets like the File I/O tab's own reads** ([#4353]) - a 7-day window used to return one row per collection per tempdb file (40,324 rows measured for 4 files at 1-minute cadence); it now buckets to the chart's point budget (4,036 rows measured for the same seed) and still stamps a short window's raw points unchanged. +- **Raw hypertables now re-tune their own chunk interval once a day from actual ingest** ([#4344]) - Every raw hypertable used the same fixed one-day chunk interval whatever its write rate, so a busy table's open chunk, with its indexes, could outgrow the memory meant to hold it. Darling now reads each raw hypertable's compressed ingest rate daily, alongside a RAM-derived budget, and narrows the interval one rung at a time through `set_chunk_time_interval` when the store-wide total is over budget, and widens it one rung when the total would stay under half the budget; a new rung history table records every change, alongside a per-run WAL-volume record. On by default; set `rawChunkIntervalReconcileEnabled: false` in the config file to turn it off. +- **The Queries grid and MCP's Query Store top read use a per-interval table for long windows** ([#4341]) - both used to deduplicate the whole raw Query Store slice on every read. The grid now reads a table that keeps one row per interval for windows of 12 hours or more, and the MCP read for 24 hours or more. On a 15-day seed of 3.47 million raw rows, a 7-day window took 2,754 ms against 7,065 ms for the grid, and 1,627 ms against 9,249 ms for the MCP read. Shorter windows, and any window the table's history doesn't cover yet (after an upgrade), read raw as before. A BRIN index on the table's `collection_time`, which the service builds in the background from about 20 minutes after it starts without blocking writes (skipped below PostgreSQL 16 and on a hypertable), serves Custom Views Query Store panels of 12 hours or more where `random_page_cost` is about 1.1 or lower. +- **Lite's memory clerk and File I/O trend charts bucket long windows in DuckDB** ([#4340]) - The memory clerk, File I/O latency, File I/O throughput and TempDB File I/O trend charts, and the Overview I/O lane, read one point per collection. They now gather collections into buckets sized to the window, at most 1,500 points per series. A bucket's latency is its summed stall over its summed operations, and its throughput is its summed bytes over its summed seconds. A window short enough that every bucket holds one collection plots each point at its own collection time, as before. The memory clerk picker's name list is cached for 15 minutes. +- **Lite keeps one DuckDB connection open, so reads attach to it instead of reopening the database file** ([#4339]) - Every read used to open and close its own connection to the local database file. One connection now stays open for the app's life, which cut a 20-tick, ten-way Overview read on a 1 GB store from 871 ms to 43 ms. Because that connection keeps DuckDB's buffer pool resident, a periodic check trims it after a heavy read: on a 1.1 GB store, one trim took process private bytes from 1,115 MB to 148 MB. +- **Lite's Performance Trends charts bucket long windows in DuckDB** ([#4338]) - The query duration, procedure duration and execution count charts read one point per collection, about 10,080 points each for a 7-day window at one collection a minute. They now gather collections into buckets sized to the window, rating each bucket as its summed work over its summed seconds, and a window short enough that every bucket holds one collection plots each point at its own collection time, as before. +- **Lite's Overview CPU, wait and memory lanes bucket long windows in DuckDB** ([#4337]) - The Overview tab's CPU, wait and memory lines, and the CPU and Memory tab charts, read one point per collection: about 10,080 points each for a 7-day window at one sample a minute. They now gather collections into at most 1,500 points per line, and a window short enough that every bucket holds one sample or collection plots each point at its own collection time, as before. +- **Settings the service manages now live in one included file, not stacked append blocks** ([#4336]) - the v1-v15 `postgresql.conf` append blocks are replaced by a single included file, `darling-managed.conf`, rewritten wholesale on every start. Existing stores migrate their current effective values into it on the first start after upgrade, without changing any value. An operator's own lines are kept, moved below the include so they keep winning, and settings set with `ALTER SYSTEM` are never changed. From then on, sizing values can change on the first start after an upgrade, and each change is logged with the inputs that produced it. A failed verification restores the previous settings files and raises the store-settings alert. Operator lines placed below the include are not yet carried across a major PostgreSQL version upgrade ([#4358]). +- **Darling viewer's Performance Trends charts bucket server-side over long windows** ([#4333]) - The query duration, procedure duration and execution count charts read one point per collection on the raw tier, about 10,080 points each for a 7-day window at one collection a minute. The store now gathers collections into buckets sized to the window, rating each bucket as its summed work over its summed seconds, and the chart title names the bucket width. A window narrow enough that every bucket holds one collection plots each point at its own collection time, as before. +- **Lite's Wait Stats and Perfmon charts bucket long windows instead of shipping one point per collection** ([#4331]) - A 7-day Wait Stats or Perfmon chart carried one row per stored collection, about 10,080 rows per wait type or counter at one collection a minute (about 200,000 for 20 wait types). It now buckets each wait type or counter to at most about 1,500 points (the chart budget, not the MCP tools' 200-point budget), and a window short enough that every bucket holds one collection still plots each point at its own collection time. The wait-type and perfmon-counter pickers also cache their name list for 15 minutes per server and window length instead of re-reading it on every 1-minute auto-refresh. +- **Darling viewer's File I/O and memory clerk charts load faster over long windows** ([#4329]) - the +- **Darling viewer's CPU, Overview wait and Overview memory charts bucket server-side over long windows** ([#4327]) - The CPU chart, and the Overview tab's total-wait and buffer-pool lanes, used to return one row per ring-buffer sample or per collection with no cap: about 10,080 rows each for a 7-day window at one collection a minute. Postgres now buckets all three to a fixed row budget, matching the sizing already applied to the Wait Stats and Perfmon trend charts. A window narrow enough that every bucket holds exactly one sample or collection still renders each point at its own exact timestamp rather than a bucket boundary, so short windows look unchanged. +- **PostgreSQL-target baselines recompute once a day instead of every hour** ([#4324]) - Every PostgreSQL-target baseline arm (13 unkeyed metrics plus the 2 statement-keyed ones) was recomputing its full 30-day window every hour; one of them cost up to 2.45 seconds and 262 MB of temp space per pass. They now share the once-a-day cache lifetime the two heaviest SQL Server baselines (Cpu, IoLatency) already used. Because a daily baseline covers history up to the start of the UTC day, a PostgreSQL target added today has no baselines, and its baseline-driven anomaly checks sit out, until the next UTC midnight. +- **Three legacy query-stats rollups stop refreshing** ([#4186]) - `query_stats_hourly`, `procedure_stats_hourly`, `query_stats_db_hourly` and their daily rollups keep the history they already hold. Their interval-honest successors take over. Reads older than the successors' own history still use them. New data goes only to the successors, so the store no longer spends refresh time on the old rollups. The raw `query_stats` and `procedure_stats` purge now waits until the successors and the old rollups together cover every raw row. After a long outage, the service fills the gap at startup, up to a day of it per start. Only then does the purge resume. `--backfill-rollups` fills it in one run. Existing compression jobs move to new hours once. Dashboards, alerts and queries do not change. +- **llms.txt and CITATION.cff now match the shipped product** ([#4157]) - llms.txt said 41 T-SQL collectors (it is 42), listed Azure SQL Database under Lite only (Darling supports it too), never mentioned Darling's 29 PostgreSQL collectors or its Windows/Linux and web-dashboard support, named only email and tray alerts (Teams, Slack, PagerDuty and generic webhooks also fire), and undercounted downloads (15,000+, not 4,300+). SentryOne is now named as SolarWinds SQL Sentry. CITATION.cff drops a version and release date no release step keeps current. A new test compares both collector counts in llms.txt against the collector catalog so they cannot go stale silently again. +- **The MCP tool list's size limit now matches its size** ([#4141]) - #3898 moved reading guidance out of the tool list. The budget test's total limit now equals the tool list's measured size. On Darling that is 170,798 bytes, down from a limit of 329,494. On Lite it is 89,719 bytes, down from 148,216. Any later growth has to raise the limit on purpose. The window_truncated note on the time-series tools also drops its issue number, and now says the field was formerly named truncated. +- **get_spinlock_stats puts a short description in the tool list** ([#4127]) - Before this change, this Darling and Lite MCP tool put 597 and 1,306 characters into the tool list. It now serves a head of 595 characters on both, under the usual 620-character cap. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **analyze_query_plan puts a short description in the tool list** ([#4126]) - Before this change, this Darling and Lite MCP tool put 915 and 903 characters into the tool list. It now serves a head of 616 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_pvs_stats puts a short description in the tool list** ([#4125]) - Before this change, this Darling and Lite MCP tool put 1,156 characters into the tool list. The tool now serves 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The guide now also says that a database size of 0 leaves pct_of_database null, as the tool already did. Nothing was deleted, and no tool behavior changed. +- **get_deadlocks (Darling and Lite) and get_blocked_process_reports (Lite) put a short description in the tool list** ([#4123]) - Before this change, these MCP tools put up to 822 characters (get_deadlocks on Darling), 694 characters (get_deadlocks on Lite), and 1,340 characters (get_blocked_process_reports on Lite) into the tool list. get_deadlocks now serves the same 591-character head on both products, and get_blocked_process_reports serves a 483-character head, and the get_tool_guide tool returns the rest of the guide by tool name. Darling's get_deadlocks dedup_key parameter lost its reference to issue #1140 in the move. No other guidance was deleted, and no tool behavior changed. +- **get_long_query_completions puts a short description in the tool list** ([#4122]) - Before this change, this Darling and Lite MCP tool put 1,037 characters into the tool list on each product. It now serves a head of 604 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_memory_pressure_events puts a short description in the tool list** ([#4120]) - Before this change, this Darling and Lite MCP tool put 835 and 1,018 characters into the tool list on the two products. It now serves a head of fewer than 620 characters on both. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_latch_stats puts a short description in the tool list** ([#4119]) - Before this change, this Darling and Lite MCP tool put 1,027 and 1,372 characters into the tool list. It now serves a head of fewer than 620 characters on both products. The get_tool_guide tool returns the rest of the guide by tool name. The description also no longer says that high ACCESS_METHODS_DATASET_PARENT or FGCB_ADD_REMOVE latch waits mean TempDB allocation contention. Microsoft's documentation says the first synchronizes parallel operations and the second covers file add, drop, grow and shrink operations. The Dashboard's copy of the sentence gets the same fix. No tool behavior changed. +- **get_index_usage puts a short description in the tool list** ([#4118]) - Before this change, this Darling and Lite MCP tool put 856 and 493 characters into the tool list. The tool now serves a head of 488 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **analyze_procedure_plan puts a short description in the tool list** ([#4117]) - Before this change, this Darling and Lite MCP tool put 926 and 912 characters into the tool list. The tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **validate_custom_view and run_custom_view_panel put a short description in the tool list** ([#4116]) - Before this change, these two Darling MCP tools put 1,576 and 1,084 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **analyze_plan_xml puts a short description in the tool list** ([#4115]) - Before this change, this Darling and Lite MCP tool put 880 characters into the tool list on both products. It now serves a head of 618 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_ag_health and get_store_query_stats put a short description in the tool list** ([#4114]) - Before this change, these two Darling MCP tools put 1,529 and 984 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **Claude Code keeps the MCP entry tools loaded even when it defers the rest** ([#4113]) - list_servers, get_fleet_overview (Darling only), analyze_server and get_tool_guide now carry anthropic/alwaysLoad in their tool metadata. A Claude Code session that defers other tools to save context still sees these four at session start. +- **get_query_store_regressions puts a short description in the tool list** ([#4109]) - Before this change, this Darling and Lite MCP tool put 1,187 characters into the tool list on both products. The tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_blocking and get_pg_replication_slots put a short description in the tool list** ([#4108]) - Before this change, these two Darling MCP tools put 1,645 and 803 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. +- **get_active_queries puts a short description in the tool list** ([#4107]) - Before this change, this Darling and Lite MCP tool put 1,406 and 1,421 characters into the tool list. It now serves a head of fewer than 620 characters on both. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_plan_corrections puts a short description in the tool list** ([#4105]) - Before this change, this Darling and Lite MCP tool put 1,672 characters into the tool list. It now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_query_store_duration_trend and get_perfmon_trend put a short description in the tool list** ([#4101]) - Before this change, get_query_store_duration_trend put 1,537 characters (Darling) and 1,276 characters (Lite) into the tool list, and get_perfmon_trend put 1,057 characters into the tool list on both products. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_resource_semaphore and get_memory_grants put a short description in the tool list** ([#4100]) - Before this change, these two Darling and Lite MCP tools put 1,310 and 988 characters into the tool list. Each tool now serves a head of 617 and 556 characters. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_daily_summary and get_daily_summary_range put a short description in the tool list** ([#4099]) - Before this change, these two Darling and Lite MCP tools put 1,414 and 1,903 characters into Darling's tool list, and 1,034 and 1,474 characters into Lite's. Each tool now serves a head of fewer than 620 characters on both products, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_query_store_health and get_default_trace_events put a short description in the tool list** ([#4095]) - Before this change, these two Darling and Lite MCP tools put up to 2,587 and 866 characters into the tool list. On both products, each tool now serves a head of fewer than 620 characters. The get_tool_guide tool returns the rest of the guide by tool name. The heads also state what an empty or unavailable answer means for each tool. Two issue numbers and a story about one production store were removed from the text of get_query_store_health. No guidance was deleted, and no tool behavior changed. +- **get_pg_kernel_stats, get_pg_xmin_horizon and get_pg_table_bloat put a short description in the tool list** ([#4093]) - Before this change, these three Darling MCP tools put 1,298, 1,294 and 1,191 characters into the tool list. Each tool now serves a head under 620 characters (613, 590 and 605). The get_tool_guide tool returns the rest of the guide by tool name. The heads also state what an empty answer means for get_pg_kernel_stats and get_pg_table_bloat, which the old descriptions left out. Two long parameter descriptions also got shorter, and their full text moved to the guide. The limit parameter of get_pg_kernel_stats went from 204 to 180 characters, and that of get_pg_table_bloat went from 270 to 187. Nothing was deleted, and no tool behavior changed. +- **get_pg_io_trend, get_pg_database_trend and get_pg_cpu_utilization put a short description in the tool list** ([#4092]) - Before this change, these three Darling MCP tools put 1,596, 1,373 and 1,341 characters into the tool list. Each tool now serves a head of 620 characters or fewer, and the get_tool_guide tool returns the rest of the guide by tool name. The backend_type parameter of get_pg_io_trend went from 205 to 86 characters, and the rest of its text moved to the guide. get_pg_cpu_utilization's description also corrects a wrong claim. It said the tool covered both Aurora and RDS, with only a self-hosted server returning empty. The collector behind this tool runs only on Aurora, so a plain RDS server was never covered either. The description now says that a plain RDS server and a self-hosted server both report not_collected, not empty. No guidance was deleted, and no tool behavior changed. +- **get_pg_column_stats, get_pg_replication_stats and get_pg_predicate_stats put a short description in the tool list** ([#4091]) - Before this change, these three Darling MCP tools put 1,105, 925 and 841 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The heads also state facts that the old descriptions left out. get_pg_column_stats returns the newest capture for each column, and a window shorter than a day can be empty because the collector runs daily. get_pg_predicate_stats reports filtered_pct as a percent that is null when no rows were evaluated, and its queryid is a string. Nothing was deleted, and no tool behavior changed. +- **The Darling service account can no longer change its own program files** ([#4090]) - The install and upgrade scripts gave the service account Modify rights on the whole install folder. It now gets Read & Execute there. It keeps Modify only on the bundled PostgreSQL runtime folders (pg-runtime and pg-runtime-prev) and, when you bring your own PostgreSQL, on the darling-keys folder. A compromised service or database process can no longer replace the service's program files to survive a restart. +- **mute_analysis_finding and audit_config put a short description in the tool list** ([#4088]) - Before this change, these two Darling and Lite MCP tools put as much as 1,444 and 932 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_pg_blocking, get_pg_wait_stats and get_pg_index_usage put a short description in the tool list** ([#4087]) - Before this change, these three Darling MCP tools put 1,606, 1,483 and 1,471 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Two long parameter descriptions also shrank with no loss of meaning: get_pg_wait_stats's limit went from 214 to 190 characters, and get_pg_index_usage's limit went from 257 to 93. Nothing was deleted, and no tool behavior changed. +- **get_pg_plan_capture_readiness, get_pg_plans and get_pg_session_states put a short description in the tool list** ([#4086]) - Before this change, these three Darling MCP tools put 1,950, 1,374 and 1,617 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of each tool's limit parameter is also shorter: 389 to 158, 235 to 72 and 282 to 117 characters. get_pg_plans' query_id parameter is shorter too, 320 to 88. Nothing was deleted, and no tool behavior changed. +- **get_query_duration_trend and get_procedure_duration_trend put a short description in the tool list** ([#4085]) - Before this change, these two Darling and Lite MCP tools put up to 1,180 characters into the tool list. get_query_duration_trend served 1,172 characters on Darling and 1,136 on Lite. get_procedure_duration_trend served 1,180 characters on both. Each tool now serves a head of 614 or 445 characters on both products. The get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_analysis_facts and get_analysis_findings put a short description in the tool list** ([#4083]) - Before this change, these two Darling and Lite MCP tools put 1,825 and 2,875 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_analysis_facts's source parameter is also shorter (515 to 180 characters), and so is get_analysis_findings's include_drilldown parameter (235 to 122 characters). get_analysis_findings' description now also says that its truncated and truncation_note fields can mean its occurrence counts are undercounted. get_analysis_facts' guide now also says what its total_facts, shown and filters fields count. get_analysis_findings' head and tail also lost their two issue-number references. The guardrails they carried stay. get_analysis_facts carried none to begin with. No tool behavior changed. +- **get_pg_database_stats, get_pg_autovacuum_health and get_pg_top_queries put a short description in the tool list** ([#4082]) - Before this change, these three Darling MCP tools put 2,361, 2,215 and 2,210 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of each tool's limit parameter is also shorter: 229 to 175, 261 to 161 and 228 to 163 characters. get_pg_autovacuum_health's description now also says that its disabled, past-threshold and growing counts cover only the returned page, not the whole server. No guidance was deleted, and no tool behavior changed. +- **get_pg_logging_audit, get_pg_io_stats and get_pg_wait_sampling put a short description in the tool list** ([#4081]) - Before this change, these three Darling MCP tools put 2,086, 2,045 and 2,032 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_pg_io_stats's limit parameter also went from 235 to 194 characters, with no loss of meaning. get_pg_logging_audit's tail also lost its parenthetical issue numbers (#3601, #3602 and #3603). The sentence still says PLANNED without naming them. No tool behavior changed. +- **validate_custom_alert_rule, test_custom_alert_rule, update_custom_alert_rule and list_custom_alert_templates put a short description in the tool list** ([#4079]) - Before this change, these four Darling MCP tools put 2,078, 922, 890 and 751 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The descriptions of update_custom_alert_rule and create_custom_alert_rule now say that enabling a rule is refused once 100 rules are enabled across the fleet. The guide of test_custom_alert_rule now says that a rule with no in-scope servers returns the status no_in_scope_servers. Nothing was deleted, and no tool behavior changed. +- **get_alert_history, set_notification_route_enabled, create_mute_rule and set_mute_rule_enabled put a short description in the tool list** ([#4077]) - Before this change, get_alert_history put 4,740 characters into the tool list on Darling and 3,573 on Lite. The three Darling-only write tools put 841, 959 and 1,477 characters. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of get_alert_history's include_dismissed parameter also went from 360 to 114 characters on Darling and from 357 to 111 on Lite, and the text it lost moved to the guide. get_alert_history's tail also lost its issue-number references on both Darling and Lite. The sentences that carried them are otherwise unchanged. The three write tools carried none to begin with. No tool behavior changed. +- **get_pg_extensions, get_pg_write_stats, get_pg_server_config and get_pg_server_config_changes put a short description in the tool list** ([#4078]) - Before this change, these four Darling MCP tools put 1,727, 1,509, 2,252 and 1,146 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_collector_stall_probes, describe_custom_view_catalog and get_sweep_reports put a short description in the tool list** ([#4074]) - Before this change, these three Darling MCP tools put 2,678, 2,589 and 2,274 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The guide of get_collector_stall_probes lost one example of a single measured stall. Nothing else was deleted, and no tool behavior changed. +- **analyze_server and compare_analysis put a short description in the tool list** ([#4073]) - Before this change, these two MCP tools put 4,160 and 1,647 characters into the tool list, on both Lite and Darling. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. The description of compare_analysis's baseline_hours_back parameter also went from 211 to 139 characters, and the sentence it lost moved to the guide. Nothing was deleted, and no tool behavior changed. +- **get_fleet_overview, add_servers and remove_server put a short description in the tool list** ([#4071]) - Before this change, these three Darling MCP tools put 3,287, 3,285 and 1,784 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. +- **get_pg_log_events, get_pg_index_bloat and get_pg_deadlocks put a short description in the tool list** ([#4068]) - Before this change, these three Darling MCP tools put 4,199, 3,491 and 2,839 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted, and no tool behavior changed. +- **get_query_store_clutter and get_oversized_plan_backlog put a short description in the tool list** ([#4067]) - Before this change, these two Darling MCP tools put 5,147 and 2,997 characters into the tool list. Each tool now serves a head of about 610 characters, and the get_tool_guide tool returns the rest of the guide by tool name. No guidance was deleted, and no tool behavior changed. +- **update_alert_settings and update_mute_rule put a short description in the tool list** ([#4066]) - Before this change, these two Darling MCP tools put 8,123 and 2,530 characters into the tool list. Each tool now serves a head of fewer than 620 characters, and the get_tool_guide tool returns the rest of the guide by tool name. Nothing was deleted. The heads keep the facts that a caller needs to change settings safely. Both tools make partial updates. In update_alert_settings, one invalid field means that no field is written. The retired poison_wait.threshold_ms setting does not change when the alert fires. health_bands and fleet_sweep are not alert families. In update_mute_rule, a rule with every scope field cleared mutes every alert. The reading guides of get_alert_settings and get_notification_routes also lost their issue numbers, on Lite and Darling. +- **get_collection_log and get_query_store_top put a short description in the tool list** ([#4065]) - Before this change, get_collection_log put its whole reading guide into the MCP tool list. The description was 6,995 characters on Darling and 4,405 characters on Lite. The tool list now gets a head of 606 characters, and the get_tool_guide tool returns the rest of the guide by tool name. get_query_store_top now serves the same head on both products. That head states that only Darling marks a window floor with window_truncated. Three parameter descriptions of get_collection_log were longer than 200 characters. Each one keeps its main fact, and the rest moves to the guide under the parameter name. Nothing was deleted. +- **Three self-monitoring MCP tools put a short description in the tool list** ([#4064]) - The tools are get_store_metrics, get_store_log and get_collector_cost. They are Darling only. Before this change, each tool put its whole reading guide into the MCP tool list. Each description is now split the same way as the earlier system_health and data-read tools. The tool list keeps the facts that a caller needs to read the answer correctly. get_store_metrics and get_store_log report on the monitoring store itself, not on a monitored SQL Server. get_collector_cost reports what the collectors cost, not the health of a server. A daily size point is the last snapshot of the day, not its peak. An empty job-history block can mean that the reader has no visibility, not that nothing ran. For query_store, most of the time that get_collector_cost reports is the store's own probe and write work. The get_tool_guide tool returns the rest of the guide by tool name. +- **get_collection_health's tools/list entry drops from 21,026 characters to 583** ([#4063]) - This was the largest tool description an MCP client had to load before asking a question, on both Darling and Lite. No guidance is lost. The guardrail facts a caller needs stay in the short entry every client loads: a stopped collector is not a failing one, a zero rows-stored count is not automatically a fault, last_error can be stale, a regression is counted separately from a failure, and the alert-read-health block covers a different window than the rest of the payload. The rest of the reading guide moves to get_tool_guide, available on request. +- **get_alert_settings and get_notification_routes serve a short head, with the rest available from get_tool_guide** ([#4061]) - These two MCP tools served 7,530 and 1,746 characters on Darling, and 3,954 and 600 on Lite, before the first question. Both now serve a head under 610 characters on both products, with a pointer to get_tool_guide for the full text. Nothing was deleted. The head keeps the facts a caller needs to read the answer correctly. For example, one cooldown gates whether an alert fires, and a separate one bounds the resulting post. It also says what an unseeded store or an empty knob list means. +- **Seven data-read MCP tools put a short description in the tool list** ([#4055]) - The tools are get_wait_stats, get_file_io_stats, get_perfmon_stats, get_server_properties, get_top_queries_by_cpu, get_top_procedures_by_cpu and list_servers. Before this change, each tool put its whole reading guide into the MCP tool list, on both Lite and Darling. Each description is now split in the same way as the system_health tools. The tool list keeps the facts that a caller needs to read the answer correctly. For example, a page holds only the heaviest rows, and a null latency is not 0 ms. Also, the min and max CPU values cover the whole life of the plan in the cache. Offline means different things on Lite and Darling. The get_tool_guide tool returns the rest of the guide by tool name. +- **MCP clients load less context up front, and a new get_tool_guide tool serves the long-form guidance on request** ([#4048]) - Every tool description went into the MCP tool list in full, so a client that loads the whole catalog paid for all of it before the first question (about 330 KB on Darling). A description can now split into a short head, which the tool list serves, and a reading guide, which get_tool_guide returns by tool name or cross-tool topic, on both Lite and Darling. The nine system_health tools are converted first, at about half their previous size. Heads keep the facts a caller needs to read the answer correctly, such as which events are filtered out and what an empty answer means. A size check keeps the tool list from growing back. +- **Darling's MCP server instructions drop from 88,532 to 7,992 characters and Lite's from 52,942 to 7,721, both now under a pinned 8,000-character budget** ([#4039]) - Phase 2 of #3898: the per-tool "Tool Reference" tables and prose that used to restate what each tool's own tools/list description already says are gone, because nothing enforced that the two copies stayed in sync. What stays in the instructions is what no single tool's description can say by itself: the read-only preamble, the status-word vocabulary (empty, unavailable, not_collected, precondition, error, invalid), the as_of/hours_back anchor rule, and a one-line tool census. Every fact the old tables carried that a tool needs to be used correctly was checked against where it landed. get_collection_health's analysis_caveats clause, get_ag_health's per-replica-column trap, get_blocking/get_deadlocks/get_deadlock_detail's dedup_key scoping, and get_sweep_reports's and get_query_store_clutter's family facts all moved into the tool's or parameter's own description. Several others (add_servers, remove_server, mute_analysis_finding, compare_analysis, the plan tools' create_statement caveat) were already fully stated there, so the instructions row was pure duplication. get_memory_pressure_events's description pointed at an instructions section this phase renamed and gutted. It now states its own follow-up-tool guidance instead of pointing anywhere. Both SKUs' tools/list grew by under 400 bytes total from the handful of relocated facts, negligible next to the instructions cut. +- **PostgreSQL log messages show as PostgreSQL wrote them, and the SQL in them is normalized with every literal replaced by ?** ([#3996]) - Regex masking of free-form log prose kept missing shapes: RAISE text, libxml lines, a value typed after a noun, and a command's stderr. So it is removed from the store's own log (`get_store_log`) and from every PostgreSQL target's log events (`get_pg_log_events` and both viewers' Log Events panels). Messages, DETAIL and CONTEXT prose, HINT and LOCATION now appear exactly as the server logged them. SQL is still read by the lexer, and withheld when it cannot be read to its end. That covers STATEMENT and QUERY lines, slow statements, a crash's or a deadlock's queries, a function's SQL frames, a postgres_fdw remote command, a statement's bound parameters, and PL/pgSQL `print_strict_params` values. An auto_explain plan logged at WARNING keeps only its duration line. The review also closed two ways one statement's text could decide how another's was read. A deadlock query cut inside a literal no longer pairs its quote with the next process's query, which could show that query's literal as a plain word. A COPY value shaped like a CONTEXT frame can no longer swallow the real frame after it. Store-log rows now count messages that differ only in a quoted value or a number as one. The existing hourly pass brings rows stored by earlier releases to these rules. A security review then closed more. The token a syntax error quotes is read as SQL in every language PostgreSQL's catalogues write it in, not only English: Spanish, Indonesian and Japanese keep the ERROR label in English, so their syntax errors are stored. An unterminated literal or a jsonpath token there is withheld. A deadlock report cut between its lines withholds every query after one that cannot be read to its end, unless the entry proves the report whole. PL/pgSQL parameter lists and portal parameter lists must read back as name and masked-value pairs, or they are withheld. Under a translated `lc_messages`, a log line whose field label this reader does not know is withheld, with the rest of its entry, rather than kept as prose, and the Turkish and Korean labels written without spaces are labels whatever follows their colon. Such a line never opens an entry from inside a statement's literal. The same applies to a `log_line_prefix` that renders a label-shaped token of its own, such as an application name ending in a colon and two spaces. Reading a deadlock report of hundreds of waiters, or a CONTEXT of a thousand frames, no longer allocates over 100 MB. `get_pg_log_events` no longer returns `raw_line_hash`, an unkeyed hash of the raw line that a reader could use to test guesses at a hidden value. +- **The shared `as_of` description is 167 characters instead of 379, cutting Darling's `tools/list` by 22,040 characters (6.4%) and Lite's by 14,246 (8.8%)** ([#3965]) - It is the `as_of` parameter on 91 Darling and 56 Lite tools, so at 379 characters it was a tenth of Darling's catalog, paid on every request by every client that loads the full tool list. The short text keeps the rule a caller acts on: the anchor is the window's END, a bare date is 00:00 UTC, omitting it means now, and a past incident is `as_of` at its end, never a wider `hours_back`; the reason stays in both SKUs' server instructions. The days twin (416 → 166), the `window_truncated` clause (441 → 254, keeping its WIRE CHANGE sentence until the rename ships) and the `discontinuities[]` sentence (489 → 317, now naming all six reason words) are cut the same way. No description grew, `get_procedure_duration_trend` drops back under the 2,048-character cut Claude Code applies, and a new pin holds the rule's words, the 200-character parameter budget and the instructions' reason on both SKUs. Part of [#3898]. +- **The review guard tells a pending workflow fix from hostile drift** - When `dev`'s `claude-review.yml` differs from `main`'s because a reviewed dev PR changed it and the release has not synced yet, the guard now warns "review pending release" and names the merged PR instead of failing every PR in the repo as if the file had been tampered with; unexplained drift still fails, and an origin the guard cannot determine fails closed. +- **The tempdb Space alert stops paging on a single collected sample** ([#3653]) - it fired on the first `tempdb_stats` row at or above the threshold and resolved on the next one under it, which on one production store class was 22 page/resolve pairs in 14 days about runs of 1-4 samples lasting at most 206 s. The arm now sits behind the shared persistence gate High CPU adopted in #3282: 3 consecutive breaching COLLECTIONS to fire (identified by the row's `collection_time`, so a 30 s sweep re-reading the last row does not count twice), the first collected sample under the bar to resolve, the open-incident bit persisted under its own metric name in the existing state table so a restart neither re-announces nor forgets it, and a tempdb reading that stops arriving freezes the gate instead of announcing "back to N/A". Blocking Wait Time and Long-Running Query await their rulings. +- **The analysis names the Agent job that is running long instead of counting it** ([#3653]) - the RUNNING_JOBS fact on both SKUs now carries the name of the job furthest past its own history (chosen among the running-long rows by percent of average, then duration), and the job card's headline, first sentence and remediation say which job — and "and N others" when several overran — where they used to send the operator to the Running Jobs view to find out. Findings persisted before this, and windows where jobs ran but none ran long, read exactly as before. +- **MCP tool failures were two wire shapes — a bare sentence on 214 tools and a JSON envelope on the PostgreSQL reads — and a `status`-keyed client read the sentences as successful text; now every tool on both SKUs answers a caught exception with one envelope through `McpHelpers.FormatError`** ([#3653]) - **WIRE CHANGE.** A tool that throws returns `{"status":"error","message":"Error during : …","hints":{"operation":""}}` — the same envelope and serializer the four miss words use, the message text unchanged — including the frozen Dashboard twin, which links the same helper. The 30 PostgreSQL catches drop their "Reading X failed" dialect for the one grammar; the web surface maps the envelope to HTTP 500 (so PostgreSQL failures that passed through as 200 are 500 now) and keeps its `{"error": sentence}` body; the payload-contract census retires its two-shape inventory and fails by name on any catch that bypasses the helper. Validation refusals are unchanged and still bare sentences — a separate ruling. +- **PostgreSQL bars the fleet measured now say so** ([#3691]) - Every v1 bar the 2026-09-19 calibration of 50 Aurora PostgreSQL clusters validated (temp 1/10 MiB/s, backlog 3/10×/5, deadlocks 5/20, bad-actor busy floor 0.05, wait rollups 0.20/1.0 and io 0.40/2.0, CPU 80/95, TPS floor 50 / fallback 500, CPU floor 40 / fallback 95, deadlock floor 1/h, wait fallback 500 ms/s) carries a measured comment naming its percentile, population and date, and the facts graded on them show `threshold_lineage = 1` in get_analysis_facts instead of calling the bar a judgment; sessions 0.8/0.9 stay engine-defined with the measured note (fleet max 10.3 % of ceiling). Still unmeasured and still saying so: wait standout bars and sampling floor, session COUNT floors, the ratio families' firing multiple, every co-fire boost, checkpoint pressure (not applicable on Aurora) and buffer cache. No bar value changed. +- **Anomaly detectors fired on one hot sample and fired more the longer the window was; the gate now judges the window peak AND the window mean, and I/O reads the pair like its siblings** ([#3653]) - Every z-score detector tested the window MAX against a per-sample hour×dow distribution, so a 24-hour anchored pass mechanically reported more anomalies than the 4-hour scheduled pass on identical behaviour. The shared AnomalyGate fires only when both the peak and the window mean clear the existing cutoffs (z on both when the baseline is trustworthy; the fallback bar on the peak and the magnitude floor on the mean when it is not) — no cutoff moves, the reported sigma stays the peak's, and the mean's sigma rides beside it in the story. I/O latency, the one family reading AVG alone, now reads MAX and AVG on both SKUs and reports the peak. +- **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. +- **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. +- **The Extended Events collectors use less CPU on the monitored server to filter events by time** ([#4912]) - The blocked process report, deadlock, long query completion and system_health collectors now compare each event's timestamp inside the XQuery, instead of converting it with a value() cast first. In local tests that filter used 3 to 14 percent less CPU. The events collected are the same. + +### Fixed + +- **A shutdown during a managed PostgreSQL tool step is no longer missed** ([#4867]) - A shutdown that came just before a tool ran was missed. When the tool finished at once, the work went on to its next step. Each tool run now checks for a shutdown before it starts. Steps that stop PostgreSQL or put files back during a shutdown still run their tools. +- **Rollup reads stop at the window end** ([#4859]) - an hourly rollup read counted one extra hour when its window ended exactly on the hour. It took the whole hour that starts at the end. This affected the Queries and Procedures tabs, the top-queries and top-procedures tools, the hourly trends, one query's hourly history, and Custom Views. A Custom View on the daily rollup counted the next day when its end fell at midnight. These reads now stop at the end. +- **Grid time columns sort by time** ([#4858]) - clicking a time column's header in Lite or the Darling viewer sorts the rows by time. Before, most time columns sorted as text, so "10/1/2026" came before "9/30/2026". +- **Six Postgres time columns follow the time display mode** ([#4858]) - six time columns on the Darling viewer's Postgres tabs always showed UTC. They are Lock Stats Last Seen, Wait Sampling Last Seen, Replication Connected Since, Column Stats Captured, and Index Bloat Measured and Estimated. They now show the same server, local or UTC time as the rest of the tab. +- **Server times and charts are right across a daylight saving change** ([#4783], [#4829], [#4838], [#4840], [#4841], [#4847], [#4848], [#4855]) - Where SQL Server reports its time zone (SQL Server 2022 and later), Lite and Darling convert a server's local times with the offset in force at each time, instead of one offset for every time. Older servers keep the fixed offset. In Server time mode, Lite and the Darling viewer follow the server's time zone and read it again on every refresh. This covers chart times, picker and custom ranges and System Events (Default Trace) times in both apps, and Job History run times and the SQL Agent next run in the Darling viewer. It also covers Custom Views Default Trace markers, config-change attribution, the parameter-sensitivity checks, the long-running job alert's "Started" time, and the server-local times in Darling's MCP tools (blocking, default trace, version store, object stats and running jobs) and in Lite's (`get_blocked_process_reports`, `get_running_jobs`, `get_index_usage`, `get_pvs_stats` and `get_default_trace_events`). Lite's `get_top_queries_by_cpu` and `get_top_procedures_by_cpu` compare last run times on the server's own clock, so a server west of UTC no longer drops a query last run early in the window and a server east of UTC no longer keeps one from before it. Recommendations "Ask AI" times use the selected server's own offset at each end of the window, and the Darling viewer's "Last analyzed" line shows the selected server's time and names its zone. Lite and the Darling viewer plot each chart point at its exact instant. In the repeated autumn hour, a chart no longer folds two hours onto one, and a drill or a typed range there reads the hour it names. The spring gap shows no hour that never happened, and the Darling viewer's Overview lanes axis spans the whole window. Grid and text times in the repeated hour end in their UTC offset, so the two 01:30s read `01:30:00 -04:00` and `01:30:00 -05:00`, and time columns that show the offset sort by time. Times read from a stored server wall clock (Default Trace events, job history and the next Agent run) stay plain in that hour, because the stored time does not say which of the two passes it was. Lite's FinOps First Seen and Last Seen and its collection health times follow the display mode, not this machine's clock. A chart CSV export's time column now names its zone, such as `DateTime (UTC)`, and every row gains a 4th column, `UTC offset`, so a script that matches the header `DateTime` or expects three columns needs updating. +- **Anomaly tiles agree on the window end** ([#4854]) - every SQL Server anomaly tile now leaves out a sample stamped exactly at the window's end. This holds in Lite and Darling. Eight of the eleven tile reads used to count it and three did not. So a boundary sample counted in one tile and not in another. +- **Lite shows a refused capture read as a failure** ([#4853]) - SQL Server can refuse the read of a blocking, deadlock or long-query session. Lite used to log a refused read (error 297 or 15151) as a success with zero rows, so collection health showed the capture as working. It now shows PERMISSIONS or ERROR, as a session that failed to start does. A read refused for permission (error 297) stops that capture until Lite restarts. A read that fails with error 15151 is retried every cycle. The Capture Not Running notice now names a long-query capture that could not start. It used to call it deadlock. +- **A backward clock step no longer pauses collection or delays repeat alerts** ([#4851]) - only a clock that stepped back can put a due time more than one interval ahead. Such work now runs at once instead of waiting out the step. This covers Darling's collectors, custom alert rules, retries and periodic checks, and Lite's collectors, collection cycle and background jobs. After a step back, a repeat alert waits one cooldown from the first check that sees the step. Before, it waited the step plus the cooldown. +- **A server edited during its connect no longer runs on the old connection string** ([#4851]) - the connect checks the definition again before its first pass. If it changed, the runtime is thrown away. +- **PostgreSQL spike advice names a baseline that measured zero** ([#4850]) - an hour-of-week can see no deadlocks, or no waiting, for the whole 30-day baseline. A spike in that hour now says the baseline measured zero, and prints no multiple. It used to say "first occurrence, no baseline yet". +- **Lite's View Block Chain reads the Blocking slicer's window when a report has no event time** ([#4848]) - For a blocked process report row with no event time, the chain is rebuilt from the slicer's selected window. That selection was converted to the server's local time before it filtered the reports' event times, which are UTC, so the chain came from a window shifted by the server's UTC offset. It now reads the window the slicer selected. +- **Fleet views show WARNING when half or more of a collector's databases fail** ([#4846]) - the run still records SUCCESS. Only its note records the loss. The collector's own Collection Health tab read that note. The fleet overview, the `get_fleet_overview` MCP tool and the viewer's Overview cards did not, so they showed the collector as Healthy. On its first start after the upgrade, the service rebuilds the hourly collection-health rollup and fills eight days of it in the background. +- **`run_custom_view_panel` runs count in read latency with the web dashboard off** ([#4839]) - the run's timing went to a slot only the web dashboard filled. With the dashboard off (the default), these runs were left out. They are now recorded as composed-panel reads, the same as a panel run from the web dashboard. +- **An alert that no channel delivered is tried again a minute later instead of waiting out its cooldown** ([#4786], [#4804], [#4826], [#4827], [#4828], [#4837]) - A send fails like this when, for example, a webhook answers HTTP 429 or 5xx or times out, or the mail server cannot be reached. The alert is tried again a minute later while its condition holds, and the wait doubles after each failed try (1, 2, 4 minutes and so on) and never passes the alert's cooldown. In Darling this covers the SQL Server high CPU, blocking, blocking wait time, deadlock, poison wait, long-running query, tempdb space, volume free space, version store, file growth, long-running job, failed agent job, database state and forced plan alerts; the PostgreSQL findings, high CPU, deadlock, blocking, long-running query and poison wait alerts; and the repeating self-alerts, such as Collection Stopped, Capture Down, Agent Not Running, Collector Cost Regression and store disk pressure. Lite reports a send that no email or webhook channel received as failed, so its alerts are retried the same way, and the tray notice shows again on each retry. In both apps, "Server Unreachable" and the availability group alerts (replica disconnected, failover, data movement suspended, and in Lite, sync fell behind) are tried again while the server stays down, with re-fire off or on, and so is a Per-event deadlock, blocking or poison wait alert whose sends all failed. A delivered alert is not repeated, and neither are the Restored and Reconnected notices. A custom alert rule has no cooldown, so its wait stops doubling at 15 minutes. A severity change that no channel delivered is sent again the same way, and a resolve goes out only for an alert that was delivered. A deadlock or blocking alert that fails to send no longer uses up its count. A failed agent job is no longer recorded as announced when every channel failed, so a restart before the retry no longer loses it; a crash between a send and that record can send the same failure again. Closing Lite ends a webhook alert post that is still in flight, instead of letting it run out its timeout. +- **A removed server no longer leaves alert state behind** ([#4837]) - an alert check or send could still be running when its server was removed. It then left state behind, and the server inherited that state when it was added again. A stale availability group role could page a failover. A stale "already reported" mark could hold back the server's first alert. In Darling, a stale offline mark sent "Server Restored" on the first connect. A check that finished after the removal could also claim an availability group for the removed server, so the group's other monitored replicas stopped judging it. The removal now drops that state, and a check or alert send that finishes afterwards records nothing. +- **The daily retention purge paces its deletes** ([#4835]) - it deleted rows at full speed, and the store wrote about 6 GB of WAL in 7 minutes. The PostgreSQL checkpoint running at the time took 23.5 seconds to sync, and collection slowed on every server. The purge now waits between batches to hold the store's WAL to half of what its checkpoint settings absorb. The collection log shows the store's WAL during the purge and how long it waited. +- **The Store Checkpointer Pressure alert sees one long checkpoint sync** ([#4835]) - it judged only the hour's average sync per checkpoint. A single 23-second sync among several short ones stayed under the 10-second bar. It now also judges the longest single sync, sampled once a minute. +- **get_store_metrics reports the longest checkpoint sync the alert judges** ([#4835]) - the hour's longest single sync is stored with the hourly checkpointer counters. The tool shows it and judges it against the same 10-second bar, so the tool and the alert agree. +- **Query Store trends no longer read low after a quiet interval** ([#4833]) - Query Store stores no row for an interval with no executions, so the next interval's rate was divided by the gap plus its own length. It now uses the interval's own length, for rows collected after the upgrade. The `get_query_store_duration_trend` description in both apps now describes that rate: its head says only a point with no stored end and no earlier point has null rates, and its guide text says each point is rated over its own stored interval. +- **Editing a server's host in the Darling viewer keeps its favorite star with the server** ([#4831]) - Before, the star stayed behind under the old address and marked any server added there later, and unchecking it in the same edit did not clear it. +- **get_store_metrics no longer reads two days of store growth as one** ([#4830]) - A day whose last snapshot came early in the day, after the service was down, was compared with the next day's last snapshot almost two days later and shown as one day's growth. Such a pair is now left out, and the tool says its times are UTC. +- **Darling and Lite count the I/O anomaly tiles' samples the same way** ([#4820]) - Darling counted a row once for both the read and the write tile, so it counted some read-latency tiles that Lite correctly left out, and the sample count on those tiles differed between the products. Darling now counts read samples and write samples separately, as Lite does. +- **A tile's peak time no longer changes between runs when two samples tie** ([#4820]) - when two samples tied on the peak value, the time shown for the peak was whichever the engine reached first, so it could differ from one run to the next with no change in the data. Both products now show the later of the tied samples, for Lite's CPU tile and for every Darling tile that reports a peak time. A Darling tile's peak time also skips a sample with no value, as the tile's peak value already did. +- **Lite's archive views stay readable while compaction swaps files** ([#4816]) - A query that ran during a compaction, or while a run finished the swap an interrupted run left behind, could find an archive table empty or missing rows for a moment. +- **Lite no longer counts archived rows twice during an archive run** ([#4816]) - a new archive file was visible before its rows were removed from the database, so a query in between counted them twice. The file is now added and the rows removed under one lock. +- **"Recurring at this hour" survives a daylight saving change** ([#4814]) - After the clocks changed, older findings shifted by an hour, so the label went missing for up to three weeks, and a job that had not moved could read as "Maintenance window moved". +- **A nightly job no longer reads as "Maintenance window moved"** ([#4814]) - Rows from other weekdays were compared as if they were the same weekly slot. +- **Reading a PostgreSQL log no longer records a false error when the read starts inside a multi-byte character** ([#4813]) - a first read, or a read after a fallback, starts 4 MB before the end of the log, and when that byte was inside a multi-byte character PostgreSQL refused the whole slice and the cycle logged an error that blamed a planted byte. The read is now repeated in the same cycle from 1, 2 and 3 bytes later, and the error row is written only if all four attempts are refused, with a message that says a split character is possible and that later reads resume from a full line. +- **A byte that is invalid in the database encoding costs one log read per cycle, not four** ([#4813]) - the retry from a later start cannot cure an invalid byte anywhere in the 4 MB window, and it is refused at every start on every cycle. After a cycle that used every start and was refused at each, the collector now makes one read per cycle until a read succeeds, and goes back to retrying after that. The memory is kept in process, so a restart pays one four-read cycle. +- **PostgreSQL error rows under the pgBadger log prefix now carry their user and database** ([#4813]) - a `log_line_prefix` written as `user=%u,db=%d` gave a null user and database on every error row, because only `user@db` was read. Both `user=` and `db=` are read now, wherever they sit in the prefix. +- **The plan-capture readiness read now reports a log prefix the log readers cannot read** ([#4813]) - a `log_line_prefix` with an unbracketed process id (`%m %p`, `%t %p:`, `%t [%p-%l]`) makes the stderr log readers drop every line, and the target looked quiet. A new `log_line_prefix_readable` row says whether the prefix starts with a timestamp and carries `[%p]`. +- **A deadlock report cut at the end of a read waits for its last lines instead of being stored as a fragment** ([#4813]) - a report whose HINT line the read did not reach was stored from the lines the read had, and one cut inside its DETAIL block was stored again under another hash when the next read had it whole; on the RDS log API, which never offers the rest again, only the fragment was stored. The newest report of a self-hosted read with no line after its DETAIL block is now left for the next read, which covers those lines again. On RDS the report is held until the next chunk and stored as it is if it is still unfinished after one more chunk, if its file has ended, or if it is larger than 1 MB. A report that other log lines follow is stored at once. +- **The fleet sweep bands a server outage as No Data instead of Warning** ([#4811]) - While a server could not be reached, its "Collection Stopped" alerts counted as data. The outage then showed as a Warning with an alert count, counted as reported, and hid the stale-collection item. +- **A collector that fails on half or more of its databases now bands Warning** ([#4811]) - A run that skipped half or more of its databases still recorded success, so Collection Health read Healthy with no errors. +- **The Darling viewer's Collection Health tab no longer re-reads the store's schema version on every refresh** ([#4811]) +- **Plan-forcing advice says when SQL Server's own recommendation names the proposed plan as the regressed one** ([#4810]) - The plan-force bot's journal now records a blocked decision for that plan instead of a would-force one. Each target in the script now also shows how long ago its plan was last seen. +- **Lite no longer archives the same rows twice after it is stopped in the middle of an archive run** ([#4808]) - If Lite was closed or killed after it wrote an archive file but before it deleted those rows, the next run archived them again, and the archive counted them twice. Leftover partial files from an interrupted run are now removed, and the archive views are rebuilt even when compaction fails. +- **Lite's Query Store repair also covers archive months that compaction split into parts** ([#4808]) - Rows in those part files were never repaired. +- **Darling retries a store that is at its connection limit when the service starts** ([#4806]) - Before, a store that was briefly full at start, after a restart storm or while another application held its connections, stopped collection until someone restarted the service. Other resource errors (disk full, out of memory, a configuration limit) still stop it, because they need an operator. +- **The compose `darling` container reports unhealthy when a startup failure has stopped collection** ([#4806]) - It used to show as running although it never collected. +- **The docs now name the oldest supported builds: SQL Server 2016 SP2 and SQL Server 2017 CU3** ([#4805]) - The query stats and procedure stats collectors read columns that older builds do not have. The docs said SQL Server 2016 and named no service pack. +- **A webhook that never answers no longer holds up alert delivery** ([#4803]) - each webhook post (Teams, Slack, generic and PagerDuty, and the test sends for them) waited up to 30 seconds with no way to cancel it, and a delivery makes those posts one after another. Each post now gives up after 10 seconds and records the channel as failed with "timed out after 10 seconds" as the reason. When the Darling service stops, an alert post in flight is cancelled instead of waited out, and the abandoned delivery writes no history row. Analysis-finding alerts, and every alert in Lite, get the 10-second bound but are not cancelled. +- **Query Store backfill now logs a warning when it cannot read its list of work** ([#4801]) - when the backfill's read of the databases to work on, or of a database's stored floor, failed, both apps logged it only at Debug and stopped filling tails and outage holes with no visible sign. Both apps now log one warning at the first failure of a run of failures, and again on the next failure after a read succeeds. +- **Query Store backfill keeps a slice size that works instead of swinging back to the size that timed out** ([#4801]) - after a timeout the slice halved, but any completed slice sent the server back to the full hour, so a database whose 30-minute slice fit and whose 60-minute slice did not wasted a 60-second read on every other tick. The slice still halves after a timeout, now keeps its size after a slice completes, and widens by one step (never above one hour) after three completed slices in a row. Both apps. +- **PostgreSQL analysis: a configuration setting shown under another finding now carries its own advice** ([#4799]) - A setting that hung off another finding, such as maintenance_work_mem under an autovacuum backlog, was described as "see its card", and only analyze_server shows that card. The viewer, get_analysis_findings and the e-mail showed neither the setting's advice nor its fix. The finding's text now names each such setting with its own headline and adds its fix, so every place that shows the finding shows the advice. +- **The advice for turning autovacuum back on now names the provider's parameter group** ([#4799]) - The advice said only "autovacuum = on in postgresql.conf", which managed PostgreSQL (RDS, Aurora, Azure, Cloud SQL) does not let you edit. It now names the provider's parameter group or server parameters, which apply the change themselves, and keeps the reload for postgresql.conf. +- **A webhook channel that keeps failing no longer goes unnoticed while another channel delivers** ([#4798]) - A Teams, Slack, generic or PagerDuty channel could fail for weeks with nothing but log lines while another channel delivered every alert. A channel that fails three times in a row now raises a "Notification Channel Failing" alert in Darling and a tray notice in Lite, and clears with "Notification Channel Recovered" when it delivers again. Turning a failing channel off closes the alert with an entry that says the channel was turned off. The alert and the notice name the channel and the count and carry no error text, since a webhook error can carry the webhook URL. +- **The configuration change card no longer calls a metric "resolved" when only minutes have passed since the change** ([#4797]) - Until the after-window reaches an hour, a metric that appeared or vanished is shown as not yet comparable. +- **A server that is down when the Darling service starts now gets a "Collection Stopped" alert once the threshold passes** ([#4796]) - the check was skipped until the service had seen the server online, so a server that stayed down across a service restart got no "Collection Stopped" alert, and no reminders, until it came back. Staleness is now judged from the later of the server's last success and the service start, so the alert fires once the staleness window (30 minutes by default) has passed since the start, and its text counts the minutes from the start. A healthy server whose last success predates the restart still does not alert at startup, and a server that reconnects after a restart is judged from the start rather than from its pre-restart rows. +- **Adding a server whose id matches a different server's no longer overwrites it in the Darling viewer, and Lite now refuses to add or edit onto it** ([#4794]) - Two different servers can hash to the same id. In the Darling viewer, Add Server and Add Multiple Servers wrote with an upsert that rewrote the server already holding it: that server stopped being monitored and its history showed under the new one, with no message. Add Server now refuses the add, saves nothing and names the server that holds the id, and adding a server that is already monitored at the same address shows the "already monitored" message instead of rewriting its row. Add Multiple Servers refuses that row, counts it apart from added, skipped and failed, and shows the count in its status text. The `--add-server` totals line now counts collided servers, and the command exits 1 when a server was not added because its id collides. In Lite, both servers were added and then collected into one history, so each tab showed both servers' rows with no message. Lite's Add Server and Edit Server now refuse a server whose id a different server holds and name that server, and adding the same server twice shows the "already monitored" message. Lite's Add Multiple Servers marks such a row "Not added", counts it apart from added, skipped and failed, and the main window's summary shows the count. An edit that keeps its id is still allowed, so a pair saved earlier stays editable. Importing follows the same rule: Lite's Import Settings no longer adds a server whose id a different server holds, and the Darling viewer's migration and Import Settings no longer leave such a server out silently as if it were already monitored. Each refuses it and reports it: Lite's Import Settings message shows the count and its log names the entry and the server that holds the id, and the Darling viewer logs both servers, with its Import Settings message showing how many servers it did not add. +- **`get_store_metrics` no longer reports a gap of several days in the store's size history as one day's growth, and it marks today's partial day as partial** ([#4792]) - The whole-store `daily_growth` labeled the difference between two neighboring daily points with the later day without checking that they were a day apart, so the first day after a stretch with no snapshots carried the whole stretch's growth as a single-day spike, and the per-server ingest rate built on it overstated what onboarding a server costs. Today's point, the latest snapshot of a day still in progress, was shown as a full day. A day is now compared only with the calendar day before it, and a wider pair is left out of the list (a hole in `daily_growth` is missing snapshots, not zero growth). Each point also carries `metric_time` (the snapshot it was read at), `span_days` (always 1) and `partial` (true for today), which makes each point about 74 bytes larger. +- **The store checkpointer alert no longer tells you to raise max_wal_size for every requested checkpoint** ([#4791]) - The informational Store Checkpointer Pressure alert, and the checkpointer note in the MCP store metrics, called any requested checkpoint "WAL-forced" and said the store had written more WAL than max_wal_size allows. PostgreSQL also counts a base backup or a CHECKPOINT statement as requested, and its counters do not say which one happened, so the suggested remedy was sometimes wrong. The alert's text now says "requested checkpoint(s)". The alert detail and the note now list all three causes, and when a requested checkpoint is what fired them, they also point at the log_checkpoints lines that say which and suggest raising max_wal_size only for the WAL cause. The get_store_metrics tool description says the same about its requested field. The alert fires on the same conditions and stays informational. +- **`mute_analysis_finding`, in Darling and in Lite, no longer mutes the pattern on whichever matching server sorts first** ([#4790]) - a `server_name` that matched more than one server (a partial name, or a display name shared by per-database and read-only registrations of one machine) muted the pattern on whichever sorted first and echoed the caller's spelling. Both products now resolve it to exactly one server, Darling the way `remove_server` does: a name that matches more than one server answers `ambiguous` with the candidates and mutes nothing, a name that matches nothing (a blank one included) answers `not_found`, and a successful call reports the resolved server name. `remove_server` resolves the same way: a name that matches one registration's own server name exactly, in the same letter case, picks it even when a sibling shows that name as its display name, while a partial name, a display name or a different letter case that matches several registrations still answers `ambiguous`, and the successful answers of both tools now say which kind of registration was picked (`kind`: plain, read-only or per-database). +- **Repeating a `create_mute_rule` call no longer creates a second identical rule** ([#4790]) - a client retry, from MCP or the web route (`POST /api/mute-rules`), left two identical mute rules. A create that repeats an enabled, unexpired rule's scope, patterns and expiry now inserts nothing and answers `already_exists` with the existing rule's id (HTTP 409 on the web route). A disabled or expired rule does not count, and a different expiry is a different rule. +- **`add_servers` reports every server in the batch when a later entry fails to save, and no longer says "added" for a save that wrote nothing** ([#4787]) - `add_servers` now reports every server in the batch when a later entry fails to save, instead of reporting the whole call as failed after it had already added the earlier ones: the failed entry and the ones after it come back as the new status `not_saved` (counted as failed) and the earlier ones stay `added`. It rejects a literal SQL password or service principal client secret on Linux, where it cannot be encrypted, and points at the `env:` or `file:` reference form. When the save wrote nothing because another server holds the same id, it answers `collides` (or `duplicate` for a concurrent add of the same server) instead of "added". +- **The plan-force bot no longer reads a database missing from the newest automatic-tuning capture as "automatic correction off"** ([#4784]) - it uses that database's last state from the past 24 hours, and blocks the database as unknown when there is none. +- **After a failed state read, the plan-force bot looks at the same plans again after 1 hour instead of holding them for a day** ([#4784]) - the blocked row from a failed read now holds its plan for 1 hour, and every other blocked row keeps the 24-hour cooldown. +- **Web viewer: a page left loading in a hidden or paused tab refreshes normally again** ([#4781]) - A page whose data finished loading while its browser tab was hidden, or while auto-refresh was paused, used to count the whole hidden or paused time as its load time. It then waited 15 minutes before its next refresh and showed "(slow page)". The page now counts its load as finished when its data arrives, and refreshes on its normal schedule. +- **The PostgreSQL plan-regression finding now reports the worst regression when more than 50 statements changed plans in the window** ([#4780]) - the plan-change read kept the 50 lowest query ids, so the worst regression could be dropped, or no regression reported at all when the kept rows had too few calls. The read now keeps the statements the pick would choose from, worst first. +- **A standby that was removed or replaced no longer outranks the live standbys for the rest of the window** ([#4780]) - its last row stayed in the window, so the finding described it in the present tense, kept its synchronous weighting and reported the whole table's span. Live standbys now rank first, and a standby that stopped reporting gets advice that says when it was last seen. +- **A dropped replication slot no longer grades Critical for the rest of the window** ([#4780]) - an inactive, growing slot kept grading Critical from its last row after it was dropped, and its inactive hours kept growing. A slot or database that stopped reporting now grades nothing, ranks behind the ones still reporting, and measures its inactive hours to its last row. +- **The alert history now records whether each notification channel delivered or failed** ([#4779]) - an alert that reached one channel and failed on another was stored as a plain delivery, so a broken channel was invisible while a sibling kept delivering. The route record on each history row now says `delivered`, `failed` or `not attempted` per channel, in both Darling and Lite, and `get_alert_history` returns it as `outcome`. No error text is stored, because a webhook error can name its endpoint URL; `send_error` is unchanged. +- **The alert notebook finds an alert's resolution even when it came late, was dismissed, or sat behind many newer alerts** ([#4778]) - The notebook's status only looked at the first 24 hours after the alert, at most 200 rows, and skipped dismissed rows. A store alert that cleared more than 24 hours later, a Cleared row hidden by "Dismiss all", or a fleet-level alert whose resolution sat behind 200 newer alerts from other servers read "Fired again" or "Unknown" instead of "Resolved at ...". The status now reads the first resolution row and the first later firing of the metric directly, with no 24-hour limit and no row cap, dismissed rows included, and scoped to the alert's server when it has one. +- **A fleet-level store alert with no resolution reads "No resolution recorded" instead of saying collection stopped** ([#4778]) - A store self-alert with no resolution row and no later firing read "Unknown (not collected since ...)" in the alert notebook, which says a collector stopped. Store alerts have no collector, and the process that evaluates them serves the page, so it now reads "No resolution recorded". +- **Darling now sends alert email through notification routes when the default recipient list is blank, instead of treating email as not set up** ([#4777]) - A notification route that named email recipients as its only destination sent nothing when the SMTP settings had a server and a from address but no default recipients, because email counted as set up only with the default list. Email is now set up with a server and a from address, and a route's recipients are enough to send. An alert that no route covers and that has no default recipients is skipped without a failed row or a cooldown, and an alert nothing else delivered is recorded as undelivered. The Send Test Email button still needs the default list. The Settings window's Validate message for a blank default list now says what the list is for. +- **`--configure-network` keeps the web listener's `tls` and `oidc` settings** ([#4775]) - Re-running the wizard for the web listener no longer drops `web.network.tls`, `web.network.oidc` or any other setting it does not ask about, so the dashboard keeps HTTPS and OIDC sign-in after the restart. The MCP and store blocks keep their other settings too, and the wizard prints a `Kept ... from the existing darling.json.` line naming what it kept. +- **A repaired hourly hole no longer leaves a partial day in the daily rollups, and days an earlier repair left short are rebuilt once after the upgrade** ([#4739], [#4763]) - After an hourly hole repair, the daily rollups that already held a bucket for the repaired day were not refreshed again, so a day older than the daily policy's 3-day window stayed partial and became the only copy once the hourly aged out. The repair now force-refreshes those complete days (at most 3 per daily per range), including the day-grain daily behind the interval daily, and the seam repair log line reports the holes still standing. After the upgrade, the service also checks each daily rollup against the hourly data under it, once, and rebuilds any day an earlier hourly repair left short, one day at a time. The repair logs each daily day it rebuilds with the seconds it took, and a day rebuilt after a repaired seam range is no longer rebuilt twice and counted twice in the repair's chained-days count. +- **Darling upgrade no longer says "New build in place." after copying nothing** ([#4762]) - when the staging folder's name contained [ or ], the upgrade script's copy matched nothing and threw nothing, so it reported success over the old build. It now copies the folder by literal path, and stops with a plain message if the installed service executable does not match the new build's after the copy. The installer no longer skips hardening older darling.json backups, or looks up its own files by wildcard, in an install folder with [ or ] in its name. +- **An older Lite refuses to open a data file from a newer version** ([#4753]) - An older Lite pointed at a data folder that a newer Lite had upgraded kept running, and every batch for the 13 tables that gained columns in schema versions 60 to 65 failed with only a log line to show for it. Lite now stops at startup with a message that names the file and both schema versions, and does not write to the file. +- **Lite re-applies its newer columns on every start** ([#4753]) - A data file where one of the columns added in schema versions 60 to 65 failed to apply, or was stamped without it, kept failing that table's collection on every start. Lite now adds any of those columns that are missing on each start, so the file gets it back. A column that still cannot be added is logged as an error naming the table and column, and the next start tries again. +- **After the computer sleeps and resumes, Lite runs each due collector once** ([#4753]) - After a sleep, each collector that was due ran twice about a minute apart, which wasted queries and stored an extra sample per collector. Lite now starts the cycle at the current collection slot after a resume, so each due collector runs once. +- **Two analyze_server calls that overlap no longer give the second one a false all-clear** ([#4742]) - The Darling and Lite MCP servers shared one analysis service, so a second analyze_server call made while the first was still running got "No significant findings" for a server it never analyzed. Each call now runs its own analysis in both products. +- **In Lite, a server that just went down no longer holds a connection slot while its retries wait** ([#4740]) - Each connect attempt now takes a slot and gives it back when the attempt ends, so a server that went down since its last status check no longer holds a slot through four connect timeouts and seven seconds of backoff, and can't stall collection for the other servers that way. +- **The self-hosted PostgreSQL log tail no longer stays on the outgoing log file after a rotation in the same second** ([#4738]) - When a size or age rotation put the old file's last write and the new file's first write in the same second, the tail could pick the old file as current on the stderr, csvlog or jsonlog route, so lines in the new file were not collected until the next line was logged in a later second; it now breaks that tie by file name, so the newer file is read. +- **Store upgrade: copy mode is chosen from the data folder's own volume and a finished size count** ([#4725]) - The pre-upgrade headroom check read the free space of the data directory's drive letter and took a size walk an error had cut short as the size, so a data directory on a folder-mounted volume, or one whose walk failed partway, could be upgraded in copy mode and fill the disk (the store came back on its old major, but was down for the attempt). The free space is now read for the data directory's parent itself, and an unfinished size walk falls back the way too little room does: hard-link mode where the volume supports it, otherwise no upgrade. +- **Store upgrade: hard-link mode removes the pre-upgrade directory even when a settings carry fails, after saving the old `postgresql.conf`** ([#4725]) - In hard-link mode the moved-aside pre-upgrade directory shares its files with the upgraded cluster and is not a rollback copy, but a failure carrying `postgresql.auto.conf` or the operator's `postgresql.conf` lines left it in place for two service starts. It is now removed as soon as the carries are done with it, whether they succeeded or failed. The old `postgresql.conf` holds the operator's lines below the `darling-managed.conf` include and exists nowhere else, so every major upgrade now first copies it beside the data folder as `postgresql.conf.pre-upgrade` (restricted to the service account like `postgresql.auto.conf.pre-upgrade`, covered by `--harden-files`, and kept until a later major upgrade replaces it), and hard-link mode removes the directory only once that copy exists, or when there was no `postgresql.conf` to copy. If the copy cannot be made, the directory is kept with a warning and ages out after two service starts, as before. The warnings for an operator line the new major rejects now name where the original line is kept (the saved copy) instead of the pre-upgrade directory. +- **Store settings migration: a repeated attempt restores the newest backup of `postgresql.conf`** ([#4725]) - A failed migration attempt restored the FIRST attempt's backup, so edits made to `postgresql.conf` between attempts were lost. A new backup is taken when the file changed since the last one, and a failed or resumed attempt restores the newest. +- **Store free-space checks and reports read the data folder's own volume** ([#4725]) - The free-space check before `--backfill-rollups` and the plan dimension compaction, the WAL sizing (`max_wal_size` and `min_wal_size` at every service start), the store host profile (the start-up log, `--check-settings` and the MCP host tool), and the store disk-pressure alert read the size and free space of the data directory's drive letter. A data directory on a volume mounted at a folder was therefore judged by another volume: a backfill or a compaction could start on a volume with no room for it, the WAL ceiling and the reported size and free space came from the wrong disk, and the disk-pressure alert watched a disk the store is not on. On Windows they now ask for the data directory itself, as the upgrade check does. The alert's free figure is now the space available to the service account, as the other reads use, which differs from the volume's total free space only where the account has a disk quota. Where that read fails, each keeps its old answer for an unreadable volume (the verbs refuse, the WAL sizing is skipped and the WAL settings in force stay, the host profile shows a volume that is not ready, the disk-pressure alert gives no signal that check). The filesystem name in the host profile still comes from the drive letter, and other platforms keep the old read. +- **Lite archive compaction no longer loses a month when a promote fails** ([#4718]) - hourly compaction deleted the month's existing parquet file before moving the merged replacement in; a move that failed (a scanner or backup agent holding the fresh file) then deleted the merged copy too and the month was gone, with part files losing both old parts and double-counting the new rows. The swap now sets the existing files aside, moves every merged file in, and deletes inputs only after all of them are in place; a failed or interrupted swap is undone or finished on the next run. +- **The size-triggered Lite reset no longer deletes the database after a failed export** ([#4718]) - when the store hit its size limit and one table's export failed, the reset ran anyway and that table's hot window was lost; a kill mid-export could also leave a truncated file that hid every archived month of the table. Exports now go to temp files, nothing is promoted until every export succeeded, a failure leaves the database and archive untouched and backs off, and a kill between export and reset no longer duplicates the hot window. +- **The tab Refresh button no longer runs collectors during a Lite database reset** ([#4718]) - a reset could delete the database under a Refresh run and lose everything collected until the next restart; the run now registers with the reset gate like the scheduled and tab-open collections. +- **Lite archive views now include compaction's part files** ([#4718]) - a month that compaction split into `_ptNNN` files dropped out of the archive views, and a table with only part files showed no archive at all. +- **Importing a previous Lite install no longer overwrites this install's part files, and imported files now expire with retention** ([#4718]) - an imported part file of the same month and table was compacted over the local one; imported files also never aged out because their prefix hid the date. +- **A failed archive export no longer leaves a partial file on disk** ([#4718]) - When DuckDB failed partway through writing an archive export (out of memory, disk full), the partial `.tmp` file stayed behind, and the size-triggered reset repeated that every 15 minutes. The reset and the hourly archival now delete the partial file when the export fails. +- **Reads of an archive view no longer fail after old archive files expire** ([#4718]) - Expiring a table's last multi-part month (or its last single-file month while part files remained) made every read of that table's history view fail until the next hourly refresh. The views are now rebuilt right after retention deletes files, and after the cleanup of files a killed size-triggered reset left behind. +- **A managed store moved aside by a failed upgrade is no longer replaced by an empty one** ([#4717]) - When an in-place PostgreSQL upgrade could not move the data directory back, the next service start initialized an empty store in its place, wrote a new superuser credential over the old one, and deleted the real store as an expired rollback copy two starts later. A start now refuses to initialize while a `-old-*` or `-upgrade-*` sibling holds a cluster and names the rename to do by hand, and the rollback sweep counts no start until a cluster is back at the data directory. +- **A start after an interrupted store upgrade resumes it instead of refusing every start** ([#4717]) - When the service died between the runtime swap and the upgrade's commit, or the revert was refused, every later start stopped with "the PostgreSQL 17 binaries are not on this host" although they were in `pg-runtime-prev`, and deleting the runtime stamp to force a retry deleted them. The start now finds the store's binaries there, the runtime update never empties `pg-runtime-prev` while the store still needs it, and the refusal's hint names a path a start reads. +- **A failed store upgrade that left no startable store stops the start** ([#4717]) - A failure that could not put the data directory back, or could not revert the runtime, used to let the start go on, into the empty-store initialize above or onto PostgreSQL 18 binaries in front of a PostgreSQL 17 cluster. It now stops with the hand step in the message, and the worker does not retry it. +- **The pre-upgrade rollback copy survives the two service starts it is kept for** ([#4717]) - A start the worker retried in the same process counted as two starts against the copy. The sweep now runs once per service start. +- **PostgreSQL 13 servers read through csvlog are no longer reported as quiet** ([#4714]) - The csvlog parser required exactly 26 columns, but PostgreSQL 13 writes 24 (`leader_pid` and `query_id` arrived in 14), so every PostgreSQL 13 record was rejected. Log events, deadlocks and plan capture came back empty, and the run counted one discard however many records were rejected. The parser now accepts 24 or 26 fields, and a read it cannot use reports how many records it dropped. A PostgreSQL 13 auto_explain capture has no query id, so it is stored as an orphan plan (query id 0) instead of being counted as forged. +- **RDS and Aurora PostgreSQL log reads now collect the lines a log file received before RDS rotated it, and resume where they stopped after a restart** ([#4713]) - Deadlock, log-event and plan-capture reads opened only the newest RDS log file, so whatever the previous file received after the last read was never collected, a new stderr file was read from its last 10,000 lines instead of its first line, and the read position lived only in memory, so a restart re-read just the last 10,000 lines of the newest file. A read now finishes the file it was reading before it moves to the newest one, in the same cycle (at most four reads per cycle), and a new file is read from its first line. Each read saves its position to collect.collector_state once its rows are stored and loads it at start; a saved file RDS no longer lists falls back to the newest file's last 10,000 lines. Files that rotate away entirely between two reads are still not read, but the run now records how many in log_files_skipped_by_rotation, and a missing saved file in log_resume_file_missing, with a sentence on the collection_log row. The read also lists every log file even when the listing is paged (up to 20 pages), so a listing too long for one page can't hide the newest file or the file a saved position names; past 20 pages it uses the files it has and logs a warning, at most once an hour for each instance. +- **Down servers no longer use up the fleet's collection slots, and a command timeout no longer drops a healthy connection** ([#4712]) - A connect attempt against a dead server takes about 15 seconds to fail, and it ran inside the fleet collection gate, so about 22 down servers filled the default gate and healthy servers queued behind them. Connect attempts now run in their own small gate, and the retry delay grows from 60 seconds to about 4 minutes (with jitter) while a server stays down; it resets when the server connects or its definition is edited. A definition edit made while a connect attempt is running is no longer lost: the attempt remembers the definition it used, and a stale attempt installs nothing and lets the next sweep connect with the new definition. Separately, a SQL Server command timeout dropped the server's connection and re-ran the Extended Events setup and on-load snapshots even though the connection was still good, costing a stressed server 75 seconds or more of collection; the service now drops the connection only when a probe on a fresh connection fails. +- **A memory grant that used none of its memory now gets an Excessive Memory Grant finding** ([#4705]) - Rule 9 skipped any plan whose `MaxUsedMemory` was 0, so a grant of 1 GB or more that the query never used, the largest possible waste, got no finding. The parser now records whether the plan carried a `MaxUsedMemory` attribute, and the rule fires for a grant of at least 1 GB that used 0 KB with the message "Granted N MB but the query used none of it." A plan with no `MaxUsedMemory` attribute (an estimated plan, or one with no runtime grant info) still does not fire, and the ratio message and 10x threshold for a grant that used some of its memory are unchanged. +- **Estimated Plan CE Guess names the predicate behind each default guess and follows the plan's CE model version** ([#4705]) - Rule 33 called the 30% guess an equality guess (it is the inequality guess), called 10% and 1% inequality guesses that no predicate produces, never looked for the real equality guess, and ignored the statement's CE model version. It now labels each guess for what produces it, detects the equality guess (the square root of the row count from CE 120, the row count to the power 0.75 under CE 70), and reports a band only when the plan's estimator has it. The warning type, the 100,000-row minimum and the rest of the message are unchanged; the label text changes. +- **Expensive Operator no longer names an exchange operator** ([#4705]) - An exchange (Gather, Distribute or Repartition Streams) spends most of its elapsed time waiting on the operators around it, so Rule 35 could name the exchange while the operator next to it did the work. Rule 35 now skips exchange operators; the operator that did the work, such as a spilling Sort, keeps its warning. The 20% share, the 1,000 ms floor, the warning type and the message text are unchanged. +- **Self-hosted PostgreSQL targets no longer lose the log lines written just before a log rotation** ([#4704]) - The log tail keeps a resume marker per target, finishes the previous log file before reading the newest, and says so on the collection log when a file is gone or the log outgrew the read window. When one read holds more deadlock reports or captured plans than the collector's row limit, the newest are now kept, and the collection log says the limit was hit. +- **A Query Store backfill database that keeps failing no longer blocks the databases after it on the same server** ([#4703]) - The backfill runs at most one slice per server per pass in a fixed database order, so a database whose slice always failed stayed first in line and the databases behind it never got a slice. In Darling and Lite, a database that fails 3 slices in a row is now skipped while any other database on that server has work, one Warning is logged when it starts being skipped, and it is retried only when no other database has work, longest-ago failure first. A completed slice clears its count. The slice window still narrows per server after failed slices, as before. +- **The plan viewer's row label, edge colours and minimap, and analyzer rules 5 and 26, no longer misread operators in a parallel zone** ([#4632], [#4688], [#4698]) - Actual rows in a plan are a total, the estimate is per execution, and the execution count is a real loop count only on the inner side of a Nested Loops join (elsewhere in a parallel zone it is the thread count). The node label now prints the totals against the expected rows, for example "609 of 2,983 (20%)" (on a Nested Loops inner side the expected rows are the estimate times the executions, so "609 of 613 (99%)"), with just enough decimals that the numbers agree with the percentage: a Key Lookup that ran 117 times for 1 row reads "1 of 1.128 (89%)". An operator that returned exactly its estimate used to read "12 of 100 (12%)" at DOP 8 and, from DOP 11, was drawn in the critical colour; it now reads "100 of 100 (100%)" and stays neutral. The edge colours and the minimap follow the same rule: accurate operators in a parallel zone at DOP 11 or more stop drawing Blue, LightBlue or FluoBlue edges, and real misestimates in a parallel zone now show their full tier (a 20x underestimate at DOP 11 draws LightOrange, where it drew no colour before). On a Nested Loops inner side, the edge colour comes from the same ratio as the node's label, so an operator that ran thousands of times no longer gets a worst-misestimate red edge while its label shows the estimate was close. Rule 5 no longer reports a false overestimate on a parallel operator (a DOP 8 join with estimate 2,983 and 609 actual rows used to read "Estimated 2,983 vs Actual 609 (76 rows x 8 executions) - 39x overestimated" and is now silent), and rule 26 now reports "Row goal active: estimate reduced from 1,000 to 100" for a parallel scan that returned 500 rows, where it used to be swallowed. +- **Selecting the plan viewer's "+" tab through UI Automation (screen readers) adds one new sub-tab, not two** ([#4688]) - a UI Automation select on "+" sets focus on the tab and then selects it, and each counted as a click on "+", so one select added two empty "New Plan" sub-tabs in Lite and in the Darling Viewer. The plan viewer now treats the pair as one gesture and re-selects the sub-tab it just added. A mouse click or keyboard selection of "+" still adds one tab, and two separate selections still add two. +- **The Darling Viewer's server list is no longer a solid white box when the store is unavailable** ([#4685]) - While the store is unavailable the sidebar server list is disabled, and the stock list template painted it white in every theme, out of place next to the themed sidebar. Each theme now has its own list template: a disabled list keeps its themed background and border and dims instead. The same applies to the tag list in Manage Tags, which is disabled on a read-only seat. Enabled lists render as before. +- **Custom tab headers and the status-bar collector text now use readable, theme-following ink** ([#4682]) - In Lite, a selected server tab or Plan Viewer tab, and in Lite and the Darling Viewer a selected plan sub-tab, drew its label in the page text colour on the accent fill (1.99:1 on Dark, 2.71:1 on Cool Breeze); it now uses the theme's on-accent ink. In both apps, the status bar's "Collectors: N OK / erroring" text kept the previous theme's colour after a live theme switch until the next 30 second tick; it now follows the switch. In Lite, "Logging: BROKEN" uses the theme's critical text colour instead of a fixed red that was under 4.5:1 on every theme. +- **Web dashboard: a slow notebook or Custom View panel is no longer re-run while its previous read is still running** ([#4671]) - Composed panels read through a request the page's in-flight guard did not count, so a periodic refresh could fire a panel again while its last read was still running on the store. Panel reads are now counted like every other page read, so the page waits for them and the new slow-page back-off measures them. +- **Custom Views: window-total Query Store measures are no longer labelled "(ratio)"** ([#4664]) - "Query Store total CPU time" and "Query Store total duration" showed "(ratio)" in the measure pickers although they divide by nothing; each is a window total. The suffix now appears only on measures that are ratios. +- **Cool Breeze's warning text now reads clearly on the plan viewer's properties panel** ([#4658]) - In Lite, the Darling Viewer and the Dashboard, warning-tier text in the Cool Breeze theme (the missing-index impact percentage and per-thread skew on the plan viewer's properties panel) was a shade too light to meet the accessibility contrast guideline there. The warning color is now slightly darker by default, so that text meets the guideline on the panel and on the theme's cards, plan nodes and status bar. +- **Darling: the daily digests keep their time of day** ([#4656]) - The collector-cost digest, the fleet-sweep daily rollup and the analysis singles digest were due 24 hours after their last send and checked on an hourly tick that itself slid, so each arrived up to an hour later than the day before. Each now keeps a daily slot, and a late tick no longer moves the next day's. +- **Darling Viewer: the Plan Viewer opens when the viewer has no configuration or can't reach the store** ([#4649]) - The failure message now covers only the content area. Open Plan Viewer, View Log, Open Log Folder and About stay usable; the entries that need the store are disabled. +- **Custom Views AVG panels read from a rollup match raw to the last digit** ([#4647]) - The rollup route divided in floating point after rounding the sum, so for very large sums it could differ from raw's average by one unit in the last place. +- **Darling Viewer: restarting as administrator during an upgrade keeps its configuration** ([#4646]) - The restarted viewer read its own `--upgrade-takeover` flag as the path to darling.json and showed "darling.json not found"; it now reads its arguments the way `--test` does and passes the first launch's arguments on. +- **Collectors run at their configured interval on large fleets, in Darling and Lite** ([#4644]) - Each collector's next run was scheduled from when its pass started (Darling) or waited a full minute after the pass's work (Lite), so late starts accumulated: busy Darling stores ran 1-minute collectors about every 71 seconds and lost about 15% of per-minute samples. Both now keep a fixed grid and skip, rather than replay, a slot missed during a stall. Stores that were drifting collect correspondingly more data per day: up to about 20% more for the per-minute tables. +- **The plan viewer's minimap now draws the first time you open it** ([#4643]) - Opening the minimap on a freshly loaded plan tab used to show only the "Minimap" header with nothing below it, until you dragged its resize grip or closed and reopened it. It now draws the plan overview immediately. +- **Double-clicking a minimap node now centers it correctly** ([#4643]) - Double-clicking a node in the minimap to zoom to it used to leave the node off to the side once the properties panel opened, by as much as 200 pixels. It now centers in the space that's actually left after the properties panel opens. +- **Jumping from a plan warning to its operator now centers the operator** ([#4643]) - Clicking a warning header's link to jump to the operator it came from used to leave that operator off to one side, because the properties panel opening alongside it narrowed the view after the centering had already happened. It now centers in the space that's actually left once the panel opens. +- **Copy and paste no longer freeze the window for up to 9 seconds when another app holds the clipboard** ([#4634]) - In Lite, the Darling Viewer and the Dashboard, a copy or paste that found the clipboard busy tried 8 times, and each try could take about a second, so the window stopped responding for up to about 9 seconds. It now tries twice and gives up after about 2 seconds. +- **get_store_metrics no longer reports retired store objects as a failing sweep** ([#4633]) - The inventory counted every row left from an older sweep as a sweep that "is not completing", and pointed at a Warning line that does not exist. On an upgraded store those rows belong to objects the product retired, such as the superseded baselines and the frozen rollups' jobs. It now checks whether each object still exists. Retired objects appear in their own `dropped_objects` list with the time of their last row. Only an object that still exists is reported as a sweep gap, with the service-log lines that say why. The compression line also explains why `collection_health_hourly` is uncompressed instead of listing it as DISABLED. +- **The Runtime Summary no longer says a query used "100%" of a memory grant it never got** ([#4632]) - When a query's memory grant was zero, the plan viewer now says "No memory grant" instead of a fabricated "0 KB granted, 0 KB used (100%)". +- **Plan viewer orange text now reads clearly in the Light theme** ([#4632]) - In Lite and the Darling Viewer, the warning badge, missing-index impact percentage, per-thread skew text, and the node cost/elapsed/CPU/row-estimate text used a fixed orange that was too pale to read on a white background; they now use theme-aware colours that stay readable in both Light and Dark. +- **Collector status text in the status bar now reads clearly in the Light theme** ([#4632]) - When collectors were erroring or capture was down, the status bar text used a fixed orange that was too pale to read on a white background; it now uses the same theme-aware colour the plan viewer uses, readable in both Light and Dark. +- **The repro script declares each parameter once** ([#4626]) - When a batch's plan lists the same parameter, or an auto-parameterized `@0`/`@1`, for more than one statement, the repro script declared it once per statement and failed to run. Each name is now declared once; a name the statements give different types is left out with a warning, and a warning says when the statements' compiled values differ. Matches PerformanceStudio. +- **Collection health no longer calls an idle activity-only collector regressed** ([#4625]) - `waiting_tasks`, `query_snapshots`, `running_jobs`, `job_history`, `procedure_stats`, `pg_lock_stats` and `pg_session_states` store rows only while the target is busy, so three empty runs in a row is normal for them, and working collectors showed WARNING. They are now flagged as stopped only after 72 hours without a row. Errors, denials and staleness are still flagged at once. Every row flagged as regressed now carries the sentence that explains it, including the default `get_collection_health` rows, and the web Collection Health table has a Regression column. +- **The daily purge of the per-interval Query Store tables no longer scans each table in full** ([#4615]) - The two tables get an index on the column the purge and the Query Store read gate filter on, so a purge with nothing to delete no longer costs minutes on a large store (measured: a cold-cache no-op purge dropped from ~4.1s to ~0.6ms on a 4M-row table). +- **A rare deadlock between a chunk drop and the alert pass's database-state check no longer fails that pass** ([#4612]) - The alert pass retries its database-state statements once when PostgreSQL picks them as a deadlock victim, the way the daily purge already retries its chunk drop. +- **Copying from Lite or the Darling Viewer no longer crashes when another program holds the clipboard** ([#4600]) - Every remaining unguarded clipboard write (recommendation copy/AI-prompt buttons, MCP command/URL copy, grid/row/cell copy, chart image copy, alert detail T-SQL copy, sign-in device-code copy) now retries briefly instead of throwing when another process is holding the clipboard. +- **The plan viewer no longer crashes when another program is holding the clipboard, and "Copy Query Text" now hands back the full query on a truncated single-statement plan** ([#4593]) - Copying anything from the plan viewer, blocking chain, deadlock graph, or a results grid used to crash the app if the Windows clipboard was briefly locked by another program; copies now fail quietly instead. Separately, "Copy Query Text" on a single-statement plan whose text hit SQL Server's 4,000-character cap now returns the full query the plan was captured from, instead of a copy cut off mid-word — for the Query Store and Active Queries plan sources that pass the original query text. +- **`get_ag_health` keeps its fleet-wide answer within the 32 KB MCP budget** ([#4568]) - The fleet-wide default page now fills most-severe-first by measured size instead of a fixed 11 groups. On a real fleet whose groups carry many databases, those 11 groups came to about twice the budget. `limit` still caps the page, and `groups_truncated` says whether the size budget or the limit cut it. +- **Plan analysis: the repro script matches PerformanceStudio's hardening** ([#4567]) - Reproduction scripts built from a plan now drop, with a header warning, a parameter whose plan-supplied name or data type is not a plain identifier or type, and use a placeholder for a compiled value that is not a safe literal. Every value written into the script's header comment is escaped so it cannot end the comment, and the `USE [database]` line is left out when the database name contains a control character. Parameters named `@0`, `@1`, … from simple and forced parameterization keep working. +- **A cancelled analysis, comparison, or collection-cycle read now propagates instead of returning an empty or fallback result** ([#4562]) - A cancelled `get_analysis_facts` or `compare_analysis` MCP call, or a shutdown mid-collection-cycle, used to come back looking like a clean empty result or an ordinary read failure; all now surface the caller's own cancellation. +- **Lite's MCP analysis tools stop reading when the client cancels the request** ([#4561]) - A cancelled `get_analysis_facts`, `compare_analysis` or `audit_config` request, and the config-change attribution behind it, now stops reading DuckDB and returns as cancelled, instead of reading to the end and logging an error. Darling's analysis tools already did this. +- **Plan analysis stops when its caller cancels** ([#4560]) - The MCP plan tools stop parsing and analysing a plan when the client cancels the request, and the Darling and Lite analysis passes stop on shutdown instead of finishing a large plan first. +- **Plan analysis now looks inside a procedure, function or cursor body** ([#4557]) - The plan viewer and the `analyze_plan_xml` MCP tool skipped every statement inside a stored procedure or user-defined function call, and a cursor's own sub-plan was never read at all. An `EXEC ` plan analyzed as a single statement with no findings, no cost, and no benefit score for the work actually happening in the body. +- **Plan analysis: the non-SARGable predicate check now knows which table a function, conversion or `ISNULL`/`COALESCE` call is wrapping, so it stops flagging a Nested Loops outer reference or a parameter-side conversion, recognizes `LIKE` as a comparison, and now also catches a function or conversion on an unaliased table variable's own column** ([#4554]) - Each previously produced a Non-SARGable Predicate warning for a predicate that could actually seek (or, for the table-variable case, missed a real one), and pointed at the wrong cause. +- **The rollup coverage check no longer writes about 170 MB of temp files every five minutes on a large store** ([#4553]) - Finding a rollup's oldest bucket sorts every compressed batch of its oldest chunk. The check now re-measures a rollup only when its oldest chunk changes, and reuses the last measurement otherwise. +- **Plan analysis now scores each finding's benefit, and the plan viewer and MCP plan tools show it** ([#4552]) - The benefit scorer was never run, so no finding had a benefit value. Findings are now ordered by their estimated benefit. The viewer's headers read "— up to X% benefit", and the MCP plan tools report `max_benefit_percent`. This turns on the Serial Plan and Bare Scan benefit estimates. +- **A deeply nested execution plan no longer crashes the Darling service, the MCP plan tools or the plan viewer** ([#4551]) - Plans nested deeper than about 80–120 operators overflowed the stack and ended the process that parsed them. Parsing now runs on its own thread with a large enough stack, stops cleanly at 1,000 levels, and rejects plan XML over 16 MB. +- **Plan analysis: adaptive-join memory grants, redundant UDF findings, and culture-dependent percentages** ([#4548]) - The Excessive Memory Grant finding now notes when an adaptive join ran as Nested Loops, so the unused grant isn't mistaken for a separate problem. Rule 6's Scalar UDF finding no longer duplicates a Serial Plan finding that already names the same UDF as the reason a plan runs serially. Three warning messages that reported a percentage now format it the same way regardless of the machine's locale. +- **Plan analysis: an operator's reported self-time no longer includes the coordinator thread's wall-clock time or double-counts a batch-mode or Compute Scalar child's time, in either a parallel or a serial plan** ([#4547]) - the "Operator time" text and the severity of plan findings now reflect the operator that actually did the work, not an operator that happened to sit above a batch subtree, a Compute Scalar pass-through, or near the top of a parallel branch. +- **The Join OR Clause plan-analysis finding no longer fires on a parameterized `IN` list** ([#4544]) - A query such as `WHERE t.A IN (@p1, @p2)` on an indexed column builds a dynamic seek with the same operator shape as a real join OR. The finding now also requires a lookup branch that reads a value from another input. +- **Plan analysis no longer flags an unexecuted operator as a row estimate mismatch, and stops recommending a rewrite for the engine's own table-valued functions (`STRING_SPLIT`, `OPENJSON`, `GENERATE_SERIES`, DMVs/DMFs)** ([#4542]) - Rule 5 previously warned about a 0-row estimate mismatch on any operator whose branch never ran; it now requires `ActualExecutions > 0`. Rule 23 previously warned on every table-valued function operator; it now skips one whose object has neither a database nor a schema, which is how the engine's own functions appear. +- **The store no longer compresses every heavy table at once after midnight** ([#4541]) - The nine largest hypertables each become eligible for compression at their own hour (1 to 9 hours after the usual one day), so the nightly compression pass no longer times out collector statements. Existing stores pick up the new delays on their next start. +- **Plan analysis rules for `MAXDOP 1`, `RECOMPILE`, `OPTIMIZE FOR UNKNOWN`, `NOT IN`, and row-goal causes ignore hints and keywords written inside a comment or a string literal** ([#4540]) - A hint or keyword sitting in a `--`/`/* */` comment or inside a quoted string no longer counts as code, so these rules no longer fire on text that isn't actually part of the query, and no longer miss a real hint hidden behind one. +- **A managed PostgreSQL or a config load that takes more than two minutes to start no longer leaves Darling running without collecting** ([#4538]) - The sustained start-up retry from [#4509] now also covers the bundled PostgreSQL's own start and, for failures already treated as transient, loading `darling.json`. While that retry runs, `/api/ping` and the status detail say it is a sustained retry, with the interval, instead of reporting an attempt count past the cap. +- **After a long store outage at start, Darling now keeps retrying and starts collecting when the store is back** ([#4509]) - Once the two-minute startup retry budget for a recoverable store connection or migration failure ran out, Darling stood down and never collected again until the service was restarted, even though the service itself kept running. It now keeps retrying, more slowly, until the store is reachable again. +- **After a SQL Agent job-history identity reset (a reseed, a restore or a failover), Darling and Lite re-read the recent history once instead of on every collection** ([#4496]) - the watermark read the highest ID ever stored, which a reset leaves above every new ID. One store collected each run about 13 times. +- **A gap of one hour in the collection-health rollup no longer makes the Viewer, web and MCP health reads scan seven days of raw collection log** ([#4494]) - the missing hours are read raw and the rest still comes from the rollup. A store measured the raw path at 6.6 s against 184 ms. +- **Lite's perfmon chart and `get_perfmon_trend` also set aside a one-sample Wait Statistics spike and say how many** ([#4492]). +- **A one-sample spike in a Wait Statistics counter no longer flattens the perfmon chart** ([#4490]) - SQL Server occasionally reports a cumulative-sized value in a per-second instance for a single sample. The Viewer's perfmon chart and `get_perfmon_trend` now set such a sample aside and say how many, and the stored value is unchanged. +- **Lite's Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4488]). +- **`query_store` no longer reads as "produced then stopped" between Query Store intervals** ([#4483]) - it runs every 5 minutes, but its source advances once per interval (up to a day). It's flagged only after more than a day plus 15 minutes with nothing new. +- **The Availability Groups tab and `get_ag_health`'s `distinct_ag_count` no longer count differently-owned AGs that share a name as one group** ([#4481]) - e.g. every Amazon RDS Multi-AZ instance's internal `RDSAG0`. An AG monitored from both its primary and a secondary still counts once. +- **Job History shows that it is loading instead of an empty grid, and says when it shows only the newest rows** ([#4481]). +- **Recommendations say "queries", not "querys"** ([#4481]). +- **Plan analysis now reads the query plan inside an IF condition, and the query and plan hashes of statements that carry several plans** ([#4470]) - an `IF EXISTS (SELECT …)` condition's operators and missing-index suggestions were dropped, and a `MULTIPLE PLAN` statement came back with no hashes. +- **Upgrading a busy store no longer stops partway and asks for a re-run when the service's process takes a few extra seconds to exit** ([#4467]) - the upgrade script now waits up to two minutes for it before refusing. +- **Stores that expose the managed PostgreSQL on the network re-verify a settings file left unstamped by a hand edit or an interrupted start, instead of reporting a failure on every start** ([#4465]) +- **Stores that expose the managed PostgreSQL on the network now finish the settings-file migration, instead of restoring the previous file and logging a warning on every start** ([#4464]) - the command-line `listen_addresses` outranks the file, so the check no longer compares keys the command line owns. +- **The daily chunk-interval adjustment now shrinks a busy table's chunks on stores that hold more than 1,000 chunks in total** ([#4458]) - its 1,000-chunk limit counted every table's chunks on the store, so a store past 1,000 in total held every table at 24 hours however far over its memory budget it was; the limit now applies to each table's own chunk count at the smaller size, and each held table and each run's store total and budget are logged at Information. +- **Severe-error rows from system_health now carry their database id, and no longer list errors below severity 16 or the two routine connection-error numbers sp_HealthParser ignores** ([#4455]) - the database id was read from the wrong part of the captured event and always came back empty, and the unfiltered view could show errors the proc's own report never would. +- **A managed PostgreSQL 17 store whose settings carried an old 2 GB maintenance_work_mem starts again after the move to darling-managed.conf** ([#4444]) - a carried value from before the PostgreSQL 17 memory cap is now capped the same way a freshly derived one already was, so `postgres -C` no longer rejects it on start. +- **After a long outage across an upgrade, repaired hourly query statistics also reach the daily rollup, so the hourly tier's retention isn't held** ([#4439]) +- **PostgreSQL statement statistics count a re-created statement entry's work since it was re-created, instead of under-counting it; on PostgreSQL 16, where the entry's creation time isn't available, such a row is recorded as unknown** ([#4435]) +- **Wait statistics on servers where a scheduled job clears them are counted from each clear instead of being recorded as unknown; only the work between the last collection and the clear stays unknown** ([#4434]) +- **The raw purge gate judges each rollup against the rows that rollup can hold, so an hour of CPU-unknown query statistics at the floor can't hold the purge forever** ([#4432]) +- **Query statistics record a restarted cached plan's executions, duration and CPU since the restart in full, instead of under-counting them; a restart the collector cannot place in time is recorded as unknown rather than estimated** ([#4431]) +- **After an outage across an upgrade, the raw purge resumes within the hour on a running store, with no second restart** ([#4430]) - a legacy/successor seam an outage opens across an upgrade used to require a second full service start before the raw purge gate would release; the hourly retention tick now closes that seam on its own. +- **The daily retention sweep no longer drops raw query statistics over a hole no rollup holds; the gated service-triggered purge owns those tables, and purge_now reports what it held** ([#4429]) +- **Query statistics no longer record a false zero CPU when only the CPU counter's delta is unknowable; those rows keep their executions and duration** ([#4423]) - a `query_stats` row whose CPU (worker time) counter reset or was seen for the first time, while its execution-count or elapsed-time counters had a real delta in the same pass, previously wrote CPU as a false 0 over a fabricated zero interval — which then caused the row's real executions and duration to be dropped by the interval-honest filter along with the fake CPU. That row now records CPU as unknown (NULL) and keeps its real interval, executions, and duration. A CPU counter that is genuinely unchanged over a real measured interval still records 0, unchanged. +- **FinOps no longer reports a database as idle when its only recent samples were a plan's first sighting** ([#4417]) - idle-database detection now counts a recent last-execution time as activity, instead of deciding on the summed execution count alone (#4394). +- **Alert notebook: the collector-freshness check now counts only successful collection runs** ([#4416]) - it previously treated a collector's own failed runs as proof it was still fresh, used no read timeout, and always logged a zero elapsed time on failure. It also now recognizes AG and Server Unreachable/Restored recovery pairs when resolving a notebook's status. +- **`get_store_host` now honours request cancellation** ([#4412]) - an abandoned or superseded call to `get_store_host` kept its store-host gather running to the tool's own fixed deadline instead of stopping when the caller went away; the gather now also observes the request's own cancellation, and a cancelled gather is never cached. +- **Web reads honour request cancellation for 2 more trend charts and 3 analysis tools** ([#4411]) - `get_file_io_trend`, `get_perfmon_trend`, `compare_analysis`, `get_analysis_facts` and `get_analysis_findings` kept running their store reads (and, for the analysis tools, the inference engine's fact collection and scoring) to completion after a web request was abandoned. They now take a cancellation token and stop when the client disconnects. +- **Web reads for PostgreSQL index bloat, column stats, CPU utilization, log events and logging audit now honour request cancellation** ([#4409]) - an abandoned web request for one of these five reads previously ran its underlying store query to completion instead of stopping; each now threads the request's cancellation token through every store call. +- **The settings redactor no longer masks a short value whole on its first call** ([#4408]) - its patterns are warmed once at start-up, so a first-use compile cost can't count against the match time bound. +- **darling-managed.conf is rewritten only when its settings change** ([#4407]) - a change in a header display field, such as the data volume's free space crossing a GiB boundary, no longer rewrites the file or re-verifies it. +- **Stop re-holding the raw retention purge for a healthy store whose successor rollup hasn't run its first refresh yet** ([#4406]) - An upgrade with no outage was reporting the raw purge's safety gate as unsafe while a freshly-added rollup's history was still empty, even though no row was actually at risk. The gate's fallback probe now stops one refresh-window short of the current time, matching how far the rollup's own first refresh is expected to reach. +- **Carry an operator's own `postgresql.conf` lines below the `darling-managed.conf` include across a major PostgreSQL upgrade** ([#4405]) - previously only `postgresql.auto.conf` (`ALTER SYSTEM`) settings survived a major upgrade; a hand-edited line below the include stayed behind in the retained old data directory. Each carried line is now probed against the new binaries and skipped (never fatal) if rejected. +- **Web reads honour request cancellation (10 more tools)** ([#4402]) - `get_store_query_stats`, `get_store_metrics`, `get_store_log`, `get_collector_stall_probes`, `get_plan_xml`, `get_oversized_plan_backlog`, `get_fleet_overview`, `get_sweep_reports`, `get_collector_cost` and `get_pg_blocking` kept running their store query to completion after a `/api/read` client disconnected or timed out, because their dispatch entries and tool methods never threaded the request's `CancellationToken` through to the query. Each now takes the token and passes it to every store call, so an abandoned request stops promptly instead of finishing unread. +- **Fixed a raw-purge gate that could hold history forever, and a repair +- **Web reads honour request cancellation (11 more SQL Server tools)** ([#4393]) - `get_session_stats`, `get_waiting_tasks`, `get_cpu_scheduler_pressure`, `get_plan_cache_bloat`, `get_latch_stats`, `get_spinlock_stats`, `get_memory_trend`, `get_default_trace_events`, `get_running_jobs`, `get_pvs_stats`, and `get_ag_health` now take a `CancellationToken` and pass it down to every store call, so an abandoned `/api/read` request stops its query instead of running to completion. Removed all from `CancellationAllowlist`. +- **The PostgreSQL settings redactor has a bounded matching time** ([#4392]) - Each redaction pattern runs under a time bound. A value that reaches it is masked whole, and the warning names only the setting. +- **An armed raw-retention purge no longer runs when PostgreSQL starts, before the service can hold it** ([#4391]) - After a long enough outage, TimescaleDB's own scheduler could run the `query_stats`, `procedure_stats` or `query_store_stats` retention job the moment PostgreSQL came up, dropping raw history that no rollup had materialized yet. These three jobs are now never scheduled on TimescaleDB's runner. The service runs the purge itself, from its hourly evaluation only, and only after it measures coverage itself, confirms the hole repair finished cleanly since the current PostgreSQL start, and finds no hole in the range it would drop. A new **Raw Purge Over Horizon** alert says why a purge didn't run, or that the purge trigger has stopped. The first start after the upgrade still runs the old armed job once. +- **PostgreSQL web reads now honour request cancellation** ([#4390]) - `get_pg_xmin_horizon`, `get_pg_wraparound_risk`, `get_pg_session_states`, `get_pg_replication_stats`, `get_pg_predicate_stats`, `get_pg_kernel_stats`, `get_pg_io_stats`, `get_pg_index_usage`, `get_pg_database_stats` and `get_pg_autovacuum_health` ran every store call to completion even after the web caller disconnected. Each now takes a `CancellationToken` and passes it to every store call, so an abandoned request stops its query instead of running to completion. +- **PostgreSQL-target MCP reads now cancel on client disconnect** ([#4388]) - nine PostgreSQL-target read tools (`get_pg_deadlocks`, `get_pg_deadlock_detail`, `get_pg_wait_stats`, `get_pg_wait_sampling`, `get_pg_replication_slots`, `get_pg_top_queries`, `get_pg_table_bloat`, `get_pg_plans`, `get_pg_plan_capture_readiness`) ran to completion even after the requesting client disconnected. Each now takes a `CancellationToken` threaded to every store call and is dropped from the web-read cancellation allowlist. +- **Web reads now honour request cancellation for 15 more MCP tools** ([#4387]) - `get_cpu_utilization`, `get_wait_stats`, `get_wait_types`, `get_wait_trend`, `get_memory_stats`, `get_memory_clerks`, `get_file_io_stats`, `get_tempdb_trend`, `get_perfmon_stats`, `get_query_store_top`, `list_servers`, `get_collection_health`, `get_collection_log`, `get_current_waits_trend` and `get_blocking_stats` used to run their store query to completion even after the web viewer's request was aborted; each now takes a `CancellationToken` threaded to every store call, so an abandoned request stops promptly. +- **Web reads honour request cancellation for Alerts, Memory Grants and Health MCP tools** ([#4386]) - `get_alert_history`, `get_alert_settings`, `get_mute_rules`, `get_notification_routes`, `get_resource_semaphore`, `get_memory_grants`, `get_memory_pressure_events`, `get_server_summary`, `get_daily_summary` and `get_daily_summary_range` previously ran their store query to completion even after an abandoned web request; they now take a `CancellationToken` and pass it through every store call. +- **Threaded cancellation through 10 PostgreSQL-target web reads** ([#4373]) - get_pg_buffer_usage, get_pg_extensions, get_pg_lock_stats, get_pg_server_config, get_pg_server_config_changes, get_pg_write_stats, get_pg_database_trend, get_pg_io_trend, get_pg_query_duration_trend and get_pg_wait_trend ran their store queries to completion after a web request was abandoned; each tool now takes a CancellationToken and passes it to every store call, and is removed from the /api/read cancellation allowlist. +- **Web reads for object-stats and config-history now honor request cancellation** ([#4372]) - get_database_sizes, get_index_usage, get_object_locking, get_table_index_sizes, get_database_config_changes, get_database_scoped_config, get_server_config_changes and get_trace_flag_changes ran their store query to completion even after a web caller abandoned the request; all eight now take a CancellationToken threaded through every store call and are removed from the cancellation allowlist. +- **Deprecated Dashboard's XE ring-buffer collectors no longer reshred unchanged data** ([#4371]) - `install/22_collect_blocked_processes.sql` and `install/24_collect_deadlock_xml.sql` converted the whole Extended Events ring buffer to XML and shredded it on every scheduled run, even when nothing new had arrived since the last cycle. Both now read the ring buffer target's own delivered-event counter first and skip the conversion when it hasn't changed, matching the fix #4212 shipped for Darling and Lite. Applies to existing installs still running the deprecated Dashboard's SQL Agent collectors; the rows each collector stores are unchanged. A no-change collector run (median of 5, on a filled ring buffer) went from 150 ms to 35 ms for blocked-process and from 56 ms to 28 ms for deadlock. +- **Bucketed the memory-grant and TempDB usage viewer trend charts** ([#4364]) - The memory-grant overlay, Memory Grants chart, and TempDB usage chart (Darling and Lite) each returned one row per collection over a 7-day window. On a 7-day seed at each collector's cadence, the memory-grant overlay went from 10,080 to 1,008 rows, the Memory Grants chart from 20,160 to 2,016, and TempDB usage from 10,080 to 1,008. All three now bucket to the chart's point budget the same way the CPU, wait, and file-I/O trend charts already do, averaging gauges and summing true deltas per bucket, with no change to what the series measures. +- **Bucketed the blocking-trend charts' lock-wait, waiting-task, and blocked-session reads** ([#4362]) - the Blocking Trends and Current Waits charts read one row per collection at wide windows, unlike the other trend charts #4353 and #4340 already bucketed. On a 7-day seed at the 1-minute cadence, lock waits went from 20,160 to 2,016 rows, waiting tasks from 30,240 to 3,024, and blocked sessions from 20,160 to 2,016, on both products. Blocked sessions is now averaged per collection within each bucket, so its value no longer grows with the bucket width. +- **Bucketed the CPU scheduler, session stats, and plan cache trend reads** ([#4361]) - These three reads returned one row per collection with no cap, unlike the file I/O, memory, wait stats, and other trend reads #4234 already fixed. On a 7-day seed at each collector's cadence, CPU scheduler pressure went from 10,080 to 1,008 rows, and Sessions and Plan cache each from 2,016 to 1,008. All three now bucket to the same width ladder the other trend charts use, averaging each gauge per bucket and (for Session Stats) carrying forward the newest collection's application/host attribution rather than blending it. +- **Blocking and deadlock web reads now cancel with the request** ([#4203]) - the seven blocking/deadlock tools behind the web viewer's Blocking page (blocked process XML, blocking, blocking trend, deadlock detail, deadlock trend, deadlocks, lock wait trend) kept running their store queries after a browser navigated away or a request was abandoned. Each now takes a cancellation token and passes it through every store call, so an abandoned request actually stops. +- **Health Parser web reads now cancel with the browser request** ([#4359]) - the nine `get_health_parser_*` `/api/read` handlers ran their Postgres queries to completion even after the browser tab closed or the request was aborted; they now thread `RequestAborted` through every store call so an abandoned read stops promptly. +- **Four Performance-Trends web reads now stop their store query when the request is abandoned** ([#4357]) - `get_query_trend`, `get_query_duration_trend`, `get_procedure_duration_trend` and `get_query_store_duration_trend` used to keep running their store query after a web caller gave up or navigated away; they now observe the request's cancellation all the way down to Npgsql. +- **A slow first-run database create no longer fails Darling's Postgres bootstrap** ([#4352]) - The managed store's first-run `CREATE DATABASE` was retried up to 6 times inside the same 10 second window used for the post-start connection probe. Because a timed-out `CREATE DATABASE` is cancelled and rolled back, every retry re-copied the template database from scratch under the same 10 second budget, so a copy that took longer than 10 seconds failed outright no matter how many retries ran. The create now runs once, on a 60 second budget, outside that retry. +- **Passwords and other secrets in stored PostgreSQL settings are now redacted** ([#4351]) - The config collector stored `pg_settings` and per-database/per-role override values verbatim, including secrets a `pg_monitor`-only monitoring role can read but should not retain in plain text, such as a standby's `primary_conninfo` replication password or a backup tool's key/token in `archive_command`/`restore_command`; new collections now mask the secret, and existing stored rows are scrubbed in place, in batches, and the scrub completes at any settings cadence; a target that fails is retried on the next start. Non-secret password-policy settings (`rds.accepted_password_auth_method`, `rds.restrict_password_commands`, `passwordcheck.min_password_length`) are no longer masked. "Keep the rest of the value" is not true for every case: `ssl_passphrase_command` and a dotted extension setting naming a secret are masked whole. Rotate any password or key that was ever stored this way: the scrub changes the store's current rows only, not copies made before it ran. Upgrade every service that writes to a store - a service still on an old build keeps storing plaintext after the scrub's marker is set, and nothing re-runs it. +- **Eight Queries-tab reads in the web viewer stop their store query when you leave the page** ([#4350]) - get_active_queries, get_plan_corrections, get_query_heatmap, get_query_store_clutter, get_top_queries_by_cpu, get_top_procedures_by_cpu, get_query_store_regressions and get_long_query_completions used to run their store query to the end after the browser gave up on the request. They now stop when the request is abandoned. The tab's duration trends and Query Store top list still run to the end; later PRs convert them. +- **Configuration-tab reads in the web viewer stop their store query when you leave the page** ([#4347]) - Leaving the Configuration tab, or an audit_config read, before it finished left its store query running to the end for a caller who was gone. Those six reads now cancel when the browser abandons the request. The viewer's other reads still run to the end; follow-up PRs convert them. +- **PostgreSQL `pending_restart` can now be trusted after a reload, on Windows targets** ([#4345]) - `pg_settings.pending_restart` is backend-local, so on Windows, where the collector's reconnect-every-cycle model always sees a brand new backend, a setting that had actually been changed and reloaded but still needed a restart could read `false` forever. Unix targets never had this gap: there, the postmaster itself applies the reload and every backend it forks inherits the flag, so `pg_settings` alone was already correct. The collector now also checks `pg_file_settings` on Windows targets, which is read from the file rather than a connection's own state, when the monitoring role can read it (two grants: `SELECT` on the view and `EXECUTE` on `pg_show_all_file_settings()`). `get_pg_server_config` and `get_pg_logging_audit` note when a Windows target's role cannot read it, and say what the two grants expose, so an operator can weigh the trade before granting them; a non-Windows target is untouched and never asked to widen its role for this. +- **Heal the Postgres v8 hardware-sizing block on stores resized before the #4225 fix shipped** ([#4342]) - A managed store whose hardware had not changed since its last hardware-sizing rewrite never re-triggered the heal, so a store that already carried duplicate sizing blocks, or a block written before `work_mem` rejoined the formula, stayed on stale settings even after upgrading past the earlier fix. The heal now also runs when the conf carries more than one sizing block, or when the newest block's content no longer matches what the current build would write. +- **Fleet Sweeps reports an error instead of "no sweeps" when its store read fails** ([#4328]) - A failed read for the sweep timeline, a sweep's verdicts, its would-have-paged ledger, or the watch-item worklist used to log the failure and silently answer an empty list, so the web page showed its normal "No sweeps in this span" empty state and the `get_sweep_reports` MCP tool answered an empty or silently incomplete document instead of reporting that the read failed. Both surfaces now answer the failure: the web page shows its error strip, and the tool answers its usual error status. +- **Lite Overview baseline bands used the wrong hour under a custom time range on a server not on UTC** +- **Dashboard query comparison grids and Server Trends baseline bands now use the server's local time** ([#4321]) - Under a preset time range (not a custom one), the Query Stats, Proc Stats and Query Store "Compare to" grids, and the Server Trends baseline bands, built their current time window from the Dashboard machine's clock in UTC instead of the monitored SQL Server's own local time. On a server not running in UTC, this shifted the comparison grids' "current" window and picked the wrong hour-of-day/day-of-week baseline bucket, by the server's UTC offset. Fixed to use the server's local time, matching the Server Trends ghost-line fix in [#4317]. +- **`get_collection_health`'s default reply now fits the MCP response budget** ([#4319]) - A collector row that +- **Dashboard Overview ghost line reads the right hours outside UTC** ([#4317]) - Under a preset time range, the +- **The Query Store activity slicer reads less history on each refresh** ([#4311]) - The slicer read one extra day of Query Store history below its window, as a margin for clock skew. The margin is now one hour. For the last 24 hours, it now reads 25 hours of history instead of 48. +- **Lite's Overview ghost line reads the right hours outside UTC** ([#4309]) - Under a preset time range, +- **Availability Groups tab no longer freezes the UI every 30 seconds** ([#4308]) - The Darling viewer's and Lite's Availability Groups tabs rebuilt every card and every per-database grid from scratch on every refresh. In the Darling viewer, that blocked the UI thread for over 2.5 seconds on a 42-AG fleet, even when nothing had changed. Refreshes now update existing cards in place, skip entirely when the data has not changed, and only render the cards that are actually on screen. +- **The Daily Summary calendar and `get_daily_summary_range` cache closed days for an hour** ([#4307]) - The WPF Daily Summary calendar (every 1-minute refresh) and `get_daily_summary_range` (the web Overview tab and MCP clients) recomputed every day in the displayed range on every poll, even though days before today do not change. A refresh now recomputes only today (and briefly yesterday, for a late collector run) and reuses the rest from a one-hour cache. A row that lands late for a closed day -- an outage catch-up, a backfill -- can take up to an hour to show, where it showed immediately before; an explicit `as_of` timestamp still always reads live. The cache holds at most 1,024 ranges, and drops entries older than an hour the next time it computes a range. +- **Query Store backfill's candidate check no longer reads old compressed chunks, and no longer drops a hole on a database that goes quiet** ([#4306]) - The backfill's candidate-database scan read across all of raw retention on every check, which decompressed chunks outside the backfill window: measured at 206 ms and over 21,000 buffers per check on a heavy server. It is now bounded at the backfill's own horizon (1.7 ms and 792 buffers in the design measurement). The per-database floor lookup now stops at the first row at or before that horizon instead of taking the minimum over every row. A database that stopped sending Query Store data while a repair "hole" was still open for it used to age out of the backfill scan and never get serviced. It now stays in scope until the hole is filled or expires. Both Lite and the Darling service get the change. +- **The Darling viewer's Wait Stats and Perfmon trend charts read time buckets, not every collection** ([#4304]) - Both charts read every collection in the window on each refresh: for 20 wait types over 7 days at a 1-minute cadence, that was about 170,000 rows. They now read buckets sized to the chart's point budget, which cut the rows returned about tenfold for a 7-day window in the measurement. A bucket's rate is its summed wait (or counter delta) over its summed collection interval. When the budget covers every collection, the chart still gets each raw point at its own timestamp. The wait-type and counter pickers ran a full-window DISTINCT on every 1-minute refresh; they now reuse the list for up to 15 minutes for the same server and window. +- **The Darling viewer's Active Queries grid and wait drill-down no longer load every snapshot's plan XML up front** ([#4303]) - +- **Lite's Queries-tab comparisons use the grid's time window** ([#4302]) - On a server not on UTC, the "Compare to" baseline on the Queries tab read a window shifted by the server's offset. That covers the Top Queries, Top Procedures and Query Store grids. It happened under a custom date range or after a slicer drag. Comparisons now read the same UTC window as the grid beside them. One behavior changes on purpose. After a slicer drag, the baseline is the dragged window shifted back by a day or a week, not the whole preset range. +- **Active Queries and wait drill-down no longer load every plan's XML just to show the grid** ([#4297]) - +- **The query heatmap loads much faster on large windows** ([#4295]) - The heatmap read resolved the query text of every row in the window, then kept one row per cell. Now it resolves the preview text only for the row that each cell shows. The cells, counts, top queries and preview text do not change. On a seeded window of 180,000 rows over 24 hours, the read went from 2,035 ms to 242 ms. +- **Less write-ahead log from the query, procedure and Query Store history tables** ([#4294]) - Five indexes on these tables wrote close to a quarter of the store's write-ahead log. They were read only a few times in several days. They are now dropped. Each feature that read them was timed without its index and stays well within its time limit. +- **Web viewer no longer shows raw error text for failed requests** ([#4293]) - Several pages and API routes answered a failed request with the underlying exception's own text, which could include a PostgreSQL SQLSTATE and message or a store's host and port: saving or deleting a Custom View, an alert rule or a mute rule (including turning a mute rule on or off), running a Custom View panel, the two fleet-sweep reads, a server lookup that could not read the server registry, and the triage page's notes and per-section cards. These now answer a fixed, generic message; the real text still goes to the service log so an operator can see what failed. A statement timeout now answers with a "took too long" message and the right status code in each of these places, matching what other reads already did. The one exception is a Custom View panel's own query error (a syntax error, a missing column, a bad value, or its own statement timeout), which still shows the database's message so the author can fix the panel. +- **Empty legacy baseline aggregates now drop instead of staying forever** ([#4292]) - On a store where nothing ever fed the old `perfmon_baseline` or `wait_stats_baseline` aggregate, both it and its replacement stayed empty. The empty replacement has no oldest bucket, so the old aggregate's cleanup rule never passed. Now an old aggregate that holds no rows drops on the next start, with its refresh, retention and compression jobs. +- **CPU and I/O-latency baselines recompute once a day, not every hour** ([#4291]) - Darling and Lite recomputed these two anomaly baselines every hour. Each time, they scanned 30 days of raw rows. The I/O-latency scan alone spilled about 50 MB to temp. They now recompute once per UTC day, and their 30-day window ends at midnight UTC. A 30-day baseline barely moves within a day. A failed compute still retries within the hour. +- **Fewer needless writes to the Darling store's plan and text tables** ([#4288]) - A plan or text seen again within the hour still cost a row lock and a WAL record. PostgreSQL locks the row before it checks the freshness rule. On production stores, that was 12 to 23 percent of all WAL. The upsert now skips a fresh row before it takes any lock. Separately, the touch that keeps Query Store plan and text rows from expiring re-stamped each row every 6 hours. It now waits 12 hours, which halves those writes. Rows are kept just as long as before. +- **Managed store: less WAL, from compressed full-page images** ([#4287]) - Most of a managed store's WAL was full-page images, written without compression. Every managed store now sets `wal_compression = lz4` on its next service start. In a test burst, that cut WAL by about a quarter. A longer checkpoint interval cuts WAL further, but it can slow checkpoint syncs past the store's own alert bar. So it waits for a production measurement. Bring-your-own PostgreSQL stores do not change. +- **Web failure handling: log batches, bad requests and error text** ([#4286]) - A route cut inside a character made Darling's service log drop its whole 5-second batch. The viewer's, Lite's and the Dashboard's log files had the same bug for any text with a broken character. A malformed or oversized request, or a client that dropped the connection, cost a 500 and an Error line. It now gets its own status and no Error line. A line break in exception text started what looked like a second entry in the service log. Each line is now cleaned before it is written. The read dispatcher and the fleet sweep reads answered some failures with raw exception text, such as a connection error that names the store's host. They now answer with a fixed message and log the detail. Darling's web and MCP hosts now always run as Production, so a stray Development setting on the machine cannot turn on the developer error page. +- **Time-based reads no longer shift on a store outside UTC** ([#4285]) - Every timestamp in the Darling store holds UTC, but a bring-your-own store keeps the session time zone its owner set. Reads that compare those timestamps with the current time shifted by the zone's offset. Their window was wider or narrower than asked, with no error. Every store connection that the service, the CLI and the desktop viewer open now sets its session time zone to UTC. Managed stores already set UTC in their `postgresql.conf`. The service and the viewer also keep a connection-string setting that has an empty value, such as `Password=''`, when they add their own settings. Before, they dropped it, and Npgsql then used the `PGPASSWORD` environment variable or a password file if either one was there. +- **Web viewer timeouts now show a message and get logged** ([#4281]) - A read that ran past the store's timeout used to show a blank error. The service log had nothing, so a timeout looked the same as a bug. Now the page says "The store took too long to answer this read. Try again in a moment." Other failures show a short generic message. For both, the service log records the route, how long the read ran and what kind of failure it was. +- **A major store upgrade keeps your ALTER SYSTEM settings** ([#4280]) - A major PostgreSQL upgrade of the managed store used to drop every `ALTER SYSTEM` setting. A raised `shared_buffers`, for example, went back to the default with no warning. The upgrade now checks each setting against the new version, test-starts the new store with the settings it accepts, and keeps them if that start works. A setting the new version rejects is left out with a warning that names it. If the test start fails, the store starts on its defaults instead, and a warning names each setting it dropped. The logs name settings but never show their values. The original file is kept as `postgresql.auto.conf.pre-upgrade` next to the data directory, so a dropped setting can be re-applied by hand. +- **Lite says when a query window was cut short** ([#4279]) - Three MCP tools read raw tables with no rollup fallback: `get_top_queries_by_cpu`, `get_top_procedures_by_cpu` and `get_query_store_top`. Lite keeps those tables 30 days by default, and a user can lower that per collector. So a long window was read from much less history, with nothing to say so. Each tool now returns `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note` when the window was cut short. The three grids show "Showing since" and the effective start above the grid in the same case, after a time-range change or a slicer drag. On Lite and Darling alike, each tool's short description now explains `window_truncated`. The false line that said Lite always reads the full window is gone. +- **Top-CPU reads disclose a short window** ([#4278]) - Two MCP tools read raw tables that the store purges at 4 days with the rollups on. They are `get_top_queries_by_cpu` and `get_top_procedures_by_cpu`. A longer window came back short, and `hours_back` came back unchanged. Both tools now return `effective_start`, `effective_hours_back` and `window_truncated`, plus a `truncation_note`, like `get_query_store_top`. The desktop viewer's Top Queries, Top Procedures and Query Store grids show "Showing since" and the effective start in the same case. The web viewer shows the same note on those panels. On the hourly tier, `window_truncated` and `effective_start` come from a per-server check of where the rollup starts. When the window ends past the rollup's materialization ceiling, the note says nothing after it was read, or that the end edge is not verified when the ceiling is unknown. +- **`get_query_store_top` stays under the MCP response-size budget** ([#4198]): The default call returned about 48 KB, over the 32 KB limit some MCP clients enforce. `query_text` is now a 400-character preview by default. A new `full_text` argument returns the whole statement. A new `query_text_truncated` flag on each row says whether the text was cut. The web viewer is unchanged and still shows up to 2,000 characters. +- **`describe_custom_view_catalog` stays under the MCP response budget** ([#4198]): The Custom Views compose catalog returned 98 KB by default, three times the budget. It now returns a compact, source-grouped list by default (name, purpose, aggregate/unit vocabulary only). A new `source` argument drills into one source's full detail. A new `full_detail` argument returns the complete catalog as before. The web Custom Views editor is unaffected: it reads the full catalog through its own endpoint. +- **MCP `get_collection_health` caps its response size** ([#4198]): A default call on a busy SQL Server fleet reached 41,669 bytes, over the 32 KB limit. Healthy collectors with nothing to report now compact to a shorter row by default. Any failing, stale, stopped, erroring, denied, or regressed collector keeps every field. A new `full_detail` argument restores every field on request. The web dashboard and Custom Views are unaffected. +- **MCP `get_blocking` (Darling) and `get_blocked_process_reports` (Lite) cap their response size** ([#4198]): A default call measured 89,096 bytes on a 30-row test seed, over the 32 KB limit. The default row limit drops from 30 to 15. The blocked and blocking SQL text come back as a 150-character preview instead of a 2,000-character cut, and each has its own `*_truncated` flag. A new `full_text` option returns both texts whole. On Darling, a call with `dedup_key` names one incident, so it always gets the whole text. The web viewer's Blocking table and Custom Views keep 30 rows and the 2,000-character text. +- **MCP get_collection_log stays under the response-size budget by default** ([#4198]) - +- **`get_query_store_regressions` default calls stayed under the MCP response budget** ([#4198]). The +- **get_pg_io_trend's default call now fits the MCP response budget** ([#4263]): The default 24-hour call +- **`get_active_queries` stays under its response-size budget by default** ([#4261]) - A default call on a busy server returned well over the 32 KB target. The number of fields per row and an uncapped query text preview were the cause. The default page size is now 25 rows (was 50). Query text now previews to 500 characters with a `query_text_truncated` flag. A new `full_text` argument opts back into the whole text. The web viewer's Active Queries tab keeps its pre-existing 2,000-character preview. +- **get_index_usage's default answer now fits the response budget** ([#4260]) - A default call, with no `limit` argument, always returned up to 200 rows regardless of width. That measured over 69 KB on a busy server, large enough for an MCP client to refuse it outright. The default `limit` is now 75 on both Darling and Lite. An explicit `limit` still returns exactly what was asked for. +- **`get_query_heatmap` default call stays under the MCP response budget** ([#4259]): A default call returned +- **`get_object_locking` default response stays under the MCP budget** ([#4258]): Before this fix, the tool returned up to 200 locking rows with no row limit. On a busy server it pushed 71 KB, and some MCP clients refused the response. It now returns 75 rows by default, highest contention first. It reports `truncated`/`objects_returned` when there are more. Pass `limit` for more rows, up to 1000. +- **`get_plan_corrections` default call stays under the MCP response budget** ([#4198]): A default call returned nearly 100 KB on a busy server. Each row carries 20+ fields and the query text ran to 2,000 characters. The text preview is now 150 characters. Each row gets a `query_text_truncated` flag and a `full_text` opt-in. The default row limit dropped from 50 to 25. +- **Job History loads faster and stops polling every 30 seconds** ([#4256]): The tab used a window function +- **Availability Group reads: bounded the newest-snapshot lookup** ([#4228]). All five AG reads used an +- **`get_deadlock_detail` no longer returns oversized deadlock graphs by default** ([#4254]) - The tool's `deadlock_graph_xml` field could push a default call past 100 KB, because each graph runs tens of kilobytes and the tool did not cap that field's size. It now previews each graph to 2000 characters by default and marks it `deadlock_graph_xml_truncated: true`. A new `full_graph` argument returns the whole graph. A `dedup_key` call, naming one incident, always returns it in full. +- **Database Sizes and Storage Growth load without a multi-chunk planning tax** ([#4252]): The latest snapshot reads had no bound on collection time. PostgreSQL had to plan a step for every retained chunk before running each read. Each read now resolves the snapshot timestamp in a separate step first. The main read then skips chunks it does not need. Clock skew between reader and collector does not drop the latest snapshot. +- **Alert triage links now skip only a disabled dashboard, and email carries one too** ([#4230]) - the per-alert triage-page link (`web.publicBaseUrl`) used to go out even when the dashboard was off, and the web host rejected every request naming the DNS host that setting suggested using. The link is now omitted only when the dashboard is disabled. The web host accepts that configured host. Alert email now carries the same link the other channels already did, in both the HTML and plain-text bodies. +- **PLAN_REGRESSION no longer deduplicates the whole raw Query Store slice every pass** ([#4208]). On a store ingesting many servers' Query Store data, the plan-regression check was the single heaviest statement in the store. It spent most of its time sorting and spilling the server's entire raw Query Store history to temp files. This adds store schema rung V143, the `collect.query_store_interval_latest` table, holding only each interval's latest snapshot. The check now reads that table and falls back to the old full read only when coverage is incomplete for a server. Findings are unchanged: the same regressions, the same snapshots. +- **Force-plan bot no longer acts on a best plan older than 4 days** ([#4208]). The unattended force-plan bot now gates on `ForcePlanBotPolicy.MaxBestPlanAgeDays` = 4. A target whose best plan has not been seen in more than 4 days is blocked with reason `best_plan_stale`. This prevents a force on a plan the server evicted. The gate value is pinned by `ForcePlanBotPolicyTests`. +- **`audit_config` no longer runs the full analysis pass** ([#4206]). It read a full ~30-family collection, detector and scorer pass just to answer 8 point-in-time configuration facts, measured at 7-15 seconds per call. It now runs only the specific family reads those 8 facts come from. The facts and recommendations returned are unchanged. +- **`get_query_store_regressions`' comparison baseline is now a fixed 7 days** ([#4206]). The baseline used to be every Query Store capture the store retained before the requested window. Both cost and the comparison period grew with retention. It is now a fixed 7-day lookback ending at the window's start, reported as `baseline_start` and `baseline_end` in the response. A regression against something that changed more than 7 days before the window is no longer caught. A store retaining less than 7 days is unaffected. Performance Monitor Lite's own copy of this same tool had the same unbounded baseline and is fixed the same way. +- **`get_pg_cpu_utilization` now returns bucketed points instead of one row per minute** ([#4206]). A wide window (a week, or longer with the V136 host-memory columns) returned several megabytes per call. It now buckets to a point budget the same way the rest of the trend family does. It averages CPU/ACU per bucket while keeping each bucket's peak. The worst (not average) memory-pressure sample per bucket is kept, so a brief spike is not smoothed away. +- **The desktop viewer's Query Store Regressions grid had the same unbounded-baseline shape as `get_query_store_regressions` and is now bounded the same way** ([#4206]). It was a third, separate copy of the defect, in the WPF app rather than the MCP surface, with its own 7-day fixed lookback. +- **The deadlock and plan-capture log patterns only offer a report whose ERROR: is the line's own label** ([#4042]) - A crafted SQL statement that echoed "ERROR: deadlock detected" plus a tab-continued DETAIL line matched the deadlock pattern through to the line's real process-id bracket. Measured end to end this forgery stored nothing, because the log assembler already takes a report's label from the line it actually came from, and new tests pin that for both the SQL and C# copies of the pattern. Both copies are narrowed anyway, matching the rule behind them exactly: the gap before ERROR: and DETAIL: can no longer cross another field's label, and the managed log-prefix family's gap to the process-id bracket can no longer slide past the real bracket into a statement's text (the same fix #4016 made for plan capture). Fewer forged lines are offered as candidates at all. +- **Plan capture keeps working under a custom log prefix with fields before the process id** ([#4016]) - Plan capture required exactly one token between the timestamp and the process-id bracket in log_line_prefix. A self-hosted prefix with more than one field there (for example '%m %u@%d [%p] %Q ') matched nothing, so those stores silently stopped capturing plans. The gap before the process id now allows any number of fields, as long as none of them is itself a bracket, so a forged log line behind the real bracket still cannot be read as a plan. +- **Trace flag reads no longer hide every enabled flag after an ordinary run** ([#4032]) - get_trace_flags, the web viewer's Trace Flags grid, and Lite's equivalent compared the newest captured row's timestamp against the newest successful run's timestamp, but Darling stamps a run's collection-log row when the run ENDS, after its capture rows are written - so that comparison read false after every ordinary run and hid every enabled flag. All three reads now keep the newest capture unless the newest successful run explicitly captured zero rows (which means every flag is off); a failed run, or one with no row count, keeps the reading from before this fix. +- **The fleet card's collection-health figures no longer reread a week of raw log rows on every call** ([#3911]) - The seven-day fleet-wide collection-health read decompressed six of its seven days of collection_log on every call. It now reads from a new hourly rollup instead, cutting the read down to the buckets it needs. The fleet card's numbers are unchanged; only how they are produced is faster. +- **The per-server collection-health summary stops leaking memory and stops going stale on a fleet with more than one active caller** ([#3900]) - The health memo keyed its cache on the window's start time, which two calls a few seconds apart would each compute freshly, so the cache never hit in production and grew without bound as more distinct start times accumulated. It now keys on the window's length, so calls asking the same question in different moments share one cached answer and old entries age out. +- **A collector that produced then stopped no longer reads healthy with zero rows** ([#3889]) - Collection health banding keyed a regressed collector's WARNING floor on the collector's STATUS word rather than on whether it was actually producing output, so a collector whose query still ran and still returned SUCCESS - just with zero rows, after previously producing rows - kept reading HEALTHY indefinitely. On one production server this hid a stopped collector for up to two weeks and over 1,900 consecutive zero-row successes. Banding now also watches for a productive collector's output falling to zero for three or more consecutive runs, and reports it as regressed. A collector whose normal resting state is zero rows (an event capture with nothing to report) is unaffected. +- **job_history collection survives an msdb reseed** ([#3886]) - The collector deduped job-history rows against a stored high-water mark taken from the target's job-history identity column. A maintenance window that purges msdb's job history also resets that identity to a lower value, so the stored watermark (in the millions) outlived the identity it was taken from (back in the thousands), and the collector's filter matched nothing from then on - forever, on that server, with no error. The watermark now yields to a bounded time window whenever the target's current identity max falls below the stored watermark, the regression is logged once, and job history collection self-heals on its next run without intervention. +- **The compression-stuck self-alert no longer pages on a healthy job's own run instant** ([#3588]) - TimescaleDB's job_stats view assembles job_status from pg_stat_activity and next_start from the background-worker job-stat row, so for a moment at both edges of every healthy run one read sees the same shape as a genuinely dead job (next_start = -infinity while the schedule still reads Scheduled). A production store paged on exactly that, 53 ms into a 63 ms run that went on to succeed. The check now re-reads five seconds after a -infinity trip and only reports the job if the trip still holds; a failed confirmation defers judgement to the next hourly check rather than paging. The hourly check itself is now snapped to :30 past the minute instead of drifting a few seconds later each time, keeping it off the fixed-schedule policies' own :00 run instants. +- **pg_deadlocks reads a self-hosted target's csvlog file, closing the same forged-line hole #4124 closed for pg_log_events** ([#4136]) - pg_deadlocks only read stderr-format log text. A target with csvlog but not stderr in log_destination produced no deadlock rows at all. A target with both was open to the same forged-line risk #4124 describes for pg_log_events. A failed login can plant a newline into a logged name. Unquoted stderr text turns that newline into a fake extra line. pg_deadlocks now parses the target's own .csv file as CSV when log_destination includes csvlog, the same forger-safe, whole-record join #4124 built. A planted newline now stays inside its own quoted field instead of becoming a fake deadlock. This change leaves pg_log_events and plan capture as they were. #4137 covers plan capture. +- **pg_plan_capture reads a self-hosted target's csvlog file** ([#4137]) - pg_plan_capture only read auto_explain plans from stderr-format log text. A self-hosted target with csvlog but not stderr in log_destination captured no plans. pg_plan_capture now reads the target's own .csv file when log_destination includes csvlog, through the same whole-record CSV parser #4124 built. It takes the query id from csvlog's own query_id column. The stderr route is unchanged. +- **Darling's daily retention purge no longer holds up collection** ([#4133]) - The purge ran inside the loop that starts each server's collection, and the loop waited for it to finish. A slow purge, 346 to 400 seconds on a large store, stalled collection for every server for that long. The purge now runs in the background, and a new purge never starts while one is still running. +- **Lite's get_index_usage no longer hides active indexes behind a silent cap** ([#4131]) - This MCP tool capped at 200 rows server-wide, with no way to ask about one database, no way to raise the cap, and no sign when rows were cut. Since unused indexes always sort first, a server with many unused indexes in one database could fill the whole answer with them, hiding every active index elsewhere, with a result that looked identical to a collection failure. It now takes a database_name filter and a limit, and reports matching_index_count and truncated so a short answer is never mistaken for an empty one. Darling's twin tool has worked this way since #2636. On Lite, Darling and the Dashboard, indexes of the same size now sort by name, so a capped answer keeps the same rows from one call to the next. An index with no recorded size, and a heap's missing index name, now sort last on all three products; Darling used to put an index with no size first. +- **pg_log_events reads a self-hosted target's csvlog file, closing a forged-line hole** ([#4124]) - Before this change, pg_log_events only read stderr-format log text. A target with csvlog but not stderr in log_destination produced no log events at all. A target with both was open to a forged line. A failed login plants a newline into a logged user or database name before authentication runs. Stderr text has no quoting, so the planted newline becomes a second, fake log line. pg_log_events now parses the target's own .csv file as CSV when log_destination includes csvlog. A planted newline inside a quoted field stays inside that field, never becoming an event of its own. Deadlocks, plan capture and the RDS route are unchanged. +- **Two install-lock tests pass on a non-elevated machine** ([#4111]) - After #4090, two `DarlingInstallLocationTests` tests failed on every non-elevated local run. There the lock cannot create `pg-runtime-prev\`, as designed, and the tests read that directory's ACL anyway. The tests now check the elevated and the non-elevated outcome separately. The elevated checks that CI runs are unchanged, and no product behavior changed. +- **MCP tool schemas no longer list an internal service as a parameter** ([#4110]) - A race in .NET reflection sometimes put a service the app supplies itself, such as the PostgreSQL connection, into tools/list as a tool parameter. It happened when two threads built the same tool's schema at once. Tool schemas now leave out every parameter whose type is a registered service. +- **Log reads through pg_read_binary_file now decode text in the database's own encoding** ([#4106]) - This route used to decode every PostgreSQL log tail as UTF-8. It now uses the connected database's server_encoding: every LATIN and ISO_8859 variant, WIN866, WIN874, WIN1250 to WIN1258, KOI8R, KOI8U, EUC_JP, EUC_CN, EUC_KR, UTF8 and SQL_ASCII. A database in one of those encodings no longer has to fall back to the text route, where one bad byte can stop the read. +- **Store Checkpointer Pressure no longer fires all the time on a healthy store** ([#4096]) - The alert compared the checkpoint sync time summed over the whole interval against a limit meant for one checkpoint. A store whose checkpoints each took a few seconds to sync breached it every hour. It now judges the average sync time per checkpoint, and a checkpoint forced by WAL volume still fires it. The alert and get_store_metrics now report the checkpoint count and the average. This adds store schema rung V140, the checkpoints_timed column on store_metrics. +- **A planted line in a PostgreSQL server's log can no longer stop plan capture** ([#4089]) - A client that fails to log in with a crafted name can put text into a PostgreSQL target's server log. A fake plan-capture line with an out-of-range query id or duration used to fail the whole read. That hid every real plan in the log tail. Darling now skips that line, counts it (forged_captures_skipped), and reads the real plans. On the pg_read_binary_file route, the deadlock and plan-capture readers also skip their pattern search when the tail holds no line they look for. +- **A Lite Query Store test that never ran now runs** ([#4084]) - The test that checks that the module filter runs after interval dedup had no [Fact] attribute, so xUnit never ran it. It now runs and passes. No product behavior changed. +- **A PostgreSQL log in a non-UTC zone no longer reports a deadlock problem on the log events collector** ([#4070]) - When log_timezone is not UTC, the log events and deadlock collectors store nothing from the server log and record why. That message said "deadlock reports" and "NOT 'no deadlocks were detected'" on both collectors. It now names the log, says that the log is not empty, and still tells you to set log_timezone = 'UTC'. +- **The install and upgrade scripts name each account once in a refusal** ([#4069]) - A folder made under `C:\` inherits two entries for `BUILTIN\Users`. One allows appending data, and one allows writing it. The [#4050] refusal listed `BUILTIN\Users` twice for the same folder. It now lists each group or account once for each folder. +- **One bad byte from a failed login no longer blinds the three PostgreSQL log readers, and RDS and Aurora targets get the time-zone fix too** ([#4051]) - A client that fails to log in with a crafted role or database name plants one invalid character in the server log. That character used to stop deadlock capture, plan capture and log-event collection from reading the server log until it aged out. Grant the monitoring role EXECUTE on `pg_read_binary_file`. Then, on a UTF8 or SQL_ASCII database, Darling reads the log in a way that tolerates the bad character. On other encodings, the error message says that the grant does not help there. While that grant is missing, Darling reminds you once a day. RDS and Aurora targets whose `log_timezone` is UTC now skip a planted line that is stamped in another zone, instead of refusing the whole read. Self-hosted targets already did this. +- **Darling's install and upgrade scripts refuse a folder that ordinary users can already write to** ([#4050]) - When you extract the zip into a folder made directly under `C:\`, the folder inherits write access for every signed-in user. The #4038 lock stops writes only from the moment that it runs, so it could never catch a binary that was swapped before then. `install-darling.ps1` and `upgrade-darling.ps1` now check every file in the tree, and the existing install, before they change anything. They name who can write to the tree, and each folder that they cannot look inside. Then they refuse, unless you pass `-AcceptWritableExtraction` for a deliberate dev loop. An upgrade copies its zip to an administrators-only folder and verifies the zip there before it extracts anything. Every doc and message now names `C:\Program Files\PerformanceMonitorDarling` as the install folder. This includes the refusal for a folder inside a user profile, which used to send people to a folder that this check refuses. +- **A planted log line in another time zone no longer stops a PostgreSQL server's log events and deadlocks from being read** ([#4049]) - Before this fix, one line stamped in a zone other than UTC anywhere in the log tail made Darling refuse every log-event and deadlock read of that server, for as long as the line stayed in the window. Any client that can reach the port can put such a line there with one failed login, because %u and %d in log_line_prefix echo the requested role and database names unescaped. Now the self-hosted readers check the server's own log_timezone in the same query. When it is UTC, a line in another zone cannot be the server's own: it is skipped and counted on the collection log row, with a note naming log_timezone and #4046, and the read goes on. A server whose log_timezone really is another zone is still refused, as before. RDS and Aurora read the log through the AWS API, cannot check the setting, and are unchanged. Plan capture never read the zone and was not affected. A failed login whose role name carries a byte that is not valid UTF-8 still makes the server's pg_read_file fail for the whole window, under any prefix. [#4051] in this release covers that when the monitoring role has EXECUTE on `pg_read_binary_file`. +- **PostgreSQL servers whose log prefix puts fields before the pid now show their log events and deadlocks, and a client's port is no longer stored as an event's SQLSTATE** ([#4047]) - Under a log_line_prefix such as '%m %u@%d [%p] ', the log reader matched no line, so the server stored no log events and no deadlocks and looked quiet. It now reads fields between the zone and the pid, and it still takes the pid from the first bracket and the label from the line itself, so text inside a statement cannot open an event. The self-hosted deadlock read also stopped missing reports under '%t' prefixes (pgBadger's recommended one) and colon-delimited prefixes. Under any prefix with %r, the RDS default among them, the client's five-digit port was read as the event's SQLSTATE, often one in the resource or system-error classes. Now the port inside %r is ignored. A bare five-digit %l, %x or %v in the prefix can still be read as a SQLSTATE. Telling those apart from %e needs the target's own log_line_prefix. +- **On Windows the log-hash key is refused if anyone beyond SYSTEM, Administrators and the service account holds any right to it, and it is checked and read through one held file handle** ([#4044]) - The key was trusted through the check it shares with the credential files. That check refuses only a file Users, Authenticated Users or Everyone can read, so INTERACTIVE, Domain Users or a single named user with read access passed it, and so did an account that could write the key or change its permissions. That account could plant a key of its own or grant itself the read, and then test guesses against the stored log hashes. The key is now held to an allowlist of the three accounts the service writes, for every right. It is opened once in a way nobody else can rename, replace or write while it is open, and it is refused if it is a link or has a second name. Its owner and permissions are checked through that same handle, and the read is capped at 1 KB. When a key is refused, log events stop being collected and the refusal names the accounts to remove. +- **A PostgreSQL server that logs only to CSV is reported by name instead of looking quiet** ([#4040]) - With log_destination set to csvlog, PostgreSQL still leaves a small stale stderr-format file in its log directory, and the plan, deadlock and log-event collectors read that file every cycle and reported a server with nothing to say. They now check log_destination itself and report that it has no stderr output, with the one-line fix (add stderr and reload, no restart needed). +- **Install and upgrade lock the Darling install folder, so an ordinary local user can no longer replace the service's binaries** ([#4038]) - The documented install location, a folder made directly under C:\, inherits write access for ordinary local users from the drive root. On Windows client editions that is Modify for every authenticated user, so any local user could replace the service exe, a DLL, or the bundled postgres.exe and have their code run as the service account. install-darling.ps1 now locks the folder before anything runs from it: it stops the folder inheriting, removes the broad groups, makes Administrators the owner, closes any write grant a user left on a file of their own, and grants back read and execute to Users and Modify to the service account only. upgrade-darling.ps1 applies the same lock as soon as the service stops, so an existing install is closed at its next upgrade, and anything that stays open is named with the command that fixes it. +- **The hourly re-mask of PostgreSQL deadlock data stored before #4005 now runs without a log-hash key, covers finding alerts, and never leaves a raw report hash behind** ([#4036]) - a service with no usable log-hash key (an untrusted key directory or ACL, an unreadable key file, or DPAPI after the service moved machines) skipped the whole re-mask, so raw SQL literals stayed in deadlock reports, alerts and findings for their full retention. Now everything is re-masked and only re-keying an alert whose report is gone waits for a key. Analysis finding alerts sent before #4005 kept a raw report hash and the raw victim statement in their stored detail, which the Viewer's alert detail showed. They are rewritten from the finding, or withheld once the finding is gone. A finding whose deadlock fact sits behind its root is rewritten too. An alert missed by the pass is keyed rather than keeping its raw hash, a stage that gives up is retried a day later instead of waiting for a restart, a page cut short by the hourly budget, or a row moved by a dismissal or VACUUM FULL, can no longer end a walk early with a row still raw, and with a log-hash key no raw report hash is sent to the store as a query parameter, where log_min_duration_statement would copy it into the store's own log. An alert is never cut from its report by the order the pass rewrites them in, and a finding alert is rewritten only from the analysis run it was sent for, never from a later run of the same story. Each hourly pass works through pages until its 60-second budget. On a test table of 120,000 compressed rows (20,000 reports, each seen 6 times), one pass rewrote about 5,500 reports. The whole table took about 4 passes. Once every row was rewritten, a walk of the whole table took 2.7 seconds. The README says precisely what is rewritten: pg_log_events rows from before #4020 keep their old hash until their 30-day retention drops them. +- **On compose, a log-hash key or role password planted in a credentials directory that was open to other users is discarded instead of trusted, `--harden-files` no longer follows a junction or a hard link, and the Viewer's always-empty Statement Fingerprint column is gone** ([#4031]) - Each file the service read judged the credentials directory on its own, and role provisioning set the directory owner-only before the log-hash key loaded, so a key planted while a bind-mounted directory was world-writable was trusted and kept, letting whoever planted it test guesses against the stored log hashes. Worse, a start that closed the directory but never provisioned (a store that was down, or a crash) left a planted admin password for the next start to re-assert on the admin role. Now whichever check first finds the directory open to other users' writes removes the role passwords and the key there and then, logs it as an error, and new ones are generated. The first `pg_log_events` run after a replaced key says so on its Collection Log row. Every credential name is tried, so a directory planted at one name no longer shields the files at the others. A directory with something in it is left alone, the credentials directory stays owner-only, and that start uses nothing in it and names each path to remove. Run one service per credentials volume (on Kubernetes, `strategy: Recreate`). `--harden-files` now covers the log-hash key, refuses (exit 1) any target reached through a junction or symbolic link, or a file with a second name (a hard link), instead of rewriting whatever it points at, checks every folder on the path when darling.json sits at a volume root, and only touches `darling-keys` on a bring-your-own install, where it is the key's directory. A directory left where the key's temporary file goes is now named as the reason instead of "it did not exist". The PostgreSQL log grid no longer shows a Statement Fingerprint column that could never fill, and the key is flushed to disk before it is renamed into place. +- **Trace flags could show a flag as enabled days or weeks after it, and every other flag, was turned off** ([#4030]) - get_trace_flags, the web viewer's Trace Flags grid, and Lite's equivalent all read the newest trace_flags row to decide what is currently set. A capture that finds every flag off writes no row at all, so the read silently fell back to an older capture that still had a flag on. Both surfaces now also check the trace_flags collector's newest successful run in the collection log, so a capture that found nothing on is recognized as current and reports no flags instead of a stale one. +- **On-load collectors could read HEALTHY forever even after their daily reschedule silently broke** ([#4029]) - server_config, database_config, database_scoped_config, trace_flags and server_properties are on-load collectors: they capture on every connect, and since #3929/#3930 also recapture once a day. Collection health banding still exempted them from every staleness check, so a daily reschedule that quietly stopped firing kept reading HEALTHY as long as its historical runs were all successes. These five collectors now band on the same STOPPED/FAILING/STALE ladder as any other collector, at their daily cadence, on the collection health grid, the fleet overview and the get_collection_health tool. +- **The PostgreSQL log tail could pick the csvlog or jsonlog file instead of the real log** ([#4025]) - On a target logging to both stderr and csvlog or jsonlog, the shared reader behind plan capture, deadlock capture and log events picked whichever file had the newer timestamp, and a csvlog or jsonlog file could win the tie. Its contents do not look like an ordinary log line, so the cycle read nothing and reported the target as quiet instead of naming the real file it needed. The tail now always reads the real log file, and a target with no such file gets a clear, named result instead of a silent miss. +- **PostgreSQL deadlock reports, deadlock alerts and analysis findings stored before the SQL normalization are rewritten in place** ([#4022]) - Since the deadlock SQL was normalized, every read showed older data normalized, but the stored rows kept their raw queries and a hash over the raw report: deadlock reports for their 90 days, deadlock alerts fired before the fix in the alert history, and analysis findings in their deadlock drill-down for 30 days, all readable by any role with a direct SELECT such as the MCP login. The service now rewrites them in small hourly slices. Each report takes the text every read already showed and the current identity, so its sightings group with newer ones. Each alert takes the incident the live alert builds today, and each finding takes what its read already showed. Only rows still raw are touched, a second pass changes nothing, and no store migration is needed. +- **PostgreSQL log events are identified by hashes keyed with a per-store secret, so a store reader can no longer test guesses at the values a log line hid** ([#4020]) - `pg_log_events` stored `raw_line_hash` and `statement_fingerprint` as plain SHA-256 over text a store reader can mostly rebuild, so anyone who could read the rows could test candidate values offline. A review recovered a four-digit PIN in 6 ms. Both are now HMAC-SHA-256 under a 32-byte key the service generates once and keeps outside the store: DPAPI-protected beside the managed credentials, in the `darling-credentials` volume on compose, and in `darling-keys` beside `darling.json` on bring-your-own, owner-only in each case. The service never replaces an existing key. If the key file cannot be trusted or read, log-event collection stops with an error that names the file and says how to fix it or delete it to rotate. No tool or web view returns either hash any more (`statement_fingerprint` left `get_pg_log_events` and the log tab). Rows stored before the upgrade keep their old hashes until retention drops them, so each log entry still in the overlap window is stored once more, and each statement's fingerprint changes once. +- **Plan capture could be spoofed by a statement's own author** ([#4015]) - Plan capture matched auto_explain's plan header anywhere in the server log, not just at the start of a real log line. PostgreSQL echoes a rejected statement back verbatim after a syntax error, so a user who could run SQL on a monitored target could write a fake header into their own query text and have it read back as a real captured plan, attached to any query id and duration they chose. Both the plan parser and the self-hosted collector's SQL now require a genuine log-line prefix immediately before the header, so only PostgreSQL's own auto_explain output can produce a stored plan. +- **PostgreSQL deadlock reports store and show their SQL normalized, and no read returns a hash of the raw report** ([#4013]) - The deadlock collector stored each report's queries and the victim's statement exactly as PostgreSQL wrote them, literals included, and get_pg_deadlocks, get_pg_deadlock_detail, the web and desktop viewers, the deadlock alert's email and webhook bodies, and the analysis drill-down returned them that way. Every query is now put through the same normalizer as the log events before it is stored: each literal becomes ?, and a query cut inside a literal is withheld. Every read also normalizes reports stored before this change, including stored analysis findings. The report hash, which could be used to test guesses at the hidden values, is now computed over the normalized report, and an older report is named by its time and process ID instead. A logged statement that quoted a deadlock message is no longer stored as a deadlock, and the graph panel now shows the newest reports first. +- **Analysis passes stop recomputing every 30-day baseline on every pass** ([#4011]) - Each scheduled analysis pass built its baselines from scratch. That meant 9 to 12 thirty-day store reads per server per pass, and on a 31-day test store they were 76 to 94 percent of a pass's time. `analyze_server` and `compare_analysis` then read the same baselines again. The Darling service now keeps one shared set of computed baselines for its scheduled passes, its MCP server and its web dashboard, so a baseline is read from the store once per analysis hour between them. A second pass in the same hour read none. On the test store, a PostgreSQL target's pass fell from about a second to between 36 and 301 ms. Only successful reads are shared, so one caller's timeout cannot hide another caller's baselines. The baseline window now ends on the analysis hour instead of the analysis minute, which is what makes a shared baseline identical to a fresh one. Lite gets the same fix for its scheduler, MCP server, Recommendations tab and overview charts. +- **CPU scheduler readings no longer flicker between two answers when a collection lands on a duplicate timestamp** ([#4010]) - A run-overlap or clock-resolution collision could occasionally store two different cpu_scheduler_stats snapshots under one collection_time. Every reader that shows the current scheduler reading, the fleet card's Threads chip, get_cpu_scheduler_pressure, the CPU Scheduler viewer tab and overview, and the RUNNABLE_TASKS analysis fact, picked between the two snapshots with no tiebreak, so the value could change from one refresh to the next with nothing actually changing on the server. Collections are now stamped so this cannot happen going forward, and every affected reader in both Darling and Lite breaks a tie deterministically, correcting reads of rows already stored this way. +- **The rest of the trend family now buckets to a point budget instead of returning every collection** ([#4007]) - get_wait_trend, get_cpu_utilization, get_tempdb_trend, get_memory_trend, get_perfmon_trend and get_pg_query_duration_trend used to return one point per collection, so a week of one-minute data ran from 160 KB up to 2 MB depending on the tool. They now bucket to the same roughly 200-point budget the file I/O, lock wait and duration trends already used, with an optional bucket_minutes to ask for a specific width. A week of get_tempdb_trend is now under 50 KB by default instead of nearly 2 MB, with the same shape of change across the other five. get_memory_trend's memory-grant figures also switched from matching the nearest grant snapshot within 30 seconds to averaging every grant snapshot inside a point's bucket, which answers correctly for a bucket that spans several snapshots instead of picking one arbitrarily. +- **get_pg_io_trend's automatic subject choice no longer scans the whole window in order** ([#4003]) - Calling get_pg_io_trend without a backend type or context asked it to sort every pg_io_stats row in the window before picking which one to follow, which took nearly 4 seconds over a week on a busy TimescaleDB store. It now reads each candidate's starting and ending values instead, which answers in a fraction of a second and still falls back to the exact original method whenever a counter reset could make that shortcut wrong. The chart it draws does not change. +- **Custom alert rules now evaluate on the Linux compose store** ([#4002]) - On the compose distribution, a user could author custom alert rules in the web dashboard, but they were never evaluated and never fired, since the evaluator only ever built its metric-reading pool from a managed Windows store's credential. The evaluator now reads with the compose store's least-privilege viewer role, which [#3983] set up for the web dashboard. Its rules now fire like any other. A bring-your-own store is unaffected: its rules still do not fire, since its viewer role does not have the resolve function the evaluator needs. +- **On-load config collectors recapture daily, so a long-lived connection keeps fresh config facts and a cleared trace flag actually clears** ([#4001]) - server_config, database_config, database_scoped_config, trace_flags and server_properties captured once per connect and never again while the connection stayed healthy. A server connected for more than 30 days lost its only capture to the 30-day retention purge, so CONFIG_*, DB_CONFIG, TRACE_FLAGS and the config audit had nothing to read until the next reconnect. Separately, TRACE_FLAGS took each trace flag's latest row across all retained history with no time bound. DBCC TRACESTATUS(-1) lists only flags that are currently on, so a flag turned off never got another row to supersede its stale ON one, and it kept reporting as enabled for up to 30 days after being turned off. Both SKUs now also re-run the on-load collectors on a daily cadence, in addition to on connect, so a long-lived connection's snapshot never gets close to aging out of retention. TRACE_FLAGS now reads the newest capture inside that same daily-aware window (about two days at the shipped cadence), so a flag turned off drops out at the next daily capture. When every flag is off, a capture writes nothing, and the window bounds the fallback to the capture before it. An operator's own schedule override for any of these collectors is unaffected. +- **get_store_metrics reads each store object's newest sample through an index instead of sorting a year of rows** ([#3998]) - The store-metrics latest read took each object's newest row with a DISTINCT ON over the whole `collect.store_metrics` table. The table keeps 400 days of hourly sweeps, and the only index was on the time column, so every call sorted every retained row: 7.8 seconds and a sort spilling to disk at full retention on a CI-sized store, and growing for over a year after a store is created. The read now steps from one object to the next through a new `(object_kind, object_name, metric_time DESC)` index and takes each object's newest row directly. The answers are identical, and the same read at full scale takes 19 ms. +- **list_servers and the per-server summary tools no longer plan a store's whole collection history to find one timestamp** ([#3995]) - list_servers, the Overview summary card, and the get_server_summary tool each read a server's newest collection with a query shape that forced TimescaleDB to plan every retained day of history before returning an answer that takes a fraction of a millisecond to compute. These reads now use the same fast per-server lookup the sidebar's freshness indicator already used, so a store that has run for months answers just as quickly as a brand new one. Answers are unchanged: a server that has gone dark still reports correctly. +- **PostgreSQL config and logging-audit tools no longer plan a year of chunks to read one row** ([#3992]) - get_pg_server_config, get_pg_logging_audit and the PostgreSQL config panel read the newest configuration snapshot with no lower bound, so on a store that had run for months TimescaleDB spent seconds planning every retained daily chunk before returning an answer that took milliseconds to compute. These reads now bound the same way the collector's own config reads already did, planning only the last day's chunks and falling back to the full history only for a target whose collector was dark for a while. Answers are unchanged. +- **A store with no readable server-log directory keeps its hourly collector-cost flush** ([#3985]) - The store-log capture's own catch kept its failure from stopping the hourly tick. But Npgsql closes the connection outright on the capture's error, so the re-mask and the collector-cost flush that ran next on that connection failed with "Connection is not open". That happened every hour on a store with no log directory, which is the Linux compose store's shape, and `get_collector_cost` never got a row there. The connection is now reopened before either runs. A capture the store will never allow (no log directory, or a login without the log read) now warns once per process instead of every hour, and `get_store_log` still reports the gap. Separately, the sizing pass gets its own narrow catch, so the next statement a store permanently rejects there can no longer take the store-log census and the collector-cost flush down with it. +- **Lite's daily summary starts its retention horizon where Lite's history actually starts** ([#3984]) - `get_daily_summary` and `get_daily_summary_range` put the retention horizon on the archive cutoff day, three months back. The archive cleanup deletes a whole month's file once that month falls before the cutoff, so the days between the cutoff and the next month start were already gone. Those days were judged as retained with no data instead of purged, and `retention_horizon` read up to a month earlier than the data really goes. The horizon is now the first month start the cleanup keeps, the same instant the Overview freshness band uses since [#3975]. +- **The web dashboard and the MCP server no longer connect to a compose or bring-your-own store as its owner** ([#3983]) - Outside managed mode both hosts used `postgres.connectionString`, the collection login, which owns the store. So a web session or an MCP token-holder there had none of the `viewer`/`mcp` roles' protections: no secret-column carve over the SMTP password, webhook URLs and stored server passwords, no narrow write grants, and no `statement_timeout` backstop. The README said they had all three. Three changes follow Erik's ruling on #3914. First, the Linux compose store provisions the `admin`, `viewer` and `mcp` roles itself, the way a managed store does, and the two hosts connect as `viewer` and `mcp`. The service recognizes that store as its own because its login is the store's bootstrap superuser (`POSTGRES_USER`) and the cluster holds no other database, so nothing needs configuring and an existing compose deployment gets the roles on its first start with the new image. The generated passwords are one owner-only file per role in a new `darling-credentials` volume. The roles carry their own marker, `darling-compose`, so the service never re-keys a role `provision-roles.sql` created; a same-named role it did not create is left alone. When a start does not provision the roles (a refusal, a failure, or a collector that stopped first), each surface keeps its role with the credential an earlier start wrote, and falls back to the owner, with the reason, only when there is none. Every start also switches off the roles' widening attributes and revokes any role membership granted to them. Second, a bring-your-own store gets two optional settings, `postgres.webConnectionString` and `postgres.mcpConnectionString`, in the same forms as `connectionString`. Left unset, a surface connects as the owner and the service warns at startup that it gives up the carve, the narrow write grants and the backstop. `provision-roles.sql` now creates the `mcp` role too, with managed's grants and carve, and gives `viewer` the `custom_alert_rules` write it was missing, so the web rule editor works when pointed at it. Third, a fresh managed or compose store let the MCP tools read the continuous aggregates only after a restart, because they are created after provisioning and `mcp` had no default read on `collect`; it now has one, SELECT on `collect` only. The README, `get_store_query_stats` and the instructions now describe the owner-identity behavior accurately. +- **A fresh store's fleet overview and web Fleet page work before the collection-health aggregate materializes** ([#3981]) - On every new TimescaleDB store, `get_fleet_overview` answered "Out of range of DateTime" and `/api/fleet` returned a bare 500, so the web dashboard's Fleet Overview and sidebar were broken until `collection_health_hourly` had materialized something. That meant until collection had rows and an hourly refresh had covered them, because a refresh over an empty log leaves the aggregate unmaterialized. The reader guarded the aggregate's watermark with `isfinite()`, expecting "nothing materialized" to read `-infinity`. TimescaleDB reports the minimum finite timestamp (4714 BC) instead, and Npgsql cannot hold that as a date. A watermark earlier than 2000 now reads as nothing materialized, so the collection-health half is read in full from the log, as designed. A guard read the client cannot convert now falls back to the raw scan instead of failing the overview. +- **Latest-value lookbacks follow the collector's cadence, and the PostgreSQL target's config reads stop planning every retained snapshot** ([#3980]) - [#3931] bounded the analysis latest-value reads to a day, but collector cadences are editable. A database-size, memory-clerk or plan-cache collector scheduled daily or slower lost its facts from 24 hours after each sample until its next run, so the findings built on them resolved and re-fired. The lookback is now a day or twice the collector's actual interval, whichever is longer. The interval comes from the same schedule rule the collector runs by: Darling's per-server and fleet-wide overrides, Lite's schedules, the Dashboard's `config.collection_schedule`. A collector set to run only on connect anchors on its newest capture however old. Every default cadence is under twelve hours, so nothing changes until someone slows a collector down. Separately, the PostgreSQL target's five reads of the newest `pg_server_config` snapshot had no lower bound. A year in, TimescaleDB planned all 366 one-day chunks: 4.0 to 8.3 seconds of planning per read, four of them on every analysis pass. They now read the last day first and fall back to every retained snapshot only when that finds nothing, so every answer is unchanged. +- **The top-CPU drill-down resolves statement text for the five queries it prints, not for every plan-cache row in the window** ([#3979]) - The drill-down behind CPU_SQL_PERCENT and CPU_SPIKE findings projected query_text inside its window. On Darling, v_query_stats resolves that column from the fleet's query-text dimension for every row, so the read looked up and sorted the whole window's text to print five. It now ranks and cuts to five without the text, then reads the same MAX over the same rows for the five that print. A group with a NULL key reads NULL-safe, because GROUP BY groups NULLs and equality cannot match them. Lite runs the same SQL, byte-identical by pin, and the frozen Dashboard mirrors it; its MAX over every window row's compressed statement drops from 1,140-1,360 ms to 32-47 ms on a 72K-row window. On a rig with a 400K-text dimension and a 72K-row window, Darling's read goes from 260.6 ms to 132.2 ms. Output is identical in all three SKUs against an old-SQL oracle, NULL keys and trap rows included. +- **A server dark past the collection log's retention reads Offline everywhere, not "Awaiting first collection"** ([#3975]) - [#3966] fixed this on the fleet card. `list_servers`, the viewer's sidebar dot and Overview card, and Lite's Overview card still read "no collection found" as "never collected". `collection_log` keeps 60 days and Lite's archive keeps three months, so a decommissioned server left enabled read Offline until its last row aged out, then turned amber: "Awaiting first collection" on Darling, and "Never" with "No collection has ever landed for this server" on Lite. One shared rule now bands a server with no collection in view by when it was registered. A server registered before the earliest instant the read can see is Offline; one registered since then is still awaiting its first collection. Lite's horizon is the first month start its archive cleanup keeps, because the cleanup deletes a month's file whole. +- **The service's start-up hole scan no longer reads every aggregate's whole materialization and source table** ([#3972]) - At every start the service scans each of its 23 continuous aggregates for materialization holes (#3731), and the scan's two per-bucket checks ran as joins: one read the aggregate's entire materialization, and the other read the entire source table once for every bucket with nothing materialized, which after an outage is every outage hour. On DARLING01 the wait-stats baseline's check wrote all 9.8 million wait_stats rows to disk and read them four times, 4.5 seconds for one aggregate. Each check now runs once per bucket as an index lookup, and finds exactly the same holes. One start's scans across all 23 aggregates went from 5.9 s to 75 ms there. +- **The trend tools answer in time buckets sized to the window: a day of `get_file_io_trend` is 34 KB, not 1.4 MB** ([#3968]) - `get_file_io_trend`, `get_lock_wait_trend`, `get_query_duration_trend`, `get_procedure_duration_trend`, `get_pg_io_trend` and `get_pg_database_trend` returned every collection in the window, so an answer grew with the window and the collection cadence: a default day of file I/O on a monitored SQL Server 2022 was 12,500 points and 1.4 MB, and a week 9.8 MB. Each now gathers its collections into buckets sized to keep the answer near 200 points (a day is ten-minute points, a week hourly), the same way on Lite and Darling; `bucket_minutes` asks for another width up to a per-tool cap that keeps the largest answer under 256 KB, and a width out of range or over the cap is refused with the width that fits. Counts are summed and rates and ratios recomputed from each bucket's sums, never averaged; every point keeps its worst single collection as a peak, so a spike survives; and the answer says what a point is (`bucket`, `bucket_minutes`, `aggregate_note`). `get_file_io_trend` charts each database's data and log files as two lines ranked by I/O stall, folding everything past the top five into one `(other)` line, and `database_name` charts one database file by file; it used to list tempdb's files under one name, indistinguishably. `get_lock_wait_trend` charts the whole lock family as one series with a legend of the types that waited, where it returned a row per type per collection, mostly zeros. On the PostgreSQL pair `point_count` now counts buckets and `interval_count` the intervals it used to count. The web viewer charts the same reads at a larger point budget, and `get_query_heatmap`'s `bucket_minutes` and `metric` refusals now carry the `invalid` status and the parameter name. +- **A server dark for more than two days reads Offline on the fleet card, not "Awaiting first collection"** ([#3966]) - The web fleet page and `get_fleet_overview` look back 48 hours for each server's newest collection. A server silent for longer fell out of that read and was banded as if it had never collected: an amber "Awaiting first collection", counted under Warning, with the same words in Needs attention. The WPF viewer called the same server Offline. The window stays, because planning the read over every retained `collection_log` chunk on every call is the cost it exists to avoid. The read now also returns each enabled server's registration instant from the registry. A server registered before the window with nothing in it reads Offline and counts in `offline_count`. One registered inside it that has not collected yet still reads awaiting. The web card's Offline status line shows how long ago the last collection was, or "no recent collection", instead of a time of day that read as today. +- **A restart's shutdown checkpoint no longer counts toward checkpoint write and sync time either** ([#3964]) - The shutdown checkpoint's own write and sync work lands in the same counters as the live checkpoints', and nothing can separate the two, so an interval that spans a PostgreSQL restart is now judged on neither arm. Store Checkpointer Pressure neither fires nor resolves on it, even when the shutdown sync is slow, and get_store_metrics reports the interval as status Restarted with no delta. PG_CHECKPOINT_PRESSURE leaves restart intervals out of its write, sync and checkpoint-buffer figures as well as the requested count, and get_pg_write_stats returns checkpoint write time, sync time and checkpoint buffers as null for a window that holds a restart. The cost is one skipped interval after a restart; the next interval is judged normally. +- **PostgreSQL config change history reports per-database and per-role overrides being set, changed and reset** ([#3957]) - `get_pg_server_config_changes` and its web twin said nothing about `ALTER DATABASE ... SET` or `ALTER ROLE ... SET`. The override rows V138 added to `pg_server_config` had to be kept out of the server-wide change read, and even a per-scope comparison could only see an existing override's value move, never one being set or reset. A second read now compares each pair of consecutive snapshots for every database and role scope. An override that appears reads `set`, one that disappears reads `reset`, and a moved value reads `changed`. Overrides already present when the store first captured them are the baseline and are not reported as set. The server-wide rows, their order and their payload shape are unchanged, and a page with no scoped rows is byte-identical to before. +- **The plan-regression drill-down no longer re-deduplicates the whole Query Store slice, and the parameter-sensitivity drill-down stops resolving text for rows it never prints** ([#3956]) - Every analysis pass that raised a PLAN_REGRESSION finding ran the fact's 14-day Query Store deduplication twice: once for the fact, and again in the drill-down that lists its top five. Those five are the head of the ranking the fact had just computed. The fact now records the queries it reported on the pass, and the drill-down deduplicates only those queries' rows. It reads the whole slice, as before, when the fact did not run, failed or found nothing. Lite and the Dashboard do the same. On a rig seeded to the production funnel (4.15M raw rows per server), the drill-down went from 27.1 s to 0.41 s, and on DARLING01 from 194 ms to 2.1 ms, with md5-identical output. The parameter-sensitivity drill-down read v_query_stats, which joins the fleet's query-text dimension for every row in the window and carries the text through its sort. It now resolves text for the five rows it prints: 520 ms to 165 ms on the rig. The Dashboard's twin carried each row's compressed statement through the same sort, and it now does the same. PlanRegressionSql's own cost needs a storage change, proposed in [#3953]. +- **A PostgreSQL restart no longer raises a false Store Checkpointer Pressure warning or reads as a WAL-forced checkpoint on a monitored server** ([#3955]) - PostgreSQL counts a shutdown checkpoint as a requested checkpoint and keeps the count across the restart, so every service restart that stopped the store fired Store Checkpointer Pressure as WAL-forced checkpoints, and a monitored server's restart read as WAL pressure in PG_CHECKPOINT_PRESSURE and get_pg_write_stats. Every checkpointer sample now records the server's postmaster start time (store schema V139), so an interval that spans a restart is recognised and no longer counted as a requested checkpoint. get_store_metrics and get_pg_write_stats report postmaster_restarted and postmaster_start_time so the gap is explained rather than hidden. +- **Log masking fails closed: a DETAIL or CONTEXT is read as SQL only where PostgreSQL writes SQL, a value cut before its close is masked to the end, and `get_store_query_stats` masks a raw text `pg_stat_statements` kept** ([#3952]) - A fourth review of [#3920] found values still reaching the viewer and mcp roles through the store's own log and every PostgreSQL target's `get_pg_log_events`. The DETAIL and CONTEXT masking split at any line shaped like `Process N:` or `SQL statement "`, a value's own lines included, which kept a literal's middle as identifiers and cut a key tuple or failing row away from the close its mask needed; now a DETAIL is SQL only in a deadlock report (a `Process N:` line starts a query only for one of the deadlock's own processes, and only once the query before it reads to its end), a crash report or a logged EXECUTE's `prepare:`, and a CONTEXT frame is SQL only where a frame can start. A pasted value that reads as an identifier to PostgreSQL (a no-break space, full-width digits) is masked, every prose value shape masks to the end when its close never arrived, a field over 64 KB is withheld and a hostile field can no longer stall capture (one key-tuple pattern took minutes on 90 KB), and `get_store_query_stats` masks the statement text `pg_stat_statements` stores raw when an entry is evicted or reset mid-statement. Covered by the reviewer's inputs as regression tests, timing pins for the hostile shapes, and a live test that forces the raw text into `pg_stat_statements`. +- **The web server page's Overview tab no longer waits on the daily summary** ([#3950]) - On the largest production store the two daily-summary reads were 26 of the Overview tab's 28 seconds, and one of them ran into the `viewer` role's 15 s timeout. The month read was slow in its query count, not in its raw sources. The check that names a day the rollup never materialized (#3653) ran as a join over the server's whole query history, rescanned once per day of the window and spilled to disk, and the distinct-query count sorted every rollup row of the month. Each check now runs once per day as an index lookup and the count is hashed, with identical results on every tier. On one busy server's seeded data the month read went from 3.3 s to 0.19 s and a 120-day read from 12.4 s to 0.16 s. The rollup-coverage lookup took 1.7 s or more in production and ran on every call. It is now cached for five minutes, concurrent reads share one lookup, and a failed lookup is retried rather than routed on. The tab's today tile now comes from the same read as the month grid, so the page runs one daily-summary query instead of two, and the tile's unique-query count matches the grid's last row. +- **The fleet overview reads each server's newest sample instead of every retained row, and the web viewer asks for it once per refresh instead of twice** ([#3947]) - Every `get_fleet_overview` call and every `/api/fleet` request behind the web sidebar, fleet page and server page read its four "latest value per server" metrics (CPU, memory, memory-grant pressure, worker threads) with a `DISTINCT ON (server_id)` or a `MAX` joined back over the whole table. That read decompressed and sorted every retained row to keep one per server. It also counted blocking and deadlocks bounded only on the event's own timestamp, which no chunk is partitioned on, so a one-hour count opened every retained chunk. Both grew with servers × retained days, and one overview took 12.3 s cold on a 43-server store. Each newest-row read is now one `LATERAL ... LIMIT 1` probe per registry server, which TimescaleDB's ordered ChunkAppend stops in the newest chunk; PostgreSQL targets, which never write those tables, are skipped. The incident counts carry a `collection_time` floor one chunk before the window, which keeps every row the window wants because a row is collected after its event. The 48-hour last-collection read is a per-server probe too. On DARLING01 the sub-reads went from 1,317 ms and 26,836 buffers to 32 ms and 182, returning identical rows. The web viewer's sidebar and page each fetched `/api/fleet` on every 60-second tick, doubling the cost per open tab; they now share one in-flight request. The WPF viewer's copies get the same fixes (its sidebar freshness read was a `GROUP BY` over every retained `collection_log` row on every refresh, 303 ms to 13 ms on DARLING01), as do `get_server_summary`'s windowed counts, and Lite's Overview card reads its newest CPU, memory and last collection from the hot table before falling back to the archive. +- **A PostgreSQL target's analysis reads its statements' own baselines once per metric, not once per statement** ([#3946]) - The bad-actor share detector and the plan-regression detector asked for each candidate statement's hour-of-week baseline one at a time, and each ask read the server's whole 30-day `pg_statement_stats` slice (the table's only index is (server_id, collection_time), so the statement predicate is a heap filter; the share arm also re-summed the same per-collection total each time). A cold pass paid five share reads plus one per flipped statement, and on the production PostgreSQL store that was about 70 % of a cold `analyze_server`. Each detector now asks once for its whole candidate set: the keyed arm makes the per-statement arm's own read with one filter per statement and runs the unchanged robust scaffold once per statement over it, so every statement's buckets are the ones its own read produced (identical tiers, counts, medians and MADs; means and standard deviations to float8 summation order). On DARLING01's PostgreSQL target the five share reads (920–1,053 ms) became one (409–466 ms), and on a 4.3M-row compressed month the share read halved and the mean fell by a third. The per-statement scaffold is the floor that remains; scheduled passes never reusing the baseline cache is tracked separately (#3941). +- **`get_store_metrics` answers with a bounded summary instead of every store object's daily series** ([#3942]) - The tool returned every store object's latest row and its daily series on every call. The object count is fixed by the schema (about 250: 72 hypertables, 25 continuous aggregates, 146 background jobs), not by the fleet, so the default answer was about 1.9 MB on every production store. That is around 500k tokens, more than an MCP client's context, and it was 1,246 KB on the dogfood store. The default is now the store-level blocks (inventory, retention, job_history, checkpointer, and the whole-store daily growth with the per-server ingest rate) plus three ranked lists bounded by `limit` (default 10): the largest objects, the fastest-growing, and the background jobs, failing ones first and then those closest to their cadence. Each row carries its change over the window in place of its series. `object_kind` lists one kind, and an exact `object_name` returns that object's daily series. On the dogfood store's own rows the default answer drops from 1,246 KB to 19 KB. Wire change: `daily` is gone from the default response, `objects` is a bounded page, and job rows no longer carry the byte fields, which were always null. The store alerts' triage page gains a background-jobs section. +- **Managed role provisioning never sends a role's password in a statement** ([#3940]) - Every service start sent all three login roles' plaintext passwords in `CREATE ROLE` / `ALTER ROLE ... PASSWORD`, and any surface that records statement text could keep them: an operator-created role with a managed role's name made provisioning fail on every start, and the store's own log then wrote the whole batch, passwords included, where the viewer role reads it for 400 days. Provisioning now sends each role's SCRAM-SHA-256 verifier, computed client-side (PostgreSQL stores a verifier as-is, which is what psql's `\password` does), and only for a role whose stored verifier no longer accepts its credential file, so a steady-state start sends none. `tools/provision-roles.sql` recommends a verifier or `\password` for a store you run yourself. +- **A store without TimescaleDB re-runs its store-object convergence every hour, not only at restart** ([#3932]) - #3817 made the service re-run its store-object convergence hourly (the baseline views, the store's statement statistics, the composer's covering indexes), but the hourly pass sat inside the tick's TimescaleDB gate, so on a plain-PostgreSQL store, a supported configuration, a dropped fallback view or an extension a DBA created by hand waited for the next restart. The hourly pass now runs on every store shape and skips only the steps that need TimescaleDB, the same ones the start path gates. +- **Analysis latest-value reads look back a day instead of scanning a server's whole history, and stop counting dropped databases** ([#3931]) - The database-size, autogrowth, disk-space, memory-clerk, plan-cache and memory facts, and the autogrowth drill-down, took each series' newest row with no lower time bound. So every analysis pass numbered every row the server had retained, and TimescaleDB could exclude no chunk. On the largest field store `DatabaseSizeSql` alone was about a tenth of `analyze_server`. On Lite the archive views could skip no parquet row group. The answers were wrong too: "latest ever" kept a dropped database's files in `DATABASE_TOTAL_SIZE_MB` and in the autogrowth drill-down until retention aged them out. The seven reads now bind a lower bound one day before the window's end, in Darling, Lite and the Dashboard, so a series with no sample in that day yields no fact rather than a stale one. `DB_CONFIG` anchors on the newest capture, as its drill-down already did, which drops the dropped databases it was still counting. +- **A store upgrade that fails before its commit point puts the old cluster back as it found it, and only claims a revert that happened** ([#3927]) - In hard-link mode pg_upgrade renames the old cluster's `global/pg_control` once linking starts, and a failure after that point left a store that could not start on either runtime while the log said the pre-upgrade data directory was never modified. The failure and shutdown paths now rename it back before reverting the runtime, and log CRITICAL with the exact rename when they cannot. The runtime revert refuses while a PostgreSQL server is still running on the data directory instead of moving its binaries out from under it, and a revert whose second move fails puts the first one back instead of leaving no runtime at all. A directory swap that could not undo itself is moved back too, so the next start can no longer initialize an empty store over the real one. The failure outcome and the Failed self-alert now say only what was actually put back, and name the manual step before the next restart when something was not. +- **Log text keeps no literal: the store's own log and every PostgreSQL target's log events mask the SQL inside DETAIL and CONTEXT, every retained store-log entry is masked, and the statement reader shows only normalized DML** ([#3920]) - Two further reviews of [#3915] found text still leaking to the viewer and mcp roles. The store-log sweep kept `statement_timeout`, `lock_timeout`, `deadlock` and `unclassified` entries as the server wrote them, so an ERROR's `STATEMENT:` line carried whatever the failed statement did, a DBA's `ALTER ROLE ... PASSWORD` literal included, for 400 days. Both log surfaces masked a deadlock's `Process N:` queries, a crashed process's query and a PL/pgSQL `SQL statement "..."` context as prose, which keeps bare numbers and dollar-quoted strings, so a monitored server's deadlock kept both sessions' values in `get_pg_log_events`. Every retained entry now has its values masked, with statements and the SQL inside DETAIL and CONTEXT going through a single-pass SQL lexer that masks every literal spelling and withholds text it cannot read to its end, a backslash before a quote that reads two ways included. Rows stored before this build are re-masked in bounded hourly slices, and both readers mask on the way out. `get_store_query_stats` shows statement text only for normalized DML that opens with no comment (every other statement keeps its timings and reads as withheld), which closes comment-split role DDL, a DML keyword hidden in a leading comment, connection strings, and a `SELECT ... INTO` on a pre-16 store that tracks utility statements; its advice about `pg_read_all_stats` now says what that grant opens. The managed store's conf reading de-escapes values the way PostgreSQL does (an include directory ending in a backslash was dropped from the preload merge), reports a preload list PostgreSQL rejects as an Error rather than as fine, and bounds its include walk. Covered by the reviewers' leak cases as regression tests, the statement patterns judged by PostgreSQL's own regex engine, and live tests of the reader and of the re-mask pass on a migrated store. +- **The store's hourly self-metrics sweep works again on TimescaleDB 2.29 and later** ([#3918]) - TimescaleDB 2.29.0 rebuilt its chunk catalog and dropped the two name columns the sweep's catch-all census joined on, so on 2.29+ that statement failed every hour with 42703. The store-size series stopped, the store-log census and collector-cost flush on the same tick stopped with it, and `get_store_metrics` silently lost its `largest_unenumerated` list. That was live on the Linux compose image, which runs 2.30.1, and it blocked the bundle bump ([#3908]). The census now reads the public `timescaledb_information.chunks` view, whose columns keep their names across the rewrite, so one statement serves 2.28.1 and 2.29+ stores with no version check. It also excludes each chunk's compressed relation through `compression_settings.compress_relid`, because from 2.29.0 compressed data is no longer a chunk catalog row, and without that the system row would count it a second time (34.8 MB of a 129 MB test store). Verified on 2.28.1, a fresh 2.30.1, a 2.28.1 store upgraded in place, and a store whose extension update never ran: in each, the sweep's rows add up to the database's relation total to the byte. +- **The bundled store moves to TimescaleDB 2.30.1, which closes GHSA-hcfx-29v5-2rcw, and a store's extension now moves before the store opens instead of under a live store** ([#3908]) - Every release since 3.2 shipped TimescaleDB 2.28.1, which that advisory covers, and the update path could not move an existing store off it. The old post-start `ALTER EXTENSION` ran on a store that the web host, MCP host, Viewer seats and the job scheduler were already connected to. Once the extension moved, every session that had loaded the old library failed its next statement, and the update's own pre-step killed running jobs, which then sat in crash backoff for up to an hour. Now, when the runtime ships a newer TimescaleDB, the service starts the store on a private loopback port with background workers off, runs the update as the first statement of its own session, verifies it, stops the store, and only then starts it normally. Nothing else can connect in that window. The runtime carries the 2.28.1 libraries beside 2.30.1, so nothing ever has to be reverted. A store whose update fails still opens on its own version, and a Critical `Store Runtime Upgrade` alert names the reason; the update is retried on the next start. A PostgreSQL 17 store's pg_upgrade restores its extension as it is, and the update follows once the upgrade commits, so a failure there can no longer cost the rollback copy. The store's version is recorded in `darling-timescaledb.version` in the data directory, and the service refuses to swap in a package that has no libraries for it, which is what a rollback past this release would otherwise do. Releases 3.3 through 3.8 keep this runtime if you roll back to one (the service keeps `pg-runtime.stamp` pinned to the package they shipped). Verified on real servers: a 2.28.1 store with compressed hypertables and continuous aggregates moves to 2.30.1 with every row intact, stamped and unstamped. A package missing the update script leaves the store on 2.28.1, running and collecting, with no runtime reverted. A server left on the update's private port by a killed service is stopped at the next start instead of being adopted. +- **A runtime update no longer stops the store from starting when the previous runtime's folder cannot be cleared** ([#3919]) - A runtime update deletes what the last one left in `pg-runtime-prev` before rescuing the current runtime into it, and that delete sat outside the guard that turns a failed rescue into a skipped update. A file held open under the folder, by an antivirus scan or a shell sitting in it, threw out of startup and the store did not start that time. This release moves the bundled runtime to PostgreSQL 18.6 ([#3906]), so every host takes that path on its first start. Clearing or re-creating the folder now fails the way the rescue does: a warning naming the folder and the error, no swap this start, the live runtime left alone, and a retry on the next start. +- **A store still on PostgreSQL 17 no longer fails to start on a host with 40 GB of RAM or more** ([#3909]) - The managed store's memory sizing derived `maintenance_work_mem = 2048MB` on large hosts. PostgreSQL 17 on Windows accepts at most 2097151 kB, one kB less, and refuses to start over it. PostgreSQL 18 accepts the value, which is why current stores never showed it. A store still on 17 got those blocks after a failed upgrade to 18 reverted. From then on it could not start, and a later release could not upgrade it either, because the upgrade's first step starts the old cluster. The cap is now 2047 MB. A store on 17 whose conf is already over the limit gets a corrective line before anything starts it. A command-line override does not help, because 17 still validates the file. An over-limit value set with `ALTER SYSTEM` is reported with the fix, since nothing appended to postgresql.conf can override it. +- **The store's statement statistics, reviewed before release: the ALTER SYSTEM advice no longer bricks the store, and the reader's filter can no longer be switched off** ([#3915]) - #3899's first version ([#3904]) merged before its adversarial review finished, and the review found four serious faults. The v13 warning told an operator to pass the whole preload list to `ALTER SYSTEM` as ONE literal, which `shared_preload_libraries` stores as a single library name, so the store would not start again; the fix is now written one quoted literal per library, and a list stored that way is reported as an Error with a remedy that works while the store is down. The reader functions' body is parsed at call time under the caller's settings, so one `SET standard_conforming_strings = off` from any grantee turned the backslash filter into letters and returned recorded role passwords; both functions now pin the setting, and the pattern has no backslash. The `slow_statement` store-log class kept any role's raw duration lines, bind-parameter DETAIL included, where the viewer and mcp roles read them; it now keeps the statement with comments stripped, every literal masked (the shared log redactor gains dollar-quoted and `E''` strings) and DETAIL dropped, one row per statement however often it ran. And the setup probe failed at plan time for any store owner that is not a superuser; it now reads whether the module is loaded from `pg_settings`, which any role can. The same pass makes `get_store_query_stats` answer `precondition` from the catalog for each setup state (including an extension older than 1.8, which `pg_upgrade` leaves in place, and a dropped one), return query ids as strings, rename `entries_evicted` to `eviction_passes`, and say what its figures leave out; derives the viewer and mcp slow-statement line from a third of their `statement_timeout`; follows include directives in the v13 merge and checks the preload line in force on every start; scopes the scrub to the store's own database; and corrects the role identities and the hourly-cadence claims. Nothing public shipped the first version (nightlies build from main). Covered by unit tests for each fix and live tests on the bundled runtime, including the `standard_conforming_strings` bypass attempt and a non-superuser store owner. +- **The bundled PostgreSQL moves to 18.6, and the self-contained .NET runtime to 10.0.12, closing published CVEs in both** ([#3906]) - A security review of 3.8.0 flagged two things. First, the Darling store runtime was on PostgreSQL 18.4, one release behind 18.6, which fixes 23 CVEs in it. Second, Lite's builds (zip, Setup and Portable) and the Darling Viewer's Setup and Portable builds carried a `Microsoft.DiaSymReader.Native` affected by CVE-2026-69439, CVE-2026-71328 and CVE-2026-69522. Those are heap overflows in PDB parsing, fixed in .NET 10.0.12. That runtime is whatever the SDK packs into a self-contained build. `global.json` pinned SDK 10.0.302 with `latestPatch`, which never leaves the 3xx feature band, and Microsoft stopped servicing that band at 10.0.303 (runtime 10.0.11). Dependabot had moved the `Microsoft.Extensions.*` packages to 10.0.12, but it never touches the SDK. The SDK is now 10.0.401, and Dependabot's `dotnet-sdk` updates keep it current. A pin test makes each of those pull requests move the Darling container's SDK line with it. Existing Darling installs pick up the new PostgreSQL on upgrade: same data directory, no pg_upgrade. A host whose runtime predates stamping is now compared on the full PostgreSQL version rather than the major alone, so a readable 18.4 is no longer adopted as the 18.6 package. The nightly now runs that same-major upgrade on a real store built on the previous release's runtime, stamped and unstamped. A weekly `Runtime currency` workflow fails when a newer PostgreSQL minor for the pinned major is out, or when a TimescaleDB advisory covers the pinned version. An advisory already tracked by an issue is reported as a warning until the change that clears it. TimescaleDB stays at 2.28.1 for now. Testing the bump on real data showed that the store upgrade cannot yet move an existing store's extension to a new version, and would have left every upgraded store's database failing. That fix, and the bump, are [#3908]. +- **Each generated store TLS root certificate carries a unique per-generation name** ([#3557]) - Windows caches every root a viewer's TLS stack ever sees into the user's intermediate-CA store, one per certificate rotation; with all rotations sharing one name, that cache eventually breaks certificate chain building outright on long-running viewer machines. Distinct names per rotation mean the pile can never form. +- **The by-CPU tools now actually rank by CPU** ([#3523]) - get_top_queries_by_cpu and get_top_procedures_by_cpu ordered by summed elapsed time in both SKUs, so on a wait-bound server the real CPU consumers could be missing from the page entirely - and attributed_cpu_ratio read as "hidden CPU" when it actually meant "wrong sort key". Every ranking site now orders by worker time, including the over-fetch cut that could drop a CPU-heavy query before the final sort ever saw it. The viewer's Duration grids keep their elapsed ranking, which is what they promise. +- **analyze_server no longer answers "all metrics are within normal ranges" when the analysis window collected nothing** ([#3524]) - The analysis gate passes on lifetime history, so a server whose collection died still reached the all-clear path with an empty window. Both SKUs' analysis services now flag the zero-facts window and analyze_server returns the "unavailable" envelope pointing at get_collection_health; the genuine all-clear (facts collected, zero findings) is unchanged. +- **The Performance Calendar, daily summary, and fleet sweep band deadlocks as a measured per-hour rate, not any-deadlock-is-Critical** ([#3525]) - The shared daily classifier routed the Deadlocks signal through the Overview card's store-backed rate tiers (#3368, V120) with each surface's real window as the denominator, so one deadlock no longer paints a calendar day red, sweep verdicts stop scaling with the cadence knob, sub-hour spans fall to Warning instead of a multiplied rate, and the day tooltip/reasons report the rate beside the count. The still-forming day clamps its window to the elapsed portion, so an active storm bands on its true in-progress rate instead of diluting against hours that have not happened yet. +- **Perfmon rates are honest per-second values in analysis** ([#3527]) - The PERFMON_*_SEC facts, the batch-request anomaly window, and both SKUs' batch-request baselines read the per-collection-interval delta as if per-second (60-300x overstatement); every read now divides by the measured sample_interval_seconds (Darling's baseline derives it from collection-time gaps, since the continuous aggregate stores no interval), and interval-0 rows - where no delta was knowable - are skipped instead of read as rates. +- **Floor the SQL count thresholds, give Store Disk Pressure a GB floor, and count measured metrics in the fleet Healthy label** ([#3528]) - The SQL Server deadlock and blocking count thresholds now floor at 1 on read like their PostgreSQL twins, so a store row hand-edited to 0 can't fire on a quiet server; Store Disk Pressure gains a self_alerts.disk_free_warn_gb floor (default 50, 0 disables) so a large store volume at a low percent stops paging CRITICAL with hundreds of GB of runway; and fleet cards carry measured_metric_count/metric_count so a Healthy label built off one measured metric of six says so ("1 of 6 measured" on the web fleet page). +- **get_memory_trend stops reporting granted memory as a hardcoded zero** ([#3529]) - The MCP payload shipped a literal total_granted_mb = 0.0 on both SKUs, steering agents away from memory grants during grant-pressure investigations. The field became an explicit null with the envelope naming get_memory_grants as the grants series' source, and both tool descriptions stopped promising granted memory. +- **Lite's Query Store time slicer reads physical reads from its own column** ([#3530]) - The reader mapped both read fields to the logical-reads ordinal and never read the SELECT's total_physical_reads column, so the physical aggregate was computed and dropped. Pinned with a test whose fixture rows carry distinct values per I/O column. +- **LCK_M_IS advice carries the same RCSI caveats as its LCK_M_S twin** ([#3531]) - The intent-shared-lock advice handed out the READ_COMMITTED_SNAPSHOT ALTER with no caveats. Both lock twins now name the brief exclusive lock the ALTER takes, the tempdb version-store cost, and the test-on-a-copy warning for NOLOCK-dependent code. +- **Collector schedules refuse cadences that would fabricate quiet** ([#3532]) - Delta-family collectors (wait/latch/spinlock/query/procedure/file I/O/memory-grant/perfmon stats, and the PostgreSQL wait/statement collectors) now cap at 30 minutes in both Lite's and Darling's schedule editors, with the store-side resolver ignoring out-of-policy rows: past the shared 60-minute delta gap policy every cycle re-baselined and recorded zeros forever, so the charts flatlined green precisely because collection stopped measuring. +- **get_pg_plans finds the plan you asked for, not just the plans in the top page** ([#3533]) - the queryid filter ran client-side over a fetched top-duration page: the reader had no query_id predicate, so the tool pulled the top limit x 10 shapes by total time and filtered them in C#, which made any plan ranked below that page unfindable at every window size - and the filtered-empty branch then told the caller capture was working, the plan was never captured, and the statement was "not the query to look at", while the plan sat in the store. The predicate now runs in the store's SQL over every capture in the window, the over-fetch is gone, and the miss text says what was actually searched and what a miss can mean, with get_pg_top_queries and get_pg_plan_capture_readiness cross-references. The web dashboard's read dispatch already passed query_id through, so it gains the server-side search with no wiring change. +- **get_pg_autovacuum_health classifies severity from the same axis it ranks by** ([#3534]) - The reader ranks tables by GREATEST(dead ratio, insert ratio) but severity only read the dead side, so an append-only worst_table ten times past its insert-vacuum threshold reported "ok"; severity now comes from the worse of the two ratios, the insert-side ratio is published as insert_threshold_ratio, a one-sample window reports growth as unknown instead of "flat" (with first_seen_at showing the window), and the page-scoped summary counts carry the sibling limit_reached flag. +- **get_pg_replication_slots headlines the worst-classified slot and never spells unknown WAL growth as stable** ([#3535]) - worst_slot was picked by retained size, so an active 45 GB keeping-pace slot ("ok") outranked an inactive growing orphan ("critical_orphan_filling_disk"); slots now rank by severity with size only breaking ties, growth is null when either endpoint is the collector's -1 sentinel or the window holds one sample, new unknown-growth severities say so explicitly, and raw retained_wal_bytes nulls the sentinel like its _gb sibling. +- **get_pg_io_stats no longer renders track_io_timing=off as an impossibly fast disk** ([#3536]) - track_io_timing is OFF by default in PostgreSQL, so on a stock server the read and write time counters are never populated - and this read divided the zeros out to 0.000 ms latencies while its trend sibling had shipped the honest contract all along. The single-window read now mirrors that contract exactly: the setting is read from the collected pg_server_config bounded by the window's end (inferred from the window's data when never collected, with io_timing_source saying which), io_timing_tracked and timing_note are published, and every time-derived figure is null when untracked rather than zero, while the operation counts, hit ratios and byte figures stand untouched. The new busiest_basis field states which key decided the "busiest" ranking. +- **The PostgreSQL xmin-horizon alert catches rotating holders and stops firing on single observations** ([#3537]) - The persistence gate gains a horizon arm that fires when the horizon sits past the age threshold in a majority of the window's real captures (counted from the collector's own collection_log runs) regardless of who holds it, naming the rotating-holder pattern under a stable dedup subject; a minimum-observations floor stops the first holder after quiet hours from reading 1-of-1 as chronic. +- **QueryStore slicer's physical-reads sort plots the physical series** ([#3547]) - Sorting the Query Store grid by physical reads relabeled the slicer but kept plotting logical reads, and the selected-row overlay had no physical series to draw at all. Bars and overlay both plot the real physical-reads aggregate now. +- **get_memory_trend joins the grants series so total_granted_mb carries real data** ([#3548]) - Completing #3529's honest null: both SKUs join the memory-grant series the viewers already chart into the trend payload, matching each memory point to the nearest grants snapshot within 30 seconds. A snapshot measuring nothing granted is a genuine 0.0, an uncovered point stays null, and the granted_note appears only when there is a gap to explain. +- **Viewer Recommendations tabs stop saying "All clear" when the analysis window collected nothing** ([#3551]) - Both viewers only branched on the insufficient-data message, so a server whose collection died still rendered the all-clear on a zero-finding read. Lite's Generate now consumes the analysis service's window-empty state directly; the Darling service persists it into the analysis-state marker (false-with-a-message, no schema change) so the viewer's read and Generate now doors both render a "nothing was measured - check Collection Health" notice. The genuine all-clear (facts measured, zero findings) is unchanged. +- **Viewer pass for the Store Disk Pressure GB floor and fleet measured-metric qualifier** ([#3563]) - The Settings window can now edit the Store Disk Pressure warning's GB floor (V126, 0 disables) next to its percent sibling, and the WPF fleet card's band label carries the web fleet page's "N of M measured" qualifier when a band folded over unmeasured metrics, so an Unknown-heavy server no longer reads as an unqualified green. +- **Deprecated Dashboard analysis reads perfmon counters as true per-second rates** ([#3561]) - The Dashboard's analysis facts, batch-request anomaly window, and batch-request baseline read the per-collection-interval perfmon delta as if it were per-second, overstating by 60-300x at common cadences; all three now divide by the row's measured sample interval and skip rows with no knowable delta, matching the Lite/Darling fix in #3560. +- **Sorting the Procedures or Query Store grid by physical reads plots the physical series, in both apps** ([#3556]) - In Lite and the Darling viewer, the Procedures grid's physical-reads sort plotted the logical aggregate under a physical label, and the Query Store slicer labeled execution-weighted slice totals "Avg". The Darling viewer's Query Store grid also still carried the original #3547 physical/logical swap, and none of its grids re-projected a selected row's overlay when the sort metric changed, so the bars and the overlay could show different metrics. Both apps now plot the series the sorted column names, label slice totals as totals, and keep the overlay on the bars' metric - pinned by distinct-per-column reader tests and source-text pins over the sorting handlers in both apps. +- **The Locking & Contention grid names the table as schema.table** ([#3576]) - On Azure SQL DB and anywhere per-tenant schemas are the pattern, the same table name lives in several schemas, so the grid's bare table name made `dbo.Orders` and `archive.Orders` read as one object. The Table column now shows the qualified name, and sorting, filtering, and CSV export all treat it as one string. Mirrored in the Darling viewer and the deprecated Dashboard, and the Darling viewer's PostgreSQL Index Usage grid, which had the same gap, names its tables the same way. +- **Extreme, corroborated anomaly findings can now cross the notify floor, so the baseline engine is no longer notification-inert at shipped settings** ([#3526]) - every `ANOMALY_*` ramp saturates its base at 1.0, the Layer-3 tuning-class cap held the final at 1.49, no amplifier arm existed, and the shipped `notify_severity` is 1.5 - so a 20σ session spike beside a 15σ batch-request spike at 3am could never page unless THREADPOOL/SOS/RESOURCE_SEMAPHORE happened to co-fire; the product's best per-server-calibrated statistics were structurally its quietest. The shared `FactScorer` gains a second, per-fact escape for `ANOMALY_*` only: a deviation at 3x the cutoff the fact fired at (10.5σ on the 3.5σ robust path, 15σ heavy-tail, 6σ classical, 3x the absolute bar on the never-blind fallback path, bounded at the 25σ display cap; never for `is_new` profiles or the ratio/count families) leaves the cap on its own evidence, and a new anomaly co-fire amplifier arm (sibling anomaly families and measured absolute facts at the bars their own arms use) carries an extreme anomaly with two corroborators to 1.6. Routine 2-4σ saturation still caps at 1.49, a lone extreme anomaly scores its 1.0 base, one corroborator reaches 1.3, and CXPACKET's cap and the impact-peer escape are untouched. Lite + Darling (+ the deprecated Dashboard via the shared scorer). +- **`get_store_metrics`' `job_history` block now says whose eyes its rows are visible to, and proves rows exist where it can** ([#3574]) - `recording: true` was a GUC echo: `timescaledb_information.job_history` shows a row only to members of the job's owner role or the database owner, while `jobs` and `job_stats` show every role everything, so a least-privilege role could list all 110 jobs and read an empty history on a store recording perfectly - which cost a real postmortem. The block now evaluates the view's own predicate for its reader (`reader_role`, `visibility`), counts the rows it actually sees over a fixed 24-hour window beside the jobs `job_stats` says ran, and names the contradiction - recording on, reader admitted, jobs ran, zero rows - as a finding. In managed mode the MCP host reads as the `mcp` role the view filters out, and the block says so rather than reporting a zero it produced by construction. Darling only. +- **The forced-plan-failures alert read no longer walks the whole fleet's two-hour slice of Query Store rows to find one server's** ([#3573]) - the read's own composite index was in the store all along, and the planner priced it out because server ids interleave physically across collection passes, so every 30-second pass re-read the entire fleet window per server and cold excursions crossed the 10-second deadline as the table grew from 6 GB to 23 GB. A covering index over exactly the read's columns makes it an Index Only Scan over one server's rows (50 buffers against 1,514 on the rig, 11x fewer pages measured live), applied at startup like the composer's indexes. The deadline does not move. +- **The viewer's tray Snooze now silences the toast itself** ([#3570]) - Snoozing or silencing an alert from the Darling viewer wrote the mute rule and then waited for the background service to reload its own cache and flag the next alert muted before the tray went quiet; when that reload was slow or failed, the rule sat in Manage Mute Rules while the toasts kept coming. The viewer now applies its own mute rules to the tray on the very next poll, the same way Lite always has in-process, and the status bar says what stops now (the tray) and what the service applies within 15 s (email/webhook). A snooze that could not be saved is now reported in the status bar instead of only logged. +- **The compression-stuck self-alert no longer pages on a healthy job's run instant** ([#3575]) - TimescaleDB's job_stats view reads job_status from pg_stat_activity and next_start from the job-stat row, so for a few milliseconds at either edge of every run it reports the dead-job shape (next_start = -infinity, not Running); a production store paged on exactly that, 53 ms into a 63 ms run that succeeded. The check now re-reads five seconds after a -infinity trip and reports the job only if it persists, and its hourly sample is pinned to :30 past the minute, off the :MM:00 instants the compression policies fire on. Re-arm and escalation semantics and the six-hour hung-run bound are unchanged. +- **Text on an accent fill gets a measured ink in every theme, and the FinOps row marks become theme brushes Dark can actually see** ([#3577]) - The selected tab on Cool Breeze read 2.71:1 because the TabItem's selected-state Foreground never reached the header text (the app-level implicit TextBlock style out-ranked it); the header presenter now shadows that style and a per-theme `AccentForegroundBrush` is the ink on every accent fill (5.39:1 on Cool Breeze, 7.52:1 on Dark, unchanged on Light), applied to tabs, highlighted combo items, accent buttons, the calendar and Dark's grid selection. The "Mark Done / To Do / Do Not Do" row tints move from three fixed 20% overlays (1.2-1.4:1 against Dark's rows) into theme brushes, with Dark's built from its own status colors at 2.9-3.1:1 while row text holds AA. +- **The duration-trend trio routes by retention tier and says what it served, so a 7-day request no longer returns 4 days labelled quiet** ([#3541] A2) - get_query_duration_trend and get_procedure_duration_trend read raw query_stats / procedure_stats only, whose rows a TimescaleDB store drops at four days, while hours_back accepts 168 — a 7-day request came back as 4 days under a label saying 7, and when nothing survived the empty branch called the window "genuinely quiet — widen hours_back", which is false (dropped, not absent) and harmful (widening cannot help). Both now route through the ladder get_query_trend already uses (age → availability → materialized coverage) onto the hourly rollups, dividing by the bucket width instead of a LAG, and every sibling — the Query Store one included — publishes `source`, `effective_start`, `effective_hours_back`, `truncated`, `bucket` and `aggregate_note` on the data path and the empty one, with the empty branch naming an unserved head and `--backfill-rollups` where widening cannot help. get_query_trend gains the availability and coverage rungs (it answered 42P01 on plain PostgreSQL past four days). Lite's twins, get_query_trend included, publish the same block with Lite's truth (raw, per-collection); `value` gains its named twin `elapsed_ms_per_second` on both SKUs. +- **Analysis facts divide by the time the collector actually observed, and a window with a hole in it says so** ([#3538] A2) - Every wait fraction, blocking rate and deadlock rate divided by the nominal window, so collector downtime deflated severity in proportion to the data lost: a CXPACKET storm at a true 25% read as 6% with the collector down three of four hours, and nothing consulted collection health. Both SKUs now stamp observed coverage from the wait_stats collection series (real LAG intervals, an interval past the delta gap policy credited as zero, first row clipped to the window) and divide by it; an unobserved window emits no rate fact and composes with the #3524 unavailable envelope even when point-in-time config facts exist. Below 70% coverage a COLLECTION_GAP context fact carries the fraction and largest gap, and analyze_server, get_analysis_facts and compare_analysis carry a coverage block and a partial-coverage caveat. +- **SQL Server's Poison Wait alert measures accumulated starvation over a ten-minute window like its PostgreSQL twin, so one slow wait no longer pages and a THREADPOOL storm no longer sleeps** ([#3539] A4) - the alert judged ONE collector delta's average ms per wait against a 500 ms bar, presence-flat CRITICAL: a single 600 ms wait paged, and ten thousand 50 ms THREADPOOL waits - 500 seconds of worker starvation a minute - never moved the average. The PostgreSQL edition had fired on TOTAL accumulated wait over a rolling ten-minute window since [#2711], graded WARNING at one backend continuously stuck (600 s) and CRITICAL at ten, under the same alert name, switch and mute key - so one mute rule meant two things. Both SKUs' reads now SUM every wait_stats delta per poison type over the window (no completed-task filter, no row cap, no threshold in the read), a shared PoisonWaitEvaluator grades the sum against constants the PostgreSQL evaluator now aliases rather than duplicates, and the message shape mirrors PostgreSQL's clause for clause. Measured first on one production store class (43 SQL Server primaries, four days, 24,757 server-ten-minute buckets): the worst bucket anywhere held 5,795 ms of THREADPOOL - 0.0097 average waiters, ~100x under the WARNING bar, the same order as the PostgreSQL research's 160x - while the old trigger's near-misses showed both wrong shapes (single rows at 247 ms over 2 tasks; a 703-task row averaging 8 ms). The clear arm now needs an observed window: a collector that stops delivering holds the alert open instead of announcing "Cleared" on silence. The `poison wait threshold (ms)` setting stays persisted and reported but is no longer consulted; both Settings windows say so and disable the box. +- **Six MCP pages now say what bounded them, so a limited page stops passing for a complete answer** ([#3541]) - `get_blocking`/`get_blocked_process_reports`, `get_deadlocks`/`get_deadlock_detail`/`get_blocked_process_xml`, `get_alert_history`, `get_long_query_completions`, `get_plan_corrections`, `get_waiting_tasks` and `get_wait_stats` carried a hidden reader cap (`LIMIT 200`/`50`/`500`, or none) under a tool that advertised `limit`, took `limit` off the top, and published the capped count as `total_*` - so an agent read a 200-row page of a 5,000-event window as the window, and "widen hours_back" could never help because the cap was on rows. One pattern on both SKUs, the one [#3287] established: the cap binds to the caller's `limit` as a SQL parameter, the read fetches `limit + 1` and reports `truncated` only when the extra row existed, the page publishes `oldest_returned_*`/`newest_returned_*` and its `order`, and every page count is `*_returned`. `get_alert_history` now states and measures its `dismissed = FALSE` filter (`dismissed_excluded`, `dismissed_excluded_count`) and takes `include_dismissed`; the dedup_key fingerprint scan on `get_blocking`/`get_deadlocks` honours [#2159]'s whole-window promise up to a stated 2,000-row ceiling (`rows_examined`, `scan_truncated`); Lite's `get_long_query_completions` now keeps the window's SLOWEST like Darling instead of the newest 200 re-ranked, which could omit the slowest run entirely. +- **The four naked delta families store the interval their deltas accrued over, so a restart's fabricated zero reads as unknowable instead of 0.00 ms/sec** ([#3540]) - wait_stats, file_io_stats, latch_stats and spinlock_stats discarded the calculator's measured interval at the write, so its (0, 0) "no delta knowable" marker could not survive and every per-second reader LAG-divided a restart's zero into a confident 0.00 (file-I/O latency rendered "0.00 ms" mid-restart; the wait-rate window counted the restart as a sample). Darling V127 / Lite v60 add sample_interval_seconds to all four (perfmon_stats and query_stats already had it); the collectors write the minimum over each row's delta groups; every reader treats a stored 0 as NULL (the point is absent, MCP fields are null), a NULL as a pre-upgrade row that keeps its LAG-derived interval, and a measured value as the divisor. The wait_stats_baseline continuous aggregate still sums the restart zero - the documented follow-up is a new aggregate, since a rebuild would forfeit 35 days of baseline history. +- **Blocking and CPU health bands are rates over the window they were measured in, tiered from 14 days of fleet blocking and CPU data** ([#3539] A2/A3/A8d) - `BlockingSeverity` banded a raw count over a caller-chosen 1–168 h window (`count >= 5 → Critical`), so five blocked-process reports were Critical at a week's read and Healthy at an hour's; the daily classifier reddened a cell on six hot CPU samples or eleven blocking events whatever the span (a 15-minute sweep or a 24-hour day — 5.9% and 5.1% of measured server-days), and on a single collection ERROR row. Blocking now bands reports per hour (Warning 5/hr, Critical 20/hr — the tiers sit at the top of the measured quiet mode and the foot of the storm mode, with the 60 s block a rate-independent Critical), the calendar/sweep delegate to that band over their own window, the high-CPU bar scales with the window (an excursion-scale minimum of 6 below ~5 h, a sustained-heat 30 per day above), collection errors band as a share of the window's runs against the collector-health classifier's own 20% bar at its Warning tier, and the collector dot grades one failing collector of forty apart from forty of forty. Cards, calendar tooltips, sweep evidence and the MCP day tools disclose the rate or share they banded on. +- **get_store_metrics stops answering for 38% of the store: continuous aggregates and the named plain tables join the inventory, every sweep is reconciled against pg_database_size, and the block says its own coverage** ([#3582]) - On the largest production store the inventory accounted for 159 GiB of 415 GiB, because timescaledb_information.hypertables never lists a materialization and the walk never named collect.query_store_text and its siblings. The hourly sweep now writes one continuous_aggregate row per aggregate (sized through its materialization, under its view name), three table rows, and two catch-all rows (other / system), and the tool reconciles one sweep's rows against that sweep's pg_database_size, states enumerated and attributed coverage with the residual and a reconciled verdict, and names the largest un-enumerated relations live. Each aggregate object carries compression_enabled and its refresh/compression/retention policy job ids read from the catalog. The same sweep persists the owner's own job_history count so the managed-mode block (#3574) is a measurement rather than a GUC echo, and the GUC-off note no longer claims an empty view — failed runs are written regardless. +- **The twenty continuous aggregates join the compression ladder** ([#3581]) - Every raw hypertable compressed since the archival tier existed; no continuous aggregate ever did, and on the largest production store the twenty materializations were 235 GiB of a 415 GiB database — an uncompressed rollup of a 9x-compressed source is larger than the source. An idempotent startup ensure now enables columnar compression on each materialization (segmentby server_id, orderby bucket) and attaches a once-a-day policy whose compress_after is derived from the tier's refresh window plus one raw chunk (2 days for hourly-refreshed aggregates, 4 for the dailies), so a refresh never decompresses what a policy just compressed. The jobs run off the hourly phase grid, one aggregate per hour at :35Z, and on an existing store the first runs are staged one aggregate per night, largest first, in the schedule itself; a fresh store gets all twenty at once. +- **PostgreSQL MCP percents name their denominator, so a three-row page stops summing to 100% of everything** ([#3541] A7) - `get_pg_top_queries`, `get_pg_wait_stats`, `get_pg_wait_sampling`, `get_pg_kernel_stats` and `get_pg_io_stats` divided every row by the sum of the rows they had fetched and published it as `pct_of_total_*` beside a `total_*` that was the same page sum, so at `limit = 3` the three shares summed to 100% by construction and read as "these three are everything"; `get_pg_top_queries` compounded it with a literal `LIMIT 50` under `Take(limit)`. Each reader now computes the window's total on the SAME statement as its rows - a `SUM(...) OVER ()` over the grouped result, evaluated before `LIMIT`, so it cannot drift from them and costs no second read - and each tool fetches `limit + 1`, observes `truncated`, publishes the window figure as `total_*`, the page's own sum as `returned_*`, the ratio once as `returned_pct_of_total`, and says in its description which denominator its shares use. Executing the statements against live PostgreSQL 18 also found that `get_pg_kernel_stats` had never been ranked by CPU: its `ORDER BY 3 + 4 DESC` is an expression PostgreSQL folds to a constant and drops, so every page was the alphabetically-first series; it now sorts by the named differenced columns, and the Viewer's kernel grid inherits the fix. A cross-SKU census over every paged tool body pins the rule, with `get_pg_database_stats`' disclosed page-summed totals as its one stated allowance. +- **Every delta family is seeded from the store at service start, and the series-age rescue finally has passes to read, so a restart no longer fabricates one interval of quiet for six families** ([#3540] A4) - both hosts' restart seeders covered four of the ten delta families, so `latch_stats`, `spinlock_stats`, `procedure_stats`, `query_stats` and the PostgreSQL wait/statement pair re-baselined on every restart and deploy and stored one interval of fabricated quiet each time - and the per-group pass window that the #2235 recompiled-plan credit reads was never seeded at all, so that credit was inert on exactly the post-restart pass it exists for. Every family a host monitors now restores its keys (latest row per key inside the 15-minute window via `DISTINCT ON` for the collectors that do not write every key every pass; the bounded latest-collection probe for the rest) and its pass window from the same read, under a per-family guard so one slow or missing table cannot cost the others their continuity; `query_stats` restores its pass window only, because its delta key carries statement offsets the store does not persist (a rung, tracked on #3540). `ClearServer` is wired into Lite's server-removal cleanup and Darling's reconcile-remove branch, so a remove-and-re-add inside the gap policy's hour starts from a first pass instead of subtracting another server's counters. A census in Lite.Tests reads both hosts' seeders against the calculator's family list and each collector's own delta-group names, so an eleventh family cannot ship unseeded. +- **MCP write tools report what happened** ([#3541] A14) - `add_servers` counted a `collides` refusal in no counter, so a collided server went unmonitored under `failed: 0`; every status now maps to exactly one of `added / skipped / collided / failed`, which sum to a new `requested`. `remove_server` no longer deletes the first partial match of an ambiguous name - it refuses with the candidates listed and honors a partial only when unique. `update_custom_view` and `update_custom_alert_rule` share one vocabulary (omitted = unchanged, empty string = cleared; the view tool used to clear on omission). `mute_analysis_finding` on both SKUs reports `registered` and `matched_now`, says `muted_unmatched` for a hash no stored finding carries, and surfaces a swallowed store failure instead of `muted`. The instruction table stops denying the Entra modes #3484 accepted, and `/api/read/get_alert_history` gains the `include_dismissed` parameter. +- **The scorer's wait thresholds carry their measurement: WRITELOG stops saturating on a third of routine windows, deadlocks grade 5/hr apart from 90/hr, and the absolute gates scale with the hours actually observed** ([#3538] A5/A7) - Every `GetWaitThresholds` entry now names its lineage against the 43-server dogfood read (1,075 server-4h-windows) or says "unmeasured", and a census pins that. WRITELOG's inherited (0.10, null) saturated base 1.0 on 339 of 1,075 windows (31.5%) and is re-derived to (0.25, 0.50); DEADLOCKS adopts the alerting layer's measured (5, 20) instead of saturating at the WARNING entry; the 0.01-saturating waits ramp to (0.01, 0.10); HADR_SYNC_COMMIT - the fleet's second-largest wait, previously invisible to the engine - gains an entry, evidence-gated advice that names synchronous commit as a durability policy (never "switch to async"), and graph edges to and from WRITELOG; PREEMPTIVE_OS_QUERYREGISTRY is an explicit no-threshold entry with its fleet-uniform measurement. THREADPOOL (>= 15 min per observed hour + 1 s avg) and PAGELATCH_UP (> 10 s per observed hour, the ported source's own hourly bar) now divide by observed time, so hours_back no longer changes the verdict on an unchanged server. The five CALIBRATE ON SQL2025/HAMMERDB markers are replaced with what the fleet pass did and did not measure. +- **Analysis pages with long compound stories now reach Slack instead of dying with invalid_attachments** ([#3612]) - The Slack builder rendered every structured detail without ever counting blocks, and a five-fact plan-regression story — the highest-severity compound finding the product makes — carries enough drill-down and incident items to cross Slack's 50-block message limit; three such pages were lost across two builds. Details are now budgeted the way #3493 budgeted the prose: head and footer costed first, the longest leading run of details kept, the rest dropped with one omission item naming what was dropped and where the full page lives. Bodies split under their heading through the same splitter and fields cap at Slack's 2,000-character field limit as hygiene; every page that fit before renders byte-identically. +- **Continuous-aggregate materializations are chunked at one raw chunk, like every raw table** ([#3620]) - TimescaleDB sizes a rollup's chunks at ten times the raw table's interval, so every aggregate carried 10-day chunks: the 7-day interval tier held up to 17 days and compression could not reach the newest ten days of any rollup. The startup ensure that compresses the aggregates now holds each materialization at the raw chunk width, derived from the one constant so the tiers cannot drift apart. Existing wide chunks age out on their own schedule, so short rollups tighten to their designed hold over about two weeks rather than overnight. +- **The PostgreSQL first-target runbook stops denying three capabilities that ship** ([#3608]) - §12 and step 9 said plan capture, blocking chains and configurable alert thresholds did not exist; all three do. Step 9 now lays out all eight PostgreSQL alert families in two groups — the three Tier 0 predictors, which carry no knob by decision, and the five shared-name alerts, two of which have their own PostgreSQL count thresholds (`pgDeadlockCountThreshold`, `pgBlockingCountThreshold`, #3444) — and §12 points each struck denial at the step that carries it. Same-vintage drift in the README's "not yet" sentence, the blocking design note's "not started" header, and the runbook's schema version (v114 → v127) corrected in the same pass. +- **Slack text cuts land on whole characters, not UTF-16 indexes** ([#3622]) - The six places the Slack builder cuts text to a limit — the prose hard split and omission fragment, the detail heading, the field label and value, and the omitted-headings list — cut by UTF-16 index, so an emoji or accented letter astride a limit reached the reader as a replacement glyph the value never held, the hard split showed two of them and no emoji, and a cut field's "N more characters" counted code units. Every cut now lands on a whole character through one helper, falling back to a code-point boundary only when a single character is wider than the whole limit, and the field's omitted count is in characters the reader can count. +- **A not-yet-valid web TLS certificate now raises the self-alert instead of reading as healthy** ([#3517]) - a `web.network.tls` certificate whose `NotBefore` was still ahead at service start (a skewed clock, or one issued for a future rotation) is refused and the LAN dashboard binds loopback-only, but the #3514 self-alert derived everything from `NotAfter` and saw a far-out expiry. The web host now carries its refusal verdict to the sweep, which fires the same `Web TLS Certificate Expiring` family at Critical — same key and mute scope — naming the validity window, the loopback-only consequence, and the restart the host needs to re-decide. +- **Light and Cool Breeze status colors read against their own page, and text on a status fill gets a theme ink** ([#3609]) - Light's Warning and Info and Cool Breeze's Warning were under the 3:1 marker floor against their page (2.47, 2.32 and 2.09:1) — the new Settings contrast readout painted the stock palette red. Re-derived to clear 4.5:1 on the page and the card, and a new StatusForegroundBrush carries the text on the Recommendations severity badge and the viewer's alert badges, which had hard-coded inks (the viewer's White was 1.41:1 on Dark's amber). Dark is unchanged. +- **Forced Plan Failing fires once per observation, not once per cooldown** ([#3579]) - The adapter now returns the collection that produced the rise and the engine remembers which one it already reported, so a plan whose force failed once produces one card instead of one per cooldown until the next collection lands (six cards for one event on a production store). A plan failing across successive collections still re-fires per collection; recovery is unchanged. +- **The compression dead-job alert now says what a -infinity row is on the store's TimescaleDB** ([#3591]) - Below TimescaleDB 2.26.4 the sentence "the scheduler will never run it again" stands and the job is re-armed once as before. From 2.26.4 on (upstream #9360) a persistent -infinity is a crashed run in the scheduler's own crash backoff; the alert says so, and the service no longer re-arms it — measured on 2.28.1, alter_job against a job in crash backoff resets the backoff rather than shortening it and would have posted a false Recovered. Such a row is logged on first sight and pages Critical only if the scheduler's retry has not cleared it an hour later. +- **Every delta family now stores the interval its deltas accrued over, and query_stats stores the statement offsets its delta key is made of** ([#3540], Darling V128 / Lite v61) - V127 dressed four of the naked delta families; this dresses the last four (`procedure_stats`, `memory_grant_stats`, `pg_wait_stats`, `pg_statement_stats`), so the calculator's (0, 0) "no delta knowable" marker reaches the store from all ten and the procedure duration trend, the per-statement PostgreSQL trend and `get_resource_semaphore` stop reading a restart as 0.00 ms/sec, 0.00 calls/sec or a quiet semaphore. `query_stats` gains `statement_start_offset` / `statement_end_offset` (byte offsets into the batch text, `-1` = end of batch, stored verbatim), so both hosts' restart seeds rebuild that family's delta key from the store instead of restoring only its pass window; pre-upgrade rows (NULL offsets) still feed the pass window and seed no fabricated key. The census's still-naked list and the seeding census's pass-window-only set are both empty and asserted so. +- **The File Growth threshold means one thing — megabytes per hour — at every surface that shows it** ([#3539] A8c) - The rise knob was compared against the raw growth inside the lookback window while the lookback was a second knob clamped 5–1440 minutes, so the same 10 GB bar meant 10 GB per five minutes on one store and per day on another. The knob is now a rate averaged over the lookback (`rate × lookback / 60`, byte-identical on the shipped 60-minute default); both Settings rows, both preview lines, the alert's threshold line (rate, window, and the bar in MB), the card and both MCP descriptions say "MB/hr averaged over the lookback" in one shared phrase a nine-surface census holds. Key, column and stored value unchanged. +- **Story confidence measures corroboration instead of path length, and the nightly rebuild's three cards become one incident that names the job** ([#3538] A6/A9) - `confidence` was (n-1)/n over the story path with a lone symptom at 1.0, so the least-evidenced finding ranked highest under an evidence name. It is now 0.20 for the fired symptom plus up to 0.48 for the share of the root fact's amplifier checks that matched and up to 0.32 for chain depth; both SKUs publish `confidence_basis`, define the term, label pre-change rows `path-shape (pre-#3538)` by their provably-disjoint value shape (no schema change), and name an anomaly fact's baseline trustworthiness `baseline_confidence`. Three symptom → RUNNING_JOBS graph edges (SCH_M, IO_WRITE_LATENCY_MS, WRITELOG), gated on the job having fired, fold a maintenance window into one incident whose advice names the long-running job's overrun. +- **The daily digest and sweep rollup no longer re-announce on a service restart** ([#3580]) - Both once-a-day gates lived in process memory, so the first tick after any start delivered both documents again; on one install night three restarts produced six re-posts among ~23 channel posts. The gate now stamps delivered-today in the store's existing state table (no migration) and reads it back after a start, while a delivery the channel reported failed writes nothing, so the next tick still retries it. +- **compare_analysis bands each delta by the server's own dispersion and folds one cause into one row, so same-hour-yesterday noise stops reading as a verdict** ([#3538] A3) - The tool compared one window against one and banded every key by its severity delta on a flat ±0.1 dead-band, so a saturated ladder's doubling read "stable", a trace wait's slope read "worse", one I/O stall was six worse keys, and plan-cache hash churn inflated new/resolved counts. Both SKUs now share one `ComparisonBanding`: keys with a same-unit per-server baseline (CPU %, read latency, connections) are banded in that hour's robust sigma (`delta_sigma`, `band_source: "baseline"`); every other key changes status only when the value moved ≥ 25% of the larger side AND sits ≥ 0.25 up its own severity ladder; `BAD_ACTOR_*` appearances are `plan_cache_churn`; rows carry a physical-cause `family` with one family row per cause; the rules are stated in `band_rules`, every verdict row flags `coverage_caveat` when a side was partly observed, and the description says what "worse" cannot mean at N=1 vs N=1. +- **A server nothing has banded yet is Unknown, not Healthy, and the alert-history grids show the severity the alert fired at instead of the colour its name implies** ([#3539]) - A collector dot with zero banded collectors read Healthy, and an online server on which not one metric was measured folded to Healthy and counted in the fleet's healthy mass with "0 of 6 measured" as its only tell; both now read Unknown, and the nothing-measured card bands Warning like a server awaiting its first collection, with the reason "no metric measured yet" on every surface. Both Alert History grids classified a row by its metric NAME, so a Warning-graded Poison Wait rendered red and a Critical-graded low-disk fire amber; the alert's fired severity is now persisted in the row's context JSON on both SKUs (no schema change) and every grid, both SKUs' get_alert_history (severity + severity_source) and the web alerts page render it, falling back to the name only for rows that predate it. +- **Every latest-snapshot MCP read says when it was captured, and no tool accepts a window it does not read** ([#3541] A10) - Latest-snapshot reads (memory stats/clerks, file I/O, perfmon, the on-connect configuration family, plan cache, scheduler) answered with the newest row a store held and nothing saying when; two memory-grant tools took hours_back and read only the newest row in it, so a grant storm three hours ago was invisible. Every such read now publishes captured_at (anchored ones age_seconds against as_of); get_resource_semaphore/get_memory_grants read the window (peak waiters and when, summed timeout/forced deltas) beside the stamped snapshot; get_cpu_scheduler_pressure has one (server_name, hours_back, as_of) contract on both SKUs and Lite publishes its verdict; get_server_summary names its three clocks; the latch band names the interval it came from. Census-pinned on both SKUs. +- **PostgreSQL servers get a measured deadlock band from their own counters, their Long-Running Query alert skips maintenance like SQL Server's does, and every one-sided alert says why it is one-sided** ([#3539]) - The fleet card's deadlock dot read Unknown on every PostgreSQL target while the store held the server's own `pg_stat_database.deadlocks` counter. Both fleet surfaces now difference that counter per database (reset-clamped, summed) and band it through the same per-hour tiers as SQL Server's graph count, measured only where a difference was actually taken; the coverage block counts those servers as read and names the instrument. The PostgreSQL Long-Running Query read gains the noise opt-outs SQL Server's has had (autovacuum/walsender, VACUUM/ANALYZE/REINDEX/CLUSTER, pg_dump-family on the shared backups switch, excludedDatabases), and the Darling README gains an engine-coverage table stating why each remaining one-sided alert and band is one-sided. +- **Database File Growth's rise arm fires once per hourly observation, not once per cooldown** ([#3636]) - The rise gate reads a stored delta between two collections of a collector that runs hourly, and re-fired on every 5-minute cooldown against the same two rows — up to twelve cards per growth event. Both SKUs' reads now return the newest sample's collection_time as the observation's identity, and the engine remembers per (server, database, file) which observation the rise arm last fired on and declines to re-fire it regardless of cooldown; a file still growing across successive hourly collections re-fires per collection, and the level gate (file ≥ X% of volume) re-fires on the cooldown exactly as before. #3579's mechanism, one condition over. +- **The daily summary stops painting purged months green, and every MCP filter is part of the query** ([#3541] A9/A13) - The daily aggregate's day spine outlived the signals it banded: the seven per-signal tables purge at 30 days, the collection log at 60 and the alert log at 90, so for every day in between the spine still had the day while deadlocks, blocking, CPU and memory had all been dropped and each `COALESCE`d to a MEASURED zero - which bands Healthy - and a 366-day `get_daily_summary_range` painted the purged months green. Both SKUs now decide each day from one shared `DailySummaryRetention.StateFor`: the reader's effective retention horizon (Darling: the shortest fleet-effective signal retention, so an operator-shortened retention moves it; Lite: its archive horizon; wall-clock deliberately, because a backdated `as_of` cannot un-purge a table), a `signal_sources_present` count so "the tables no longer hold it" is never said of a held row, and #3596's `collection_runs`. Days read `collected` / `purged` (NoData, never Healthy) / `past_horizon` (rows survive, verdict withheld) / `no_run_record` (disclosure only), the range publishes `retention_horizon` and the counts, and `summary_date` is ISO-only. On the filter side `parallel_only`/`min_dop` are a HAVING floor before the CPU ordering and cap instead of a `.Where` over an already-cut page, `get_active_queries` pushes `database_name`/`blocking_only` into SQL, counts the filtered population with `COUNT(*) OVER ()`, joins the paged dialect and never strips a head blocker a row in the same capture names (`blocker_not_shown` says `not_captured` / `filtered` / `past_page` otherwise), three uncapped reads refuse a non-positive `hours_back` instead of `Math.Abs`-ing it, and `get_analysis_facts` validates `source` against `FactScorer.KnownSources` (fifteen, pinned to every literal) and refuses with the whole set. +- **Zero is a measurement: health parsers say whether their source was ever seen, a regression with no baseline stays null, and the first point of a differenced trend is no longer a fabricated 0** ([#3541] A12) - Eight of the nine `get_health_parser_*` tools answered a dead system_health session with the same `empty` a healthy hour earns; every one now carries `source_observed` / `last_captured_at` and a nothing-ever-captured store answers `unavailable`. `get_query_store_regressions` keeps a NULL percent null (a 0 baseline has no ratio) with the reason under `undefined_percents`; the duration trends publish the window's first collection with null rates and `unrated_points` instead of 0.0; `get_pg_xmin_horizon` divides by every capture in the window (the alert evaluator's own denominator); `get_pvs_stats` reports a measured 0 MB as 0.00% with `pvs_measured`; `get_table_index_sizes` derives growth only from baselines the store holds, with `history_days_available` and `growth_over_available_history_*`. +- **The interval-hourly Query Store refresh stops paying twelve index inserts per re-materialized row for eleven indexes nothing reads, and the capture-down alert read stops decompressing a server's whole collection log to learn two statuses** ([#3597]) - Measured on a TimescaleDB rig: a refresh recomputes exactly the hour-buckets any write dirtied, so a single backdated row re-materializes the whole fleet's hour, and each of those rows carried eleven per-column group indexes on the dedup materialization that no reader uses. The aggregate is now created without them and existing stores drop them at startup under a lock timeout that yields to a refresh in flight. The capture-down self-alert read, the heaviest statement on the alert pass, now asks each collector for its newest row through the partition column and stops at the newest chunk. +- **Top CPU Queries reads as one record per query on Slack, not seven fields interleaved across a two-column grid** ([#3644]) - A drill-down's rows now travel as records beside their flat fields, and Slack renders each as a bold summary line over its SQL in a code block, packed into as few sections as fit. The five-fact analysis page's fixed items cost 20 blocks instead of 33, so thirteen incidents fit where six did and the three pages #3612 could only deliver by dropping incidents now deliver whole. Email and Teams render the same compact list; every payload that carries no record array is byte-identical. +- **Top Cpu Queries' Max Dop is the newest plan's reading, with the cross-plan maximum kept as a dated history** ([#3648]) - The High CPU card's drill-down (and the bad-actor detail) reported MAX(max_dop) grouped by query_hash, which folded every cached plan's lifetime high-water mark into one provenance-free number: a MAXDOP-1 instance whose stored plan was serial read 16 and drove a tuning recommendation that had to be retracted. max_dop is now the newest plan's DOP; max_dop_any_plan, max_dop_any_plan_last_seen, plan_count and a dop_note sentence carry the history beside it, and an unknown reading is null rather than 0. Both SKUs, byte-identical SQL. +- **The force-plan remediation said "eligible, no blockers" for plans automatic plan correction already owned, had failed to force, or had withdrawn** ([#3652]) - The verdict now reads the store's forcing and APC state at read time — `query_store_stats` (is_forced_plan, plan_forcing_type, force_failure_count) and `plan_correction` (recommendation state/reason, last-good plan, FORCE_LAST_GOOD_PLAN enablement) — and adds five named blockers with evidence and snapshot time: `apc_owns_it`, `already_forced`, `forcing_failed_on_this_plan`, `apc_withdrew_it`, `apc_resolved_differently`. When APC is on for the database the target carries `apc_mode: on` and a guidance sentence ("the engine is Verifying via plan N; intervene only if it reverts or expires"), and whenever the state could not be read the target says so in `state_note` rather than reading as eligible by silence. Both SKUs; the in-app arming gate disarms on the new blockers unchanged. +- **A Claude review that posted nothing no longer finishes green** ([#3650]) - the reviewer's allowlist forbade every read tool the prompt invited, so swallowed runs read denials ≈ turns and ended without a verdict. Read-only tools (Read, Grep, Glob, git diff/log/show) join the allowlist; the job now fails itself when no non-empty-bodied claude[bot] review was submitted since the run's start, with the transcript's result block in the log and the transcript retained seven days as an artifact. +- **The deprecated Dashboard mirrors five of the brains-review honesty fixes in its own idiom** ([#3653]) - The frozen Full-edition Dashboard (bug-fix support) said the same five untrue things the shipping SKUs fixed today: `get_blocking` / `get_deadlocks` / `get_alert_history` published a capped page count as a total (now `*_returned` + `truncated`, with the reader's fixed cap named as `limit_applied_by_reader`); the Poison Wait alert paged on one slow wait's average and slept through a THREADPOOL storm (now accumulated over the ten-minute window and graded on the shared `PoisonWaitEvaluator` bars, clearing only on an observed quiet window; the ms preference is retired but round-trips); `mute_analysis_finding` answered "muted" for any hash (now `registered` / `matched_now` / `muted_unmatched`); an online server with no collector banded was a green "OK" (now Unknown / `--`); and the Perfmon per-second rate was integer division (now fractional on the read). The anomaly detector's "calibrate on the lab box" markers now state what the fleet pass measured and that it never reached the Dashboard tier. The wait-fact nominal-window divisor stays declined per the issue. +- **Six small honesty riders from the brains-review residue** ([#3653]) - `poison_wait.threshold_ms` (both SKUs) now carries `threshold_ms_note` saying #3593 retired it, and Darling's `update_alert_settings` stores it with a `warnings[]` entry instead of pretending it tunes anything; `get_pg_server_config` publishes `captured_at` and joins the latest-snapshot census the `GetCurrent*Async` name had kept it out of; Lite's `get_latch_stats` / `get_spinlock_stats` bind their hidden `LIMIT 20` to the caller's `limit` and report `*_returned` / `truncated` (the grid keeps its 20 by name); a no-server census fails any reader on either SKU whose `ORDER BY` is an integer expression PostgreSQL/DuckDB would fold to a constant (zero hits today); V79/V122 rung docs name the PRs that superseded them; Lite's `analyze_server` recommends next reads for `HADR_SYNC_COMMIT`. +- **The PostgreSQL poison-wait host holds on silence like the SQL Server engine does, and three presence-flat alerts grade their severity from the bars the health bands already measured** ([#3653]) - The PG Poison Wait host announced "Cleared" the moment its read came back empty — collector silence read as recovery. Because `pg_wait_stats` skips idle events (#2694), the rows cannot witness their own absence, so the read now carries the collector's own `collection_log` run count over the same window and the host clears only on an observed window (the #3593 contract, ported). Deadlocks Detected grades Warning/Critical on the #3368 rate tiers (Darling's V120 knob honoured via `IAlertEngineSettings.DeadlockRateThresholds`; Lite the shipped pair), High CPU grades Critical at the CPU health band's 95% bar, tempdb Space fires an explicit Warning with no Critical tier (no measured bar exists to cite) — so history grids, `get_alert_history` and every channel render the tier the alert fired at instead of the colour its name implies. +- **The Darling viewer's trend charts and calendar tell the same truth the MCP tools learned today** ([#3653]) - The Performance Trends tab read the raw tier only, so a 7-day chart on a TimescaleDB store plotted the 4 days raw still held under an axis that said 7; the query-duration, procedure-duration and execution-count charts now route by retention tier through the same ladder and hourly SQL the MCP trend tools use (moved to Storage as `DurationTrendRouting`, pinned equal on both sides) and each chart titles itself with the tier it served from and a truncation note when the store no longer holds the window's head. The viewer's trend SQL no longer fabricates a 0 for the first differenced point; an unrated point is skipped, not plotted or interpolated. The Performance Calendar judges every day against the store's retention horizon with the one `DailySummaryRetention` decision the MCP reader makes (`DailySummaryHorizon`, Storage; the purge's retention constants and fleet rule move down and the service aliases them), so a purged day is grey, not green, and its tooltip says why - on both SKUs. The PVS top-5 trend no longer plots an unmeasured size as 0 MB (Lite's `get_pvs_trend` carries it as null with `pvs_measured`). +- **`get_pg_server_config` counted the page and called it the server** ([#3653]) - `non_default_count` was a count over the rows fetched, so a limit below the number of chosen settings reported the limit as a fact about the snapshot, and `truncated` was inferred from a full page — always up on the default view. The count is now the snapshot's, computed on the row statement above the cap; the page's own count is `non_default_returned`; the `include_defaults` filter is in the statement so `truncated` is about the population asked for; and the three sibling pages in the same file observe truncation off a `limit + 1` fetch. +- **The four PostgreSQL host alerts fire with the tier they earned instead of no tier at all** ([#3653]) - High CPU, Deadlocks Detected, Blocking Detected and Long-Running Query on a PostgreSQL target passed no severity, so the history grids, get_alert_history and every channel coloured them by name after #3635. CPU now grades on the CPU health band's own classifier (Critical at 95% of the configured ACU ceiling), deadlocks on the shared rate grader against the store's deadlock tiers, blocking and long-running query as an explicit Warning with the missing measured bar named. Rows written before this keep their by-name colour. +- **Darling's `get_pvs_stats` trend drew an unmeasured pass as 0 MB** ([#3653]) - a collection on which the DMV reported no PVS size for a database was published as a real zero in the top-5 series, a cliff in a series that had none. The point is now null with `pvs_measured` beside it, the same two keys Lite's twin has carried since #3666; a measured 0 MB is still a zero. +- **The Query Store duration chart now says what served it and where the rollup's floor cut the window** ([#3653]) - The viewer's fourth Performance Trends chart plotted what the corrected Query Store rollup had materialized under an axis spanning the requested window, with no title; it now carries the sibling charts' disclosure — the route word the MCP tool publishes, the grain seam, and a "data begins" clause only when the rollup's measured floor sits above the requested start. The MCP trend reader's tier ladder and hourly SQL became aliases of the Storage definitions rather than pinned-equal copies, so the tool and the viewer cannot drift. +- **The analysis pass no longer says "collection appears to have stopped … NOT an all-clear" for a window the coverage witness proves the collector observed** ([#3653]) - The empty-window rule in both analysis services tested `facts.Count == 0` before it tested the coverage witness, so an observed window that simply produced no fact wore the dead-collector envelope: `unavailable` with a pointer at collection health from `analyze_server`, and the Viewer's dead-collector marker from the scheduled pass. The rule now gates on `ObservedDurationMs <= 0` alone; an observed window with no facts runs the pass and reads `empty` at its stated coverage, with one Information line naming that coverage for the scheduled pass. +- **The PostgreSQL analysis vocabulary absorbs what six content lanes reported back** ([#3542]) - Two `pg_config` facts were inert by construction: `autovacuum = off` and `maintenance_work_mem` had no scorer arm, so they scored 0 and no co-fire could lift them; `autovacuum = off` is now a 0.9 posture fact and `maintenance_work_mem` is evidence-gated on the backlog the way `work_mem` is on the spill. The connection ceiling subtracts PostgreSQL 16's `reserved_connections`, edges can name "the bad actor" through a stable `PG_BAD_ACTOR` alias the graph resolves to the window's heaviest statement, and a bad actor's next reads lead with `get_pg_query_duration_trend`. +- **A target that restarted, failed over or was re-pointed no longer keeps subtracting from the old instance's counters** ([#3653]) - Every delta family subtracted from a baseline cached under the server_id with nothing checking the readings came from the same instance; a failover to a busier replica stored `new total − old baseline` as one interval's work. Both hosts now detect an identity epoch on a read they already make — `sqlserver_start_time`/`@@SERVERNAME` for SQL Server, `pg_stat_statements_info.stats_reset` for the PostgreSQL statements family — compared against the pair persisted in collector_state, forget the affected baselines before subtracting, mark the run's collection_log note (`identity_epoch_changes=1`) and log old→new at Information; Darling's same-id reconnect on a definition edit forgets its baselines too. +- **A quiet hour no longer halves the next hour's Query Store rate** ([#3653]) - the rollup-routed Query Store duration trend rated every point over the gap to the previous EMITTED point, so a corrected-hourly bucket with no rows made its neighbour's denominator 7,200 seconds and published half its true rate; each point class now carries its own denominator - a rollup bucket its bucket width (and is therefore always rated, first bucket included), a raw Query Store interval its spacing (the store holds no interval length for it, said on the CTE). Both the MCP tool and the viewer read one builder. +- **The query-stats trends read the interval the store has, on both SKUs** ([#3653]) - `query_stats` has carried `sample_interval_seconds` from the start, yet the query-duration and execution-count trends (Darling viewer, Lite) LAG-recomputed it from row spacing and divided a restart row's fabricated 0 into a confident 0.00 ms/sec; they now read it three-state like the procedure trends have since V128 - stored interval, 0 = unrated, LAG only for a pre-upgrade collection - through one Storage builder. The MCP reader's own raw query-stats const is the named one-line follow-up. +- **Compose delta aggregates exclude the restart marker** ([#3653]) - every raw-tier SUM/AVG/MIN/MAX over a delta column on one of the ten interval-carrying families now carries its own `FILTER (WHERE sample_interval_seconds IS DISTINCT FROM 0)`, so a restart's (0, 0) marker is no longer averaged in as a measured zero or reported as the window's minimum; gauges, overlays, ratios, COUNT(*), Query Store and the rollup route are untouched. +- **`mute_analysis_finding` stops writing the hash as the path and stops registering the same mute twice, `remove_server` can remove a server that never connected, and eight MCP descriptions stop saying what the code does not do** ([#3653]) - The mute registry write is one guarded `INSERT … WHERE NOT EXISTS … RETURNING` on both SKUs: idempotent per (scope, hash), the `story_path` column names the chain resolved from the retained findings (the hash only as a disclosed placeholder), and the payload says `registered` / `already_muted` / `story_path` truthfully. `remove_server` resolves against `config_monitored_servers` — the table it deletes from — so a definition that never connected is removable, with `ever_connected` and `matched_in` disclosed. Descriptions fixed: `audit_config` (no edition branch exists; PostgreSQL targets are refused and redirected), Lite `get_cpu_utilization` (one ring-buffer record per minute; 15 s is Azure's `dm_db_resource_stats`), the plan tools (`top_operators` publishes its cap/count/truncation and its ranking basis; `missing_indexes` carries a labelled statement-scoped impact and column lists, no paste-ready DDL), `get_ag_health` (lag not banded, lag 0 while suspended, stale last snapshot), the duration-trend catalogue line, and `get_resource_semaphore` row order now matches across SKUs. +- **The web server page labelled page sums as totals, drew one instant as a trend, and four tools called their capture time by another name** ([#3653]) - `get_pg_database_stats` now computes `total_temp_files` / `total_temp_bytes` / `total_deadlocks`, `database_count`, a cluster-wide `cache_hit_pct` and the reset flag as window aggregates on the same statement as its rows, publishes the page's own figures as `returned_*` / `databases_returned` / `cache_hit_pct_of_returned`, observes `truncated` off a `limit + 1` fetch instead of inferring `limit_reached`, and the A7 census's one stated allowance is gone; `get_pg_io_stats` spells its page count `combinations_returned` like every other paged tool. The Memory Grants line chart drew `grants[]` — one instant, every row at the same stamp — under a window caption; it and the Resource Semaphore table are now two tables per read, the `window[]` aggregates (peak waiters and when, peak granted, floor of available, timeouts and forced grants across the window) first and the newest snapshot second, labelled as a moment. `get_database_sizes`, `get_running_jobs`, `get_server_properties` and `get_session_stats` stamp `captured_at` on both SKUs and join the latest-is-a-time roster; the `StampedUnderCollectionTime` allowance is deleted. +- **The wait and perfmon anomaly baselines stop counting every restart's fabricated zero as a quiet sample** ([#3653]) - Interval-honest successor aggregates (`sample_interval_seconds IS DISTINCT FROM 0` baked in, the measured interval carried) replace the legacy pair in place; the provider reads whichever supply covers its window, divides by the stored interval and applies the `LAG > N` heuristic only to pre-column rows, and the legacy pair retires by a self-executing coverage condition about five days after the release. The startup baseline backfill now fires on the first start (its gate read coverage through the real-time view), and a Daily-routed Performance Calendar answers the days its rollup has not reached from raw instead of printing `unique_queries = 0`. +- **Three PostgreSQL pages stop guessing truncation from a full page, and four of the eleven payload rules stop being sentences** ([#3653]) - `get_pg_deadlocks`, `get_pg_plan_capture_readiness` and `get_pg_index_bloat` published `truncated = rows.Count >= limit`, and the two that withhold their summaries on that flag withheld them for pages that were the whole set; `get_pg_plans` cut at `limit` and said nothing. All four now fetch `limit + 1` and observe through one shared `McpHelpers.BoundPage`, the page census sweeps the inference across every tool body on both SKUs instead of a roster (which is why it missed these), and `McpPayloadContractCensusTests` pins errors-one-shape, refuse-what-you-cannot-honor and name-is-truth as far as a census honestly can, with the one-vocabulary inventories (14 truncation dialects, 8 severity spellings, two error shapes) as exact rosters for the lane that collapses them. +- **The MCP query-duration trend still divided a restart's zero into 0.00 after the viewer stopped, and two sentences that #3695/#3696 made false** ([#3653]) - `get_query_duration_trend`'s raw route now reads `query_stats.sample_interval_seconds` three-state through the same Storage builder the viewer runs (`DarlingTrendReader.QueryDurationTrendSql` and both `ProcedureDurationTrendSql` consts are aliases of `DurationTrendRouting`), so a restart collection is unrated instead of a confident 0.00 ms/sec and a measured pass is no longer halved by a LAG spanning it. The trend trio's descriptions say which points are rated over what (rollup buckets over their width, first bucket included; raw points over the stored interval or, lacking one, the LAG). `get_cpu_utilization`'s Darling note ports Lite's corrected cadences (one ring-buffer record per minute on-prem; 15 s is Azure's `sys.dm_db_resource_stats`), pinned byte-identical across SKUs. +- **The perfmon chart plotted deltas under a "Value" label with the divisor sitting unused on the row, and a latch/spinlock restart read as zero** ([#3653]) - both viewers now shape every perfmon series through the stored `sample_interval_seconds` via one shared `DeltaSeriesShaping`: a counter whose name ends in `/sec` plots per second (a name proxy until the `cntr_type` rung lands, its mis-classes named), every other counter plots its raw delta under a legend and axis that say so, and a restart's (0, 0) is a line break, not a trough. Both latch/spinlock snapshot grids render the (0, 0) marker as "—" with an Interval (sec) column saying "restart / first sample", and Lite's `get_latch_stats` / `get_spinlock_stats` publish null, not 0, for it. The gap clause was already landed by #1944's cadence rule; this adds the restart-at-normal-cadence break it could not see. +- **One payload said NoData and No Data, and the page cut had five names** ([#3653]) - get_daily_summary / get_daily_summary_range publish overall_health and health_band from one enum token on both SKUs; four PostgreSQL tools, the autovacuum run history and get_analysis_findings stop inferring a cut from a full page and fetch one past their cap through McpHelpers.BoundPage, publishing truncated and *_returned; McpPayloadContractCensusTests classifies every cut key and severity-word literal by what it is (six of #3699's eight "severity spellings" were other vocabularies) and fails a retired or unclassified spelling by name. McpHelpers.ValidateDaysBack adopts the five inline days_back refusals and list_servers goes through FormatError; FormatError's wire shape awaits ruling Q11. +- **Five families subtracted from the old instance once before anyone noticed it had changed, and Aurora's wait counters had no one watching for a restart at all** ([#3653]) - #3694's only SQL Server identity carrier was `cpu_utilization`, tenth in the schedule, so on the pass where a restart, failover or re-point first became visible wait_stats, latch_stats, spinlock_stats, query_stats and procedure_stats each subtracted the new instance's counters from the dead instance's baseline once and then ate a second (0, 0) re-baseline pass. `WaitStatsCollector`, first in the order on both hosts, now carries the identity pair (`sqlserver_start_time`, `@@SERVERNAME`) as a second result set observed after the rows are read and before anything subtracts, so every SQL Server delta family re-baselines against nothing on the epoch pass; the CPU carrier stays as the fallback for an operator who disables wait_stats, and `ServerEpoch` remembers per calculator and per server the identity it last forgot to, so two carriers seeing one epoch forget once. `PgWaitStatsCollector` carries `pg_postmaster_start_time()` as its own epoch (a clean restart zeroes `aurora_stat_system_waits()` while leaving `pg_stat_statements_info.stats_reset` continuous) and forgets only the wait groups. Both census rosters (`FamiliesThatSubtractOnceBeforeTheCarrier`, `FamiliesWithoutAnEpochCarrier`) are empty and asserted empty. No Azure SQL DB epoch (#3694's ruling stands); the marker is still the run's `collection_log` note plus `collector_state`, not rendered. +- **Lite's plan-cache trend descriptions rated every point over the gap since the previous one, the shared unrated_note named one of two unrated reasons, and the latch/spinlock restart row was spelled two ways across SKUs** ([#3653]) - Lite's `get_query_duration_trend` / `get_procedure_duration_trend` descriptions and instructions row now carry the three-state rule (stored interval; a restart's 0 is unrated; LAG only where no interval was stored). The trio's `unrated_note` names both the stored-0 restart and the first-in-window LAG in one sentence, byte-identical on both SKUs. `get_latch_stats` / `get_spinlock_stats` publish the unknowable row one way on both SKUs — per-second rates null, `interval_seconds` null beside them, the latest delta null — with Lite gaining `interval_seconds` and the per-second pair, Darling's latch nulling `severity` and the banded-from delta instead of a LOW from a zero nobody measured, and Darling's spinlock query returning the interval its null rates lacked. +- **Fifteen rate arms spelled "unknowable" as 0 behind a guard that happened to hide it** ([#3653]) - Every `CASE WHEN interval > 0 THEN delta / interval` that fell back to `ELSE 0` — the file-I/O throughput trend on both SKUs, nine LAG-differenced PostgreSQL trend rates, and the two wait-ms/sec baseline arms — now ends at `END`, so a collection with no interval to rate over yields NULL rather than a measured 0.00; the PostgreSQL trend readers and `get_pg_*_trend` carry that null instead of reading it back as 0, and `evictions_per_second` follows. Two of the fifteen were live: two collections landing in one second on a pre-column store rated a 0 ms/sec sample into the wait baseline (mean 66.7 where the rated collections say 100), so the baseline's row filter also takes Lite's `interval_sec > 0` before the restart LAG. Both census rosters are empty and asserted empty. +- **A falling gauge read as a counter reset because the store did not know it was a gauge** ([#3653]) - `perfmon_stats` gains `cntr_type` (Darling V132 / Lite v62), so the collector writes a gauge such as Total Server Memory (KB) as its level with no delta instead of differencing it like Batch Requests/sec and storing the (0, 0) "counter reset" marker when the level fell. Both viewers' perfmon charts plot a gauge as its value, a rate per second and everything else as its per-interval delta, classified by the stored type with the `/sec` name proxy kept only for rows written before the rung; both SKUs' `get_perfmon_stats` / `get_perfmon_trend` publish `cntr_type` and `counter_kind` and null a gauge's `delta_value`. The ten Wait Statistics "Average wait time (ms)" instances are PERF_AVERAGE_BULK numerators whose average needs a base row this store does not join — stated, not fixed. +- **A maintenance job's own sub-threshold anomalies fold onto the job's incident and name the job** ([#3704]) - #3632's three maintenance edges (SCH_M, IO_WRITE_LATENCY_MS, WRITELOG → RUNNING_JOBS, gated on the job having fired) were keyed on the regular symptom facts, and AnomalyIncidentReconciler folded an ANOMALY_* story only onto a regular story carrying its family — so four one-fact anomalies during one server's 116-minute index-maintenance job paged separately and never said the job's name. A maintenance-family anomaly's fold-target set now includes any story carrying RUNNING_JOBS (the same fired-gate, seen through the story set; no new graph edge), and its frozen Investigation gains one sentence naming the job from the fact's ObjectName (#3693). Non-maintenance anomalies stay solo, as #3632 ruled. +- **PostgreSQL baselines survive a shortened retention, and pg_cpu carries the CPU dispersion floor** ([#3691]) - The four `pg_*` raw hypertables the PostgreSQL-target baselines read directly were user-editable and unfloored, so a 7-day retention would have silently switched every PostgreSQL anomaly detector off; the purge now floors them at the 30-day baseline window, the detector's own minimum-history gate, exactly as #1757 floored `cpu_utilization` / `file_io_stats`. `BaselineMath.AbsStdDevFloorFor` gives `pg_cpu` (percent of the capacity ceiling) the 5-point floor SQL Server CPU carries, by unit parity, so a flat month of ACU utilisation no longer manufactures a display-capped z-score on a one-point wobble. +- **`compare_analysis` sigma-bands the PostgreSQL baselined metrics** ([#3691]) - On a PostgreSQL target the tool banded a 10 → 60 tps move "stable" (absolute rule; `PG_TPS` sits at ladder 0 by design) in the window the detector called 25σ, because only SQL Server keys were mapped to baselines. `PG_TPS`, `PG_CONNECTION_SATURATION` (on its peak session count, never the fraction), `PG_DEADLOCK_RATE` and `PG_CPU_PERCENT` (capacity unit only) now band against their own `pg_*` hour-of-week buckets; the `plan_cache_churn` note speaks the engine of the facts. SQL Server output is byte-identical. +- **`get_analysis_facts` now runs the anomaly detector on both engines** ([#3691]) - the read the tool sold as "every observation the engine sees" was collector + scorer only on Lite and Darling alike, so it never showed an ANOMALY_* / ANOMALY_PG_* fact and the detector's gate metadata (deviation_sigma, fire_threshold, baseline_samples, threshold_lineage) was reachable only through a finding that had already crossed the severity floor. The resolved engine's detector now runs between collector and scorer over the same window, gated on the coverage witness like the pass, so anomaly facts arrive scored with their metadata — including the ones that fired but stayed under the finding floor. Descriptions and instructions say so on both SKUs. +- **Full-edition `perfmon_stats.cntr_value_per_second` divided as an integer, so every counter under one event per second read 0/sec** ([#3653]) - The computed column is now `cntr_value_delta * 1.0 / NULLIF(sample_interval_seconds, 0)` (numeric(33,12)) in `install/02` and `06`, and `06` converges an existing install idempotently, guarded on `sys.computed_columns` by the column's integer type rather than its rewritten definition text. `report.daily_summary_v2`'s throughput rows stop averaging truncated zeros; the Dashboard's read was already fixed in #3658, this is the schema half. +- **The write family tells Aurora the truth** ([#3691]) - On aurora-postgres, PG_CHECKPOINT_PRESSURE and CONFIG_PG_MAX_WAL_SIZE were a permanent measured 0 and a forever-0.4 advisory about a knob the engine never consults (fifty clusters: sixty synthetic timed checkpoints an hour, requested share 0). Both are now emitted `not_applicable` with the shape and reason in metadata, score 0, root nothing, and say what Aurora does instead. Where the engine reports WAL, PG_WAL_VOLUME_SHIFT states the window's mean/peak bytes/s (or why it cannot) and ANOMALY_PG_WAL_VOLUME grades the peak against the server's own hour-of-week baseline, lifting and folding onto the checkpoint incident it leads. +- **Three hourly rollups counted every restart's fabricated zero as a sample, and a service outage longer than a day left a two-hour hole under a floor that said covered** ([#3653]) - `query_stats_interval_hourly`, `procedure_stats_interval_hourly` and `query_stats_db_interval_hourly` carry the collector's knowability verdict in their WHERE and the measured interval summed, every hourly-tier reader takes them where they reach as far as the legacy, and the refresh phase grid re-derived itself around them (heaviest refresh at :18, watch line 900 s). At service start every continuous aggregate is scanned for bucket ranges its source holds rows for and it never materialized, and each is closed with one refresh over exactly its bounds — no policy window widened. +- **The PostgreSQL engine absorbs what the v2 lanes reported back** ([#3691]) - Shortening PostgreSQL retention no longer starves the I/O-latency and WAL-volume detectors (both tables floored at the 30-day window). The I/O-latency baseline is built at a quarter-hour grain with a 250-read floor, so it is judged against this hour of the week rather than collapsing to the hour of the day. A slot-retention or replication-lag finding is now lifted by a fired WAL-volume anomaly (the co-fire had read a fact that could never fire), a Lock wait walks to the idle-in-transaction holder behind it, and the idle finding's next reads include the xmin-horizon and blocking tools. compare_analysis says which PostgreSQL keys are baseline-banded. Wave-3 stubs for the blocking family (lane 17). +- **`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. +- **`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. +- **`provision-roles.sql` stops at a role-name collision** ([#4809]) - When a role the script would create (`admin`, `viewer` or `mcp`) already exists without Darling's `darling-managed` marker, psql stops there with exit status 3 and leaves that role as it was. A caller's own `ON_ERROR_STOP` setting is kept. The README's psql command now passes `-X`, so an operator's psqlrc can't change the run, and asks for psql 10 or later. +- **Command-line verbs that open the store report an unusable store setting instead of crashing** ([#4809]) - Every verb that opens the store (`--validate-config`, `--check-settings`, the MCP and web endpoint verbs, `--add-server`, `--backfill-rollups` and the others) now exits 1 with a clear message when the store connection string can't be used. A managed store's unreadable credential, a DPAPI failure included, is reported as that. +- **Azure SQL Database and Managed Instance servers show their platform, not a SQL Server year** ([#4870]) - An Azure SQL Database showed as "SQL Server 2014". The MCP `list_servers` tool, the Viewer's server list and the Add-server test now say "Azure SQL Database" or "Azure SQL Managed Instance". Other servers keep their label. +- **Lite's MCP plan tools say Lite keeps no plans** ([#4871]) - They said a plan "may have been evicted from the plan cache", but Lite never stores plans. `analyze_query_plan`, `analyze_procedure_plan` and `get_plan_xml` now answer `not_collected`, say so, and point to `analyze_plan_xml`, and Lite's `analyze_server` next-step hints suggest `analyze_plan_xml` too. +- **Lite's MCP tools and FinOps inventory read the collected server properties** ([#4872]) - Lite looked up the edition and FinOps figures in a table that is never filled. On Azure SQL Database, 15 MCP tools answered `empty` or "may not have run yet" instead of `not_collected`, and the Server Inventory never showed average CPU, storage, idle database count or provisioning status. Both now read the collected server properties. `audit_config` names editions correctly in Lite and Darling. A server with no CPU sample in the last 24 hours shows no provisioning verdict, where it read as 0% CPU and over-provisioned. +- **Alert History's expanded rows show their labels** ([#4873]) - Blocking and incident details in Alert History showed bare values, with their labels pushed out of sight. Each value now shows its label, and each item's heading sits on its own row. +- **The server health starter dashboard can be created again, server pages show display names, and count charts use whole numbers** ([#4874]) - Creating the "Server health at a glance" dashboard failed, server pages showed registry keys instead of display names, and count axes repeated labels. +- **Darling stores Query Store text and plans for Azure SQL Database** ([#4875]) - On Azure SQL Database, Darling stored Query Store rows with no statement text and no plan, so plan analysis reported the plan as unavailable and blamed the database's capture mode. Darling now fetches the text and plan for each database it reads, and the missing-plan message also covers a plan that hasn't been collected yet. +- **Azure SQL Database no longer shows the host's hardware as its own** ([#4876], [#4882]) - On Azure SQL Database, the web's Server Properties, `get_server_properties`, the server inventory and FinOps showed the host machine's memory, sockets, cores per socket and hyperthread ratio as if they were the database's. Those now read n/a, with a note that they describe the host, and the service objective is shown. Logical CPUs still show, as the database's own scheduler count. +- **FinOps stops advising shrinks without CPU data, or VM and memory changes on Azure SQL Database** ([#4877]) - A server with no CPU sample in the window read as 0% CPU and was told to cut cores. It now gets no CPU or VM right-sizing advice. On Azure SQL Database, VM and memory right-sizing advice no longer appears, since a database's memory comes with its service objective and can't be resized on its own. CPU advice still applies there. +- **File I/O shows real file sizes on Azure SQL Database, and no size for a Hyperscale log** ([#4878]) - On Azure SQL Database, File I/O now takes each file's size from the database's own file list, so a Hyperscale data file shows its real size instead of a fraction of a megabyte. A Hyperscale log file lives in the log service, so it shows "n/a (log service)" with no size, and no size total counts it. Both apps. SQL Server and Managed Instance are unchanged. +- **Web panels show the history their read keeps when the Range asks for more** ([#4881]) - With the web server page's Range at "last 30 days", a panel whose read keeps only 7 days showed a "pick a shorter range" notice and no data. It now shows the last 7 days, says so, and its chart spans those days. Saved views behave the same way. In the view editor, Save and Auto-detect work for such a panel. +- **Azure SQL Database figures use the database's own vCores and memory limit** ([#4879]) - On Azure SQL Database, CPU share in top queries and top procedures is now measured against the database's vCores, so a 1-vCore database no longer shows half its real share. The FinOps Utilization card's CPU count shows the vCores too. A DTU-model database or an elastic pool names no vCores, so there the count and the share read n/a instead of using the host's count. The card's memory figure is captioned "Memory limit", since it is the database's own limit and not physical RAM. Both apps. +- **A Hyperscale log file no longer counts as ~1 TB of database storage** ([#4880]) - On Azure SQL Database Hyperscale the log lives in the log service, but its file reported about 1 TB, which inflated Database Sizes and the FinOps storage totals. It now reads "n/a (log service)" and stays out of every allocated total, in Lite, the Darling Viewer and the web, and `get_database_sizes` returns no size for it, with a note. Storage Growth leaves it out of the earlier sums too, so a database's older rows don't show up as a sudden shrink. +- **Wait names with a trailing space are trimmed, and two Hyperscale timer waits are ignored** ([#4884]) - Four wait names come back from SQL Server with a trailing space: EXTERNAL_GOVERNANCE_ATTR_SYNC_BACKGROUND, EDC_DOPP_LOCK, EDC_DOPP_BACKGROUND and SQP_STATS_REPORTING. An ignore entry or a lookup by the clean name never matched them. Both apps now trim the name as they read it. The first sample under the trimmed name starts fresh, so the upgrade shows no spike, and rows stored with the space stay until retention removes them. RBIO_COMM_RETRY and SQP_STATS_REPORTING, fixed-interval timers on Hyperscale, join the default ignore list for Darling and for new Lite installs. An existing Lite install keeps its own list. REMOTE_BLOCK_IO stays visible. +- **Lite no longer stores events twice, or loses its settings, after its 512 MB archive-and-reset** ([#4887]) - When the database passed 512 MB, Lite archived it to Parquet and reset it. The next collection then stored recent deadlocks, blocked-process reports, long queries and CPU and memory-pressure samples a second time, and re-read default trace and job history from the start. After the next restart, alerts that had already been sent could fire again, and a restart during an alert's cooldown could send it again. The reset also lost the user's analysis mutes, server tags and tag assignments. On a store created by an older version, it could fail to restore saved alert state or swap two of its timestamps. Lite now carries on from where it stopped across the reset, and keeps its alert, collector and user settings. Copies that an earlier reset stored now count once: blocked process reports, long query completions and system_health events show and count once ([#4918]), and deadlock copies are removed or counted once ([#4910]). Copied CPU and memory-pressure samples are not removed. +- **Perfmon rate counters show a per-second rate** ([#4883]) - The web Perfmon Counters grid showed a rate counter's stored value, which is a running total since the counter started, so Batch Requests/sec could read 11,641. The grid now shows the rate under "Per second" and the running total under "Total since counter start", and the trend chart below it plots rate counters per second. A small rate no longer reads as 0: one deadlock in 300 seconds shows 0.0033 a second. `get_perfmon_stats` and `get_perfmon_trend` add a `per_second` field for rate counters, in Lite and in Darling. +- **On Azure SQL Database, empty tabs say their collector doesn't run there, and the page file and memory state read n/a** ([#4888]) - Default Trace said there were no events in the window, CPU Scheduler showed nothing, and the ten System Events tabs fed by the system_health session said there were no events. None of those collectors runs on Azure SQL Database, and each tab now says so, in Lite and the Darling Viewer. Memory > Overview showed the page file as 0 MB and the memory state as "Available", values the collector stores because it has no source for them there. Both now read n/a in both apps and on the web, and `get_memory_stats` returns the state as null with a note. Lite's `get_blocked_process_reports` labels each row's source ("blocked-process-report" or "DMV snapshot"), as Darling's `get_blocking` does. +- **Lite keeps its saved settings through a crash during the archive-and-reset, and no longer double-counts an interrupted one** ([#4889]) - When Lite archived and reset its database, it copied the settings it keeps (mute rules, dismissed archive alerts, and, with #4887, alert state and server tags) to a temporary folder and put them back after the reset. A crash, a forced restart or an end-task between those two steps lost them silently. The copy now lives in the archive folder behind a marker, and the next start puts the settings back before anything reads them. While a restore is pending, those settings are read-only, so a change can't be undone at the next start. Changes made to them while the reset was starting are no longer lost either, which happened on every reset. A reset interrupted before the database was replaced no longer leaves its archive files counting history twice. A mute-rule edit or snooze that couldn't be saved is now reported as not saved, instead of taking effect until the next restart. +- **Azure SQL Database shows its own CPU count and calls its memory a limit** ([#4882]) - On Azure SQL Database, Logical CPUs show again in Server Properties, the server inventory and `get_server_properties`, as the database's own scheduler count. Memory, sockets, cores per socket and hyperthread ratio stay blank, because they describe the host. The Memory tabs in Lite, the Darling Viewer and the web, and the ready-made memory dashboard, label the totals "Memory limit" and "Available under limit", and `get_memory_stats` adds a note that the total is the database's limit, so use near 100% is normal. FinOps says "vCores" beside the CPU count and in CPU right-sizing advice, and shows Worker Threads in use as n/a when it wasn't collected, instead of 0. The plan viewer's Server Context card shows vCores and no host memory. On every edition, the FinOps health score now leaves out the CPU term when the window has no CPU sample, where it used to score a full 100. +- **Other databases on an Azure SQL Database server show their allocated size, with used space beside it** ([#4890]) - Database Sizes showed each other database's used space as its size, so a Hyperscale database read 119 MB with 10,240 MB allocated. Each now shows its allocated size as the total and its used space beside it. Its log size reads n/a in the Database Sizes grids, the web table and `get_database_sizes`, because the server doesn't report it, and Storage Growth and the Allocated vs Used chart say when a database's log isn't counted. At upgrade, the stored size of these databases jumps from used to allocated. Storage Growth and the file growth alert leave the older rows out, so the jump isn't read as growth, and these databases show no past size until new history builds up. A used size that wasn't read is reported as null, not 0. +- **On Azure SQL Database, an unknown volume is no longer reported as 0 MB free** ([#4892]) - Azure SQL Database doesn't expose the volume under a database file, so none is collected. Lite's `get_database_sizes` reported that as an empty mount point with 0 MB total and 0 MB free, which reads as a full volume. It now returns null for all three, as Darling does. The file-growth alert in both apps shows the free space and the file's share of the volume as n/a instead of 0.0 GB and 0%, and the FinOps grids show n/a for an unknown volume. +- **A new Azure SQL Database Hyperscale database no longer raises a wait-profile anomaly on every analysis window for its first three days** ([#4893]) - Until a server has three days of history, the wait-profile anomaly fires on a fixed bar of 250 ms of waiting per second. On Hyperscale, REMOTE_BLOCK_IO alone runs at about 1,000 ms/s on an idle database, so every window fired. On Azure SQL Database that bar now leaves REMOTE_BLOCK_IO out of the rate it tests. The wait is still collected, charted and counted in the reported rate, and SQL Server, Managed Instance and any server with an established baseline are judged as before. +- **Lite's FinOps advice, High Impact Queries and the SQL Server Agent check read archived data too** ([#4921]) - After Lite's 512 MB archive step, these saw only the data collected since then. The reserved-capacity, long-running-jobs and storage-latency advice judged their 7-day windows on hours of data, High Impact Queries showed only recent activity for any range, and a stopped SQL Server Agent read as never having run, as it also did 7 days after Agent last ran. They now read the archived rows too. +- **Lite keeps its learned database states, and its database state alerts stay right, after the 512 MB archive step** ([#4917]) - After Lite archived its data at 512 MB, or after a week with no database state rows for a server, the database state alert check read an empty table: it deleted every learned baseline and treated every database as recovered, so state alerts repeated or were lost. The editor also listed no databases, so their overrides couldn't be seen or changed. The check, the editor and the re-baseline button now read archived snapshots too. With fewer than two snapshots, or with data more than 7 days old, the check makes no decision: it doesn't fire, resolve or forget anything until the server collects again. +- **The Darling Viewer and Lite no longer close with an error when you check or uncheck a picker item** ([#4920]) - Checking or unchecking an item in the Wait Types, Memory Clerks or Perfmon Counters picker re-sorted the list inside the checkbox event, which WPF can reject with "Cannot modify the Visual children for this node because a tree walk is in progress", closing the app. The re-sort and chart update now run just after the event, once per burst of changes, and only when the selection changed. +- **A new server no longer reports that a collector never ran, or that it's AWS RDS, before the collector is due** ([#4915]) - Until a collector was due, `get_running_jobs` in Lite and Darling said the collector was switched off or that the server was AWS RDS. A collector is due at the server's first collection, plus its default interval, plus 10 minutes: 15 minutes for Running Jobs. Before then, it now says the collector hasn't run yet, names when the server started and last collected and how often the collector runs by default, and returns `status` `unavailable` instead of `precondition`, which matters to an MCP client that branches on it. The empty-tab notes in Lite, the Darling Viewer and both database state editors say the same. Once a collector is overdue, the never-ran note returns, and the Running Jobs note names AWS RDS as a possible cause, not a certain one. +- **Silencing one of several databases that share a display name no longer silences the others, and their alerts no longer share a dedup key** ([#4908]) - Darling and the Viewer matched a whole-server silence by display name, and a database added with no display name shows its host, so two databases on one Azure SQL Database server shared one silence. A silence now keys on the server's store id. Existing silences keep exactly the effect they had, and Unsilence keeps silenced any other server an older silence covered. Alerts from a server that shares its display name with another registration now carry the store id in their dedup key; every other server keeps its key and its open incidents. +- **Blocking and deadlock counts for a time window agree everywhere, counted by when each event happened** ([#4909], [#4913]) - Grids, slicers, trends, severity graphs, the daily summary, the MCP reads, analysis findings, drill-downs and anomaly checks counted events by when they were collected, while the Overview and fleet cards counted them by when they happened, so one window could show different counts in different places. All of them now count by when the event happened, in both apps: an event from before the window that was collected inside it no longer counts, and one collected late still counts in the window it happened in. Alerts still pick up events by when they were collected, so a late-collected event still alerts. On PostgreSQL targets, a deadlock with no timestamp is counted by when it was collected. +- **Collection Health no longer makes a collector's latest counts look like a total for every run** ([#4914]) - Collection Health showed a collector's newest counts followed by "(all N runs)", so a quiet cycle read as "nothing stored in 174 runs" beside a grid of stored rows. The counts now read "latest run: ..." when every run recorded counts, and "latest noted run: ... (k of N runs)" otherwise, in both apps' health grids and in `get_collection_health` in both MCP servers. +- **An Azure SQL Database logical server monitored at master stores each deadlock once, and loses none** ([#4900], [#4910]) - The server-wide deadlock read keyed its cutoff on rows stored under `master`, but it stores each deadlock under the database it happened in, so every run re-read the last 10 minutes and stored the same deadlocks again, up to 10 times. A deadlock that both a database's own read and the server-wide read returned was also stored twice. Each read now keeps its own cutoff and re-reads 10 minutes behind it, so a late event is still stored, and a deadlock already stored (same server, time and exact graph) isn't stored again. A deadlock only a database's own read saw can no longer be skipped. Copies stored by earlier versions are removed once at startup, and Lite's archived copies are counted once. +- **On Azure SQL Database, a monitored master no longer repeats the blocking and deadlock alerts and findings of databases you also monitor on their own** ([#4894], [#4906]) - A target on a logical server's master database collects blocked-process reports and deadlocks for every database on the server, so each event for a database you also monitor as its own target alerted twice. Master now skips those databases' events (read-only-intent targets don't count as monitored) and still alerts on events for databases that aren't monitored on their own. Its analysis does the same: the blocking, blocking-chain and deadlock findings, their drill-down evidence, the anomaly counts and `analyze_server` leave out events of databases monitored on their own. With excluded databases configured, the blocking count now follows the same Extended Events preference as the unfiltered count instead of coming out higher. `get_deadlocks` names each deadlock's database in both apps. +- **Lite's Recommendations tab says there isn't enough data yet for a newly added server, instead of "All clear"** ([#4901]) - The tab showed "All clear" for a server with less than the 24 hours of history the analysis needs, because its refresh never checked how much history there was; only the Generate button did. It now shows the same not-enough-data message as the Darling Viewer. +- **FinOps no longer gives an Azure SQL Database logical server's master database a provisioning verdict or right-sizing advice** ([#4896]) - A target on a logical server's master database was rated over-provisioned and offered CPU, memory and VM right-sizing advice, though master has no service objective to resize. Both apps now show its provisioning as N/A, in the card, the 7-day trend and Server Inventory, and give it no right-sizing advice. User databases on Azure SQL Database, and SQL Server and Managed Instance, are judged as before. +- **FinOps picks up a server added while the app is open** ([#4898]) - Lite's Database Sizes and Storage Growth grids stayed empty for a newly added server until the app restarted. They now reload when the tab is shown again if their last load came back empty or failed. The Darling Viewer's FinOps server picker now lists servers added after the Viewer started. +- **FinOps right-sizing advice says how much data it's based on, and no longer advises "reduce from 4 GB to 4 GB"** ([#4905]) - The CPU, memory and storage right-sizing texts said "over the last 7 days" even on two hours of data. They now give the number of samples and the span they cover, for example "16 samples over 3 hours", up to 7 days. Memory advice is skipped when the recommended size, as shown, equals the current size, and idle-database advice waits until there are 7 days of query statistics. Both apps. +- **The Darling Viewer says when Azure SQL Database doesn't collect a tab's data, instead of showing an empty grid** ([#4904]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, the two change grids and Memory Pressure Events showed an empty grid or chart. They now say the data isn't collected there, and the database state editor says so in its status line. On AWS RDS, Running Jobs says the same. The FinOps Logical CPUs header explains that the count can differ from the vCores you pay for, and the Memory Overview shows an N/A memory model as n/a. +- **Databases on one Azure SQL Database server no longer get mixed up** ([#4899]) - In Lite, double-clicking an Overview card opens that card's own database, and each card keeps its own silenced bell. Import Settings in Lite and the Viewer no longer skips every database after the first on one server. When a server name matches several servers, on one host or across hosts, the MCP read tools in Lite and Darling list the matches instead of answering with the first, and a full name from the list picks one. The Viewer's `--open-server` link opens a server only when exactly one has that name, and says so when several do. +- **Lite says why a tab is empty when its collector doesn't run on Azure SQL Database** ([#4903]) - On Azure SQL Database, Running Jobs, Server Configuration, Trace Flags, Memory Pressure Events, the two configuration change grids and the Database State window showed an empty grid or chart. They now say the collector doesn't run there. On AWS RDS, Running Jobs says the same and no longer asks you to grant msdb access where no grant can help. On any engine, a tab now also says when its collector has never run for a server that is collecting other data. The FinOps Logical CPUs column has a tooltip that explains the count, and Memory Model shows n/a instead of N/A. +- **Optimized locking is read on Azure SQL Database, and a flag that couldn't be read shows as unknown, not off** ([#4907]) - Azure SQL Database reports major version 12, so the optimized-locking flag was never collected there, and every config view and `get_database_config` showed it as off. It's now collected there, and a flag that couldn't be read shows as unknown (null in MCP). When optimized locking is on, Locking & Contention and `get_object_locking` say that their per-index counters don't count transaction-ID lock waits, including when they have no rows. The upgrade doesn't record a false config change for the flag. +- **Storage Growth shows n/a, not 0, when there's no earlier size to compare** ([#4902]) - A database with no size row 7 or 30 days back, a server whose collection stopped more than a window ago, and a table in the per-table drill with no earlier sample all showed 0 growth, rate and percent in Lite and the Viewer. They now show n/a. The daily rate also divides by the real number of days between the two snapshots, instead of 7 or 30. + +### Security + +- **Scrubbed legacy plan-force-action audit text** ([#4384]) - a one-time startup pass rewrites audit lines written by older builds to the same safe form the read path already applies; every other field and row is left untouched. +- **Collected PostgreSQL statement text applies the same sensitive-statement filter as the store's own statements** ([#4383]) - matching text is withheld before storage, and a one-time job rewrites rows stored earlier. +- **Stored PostgreSQL setting values are redacted in more shapes, and the one-time scrub resumes a large server-day after a restart** ([#4380]). +- **Plan-force journal reads no longer return pre-#4326 exception text** ([#4363]) - Both plan-force journal reads now replace exception text written before #4326 with a fixed sentence; evidence lines written after #4326 are returned unchanged. +- **Stopped `/api/ping` and the analysis notes from echoing raw exception text** ([#4326]) - `/api/ping`'s + +[#2159]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/2159 +[#2711]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/2711 +[#3287]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3287 +[#3517]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3517 +[#3523]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3523 +[#3524]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3524 +[#3525]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3525 +[#3526]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3526 +[#3527]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3527 +[#3528]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3528 +[#3529]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3529 +[#3530]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3530 +[#3531]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3531 +[#3532]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3532 +[#3533]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3533 +[#3534]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3534 +[#3535]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3535 +[#3536]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3536 +[#3537]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3537 +[#3538]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3538 +[#3539]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3539 +[#3540]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3540 +[#3541]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3541 +[#3542]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3542 +[#3547]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3547 +[#3548]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3548 +[#3551]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3551 +[#3556]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3556 +[#3557]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3557 +[#3561]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3561 +[#3563]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3563 +[#3570]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3570 +[#3573]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3573 +[#3574]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3574 +[#3575]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3575 +[#3576]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3576 +[#3577]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3577 +[#3579]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3579 +[#3580]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3580 +[#3581]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3581 +[#3582]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3582 +[#3588]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3588 +[#3591]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3591 +[#3597]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3597 +[#3598]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3598 +[#3601]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3601 +[#3602]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3602 +[#3603]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3603 +[#3604]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3604 +[#3607]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3607 +[#3608]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3608 +[#3609]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3609 +[#3612]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3612 +[#3620]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3620 +[#3622]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3622 +[#3636]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3636 +[#3644]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3644 +[#3648]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3648 +[#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 +[#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 +[#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 +[#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 +[#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 +[#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 +[#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 +[#3886]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3886 +[#3889]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3889 +[#3898]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3898 +[#3899]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3899 +[#3900]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3900 +[#3904]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3904 +[#3906]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3906 +[#3908]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3908 +[#3909]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3909 +[#3911]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3911 +[#3914]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3914 +[#3915]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3915 +[#3918]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3918 +[#3919]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3919 +[#3920]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3920 +[#3927]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3927 +[#3931]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3931 +[#3932]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3932 +[#3940]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3940 +[#3942]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3942 +[#3946]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3946 +[#3947]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3947 +[#3950]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3950 +[#3952]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3952 +[#3953]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3953 +[#3955]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3955 +[#3956]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3956 +[#3957]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3957 +[#3964]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/3964 +[#3965]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3965 +[#3966]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3966 +[#3968]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3968 +[#3972]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3972 +[#3975]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3975 +[#3979]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3979 +[#3980]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3980 +[#3981]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3981 +[#3983]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3983 +[#3984]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3984 +[#3985]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3985 +[#3992]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3992 +[#3995]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3995 +[#3996]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3996 +[#3998]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/3998 +[#4001]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4001 +[#4002]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4002 +[#4003]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4003 +[#4007]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4007 +[#4010]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4010 +[#4011]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4011 +[#4013]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4013 +[#4015]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4015 +[#4016]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4016 +[#4020]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4020 +[#4022]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4022 +[#4025]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4025 +[#4029]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4029 +[#4030]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4030 +[#4031]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4031 +[#4032]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4032 +[#4036]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4036 +[#4038]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4038 +[#4039]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4039 +[#4040]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4040 +[#4042]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4042 +[#4044]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4044 +[#4047]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4047 +[#4048]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4048 +[#4049]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4049 +[#4050]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4050 +[#4051]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4051 +[#4055]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4055 +[#4057]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4057 +[#4061]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4061 +[#4063]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4063 +[#4064]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4064 +[#4065]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4065 +[#4066]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4066 +[#4067]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4067 +[#4068]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4068 +[#4069]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4069 +[#4070]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4070 +[#4071]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4071 +[#4073]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4073 +[#4074]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4074 +[#4077]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4077 +[#4078]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4078 +[#4079]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4079 +[#4081]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4081 +[#4082]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4082 +[#4083]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4083 +[#4084]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4084 +[#4085]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4085 +[#4086]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4086 +[#4087]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4087 +[#4088]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4088 +[#4089]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4089 +[#4090]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4090 +[#4091]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4091 +[#4092]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4092 +[#4093]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4093 +[#4095]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4095 +[#4096]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4096 +[#4099]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4099 +[#4100]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4100 +[#4101]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4101 +[#4103]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4103 +[#4105]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4105 +[#4106]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4106 +[#4107]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4107 +[#4108]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4108 +[#4109]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4109 +[#4110]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4110 +[#4111]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4111 +[#4113]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4113 +[#4114]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4114 +[#4115]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4115 +[#4116]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4116 +[#4117]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4117 +[#4118]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4118 +[#4119]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4119 +[#4120]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4120 +[#4121]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4121 +[#4122]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4122 +[#4123]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4123 +[#4124]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4124 +[#4125]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4125 +[#4126]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4126 +[#4127]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4127 +[#4131]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4131 +[#4133]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4133 +[#4136]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4136 +[#4137]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4137 +[#4141]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4141 +[#4157]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4157 +[#4186]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4186 +[#4198]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/4198 +[#4203]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/4203 +[#4206]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4206 +[#4208]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4208 +[#4228]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4228 +[#4230]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4230 +[#4252]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4252 +[#4254]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4254 +[#4256]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4256 +[#4258]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4258 +[#4259]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4259 +[#4260]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4260 +[#4261]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4261 +[#4263]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4263 +[#4271]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4271 +[#4278]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4278 +[#4279]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4279 +[#4280]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4280 +[#4281]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4281 +[#4282]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4282 +[#4285]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4285 +[#4286]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4286 +[#4287]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4287 +[#4288]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4288 +[#4291]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4291 +[#4292]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4292 +[#4293]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4293 +[#4294]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4294 +[#4295]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4295 +[#4297]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4297 +[#4302]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4302 +[#4303]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4303 +[#4304]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4304 +[#4306]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4306 +[#4307]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4307 +[#4308]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4308 +[#4309]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4309 +[#4311]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4311 +[#4317]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4317 +[#4319]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4319 +[#4321]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4321 +[#4324]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4324 +[#4326]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4326 +[#4327]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4327 +[#4328]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4328 +[#4329]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4329 +[#4330]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4330 +[#4331]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4331 +[#4333]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4333 +[#4336]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4336 +[#4337]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4337 +[#4338]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4338 +[#4339]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4339 +[#4340]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4340 +[#4341]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4341 +[#4342]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4342 +[#4344]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4344 +[#4345]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4345 +[#4347]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4347 +[#4350]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4350 +[#4351]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4351 +[#4352]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4352 +[#4353]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4353 +[#4357]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4357 +[#4358]: https://github.com/erikdarlingdata/PerformanceMonitor/issues/4358 +[#4359]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4359 +[#4361]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4361 +[#4362]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4362 +[#4363]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4363 +[#4364]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4364 +[#4365]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4365 +[#4366]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4366 +[#4367]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4367 +[#4368]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4368 +[#4370]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4370 +[#4371]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4371 +[#4372]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4372 +[#4373]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4373 +[#4380]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4380 +[#4382]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4382 +[#4383]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4383 +[#4384]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4384 +[#4386]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4386 +[#4387]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4387 +[#4388]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4388 +[#4390]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4390 +[#4391]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4391 +[#4392]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4392 +[#4393]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4393 +[#4395]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4395 +[#4396]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4396 +[#4399]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4399 +[#4402]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4402 +[#4405]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4405 +[#4406]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4406 +[#4407]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4407 +[#4408]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4408 +[#4409]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4409 +[#4411]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4411 +[#4412]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4412 +[#4413]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4413 +[#4416]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4416 +[#4417]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4417 +[#4418]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4418 +[#4419]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4419 +[#4420]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4420 +[#4421]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4421 +[#4422]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4422 +[#4423]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4423 +[#4424]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4424 +[#4426]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4426 +[#4429]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4429 +[#4430]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4430 +[#4431]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4431 +[#4432]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4432 +[#4433]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4433 +[#4434]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4434 +[#4435]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4435 +[#4436]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4436 +[#4437]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4437 +[#4439]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4439 +[#4444]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4444 +[#4447]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4447 +[#4454]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4454 +[#4455]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4455 +[#4456]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4456 +[#4458]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4458 +[#4464]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4464 +[#4465]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4465 +[#4467]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4467 +[#4470]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4470 +[#4472]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4472 +[#4474]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4474 +[#4480]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4480 +[#4481]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4481 +[#4482]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4482 +[#4483]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4483 +[#4486]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4486 +[#4488]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4488 +[#4489]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4489 +[#4490]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4490 +[#4492]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4492 +[#4493]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4493 +[#4494]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4494 +[#4495]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4495 +[#4496]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4496 +[#4501]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4501 +[#4502]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4502 +[#4506]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4506 +[#4509]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4509 +[#4538]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4538 +[#4540]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4540 +[#4541]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4541 +[#4542]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4542 +[#4543]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4543 +[#4544]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4544 +[#4545]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4545 +[#4547]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4547 +[#4548]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4548 +[#4549]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4549 +[#4550]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4550 +[#4551]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4551 +[#4552]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4552 +[#4553]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4553 +[#4554]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4554 +[#4555]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4555 +[#4556]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4556 +[#4557]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4557 +[#4559]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4559 +[#4560]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4560 +[#4561]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4561 +[#4562]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4562 +[#4563]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4563 +[#4565]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4565 +[#4567]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4567 +[#4568]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4568 +[#4583]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4583 +[#4585]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4585 +[#4586]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4586 +[#4587]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4587 +[#4588]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4588 +[#4590]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4590 +[#4591]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4591 +[#4592]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4592 +[#4593]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4593 +[#4595]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4595 +[#4596]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4596 +[#4599]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4599 +[#4600]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4600 +[#4601]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4601 +[#4602]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4602 +[#4603]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4603 +[#4604]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4604 +[#4610]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4610 +[#4612]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4612 +[#4614]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4614 +[#4615]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4615 +[#4616]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4616 +[#4617]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4617 +[#4618]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4618 +[#4625]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4625 +[#4626]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4626 +[#4632]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4632 +[#4633]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4633 +[#4634]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4634 +[#4643]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4643 +[#4644]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4644 +[#4646]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4646 +[#4647]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4647 +[#4649]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4649 +[#4656]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4656 +[#4658]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4658 +[#4664]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4664 +[#4665]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4665 +[#4667]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4667 +[#4669]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4669 +[#4671]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4671 +[#4680]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4680 +[#4682]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4682 +[#4685]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4685 +[#4688]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4688 +[#4698]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4698 +[#4700]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4700 +[#4703]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4703 +[#4704]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4704 +[#4705]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4705 +[#4712]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4712 +[#4713]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4713 +[#4714]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4714 +[#4717]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4717 +[#4718]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4718 +[#4725]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4725 +[#4738]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4738 +[#4739]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4739 +[#4740]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4740 +[#4742]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4742 +[#4753]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4753 +[#4762]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4762 +[#4763]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4763 +[#4775]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4775 +[#4777]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4777 +[#4778]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4778 +[#4779]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4779 +[#4780]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4780 +[#4781]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4781 +[#4783]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4783 +[#4784]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4784 +[#4786]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4786 +[#4787]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4787 +[#4790]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4790 +[#4791]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4791 +[#4792]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4792 +[#4794]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4794 +[#4796]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4796 +[#4797]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4797 +[#4798]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4798 +[#4799]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4799 +[#4801]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4801 +[#4802]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4802 +[#4803]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4803 +[#4804]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4804 +[#4805]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4805 +[#4806]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4806 +[#4808]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4808 +[#4809]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4809 +[#4810]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4810 +[#4811]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4811 +[#4813]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4813 +[#4814]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4814 +[#4816]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4816 +[#4818]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4818 +[#4820]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4820 +[#4826]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4826 +[#4827]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4827 +[#4828]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4828 +[#4829]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4829 +[#4830]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4830 +[#4831]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4831 +[#4832]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4832 +[#4833]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4833 +[#4835]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4835 +[#4837]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4837 +[#4838]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4838 +[#4839]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4839 +[#4840]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4840 +[#4841]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4841 +[#4846]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4846 +[#4847]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4847 +[#4848]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4848 +[#4849]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4849 +[#4850]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4850 +[#4851]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4851 +[#4852]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4852 +[#4853]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4853 +[#4854]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4854 +[#4855]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4855 +[#4858]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4858 +[#4859]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4859 +[#4861]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4861 +[#4863]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4863 +[#4867]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4867 +[#4870]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4870 +[#4871]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4871 +[#4872]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4872 +[#4873]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4873 +[#4874]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4874 +[#4875]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4875 +[#4876]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4876 +[#4877]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4877 +[#4878]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4878 +[#4879]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4879 +[#4880]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4880 +[#4881]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4881 +[#4882]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4882 +[#4883]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4883 +[#4884]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4884 +[#4886]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4886 +[#4887]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4887 +[#4888]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4888 +[#4889]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4889 +[#4890]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4890 +[#4892]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4892 +[#4893]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4893 +[#4894]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4894 +[#4896]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4896 +[#4898]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4898 +[#4899]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4899 +[#4900]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4900 +[#4901]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4901 +[#4902]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4902 +[#4903]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4903 +[#4904]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4904 +[#4905]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4905 +[#4906]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4906 +[#4907]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4907 +[#4908]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4908 +[#4909]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4909 +[#4910]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4910 +[#4912]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4912 +[#4913]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4913 +[#4914]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4914 +[#4915]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4915 +[#4917]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4917 +[#4918]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4918 +[#4920]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4920 +[#4921]: https://github.com/erikdarlingdata/PerformanceMonitor/pull/4921 diff --git a/tools/changelog/archive-census.txt b/tools/changelog/archive-census.txt index 083d2e8c02..6c8c83f3b6 100644 --- a/tools/changelog/archive-census.txt +++ b/tools/changelog/archive-census.txt @@ -10,6 +10,7 @@ # fails CI. It is the durable half of the proof; `roundtrip` is the whole-document half and # needs the pre-split revision to compare against. +3.9.0 756 a5674294b08e847a269d5585424c7dad04e51e9be54aed8ab7daf43a39d4cc06 3.8.0 35 7c531d7f349f1432913ae72b9ea8542821878e15f1aafe9c8a773abc55e7a5e1 3.7.0 279 8912147a684e50dbd37b772b44688d68b71f46b854b5f90a2cfd9aeca5c71021 3.6.0 111 18d83858c51eee65c76c97e9e6d8ff90b6553e38a66388b4346c3d36e20bbaa0 From c3bf9a5080896c0465fb799004a26951358eb15d Mon Sep 17 00:00:00 2001 From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com> Date: Thu, 1 Oct 2026 18:07:11 -0400 Subject: [PATCH 5/5] Add the v3.8.0 migration-ladder fixture Generated from the v3.8.0 tag by tools/generate-ladder-fixture, not hand-written: 124 rungs, top V125. --- .../Fixtures/migration-ladder-v3.8.0.sql | 4665 +++++++++++++++++ 1 file changed, 4665 insertions(+) create mode 100644 Darling/Darling.Tests/Fixtures/migration-ladder-v3.8.0.sql diff --git a/Darling/Darling.Tests/Fixtures/migration-ladder-v3.8.0.sql b/Darling/Darling.Tests/Fixtures/migration-ladder-v3.8.0.sql new file mode 100644 index 0000000000..22ac20fa94 --- /dev/null +++ b/Darling/Darling.Tests/Fixtures/migration-ladder-v3.8.0.sql @@ -0,0 +1,4665 @@ +-- Migration ladder as RESOLVED by the release this fixture is named for — every rung's +-- SQL frozen as that era's code (including its generators) emitted it, plus the same +-- version-table DDL and stamps MigrateLockedAsync writes. Generated by tools/generate- +-- ladder-fixture; regenerate at each release cut from the release tag. DO NOT HAND-EDIT. +-- ===BATCH=== bootstrap +SET search_path = collect, config, public; +CREATE TABLE IF NOT EXISTS darling_schema_version ( + version integer NOT NULL PRIMARY KEY, + name text NOT NULL, + applied_at timestamp NOT NULL +); +-- ===BATCH=== V1 collector-tables +/* Darling collector tables — generated from PerformanceMonitor.Collectors definitions. + Column names and types mirror Lite's DuckDB schema (see PgSchemaGenerator remarks). */ + +CREATE TABLE IF NOT EXISTS wait_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + wait_type text, + waiting_tasks_count bigint, + wait_time_ms bigint, + signal_wait_time_ms bigint, + delta_waiting_tasks bigint, + delta_wait_time_ms bigint, + delta_signal_wait_time_ms bigint +); +CREATE INDEX IF NOT EXISTS idx_wait_stats_time ON wait_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS latch_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + latch_class text, + waiting_requests_count bigint, + wait_time_ms bigint, + max_wait_time_ms bigint, + delta_waiting_requests_count bigint, + delta_wait_time_ms bigint, + delta_max_wait_time_ms bigint +); +CREATE INDEX IF NOT EXISTS idx_latch_stats_time ON latch_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS spinlock_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + spinlock_name text, + collisions bigint, + spins bigint, + spins_per_collision double precision, + sleep_time bigint, + backoffs bigint, + delta_collisions bigint, + delta_spins bigint, + delta_sleep_time bigint, + delta_backoffs bigint +); +CREATE INDEX IF NOT EXISTS idx_spinlock_stats_time ON spinlock_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS cpu_scheduler_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + max_workers_count integer, + scheduler_count integer, + cpu_count integer, + total_runnable_tasks_count integer, + total_work_queue_count bigint, + total_current_workers_count integer, + avg_runnable_tasks_count numeric(38,2), + total_active_request_count integer, + total_queued_request_count integer, + total_blocked_task_count integer, + total_active_parallel_thread_count bigint, + runnable_request_count integer, + total_request_count integer, + runnable_percent numeric(38,2), + worker_thread_exhaustion_warning boolean, + runnable_tasks_warning boolean, + blocked_tasks_warning boolean, + queued_requests_warning boolean, + total_physical_memory_kb bigint, + available_physical_memory_kb bigint, + system_memory_state_desc text, + physical_memory_pressure_warning boolean, + total_node_count integer, + nodes_online_count integer, + offline_cpu_count integer, + offline_cpu_warning boolean +); +CREATE INDEX IF NOT EXISTS idx_cpu_scheduler_stats_time ON cpu_scheduler_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS plan_cache_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + cacheobjtype text, + objtype text, + total_plans integer, + total_size_mb integer, + single_use_plans integer, + single_use_size_mb integer, + multi_use_plans integer, + multi_use_size_mb integer, + avg_use_count numeric(38,2), + avg_size_kb integer, + oldest_plan_create_time timestamp +); +CREATE INDEX IF NOT EXISTS idx_plan_cache_stats_time ON plan_cache_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS tempdb_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + user_object_reserved_mb numeric(18,2), + internal_object_reserved_mb numeric(18,2), + version_store_reserved_mb numeric(18,2), + total_reserved_mb numeric(18,2), + unallocated_mb numeric(18,2), + total_sessions_using_tempdb bigint, + top_session_id integer, + top_session_tempdb_mb numeric(18,2), + max_size_mb numeric(18,2) +); +CREATE INDEX IF NOT EXISTS idx_tempdb_stats_time ON tempdb_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS memory_grant_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + resource_semaphore_id smallint, + pool_id integer, + target_memory_mb numeric(18,2), + max_target_memory_mb numeric(18,2), + total_memory_mb numeric(18,2), + available_memory_mb numeric(18,2), + granted_memory_mb numeric(18,2), + used_memory_mb numeric(18,2), + grantee_count integer, + waiter_count integer, + timeout_error_count bigint, + forced_grant_count bigint, + timeout_error_count_delta bigint, + forced_grant_count_delta bigint +); +CREATE INDEX IF NOT EXISTS idx_memory_grant_stats_time ON memory_grant_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS cpu_utilization_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + sample_time timestamp, + sqlserver_cpu_utilization integer, + other_process_cpu_utilization integer +); +CREATE INDEX IF NOT EXISTS idx_cpu_utilization_stats_time ON cpu_utilization_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS memory_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + total_physical_memory_mb numeric(18,2), + available_physical_memory_mb numeric(18,2), + total_page_file_mb numeric(18,2), + available_page_file_mb numeric(18,2), + system_memory_state text, + sql_memory_model text, + target_server_memory_mb numeric(18,2), + total_server_memory_mb numeric(18,2), + buffer_pool_mb numeric(18,2), + plan_cache_mb numeric(18,2), + max_workers_count integer, + current_workers_count integer +); +CREATE INDEX IF NOT EXISTS idx_memory_stats_time ON memory_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS memory_clerks ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + clerk_type text, + memory_mb numeric(18,2) +); +CREATE INDEX IF NOT EXISTS idx_memory_clerks_time ON memory_clerks(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS memory_pressure_events ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + sample_time timestamp, + memory_notification text, + memory_indicators_process integer, + memory_indicators_system integer +); +CREATE INDEX IF NOT EXISTS idx_memory_pressure_events_time ON memory_pressure_events(server_id, sample_time); + +CREATE TABLE IF NOT EXISTS file_io_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + file_name text, + file_type text, + physical_name text, + size_mb numeric(18,2), + num_of_reads bigint, + num_of_writes bigint, + read_bytes bigint, + write_bytes bigint, + io_stall_read_ms bigint, + io_stall_write_ms bigint, + io_stall_queued_read_ms bigint, + io_stall_queued_write_ms bigint, + delta_reads bigint, + delta_writes bigint, + delta_read_bytes bigint, + delta_write_bytes bigint, + delta_stall_read_ms bigint, + delta_stall_write_ms bigint, + delta_stall_queued_read_ms bigint, + delta_stall_queued_write_ms bigint +); +CREATE INDEX IF NOT EXISTS idx_file_io_stats_time ON file_io_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS server_properties ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + edition text, + product_version text, + product_level text, + product_update_level text, + engine_edition integer, + cpu_count integer, + hyperthread_ratio integer, + physical_memory_mb bigint, + socket_count integer, + cores_per_socket integer, + is_hadr_enabled boolean, + is_clustered boolean, + enterprise_features text, + service_objective text, + vcore_count integer, + lock_pages_in_memory boolean, + instant_file_initialization_enabled boolean, + memory_dump_count integer, + sqlserver_start_time timestamp, + host_os_version text, + ag_replica_role text, + utc_offset_minutes integer +); +CREATE INDEX IF NOT EXISTS idx_server_properties_time ON server_properties(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS server_config ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + configuration_name text, + value_configured bigint, + value_in_use bigint, + is_dynamic boolean, + is_advanced boolean +); + +CREATE TABLE IF NOT EXISTS database_config ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + state_desc text, + compatibility_level integer, + collation_name text, + recovery_model text, + is_read_only boolean, + is_auto_close_on boolean, + is_auto_shrink_on boolean, + is_auto_create_stats_on boolean, + is_auto_update_stats_on boolean, + is_auto_update_stats_async_on boolean, + is_read_committed_snapshot_on boolean, + snapshot_isolation_state text, + is_parameterization_forced boolean, + is_query_store_on boolean, + is_encrypted boolean, + is_trustworthy_on boolean, + is_db_chaining_on boolean, + is_broker_enabled boolean, + is_cdc_enabled boolean, + is_mixed_page_allocation_on boolean, + log_reuse_wait_desc text, + page_verify_option text, + target_recovery_time_seconds integer, + delayed_durability text, + is_accelerated_database_recovery_on boolean, + is_memory_optimized_enabled boolean, + is_optimized_locking_on boolean +); + +CREATE TABLE IF NOT EXISTS database_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + database_id integer, + state_desc text, + is_in_standby boolean +); +CREATE INDEX IF NOT EXISTS idx_database_states_time ON database_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS trace_flags ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + trace_flag integer, + status boolean, + is_global boolean, + is_session boolean +); +CREATE INDEX IF NOT EXISTS idx_trace_flags_time ON trace_flags(server_id, capture_time); + +CREATE TABLE IF NOT EXISTS database_scoped_config ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + configuration_name text, + value text, + value_for_secondary text +); +CREATE INDEX IF NOT EXISTS idx_database_scoped_config_time ON database_scoped_config(server_id, capture_time); + +CREATE TABLE IF NOT EXISTS query_store_health ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + actual_state text, + desired_state text, + readonly_reason integer, + current_storage_size_mb bigint, + max_storage_size_mb bigint, + size_based_cleanup_mode text, + stale_query_threshold_days bigint, + max_plans_per_query bigint, + interval_length_minutes bigint +); +CREATE INDEX IF NOT EXISTS idx_query_store_health_time ON query_store_health(server_id, capture_time); + +CREATE TABLE IF NOT EXISTS session_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + program_name text, + connection_count bigint, + running_count integer, + sleeping_count integer, + dormant_count integer, + total_cpu_time_ms bigint, + total_reads bigint, + total_writes bigint, + total_logical_reads bigint +); +CREATE INDEX IF NOT EXISTS idx_session_stats_time ON session_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS session_summary_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + total_sessions integer, + running_sessions integer, + sleeping_sessions integer, + background_sessions integer, + dormant_sessions integer, + idle_sessions_over_30min integer, + sessions_waiting_for_memory integer, + databases_with_connections integer, + top_application_name text, + top_application_connections integer, + top_host_name text, + top_host_connections integer +); +CREATE INDEX IF NOT EXISTS idx_session_summary_stats_time ON session_summary_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS waiting_tasks ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + session_id integer, + wait_type text, + wait_duration_ms bigint, + blocking_session_id integer, + resource_description text, + database_name text +); +CREATE INDEX IF NOT EXISTS idx_waiting_tasks_time ON waiting_tasks(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS procedure_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + object_name text, + object_type text, + cached_time timestamp, + last_execution_time timestamp, + execution_count bigint, + total_worker_time bigint, + total_elapsed_time bigint, + total_logical_reads bigint, + total_physical_reads bigint, + total_logical_writes bigint, + min_worker_time bigint, + max_worker_time bigint, + min_elapsed_time bigint, + max_elapsed_time bigint, + min_logical_reads bigint, + max_logical_reads bigint, + min_physical_reads bigint, + max_physical_reads bigint, + min_logical_writes bigint, + max_logical_writes bigint, + total_spills bigint, + min_spills bigint, + max_spills bigint, + sql_handle text, + plan_handle text, + delta_execution_count bigint, + delta_worker_time bigint, + delta_elapsed_time bigint, + delta_logical_reads bigint, + delta_logical_writes bigint, + delta_physical_reads bigint, + delta_spills bigint, + query_plan_xml text, + query_plan_xml_bytes bigint +); +CREATE INDEX IF NOT EXISTS idx_procedure_stats_time ON procedure_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS running_jobs ( + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + job_name text, + job_id text, + job_enabled boolean, + start_time timestamp, + current_duration_seconds bigint, + avg_duration_seconds bigint, + p95_duration_seconds bigint, + successful_run_count bigint, + is_running_long boolean, + percent_of_average numeric(10,1) +); +CREATE INDEX IF NOT EXISTS idx_running_jobs_time ON running_jobs(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS perfmon_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + object_name text, + counter_name text, + instance_name text, + cntr_value bigint, + delta_cntr_value bigint, + sample_interval_seconds integer +); +CREATE INDEX IF NOT EXISTS idx_perfmon_stats_time ON perfmon_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS dmv_blocking_snapshots ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + monitor_loop integer, + event_time timestamp, + database_name text, + blocked_spid integer, + blocked_ecid integer, + blocked_last_tran_started timestamp, + blocking_spid integer, + blocking_ecid integer, + blocking_last_tran_started timestamp, + wait_time_ms bigint, + lock_mode text, + blocking_status text, + contentious_object text, + blocked_sql_text text, + blocking_sql_text text, + blocked_login_name text, + blocked_host_name text, + blocked_client_app text, + blocking_login_name text, + blocking_host_name text, + blocking_client_app text +); +CREATE INDEX IF NOT EXISTS idx_dmv_blocking_snapshots_time ON dmv_blocking_snapshots(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS database_size_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + database_id integer, + file_id integer, + file_type_desc text, + file_name text, + physical_name text, + total_size_mb numeric(19,2), + used_size_mb numeric(19,2), + auto_growth_mb numeric(19,2), + max_size_mb numeric(19,2), + recovery_model_desc text, + compatibility_level integer, + state_desc text, + volume_mount_point text, + volume_total_mb numeric(19,2), + volume_free_mb numeric(19,2), + is_percent_growth boolean, + growth_pct integer, + vlf_count integer +); +CREATE INDEX IF NOT EXISTS idx_database_size_stats_time ON database_size_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS index_object_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + sqlserver_start_time timestamp, + database_name text, + database_id integer, + schema_name text, + object_id integer, + table_name text, + index_id integer, + index_name text, + index_type_desc text, + is_unique boolean, + is_primary_key boolean, + is_filtered boolean, + partition_count integer, + reserved_mb numeric(19,2), + used_mb numeric(19,2), + in_row_data_mb numeric(19,2), + lob_data_mb numeric(19,2), + row_overflow_mb numeric(19,2), + total_rows bigint, + user_seeks bigint, + user_scans bigint, + user_lookups bigint, + user_updates bigint, + last_user_seek timestamp, + last_user_scan timestamp, + last_user_lookup timestamp, + last_user_update timestamp, + leaf_insert_count bigint, + leaf_update_count bigint, + leaf_delete_count bigint, + range_scan_count bigint, + singleton_lookup_count bigint, + row_lock_count bigint, + row_lock_wait_count bigint, + row_lock_wait_in_ms bigint, + page_lock_count bigint, + page_lock_wait_count bigint, + page_lock_wait_in_ms bigint, + index_lock_promotion_attempt_count bigint, + index_lock_promotion_count bigint, + page_latch_wait_count bigint, + page_latch_wait_in_ms bigint, + page_io_latch_wait_count bigint, + page_io_latch_wait_in_ms bigint, + key_columns text, + included_columns text, + filter_definition text, + is_unique_constraint boolean, + is_foreign_key boolean, + is_foreign_key_reference boolean, + is_disabled boolean, + data_compression_desc text, + optimize_for_sequential_key boolean, + fill_factor smallint, + is_padded boolean, + allow_page_locks boolean, + allow_row_locks boolean, + is_indexed_view boolean +); +CREATE INDEX IF NOT EXISTS idx_index_object_stats_object ON index_object_stats(server_id, database_name, object_id, index_id, collection_time); + +CREATE TABLE IF NOT EXISTS query_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + query_hash text, + query_plan_hash text, + creation_time timestamp, + last_execution_time timestamp, + execution_count bigint, + total_worker_time bigint, + total_elapsed_time bigint, + total_logical_reads bigint, + total_logical_writes bigint, + total_physical_reads bigint, + total_clr_time bigint, + total_rows bigint, + total_spills bigint, + min_worker_time bigint, + max_worker_time bigint, + min_elapsed_time bigint, + max_elapsed_time bigint, + min_physical_reads bigint, + max_physical_reads bigint, + min_rows bigint, + max_rows bigint, + min_dop bigint, + max_dop bigint, + min_grant_kb bigint, + max_grant_kb bigint, + min_used_grant_kb bigint, + max_used_grant_kb bigint, + min_ideal_grant_kb bigint, + max_ideal_grant_kb bigint, + min_reserved_threads bigint, + max_reserved_threads bigint, + min_used_threads bigint, + max_used_threads bigint, + min_spills bigint, + max_spills bigint, + query_text text, + query_plan_xml text, + sql_handle text, + plan_handle text, + delta_execution_count bigint, + delta_worker_time bigint, + delta_elapsed_time bigint, + delta_logical_reads bigint, + delta_logical_writes bigint, + delta_physical_reads bigint, + delta_rows bigint, + delta_spills bigint, + plan_generation_num bigint, + sample_interval_seconds integer, + host_object_name text, + query_plan_xml_bytes bigint +); +CREATE INDEX IF NOT EXISTS idx_query_stats_time ON query_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS query_snapshots ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + session_id integer, + database_name text, + elapsed_time_formatted text, + query_text text, + query_plan text, + live_query_plan text, + status text, + blocking_session_id integer, + wait_type text, + wait_time_ms bigint, + wait_resource text, + cpu_time_ms bigint, + total_elapsed_time_ms bigint, + reads bigint, + writes bigint, + logical_reads bigint, + granted_query_memory_gb numeric(18,2), + transaction_isolation_level text, + dop integer, + parallel_worker_count integer, + login_name text, + host_name text, + program_name text, + open_transaction_count integer, + percent_complete numeric(5,2), + is_cdc_capture boolean, + query_hash text, + requested_memory_mb double precision, + used_memory_mb double precision, + max_used_memory_mb double precision, + tempdb_current_mb double precision, + tempdb_allocations_mb double precision, + tran_log_used_mb double precision, + tran_start_time timestamp, + request_id integer +); +CREATE INDEX IF NOT EXISTS idx_query_snapshots_time ON query_snapshots(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS query_store_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + query_id bigint, + plan_id bigint, + execution_type_desc text, + first_execution_time timestamp, + last_execution_time timestamp, + module_name text, + query_text text, + query_hash text, + execution_count bigint, + avg_duration_us bigint, + min_duration_us bigint, + max_duration_us bigint, + avg_cpu_time_us bigint, + min_cpu_time_us bigint, + max_cpu_time_us bigint, + avg_logical_io_reads bigint, + min_logical_io_reads bigint, + max_logical_io_reads bigint, + avg_logical_io_writes bigint, + min_logical_io_writes bigint, + max_logical_io_writes bigint, + avg_physical_io_reads bigint, + min_physical_io_reads bigint, + max_physical_io_reads bigint, + avg_clr_time_us bigint, + min_clr_time_us bigint, + max_clr_time_us bigint, + min_dop bigint, + max_dop bigint, + avg_query_max_used_memory bigint, + min_query_max_used_memory bigint, + max_query_max_used_memory bigint, + avg_rowcount bigint, + min_rowcount bigint, + max_rowcount bigint, + avg_num_physical_io_reads bigint, + min_num_physical_io_reads bigint, + max_num_physical_io_reads bigint, + avg_log_bytes_used bigint, + min_log_bytes_used bigint, + max_log_bytes_used bigint, + avg_tempdb_space_used bigint, + min_tempdb_space_used bigint, + max_tempdb_space_used bigint, + plan_type text, + plan_forcing_type text, + is_forced_plan boolean, + force_failure_count bigint, + last_force_failure_reason text, + compatibility_level integer, + query_plan_text text, + query_plan_hash text, + replica_role text, + runtime_stats_interval_id bigint, + interval_start_time_utc timestamp +); +CREATE INDEX IF NOT EXISTS idx_query_store_stats_time ON query_store_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS deadlocks ( + deadlock_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + deadlock_time timestamp, + victim_process_id text, + victim_sql_text text, + deadlock_graph_xml text, + victim_query_plan_xml text, + database_name text +); +CREATE INDEX IF NOT EXISTS idx_deadlocks_time ON deadlocks(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS blocked_process_reports ( + blocked_report_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + database_name text, + blocked_spid integer, + blocked_ecid integer, + blocking_spid integer, + blocking_ecid integer, + wait_time_ms bigint, + wait_resource text, + lock_mode text, + blocked_status text, + blocked_isolation_level text, + blocked_log_used bigint, + blocked_transaction_count integer, + blocked_client_app text, + blocked_host_name text, + blocked_login_name text, + blocked_sql_text text, + blocking_status text, + blocking_isolation_level text, + blocking_client_app text, + blocking_host_name text, + blocking_login_name text, + blocking_sql_text text, + blocked_transaction_name text, + blocking_transaction_name text, + blocked_last_tran_started timestamp, + blocking_last_tran_started timestamp, + blocked_last_batch_started timestamp, + blocking_last_batch_started timestamp, + blocked_last_batch_completed timestamp, + blocking_last_batch_completed timestamp, + blocked_priority integer, + blocking_priority integer, + blocked_process_report_xml text, + object_id integer, + database_id integer, + contentious_object text, + monitor_loop integer, + blocked_query_plan_xml text, + blocking_query_plan_xml text +); +CREATE INDEX IF NOT EXISTS idx_blocked_process_reports_time ON blocked_process_reports(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS long_query_completions ( + long_query_completion_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_type text, + database_id integer, + database_name text, + session_id integer, + client_app_name text, + client_pid integer, + nt_username text, + server_principal_name text, + query_hash text, + event_sequence bigint, + duration_microseconds bigint, + cpu_time_microseconds bigint, + physical_reads bigint, + logical_reads bigint, + writes bigint, + row_count bigint, + result text, + statement_text text, + object_name text +); +CREATE INDEX IF NOT EXISTS idx_long_query_completions_time ON long_query_completions(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS system_health_events ( + system_health_event_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_type text, + event_xml text +); +CREATE INDEX IF NOT EXISTS idx_system_health_events_time ON system_health_events(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS default_trace_events ( + default_trace_event_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_name text, + event_class integer, + spid integer, + database_name text, + database_id integer, + login_name text, + host_name text, + application_name text, + object_name text, + filename text, + integer_data bigint, + integer_data_2 bigint, + text_data text, + session_login_name text, + error_number integer, + severity integer, + state integer, + event_sequence bigint, + duration_us bigint, + end_time timestamp +); +CREATE INDEX IF NOT EXISTS idx_default_trace_events_time ON default_trace_events(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS job_history ( + job_history_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + instance_id bigint, + job_id text, + job_name text, + job_enabled boolean, + category_name text, + step_id integer, + step_name text, + run_status integer, + run_status_desc text, + run_datetime timestamp, + run_duration_seconds bigint, + retries_attempted integer, + message text +); +CREATE INDEX IF NOT EXISTS idx_job_history_time ON job_history(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS agent_status ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + agent_running boolean, + agent_status_desc text, + agent_startup_desc text, + next_scheduled_run timestamp +); +CREATE INDEX IF NOT EXISTS idx_agent_status_time ON agent_status(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS ag_replica_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + ag_name text, + replica_server_name text, + role_desc text, + operational_state_desc text, + connected_state_desc text, + recovery_health_desc text, + synchronization_health_desc text, + availability_mode_desc text, + failover_mode_desc text, + endpoint_url text, + is_local boolean +); +CREATE INDEX IF NOT EXISTS idx_ag_replica_states_time ON ag_replica_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS ag_database_replica_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + ag_name text, + database_name text, + replica_server_name text, + is_local boolean, + synchronization_state_desc text, + last_hardened_lsn text, + last_commit_lsn text, + log_send_queue_size bigint, + redo_queue_size bigint, + log_send_rate bigint, + redo_rate bigint, + is_suspended boolean, + suspend_reason_desc text, + availability_mode_desc text, + secondary_lag_seconds bigint, + last_commit_time timestamp, + last_hardened_time timestamp, + last_redone_time timestamp, + last_received_time timestamp, + est_redo_completion_time_min double precision, + est_send_drain_time_min double precision +); +CREATE INDEX IF NOT EXISTS idx_ag_database_replica_states_time ON ag_database_replica_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS plan_correction ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + force_last_good_plan_desired_state text, + force_last_good_plan_actual_state text, + force_last_good_plan_reason text, + create_index_actual_state text, + drop_index_actual_state text, + recommendation_name text, + recommendation_type text, + recommendation_state text, + recommendation_state_reason text, + recommendation_reason text, + valid_since timestamp, + last_refresh timestamp, + score integer, + query_id bigint, + query_text text, + regressed_plan_id bigint, + last_good_plan_id bigint, + last_good_plan_forcing_type text, + last_good_plan_is_forced boolean, + last_good_plan_force_failure_reason text, + regressed_plan_execution_count bigint, + regressed_plan_cpu_time_average_ms double precision, + regressed_plan_error_count bigint, + last_good_plan_execution_count bigint, + last_good_plan_cpu_time_average_ms double precision, + last_good_plan_error_count bigint, + estimated_gain_seconds double precision, + is_executable_action boolean, + is_revertable_action boolean, + execute_action_initiated_by text, + execute_action_initiated_time timestamp, + execute_action_start_time timestamp, + execute_action_duration_seconds double precision, + revert_action_initiated_by text, + revert_action_initiated_time timestamp, + revert_action_start_time timestamp, + revert_action_duration_seconds double precision, + implementation_script text +); +CREATE INDEX IF NOT EXISTS idx_plan_correction_time ON plan_correction(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pvs_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + database_id integer, + is_accelerated_database_recovery_on boolean, + pvs_filegroup_id smallint, + persistent_version_store_size_mb numeric(19,2), + online_index_version_store_size_mb numeric(19,2), + database_data_size_mb numeric(19,2), + current_aborted_transaction_count bigint, + oldest_active_transaction_id bigint, + oldest_aborted_transaction_id bigint, + min_transaction_timestamp bigint, + online_index_min_transaction_timestamp bigint, + secondary_low_water_mark bigint, + offrow_version_cleaner_start_time timestamp, + offrow_version_cleaner_end_time timestamp, + aborted_version_cleaner_start_time timestamp, + aborted_version_cleaner_end_time timestamp, + pvs_off_row_page_skipped_low_water_mark bigint, + pvs_off_row_page_skipped_transaction_not_cleaned bigint, + pvs_off_row_page_skipped_oldest_active_xdesid bigint, + pvs_off_row_page_skipped_min_useful_xts bigint, + pvs_off_row_page_skipped_oldest_snapshot bigint, + pvs_off_row_page_skipped_oldest_aborted_xdesid bigint +); +CREATE INDEX IF NOT EXISTS idx_pvs_stats_time ON pvs_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_wait_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + wait_type_id integer, + wait_event_id bigint, + wait_type text, + wait_event text, + waits bigint, + wait_time_us bigint, + delta_waits bigint, + delta_wait_time_us bigint +); +CREATE INDEX IF NOT EXISTS idx_pg_wait_stats_time ON pg_wait_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_statement_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + queryid bigint, + database_id bigint, + user_id bigint, + toplevel boolean, + calls bigint, + total_exec_time_ms double precision, + min_exec_time_ms double precision, + max_exec_time_ms double precision, + mean_exec_time_ms double precision, + rows_returned bigint, + shared_blks_hit bigint, + shared_blks_read bigint, + shared_blks_dirtied bigint, + shared_blks_written bigint, + temp_blks_read bigint, + temp_blks_written bigint, + blk_read_time_ms double precision, + blk_write_time_ms double precision, + storage_blks_read bigint, + orcache_blks_hit bigint, + storage_blk_read_time_ms double precision, + orcache_blk_read_time_ms double precision, + wal_records bigint, + wal_fpi bigint, + wal_bytes bigint, + total_exec_peakmem_bytes bigint, + max_exec_peakmem_bytes bigint, + delta_calls bigint, + delta_total_exec_time_ms bigint, + delta_rows bigint +); +CREATE INDEX IF NOT EXISTS idx_pg_statement_stats_time ON pg_statement_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_wraparound_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + frozen_xid_age bigint, + min_multixid_age bigint, + autovacuum_freeze_max_age bigint, + autovacuum_multixact_freeze_max_age bigint, + pct_toward_emergency_vacuum double precision, + pct_toward_wraparound double precision, + pct_toward_multixact_emergency double precision, + pct_toward_multixact_wraparound double precision, + xids_remaining bigint, + multixids_remaining bigint, + allows_connections boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_wraparound_stats_time ON pg_wraparound_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_server_config ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + name text, + setting text, + unit text, + category text, + context text, + vartype text, + source text, + boot_val text, + reset_val text, + sourcefile text, + sourceline integer, + pending_restart boolean, + short_desc text +); +CREATE INDEX IF NOT EXISTS idx_pg_server_config_time ON pg_server_config(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_deadlocks ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + occurred_at timestamp, + victim_pid integer, + participant_count integer, + deadlock_hash text, + lock_modes text, + resources text, + victim_statement text, + graph_text text +); +CREATE INDEX IF NOT EXISTS idx_pg_deadlocks_time ON pg_deadlocks(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_xmin_horizon ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + source text, + xmin_age bigint, + holder text, + detail text, + is_winner boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_xmin_horizon_time ON pg_xmin_horizon(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_replication_slot_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + slot_name text, + slot_type text, + plugin text, + database_name text, + is_active boolean, + active_pid bigint, + is_temporary boolean, + two_phase boolean, + wal_status text, + safe_wal_size_bytes bigint, + retained_wal_bytes bigint, + xmin_age bigint, + catalog_xmin_age bigint, + inactive_since timestamp, + invalidation_reason text, + conflicting boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_replication_slot_stats_time ON pg_replication_slot_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_autovacuum_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + live_tuples bigint, + dead_tuples bigint, + mods_since_analyze bigint, + inserts_since_vacuum bigint, + vacuum_threshold bigint, + insert_vacuum_threshold bigint, + analyze_threshold bigint, + autovacuum_disabled boolean, + total_bytes bigint, + last_vacuum timestamp, + last_autovacuum timestamp, + last_analyze timestamp, + last_autoanalyze timestamp, + vacuum_count bigint, + autovacuum_count bigint, + analyze_count bigint, + autoanalyze_count bigint +); +CREATE INDEX IF NOT EXISTS idx_pg_autovacuum_stats_time ON pg_autovacuum_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_io_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + backend_type text, + object_type text, + context text, + reads bigint, + read_time_ms double precision, + writes bigint, + write_time_ms double precision, + writebacks bigint, + writeback_time_ms double precision, + extends bigint, + extend_time_ms double precision, + op_bytes bigint, + hits bigint, + evictions bigint, + reuses bigint, + fsyncs bigint, + fsync_time_ms double precision, + stats_reset timestamp, + read_bytes numeric(28,0), + write_bytes numeric(28,0), + extend_bytes numeric(28,0) +); +CREATE INDEX IF NOT EXISTS idx_pg_io_stats_time ON pg_io_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_blocking_edges ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + blocked_backend_id bigint, + blocked_pid integer, + blocking_backend_id bigint, + blocking_pid integer, + database_name text, + blocked_username text, + blocked_application_name text, + blocked_client_addr text, + blocked_state text, + blocked_wait_event_type text, + blocked_wait_event text, + blocked_query text, + blocked_xact_duration_ms bigint, + blocked_query_duration_ms bigint, + blocking_username text, + blocking_application_name text, + blocking_client_addr text, + blocking_state text, + blocking_wait_event_type text, + blocking_wait_event text, + blocking_query text, + blocking_xact_duration_ms bigint, + blocking_query_duration_ms bigint, + blocked_pid_count integer, + blocking_is_idle_in_transaction boolean, + query_text_may_be_truncated boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_blocking_edges_time ON pg_blocking_edges(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_database_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + xact_commit bigint, + xact_rollback bigint, + blks_read bigint, + blks_hit bigint, + temp_files bigint, + temp_bytes bigint, + deadlocks bigint, + stats_reset timestamp +); +CREATE INDEX IF NOT EXISTS idx_pg_database_stats_time ON pg_database_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_index_usage_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + index_name text, + index_scans bigint, + tuples_read bigint, + tuples_fetched bigint, + blocks_read bigint, + blocks_hit bigint, + index_bytes bigint, + table_bytes bigint, + is_unique boolean, + is_primary_key boolean, + is_valid boolean, + is_ready boolean, + is_replica_identity boolean, + is_partial boolean, + is_expression boolean, + supports_constraint boolean, + index_method text, + column_count integer, + index_definition text, + last_scan timestamp, + stats_reset timestamp +); +CREATE INDEX IF NOT EXISTS idx_pg_index_usage_stats_time ON pg_index_usage_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_table_bloat_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + heap_bytes bigint, + heap_pages bigint, + toast_bytes bigint, + index_bytes bigint, + live_tuples bigint, + dead_tuples bigint, + mods_since_analyze bigint, + last_analyzed timestamp, + estimated_tuple_bytes double precision, + estimated_heap_pages bigint, + fillfactor integer, + bloat_bytes_estimate bigint, + bloat_pct_estimate numeric(5,2), + estimate_unavailable boolean, + alignment_bytes integer, + pgstattuple_available boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_table_bloat_stats_time ON pg_table_bloat_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_session_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + backend_id bigint, + pid integer, + database_name text, + username text, + application_name text, + client_addr text, + backend_type text, + state text, + wait_event_type text, + wait_event text, + command_tag text, + query_id bigint, + state_duration_ms bigint, + xact_duration_ms bigint, + query_duration_ms bigint, + backend_duration_ms bigint, + xmin_age bigint, + xid_age bigint, + horizon_age bigint, + is_idle_in_transaction boolean, + is_horizon_holder boolean, + state_is_redacted boolean, + total_sessions integer, + active_sessions integer, + idle_in_transaction_sessions integer, + reportable_sessions integer +); +CREATE INDEX IF NOT EXISTS idx_pg_session_states_time ON pg_session_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_plan_capture_readiness ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + facet text, + is_satisfied boolean, + observed text, + detail text +); +CREATE INDEX IF NOT EXISTS idx_pg_plan_capture_readiness_time ON pg_plan_capture_readiness(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_write_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + num_timed bigint, + num_requested bigint, + num_done bigint, + restartpoints_timed bigint, + restartpoints_req bigint, + restartpoints_done bigint, + checkpoint_write_time_ms double precision, + checkpoint_sync_time_ms double precision, + buffers_written_checkpoint bigint, + slru_written bigint, + checkpointer_stats_reset timestamp, + buffers_clean bigint, + maxwritten_clean bigint, + buffers_alloc bigint, + buffers_backend bigint, + buffers_backend_fsync bigint, + bgwriter_stats_reset timestamp, + wal_records bigint, + wal_fpi bigint, + wal_bytes numeric(38,0), + wal_buffers_full bigint, + wal_write bigint, + wal_sync bigint, + wal_write_time_ms double precision, + wal_sync_time_ms double precision, + wal_stats_reset timestamp +); +CREATE INDEX IF NOT EXISTS idx_pg_write_stats_time ON pg_write_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_extension_availability ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + extension_name text, + state text, + installed_version text, + default_version text, + is_monitoring_relevant boolean, + comment text +); +CREATE INDEX IF NOT EXISTS idx_pg_extension_availability_time ON pg_extension_availability(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_lock_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + lock_type text, + mode text, + granted boolean, + relation_oid bigint, + relation_name text, + backend_count bigint, + oldest_wait_ms double precision +); +CREATE INDEX IF NOT EXISTS idx_pg_lock_stats_time ON pg_lock_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_wait_sampling ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_type text, + event text, + query_id bigint, + sample_count bigint, + profile_period_ms integer, + backend_count integer +); +CREATE INDEX IF NOT EXISTS idx_pg_wait_sampling_time ON pg_wait_sampling(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_kernel_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + query_id bigint, + exec_user_time_ms double precision, + exec_system_time_ms double precision, + plan_cpu_time_ms double precision, + exec_read_bytes bigint, + exec_write_bytes bigint, + minor_faults bigint, + major_faults bigint, + stats_since timestamp +); +CREATE INDEX IF NOT EXISTS idx_pg_kernel_stats_time ON pg_kernel_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_predicate_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + column_name text, + operator text, + query_id bigint, + sample_count bigint, + rows_evaluated bigint, + rows_filtered bigint, + worst_estimate_error_ratio double precision, + sample_rate double precision +); +CREATE INDEX IF NOT EXISTS idx_pg_predicate_stats_time ON pg_predicate_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_plan_capture ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + query_id bigint, + plan_hash text, + duration_ms double precision, + node_count integer, + top_node_type text, + plan_json text +); +CREATE INDEX IF NOT EXISTS idx_pg_plan_capture_time ON pg_plan_capture(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_column_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + column_name text, + n_distinct double precision, + null_frac double precision, + avg_width integer, + correlation double precision, + top_value_frequency double precision, + common_value_count integer +); +CREATE INDEX IF NOT EXISTS idx_pg_column_stats_time ON pg_column_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_replication_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + application_name text, + client_addr text, + state text, + sync_state text, + sync_priority integer, + sent_bytes_behind bigint, + write_bytes_behind bigint, + flush_bytes_behind bigint, + replay_bytes_behind bigint, + write_lag_ms double precision, + flush_lag_ms double precision, + replay_lag_ms double precision, + backend_start timestamp +); +CREATE INDEX IF NOT EXISTS idx_pg_replication_stats_time ON pg_replication_stats(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_buffer_usage ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + relation_name text, + relation_kind text, + buffers bigint, + dirty_buffers bigint, + avg_usage_count double precision, + pool_buffers_total bigint, + pool_buffers_used bigint +); +CREATE INDEX IF NOT EXISTS idx_pg_buffer_usage_time ON pg_buffer_usage(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_index_bloat ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + index_name text, + index_bytes bigint, + tree_level integer, + internal_pages bigint, + leaf_pages bigint, + empty_pages bigint, + deleted_pages bigint, + avg_leaf_density double precision, + leaf_fragmentation double precision, + skipped_reason text, + index_pages bigint, + table_rows bigint, + fillfactor integer, + est_tuple_bytes bigint, + est_leaf_pages bigint, + est_bloat_pct double precision, + est_reclaimable_bytes bigint, + pgstattuple_available boolean +); +CREATE INDEX IF NOT EXISTS idx_pg_index_bloat_time ON pg_index_bloat(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS pg_cpu_utilization ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + sample_time timestamp, + cpu_percent double precision, + acu_utilization_percent double precision, + serverless_capacity_acu double precision, + max_configured_acu double precision +); +CREATE INDEX IF NOT EXISTS idx_pg_cpu_utilization_time ON pg_cpu_utilization(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (1, 'collector-tables', now()::timestamp); +-- ===BATCH=== V2 server-registry-and-collection-log + +CREATE TABLE IF NOT EXISTS servers ( + server_id integer NOT NULL PRIMARY KEY, + server_name text NOT NULL, + display_name text, + is_enabled boolean NOT NULL DEFAULT TRUE, + sql_engine_edition integer, + sql_major_version integer, + created_date timestamp, + modified_date timestamp +); + +CREATE TABLE IF NOT EXISTS collection_log ( + log_id bigint NOT NULL, + server_id integer NOT NULL, + server_name text, + collector_name text NOT NULL, + collection_time timestamp NOT NULL, + duration_ms integer, + status text NOT NULL, + error_message text, + rows_collected integer, + sql_duration_ms integer, + duckdb_duration_ms integer +); + +CREATE INDEX IF NOT EXISTS idx_collection_log_time ON collection_log(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (2, 'server-registry-and-collection-log', now()::timestamp); +-- ===BATCH=== V3 alerting-stores + +CREATE TABLE IF NOT EXISTS config_alert_log ( + alert_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + metric_name text NOT NULL, + current_value double precision NOT NULL, + threshold_value double precision NOT NULL, + alert_sent boolean NOT NULL DEFAULT FALSE, + notification_type text NOT NULL DEFAULT 'tray', + send_error text, + dismissed boolean NOT NULL DEFAULT FALSE, + muted boolean NOT NULL DEFAULT FALSE, + detail_text text, + context_json text +); + +CREATE INDEX IF NOT EXISTS idx_config_alert_log_time ON config_alert_log(server_id, metric_name, alert_time); + +CREATE TABLE IF NOT EXISTS config_edge_trigger_watermarks ( + server_id integer NOT NULL, + metric_name text NOT NULL, + watermark integer NOT NULL, + watermark_time timestamp, + updated_at timestamp NOT NULL, + PRIMARY KEY (server_id, metric_name) +); + +CREATE TABLE IF NOT EXISTS config_mute_rules ( + id text NOT NULL PRIMARY KEY, + enabled boolean NOT NULL DEFAULT TRUE, + created_at_utc timestamp NOT NULL, + expires_at_utc timestamp, + reason text, + server_name text, + metric_name text, + database_pattern text, + query_text_pattern text, + wait_type_pattern text, + job_name_pattern text +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (3, 'alerting-stores', now()::timestamp); +-- ===BATCH=== V4 analysis-tables + +CREATE TABLE IF NOT EXISTS analysis_findings ( + finding_id bigint NOT NULL, + analysis_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + time_range_start timestamp, + time_range_end timestamp, + severity double precision NOT NULL, + confidence double precision NOT NULL, + category text NOT NULL, + story_path text NOT NULL, + story_path_hash text NOT NULL, + story_text text NOT NULL, + root_fact_key text NOT NULL, + root_fact_value double precision, + leaf_fact_key text, + leaf_fact_value double precision, + fact_count integer NOT NULL, + incident_id text, + remediation_action_json text +); + +CREATE INDEX IF NOT EXISTS idx_analysis_findings_time ON analysis_findings(server_id, analysis_time); +CREATE INDEX IF NOT EXISTS idx_analysis_findings_hash ON analysis_findings(story_path_hash); + +CREATE TABLE IF NOT EXISTS analysis_muted ( + mute_id bigint NOT NULL PRIMARY KEY, + server_id integer, + database_name text, + story_path_hash text NOT NULL, + story_path text NOT NULL, + muted_date timestamp NOT NULL, + reason text +); + +CREATE INDEX IF NOT EXISTS idx_analysis_muted_hash ON analysis_muted(story_path_hash); + +CREATE OR REPLACE VIEW v_wait_stats AS SELECT * FROM wait_stats; +CREATE OR REPLACE VIEW v_query_stats AS SELECT * FROM query_stats; +CREATE OR REPLACE VIEW v_query_store_stats AS SELECT * FROM query_store_stats; +CREATE OR REPLACE VIEW v_cpu_utilization_stats AS SELECT * FROM cpu_utilization_stats; +CREATE OR REPLACE VIEW v_memory_grant_stats AS SELECT * FROM memory_grant_stats; +CREATE OR REPLACE VIEW v_memory_stats AS SELECT * FROM memory_stats; +CREATE OR REPLACE VIEW v_perfmon_stats AS SELECT * FROM perfmon_stats; +CREATE OR REPLACE VIEW v_session_stats AS SELECT * FROM session_stats; +CREATE OR REPLACE VIEW v_file_io_stats AS SELECT * FROM file_io_stats; +CREATE OR REPLACE VIEW v_blocked_process_reports AS SELECT * FROM blocked_process_reports; +CREATE OR REPLACE VIEW v_deadlocks AS SELECT * FROM deadlocks; +CREATE OR REPLACE VIEW v_dmv_blocking_snapshots AS SELECT * FROM dmv_blocking_snapshots; +CREATE OR REPLACE VIEW v_index_object_stats AS SELECT * FROM index_object_stats; +CREATE OR REPLACE VIEW v_database_size_stats AS SELECT * FROM database_size_stats; +CREATE OR REPLACE VIEW v_tempdb_stats AS SELECT * FROM tempdb_stats; +CREATE OR REPLACE VIEW v_query_snapshots AS SELECT * FROM query_snapshots; +CREATE OR REPLACE VIEW v_database_config AS SELECT * FROM database_config; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (4, 'analysis-tables', now()::timestamp); +-- ===BATCH=== V5 viewer-passthrough-views + +CREATE OR REPLACE VIEW v_running_jobs AS SELECT * FROM running_jobs; +CREATE OR REPLACE VIEW v_server_config AS SELECT * FROM server_config; +CREATE OR REPLACE VIEW v_database_scoped_config AS SELECT * FROM database_scoped_config; +CREATE OR REPLACE VIEW v_trace_flags AS SELECT * FROM trace_flags; +CREATE OR REPLACE VIEW v_collection_log AS SELECT * FROM collection_log; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (5, 'viewer-passthrough-views', now()::timestamp); +-- ===BATCH=== V6 memory-tab-passthrough-views + +CREATE OR REPLACE VIEW v_memory_clerks AS SELECT * FROM memory_clerks; +CREATE OR REPLACE VIEW v_memory_pressure_events AS SELECT * FROM memory_pressure_events; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (6, 'memory-tab-passthrough-views', now()::timestamp); +-- ===BATCH=== V7 viewer-plan-capture-columns + +ALTER TABLE procedure_stats ADD COLUMN IF NOT EXISTS query_plan_xml text; +ALTER TABLE blocked_process_reports ADD COLUMN IF NOT EXISTS blocked_query_plan_xml text; +ALTER TABLE blocked_process_reports ADD COLUMN IF NOT EXISTS blocking_query_plan_xml text; +ALTER TABLE deadlocks ADD COLUMN IF NOT EXISTS victim_query_plan_xml text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (7, 'viewer-plan-capture-columns', now()::timestamp); +-- ===BATCH=== V8 schema-split-collect-config +/* V8: split public into collect/config (Darling security hardening, #1262). + Table NAMES are unchanged; search_path = collect, config, public resolves the bare + references every SQL site already uses, so no query is re-qualified. */ + +CREATE SCHEMA IF NOT EXISTS collect AUTHORIZATION darling; +CREATE SCHEMA IF NOT EXISTS config AUTHORIZATION darling; + +/* collect: all collector tables (from the catalog) + registry/metadata + the V4-V6 views */ +ALTER TABLE IF EXISTS public.wait_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.latch_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.spinlock_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.cpu_scheduler_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.plan_cache_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.tempdb_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.memory_grant_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.cpu_utilization_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.memory_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.memory_clerks SET SCHEMA collect; +ALTER TABLE IF EXISTS public.memory_pressure_events SET SCHEMA collect; +ALTER TABLE IF EXISTS public.file_io_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.server_properties SET SCHEMA collect; +ALTER TABLE IF EXISTS public.server_config SET SCHEMA collect; +ALTER TABLE IF EXISTS public.database_config SET SCHEMA collect; +ALTER TABLE IF EXISTS public.database_states SET SCHEMA collect; +ALTER TABLE IF EXISTS public.trace_flags SET SCHEMA collect; +ALTER TABLE IF EXISTS public.database_scoped_config SET SCHEMA collect; +ALTER TABLE IF EXISTS public.query_store_health SET SCHEMA collect; +ALTER TABLE IF EXISTS public.session_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.session_summary_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.waiting_tasks SET SCHEMA collect; +ALTER TABLE IF EXISTS public.procedure_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.running_jobs SET SCHEMA collect; +ALTER TABLE IF EXISTS public.perfmon_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.dmv_blocking_snapshots SET SCHEMA collect; +ALTER TABLE IF EXISTS public.database_size_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.index_object_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.query_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.query_snapshots SET SCHEMA collect; +ALTER TABLE IF EXISTS public.query_store_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.deadlocks SET SCHEMA collect; +ALTER TABLE IF EXISTS public.blocked_process_reports SET SCHEMA collect; +ALTER TABLE IF EXISTS public.long_query_completions SET SCHEMA collect; +ALTER TABLE IF EXISTS public.system_health_events SET SCHEMA collect; +ALTER TABLE IF EXISTS public.default_trace_events SET SCHEMA collect; +ALTER TABLE IF EXISTS public.job_history SET SCHEMA collect; +ALTER TABLE IF EXISTS public.agent_status SET SCHEMA collect; +ALTER TABLE IF EXISTS public.ag_replica_states SET SCHEMA collect; +ALTER TABLE IF EXISTS public.ag_database_replica_states SET SCHEMA collect; +ALTER TABLE IF EXISTS public.plan_correction SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pvs_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_wait_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_statement_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_wraparound_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_server_config SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_deadlocks SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_xmin_horizon SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_replication_slot_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_autovacuum_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_io_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_blocking_edges SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_database_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_index_usage_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_table_bloat_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_session_states SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_plan_capture_readiness SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_write_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_extension_availability SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_lock_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_wait_sampling SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_kernel_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_predicate_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_plan_capture SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_column_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_replication_stats SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_buffer_usage SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_index_bloat SET SCHEMA collect; +ALTER TABLE IF EXISTS public.pg_cpu_utilization SET SCHEMA collect; +ALTER TABLE IF EXISTS public.servers SET SCHEMA collect; +ALTER TABLE IF EXISTS public.collection_log SET SCHEMA collect; +ALTER TABLE IF EXISTS public.analysis_findings SET SCHEMA collect; +ALTER TABLE IF EXISTS public.darling_schema_version SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_wait_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_query_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_query_store_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_cpu_utilization_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_memory_grant_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_memory_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_perfmon_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_session_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_file_io_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_blocked_process_reports SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_deadlocks SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_dmv_blocking_snapshots SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_index_object_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_database_size_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_tempdb_stats SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_query_snapshots SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_database_config SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_running_jobs SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_server_config SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_database_scoped_config SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_trace_flags SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_collection_log SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_memory_clerks SET SCHEMA collect; +ALTER VIEW IF EXISTS public.v_memory_pressure_events SET SCHEMA collect; + +/* config: the operator-writable coordination + analysis-mute tables */ +ALTER TABLE IF EXISTS public.config_alert_log SET SCHEMA config; +ALTER TABLE IF EXISTS public.config_edge_trigger_watermarks SET SCHEMA config; +ALTER TABLE IF EXISTS public.config_mute_rules SET SCHEMA config; +ALTER TABLE IF EXISTS public.analysis_muted SET SCHEMA config; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (8, 'schema-split-collect-config', now()::timestamp); +-- ===BATCH=== V9 server-inventory-cost-fields + +ALTER TABLE server_properties ADD COLUMN IF NOT EXISTS sqlserver_start_time timestamp; +ALTER TABLE server_properties ADD COLUMN IF NOT EXISTS host_os_version text; +ALTER TABLE server_properties ADD COLUMN IF NOT EXISTS ag_replica_role text; +ALTER TABLE servers ADD COLUMN IF NOT EXISTS monthly_cost_usd numeric; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (9, 'server-inventory-cost-fields', now()::timestamp); +-- ===BATCH=== V10 latch-spinlock-collectors +/* V10: latch_stats + spinlock_stats collectors (Dashboard->Darling parity, #1262). + Generated from the collector definitions so the tables match the fresh V1 shape. */ + +CREATE TABLE IF NOT EXISTS latch_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + latch_class text, + waiting_requests_count bigint, + wait_time_ms bigint, + max_wait_time_ms bigint, + delta_waiting_requests_count bigint, + delta_wait_time_ms bigint, + delta_max_wait_time_ms bigint +); +CREATE INDEX IF NOT EXISTS idx_latch_stats_time ON latch_stats(server_id, collection_time); +CREATE OR REPLACE VIEW v_latch_stats AS SELECT * FROM latch_stats; + +CREATE TABLE IF NOT EXISTS spinlock_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + spinlock_name text, + collisions bigint, + spins bigint, + spins_per_collision double precision, + sleep_time bigint, + backoffs bigint, + delta_collisions bigint, + delta_spins bigint, + delta_sleep_time bigint, + delta_backoffs bigint +); +CREATE INDEX IF NOT EXISTS idx_spinlock_stats_time ON spinlock_stats(server_id, collection_time); +CREATE OR REPLACE VIEW v_spinlock_stats AS SELECT * FROM spinlock_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (10, 'latch-spinlock-collectors', now()::timestamp); +-- ===BATCH=== V11 cpu-scheduler-plan-cache-collectors +/* V11: cpu_scheduler_stats + plan_cache_stats collectors (Dashboard->Darling parity, #1262). + Generated from the collector definitions so the tables match the fresh V1 shape. */ + +CREATE TABLE IF NOT EXISTS cpu_scheduler_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + max_workers_count integer, + scheduler_count integer, + cpu_count integer, + total_runnable_tasks_count integer, + total_work_queue_count bigint, + total_current_workers_count integer, + avg_runnable_tasks_count numeric(38,2), + total_active_request_count integer, + total_queued_request_count integer, + total_blocked_task_count integer, + total_active_parallel_thread_count bigint, + runnable_request_count integer, + total_request_count integer, + runnable_percent numeric(38,2), + worker_thread_exhaustion_warning boolean, + runnable_tasks_warning boolean, + blocked_tasks_warning boolean, + queued_requests_warning boolean, + total_physical_memory_kb bigint, + available_physical_memory_kb bigint, + system_memory_state_desc text, + physical_memory_pressure_warning boolean, + total_node_count integer, + nodes_online_count integer, + offline_cpu_count integer, + offline_cpu_warning boolean +); +CREATE INDEX IF NOT EXISTS idx_cpu_scheduler_stats_time ON cpu_scheduler_stats(server_id, collection_time); +CREATE OR REPLACE VIEW v_cpu_scheduler_stats AS SELECT * FROM cpu_scheduler_stats; + +CREATE TABLE IF NOT EXISTS plan_cache_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + cacheobjtype text, + objtype text, + total_plans integer, + total_size_mb integer, + single_use_plans integer, + single_use_size_mb integer, + multi_use_plans integer, + multi_use_size_mb integer, + avg_use_count numeric(38,2), + avg_size_kb integer, + oldest_plan_create_time timestamp +); +CREATE INDEX IF NOT EXISTS idx_plan_cache_stats_time ON plan_cache_stats(server_id, collection_time); +CREATE OR REPLACE VIEW v_plan_cache_stats AS SELECT * FROM plan_cache_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (11, 'cpu-scheduler-plan-cache-collectors', now()::timestamp); +-- ===BATCH=== V12 session-summary-collector +/* V12: session_summary_stats collector (Dashboard->Darling connection-leak / idle parity, #1262). + Generated from the collector definition so the table matches the fresh V1 shape. */ + +CREATE TABLE IF NOT EXISTS session_summary_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + total_sessions integer, + running_sessions integer, + sleeping_sessions integer, + background_sessions integer, + dormant_sessions integer, + idle_sessions_over_30min integer, + sessions_waiting_for_memory integer, + databases_with_connections integer, + top_application_name text, + top_application_connections integer, + top_host_name text, + top_host_connections integer +); +CREATE INDEX IF NOT EXISTS idx_session_summary_stats_time ON session_summary_stats(server_id, collection_time); +CREATE OR REPLACE VIEW v_session_summary_stats AS SELECT * FROM session_summary_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (12, 'session-summary-collector', now()::timestamp); +-- ===BATCH=== V13 system-health-events-collector +/* V13: system_health_events collector (Dashboard->Darling health-parser capture parity, #1262). + Generated from the collector definition so the table matches the fresh V1 shape. */ + +CREATE TABLE IF NOT EXISTS system_health_events ( + system_health_event_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_type text, + event_xml text +); +CREATE INDEX IF NOT EXISTS idx_system_health_events_time ON system_health_events(server_id, collection_time); +CREATE OR REPLACE VIEW v_system_health_events AS SELECT * FROM system_health_events; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (13, 'system-health-events-collector', now()::timestamp); +-- ===BATCH=== V14 refresh-passthrough-views +/* V14: refresh every v_* passthrough view's pinned SELECT * column list (#1262). + Postgres freezes SELECT * at CREATE, so an upgraded store's views omit columns + ADDed later (V7 plan columns, V9 inventory); CREATE OR REPLACE re-expands them. + Append-only ADD COLUMNs => the refresh only adds columns at the end (always legal). */ + +CREATE OR REPLACE VIEW v_wait_stats AS SELECT * FROM wait_stats; +CREATE OR REPLACE VIEW v_query_store_stats AS SELECT * FROM query_store_stats; +CREATE OR REPLACE VIEW v_cpu_utilization_stats AS SELECT * FROM cpu_utilization_stats; +CREATE OR REPLACE VIEW v_memory_grant_stats AS SELECT * FROM memory_grant_stats; +CREATE OR REPLACE VIEW v_memory_stats AS SELECT * FROM memory_stats; +CREATE OR REPLACE VIEW v_perfmon_stats AS SELECT * FROM perfmon_stats; +CREATE OR REPLACE VIEW v_session_stats AS SELECT * FROM session_stats; +CREATE OR REPLACE VIEW v_file_io_stats AS SELECT * FROM file_io_stats; +CREATE OR REPLACE VIEW v_blocked_process_reports AS SELECT * FROM blocked_process_reports; +CREATE OR REPLACE VIEW v_deadlocks AS SELECT * FROM deadlocks; +CREATE OR REPLACE VIEW v_dmv_blocking_snapshots AS SELECT * FROM dmv_blocking_snapshots; +CREATE OR REPLACE VIEW v_index_object_stats AS SELECT * FROM index_object_stats; +CREATE OR REPLACE VIEW v_database_size_stats AS SELECT * FROM database_size_stats; +CREATE OR REPLACE VIEW v_tempdb_stats AS SELECT * FROM tempdb_stats; +CREATE OR REPLACE VIEW v_query_snapshots AS SELECT * FROM query_snapshots; +CREATE OR REPLACE VIEW v_database_config AS SELECT * FROM database_config; +CREATE OR REPLACE VIEW v_running_jobs AS SELECT * FROM running_jobs; +CREATE OR REPLACE VIEW v_server_config AS SELECT * FROM server_config; +CREATE OR REPLACE VIEW v_database_scoped_config AS SELECT * FROM database_scoped_config; +CREATE OR REPLACE VIEW v_trace_flags AS SELECT * FROM trace_flags; +CREATE OR REPLACE VIEW v_collection_log AS SELECT * FROM collection_log; +CREATE OR REPLACE VIEW v_memory_clerks AS SELECT * FROM memory_clerks; +CREATE OR REPLACE VIEW v_memory_pressure_events AS SELECT * FROM memory_pressure_events; +CREATE OR REPLACE VIEW v_latch_stats AS SELECT * FROM latch_stats; +CREATE OR REPLACE VIEW v_spinlock_stats AS SELECT * FROM spinlock_stats; +CREATE OR REPLACE VIEW v_cpu_scheduler_stats AS SELECT * FROM cpu_scheduler_stats; +CREATE OR REPLACE VIEW v_plan_cache_stats AS SELECT * FROM plan_cache_stats; +CREATE OR REPLACE VIEW v_session_summary_stats AS SELECT * FROM session_summary_stats; +CREATE OR REPLACE VIEW v_system_health_events AS SELECT * FROM system_health_events; +CREATE OR REPLACE VIEW v_pvs_stats AS SELECT * FROM pvs_stats; +CREATE OR REPLACE VIEW v_query_store_health AS SELECT * FROM query_store_health; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (14, 'refresh-passthrough-views', now()::timestamp); +-- ===BATCH=== V15 index-metadata-columns + +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS key_columns text; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS included_columns text; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS filter_definition text; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_unique_constraint boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_foreign_key boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_foreign_key_reference boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_disabled boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS data_compression_desc text; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS optimize_for_sequential_key boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS fill_factor smallint; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_padded boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS allow_page_locks boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS allow_row_locks boolean; +ALTER TABLE index_object_stats ADD COLUMN IF NOT EXISTS is_indexed_view boolean; + +CREATE OR REPLACE VIEW v_index_object_stats AS SELECT * FROM index_object_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (15, 'index-metadata-columns', now()::timestamp); +-- ===BATCH=== V16 server-utc-offset + +ALTER TABLE server_properties ADD COLUMN IF NOT EXISTS utc_offset_minutes integer; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (16, 'server-utc-offset', now()::timestamp); +-- ===BATCH=== V17 config-control-plane + +/* V17: store<->service control plane (Stage 1). EVERY object is schema-qualified config.* — + the migrate session's search_path resolves bare names to collect (wrong schema/ACL). */ + +/* --- A. Config plane: the Viewer writes desired state, the service reads + honors it. --- */ + +/* 1. config_monitored_servers — the desired-state twin of the collect.servers observed registry. + server_id is THIS ROW'S identity and this table owns it: the service reads it here rather than + recomputing it, so a stored id keeps working when the fields below no longer produce it (#2218). + It is minted from the storage identity host[:database][:RO] — the same value the collectors + stamp, which is why it JOINs collected data and why no existing store needs migrating — but that + is now the ALLOCATION rule, not a definition anything re-derives. is_enabled drives collection; + the connection fields reconstruct a MonitoredServer for the service's connect path. */ +CREATE TABLE IF NOT EXISTS config.config_monitored_servers ( + server_id integer NOT NULL PRIMARY KEY, + name text NOT NULL, + host text NOT NULL, + database text, + auth text NOT NULL DEFAULT 'integrated', + username text, + encrypted_password text, + encrypt_mode text NOT NULL DEFAULT 'Mandatory', + trust_server_certificate boolean NOT NULL DEFAULT FALSE, + read_only_intent boolean NOT NULL DEFAULT FALSE, + multi_subnet_failover boolean NOT NULL DEFAULT FALSE, + excluded_databases text[] NOT NULL DEFAULT '{}'::text[], + monthly_cost_usd numeric NOT NULL DEFAULT 0, + capture_plans boolean, + is_enabled boolean NOT NULL DEFAULT TRUE, + created_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + modified_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC') +); + +/* 2. config_alert_settings — single row (id=1), one column per AlertsConfig field + the analysis + cadence knobs (analysis_enabled / interval / notifications_enabled / notify_severity). */ +CREATE TABLE IF NOT EXISTS config.config_alert_settings ( + id smallint NOT NULL PRIMARY KEY DEFAULT 1 CHECK (id = 1), + enabled boolean NOT NULL DEFAULT TRUE, + cpu_enabled boolean NOT NULL DEFAULT TRUE, + cpu_threshold_percent integer NOT NULL DEFAULT 80, + cpu_mode text NOT NULL DEFAULT 'total', + blocking_enabled boolean NOT NULL DEFAULT TRUE, + blocking_count_threshold integer NOT NULL DEFAULT 1, + deadlock_enabled boolean NOT NULL DEFAULT TRUE, + deadlock_count_threshold integer NOT NULL DEFAULT 1, + poison_wait_enabled boolean NOT NULL DEFAULT TRUE, + poison_wait_threshold_ms integer NOT NULL DEFAULT 500, + long_running_query_enabled boolean NOT NULL DEFAULT TRUE, + long_running_query_threshold_minutes integer NOT NULL DEFAULT 30, + tempdb_space_enabled boolean NOT NULL DEFAULT TRUE, + tempdb_space_threshold_percent integer NOT NULL DEFAULT 80, + low_disk_enabled boolean NOT NULL DEFAULT TRUE, + low_disk_threshold_percent integer NOT NULL DEFAULT 10, + low_disk_threshold_gb integer NOT NULL DEFAULT 5, + long_running_job_enabled boolean NOT NULL DEFAULT TRUE, + long_running_job_multiplier integer NOT NULL DEFAULT 3, + failed_job_enabled boolean NOT NULL DEFAULT TRUE, + failed_job_lookback_minutes integer NOT NULL DEFAULT 60, + cooldown_minutes integer NOT NULL DEFAULT 5, + excluded_databases text[] NOT NULL DEFAULT '{}'::text[], + analysis_enabled boolean NOT NULL DEFAULT TRUE, + analysis_interval_minutes integer NOT NULL DEFAULT 30, + analysis_notifications_enabled boolean NOT NULL DEFAULT TRUE, + analysis_notify_severity double precision NOT NULL DEFAULT 1.5, + modified_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC') +); + +/* 3. config_notification — single row: SMTP + webhook delivery. Non-secret fields plus the SMTP + DPAPI blob (smtp_encrypted_password); webhook URLs/proxies carry as darling.json holds them. */ +CREATE TABLE IF NOT EXISTS config.config_notification ( + id smallint NOT NULL PRIMARY KEY DEFAULT 1 CHECK (id = 1), + smtp_host text NOT NULL DEFAULT '', + smtp_port integer NOT NULL DEFAULT 587, + smtp_use_ssl boolean NOT NULL DEFAULT TRUE, + smtp_username text, + smtp_encrypted_password text, + smtp_from_address text NOT NULL DEFAULT '', + smtp_recipients text NOT NULL DEFAULT '', + email_cooldown_minutes integer NOT NULL DEFAULT 15, + teams_url text NOT NULL DEFAULT '', + teams_proxy text NOT NULL DEFAULT '', + slack_url text NOT NULL DEFAULT '', + slack_proxy text NOT NULL DEFAULT '', + modified_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC') +); + +/* 4. config_collector_schedules — SPARSE per-collector overrides layered on CollectorScheduleDefaults. + Absent row / NULL column = code default; server_id NULL = fleet-wide. A PRIMARY KEY cannot span a + nullable server_id, so two partial-unique indexes enforce one fleet-wide row + one per-server row + per collector. */ +CREATE TABLE IF NOT EXISTS config.config_collector_schedules ( + server_id integer, + collector_name text NOT NULL, + frequency_minutes integer CHECK (frequency_minutes >= 0), + retention_days integer CHECK (retention_days >= 1), + enabled boolean NOT NULL DEFAULT TRUE +); +CREATE UNIQUE INDEX IF NOT EXISTS ux_config_collector_schedules_fleet + ON config.config_collector_schedules (collector_name) WHERE server_id IS NULL; +CREATE UNIQUE INDEX IF NOT EXISTS ux_config_collector_schedules_server + ON config.config_collector_schedules (server_id, collector_name) WHERE server_id IS NOT NULL; + +/* 5. config_service — single row: the service-wide flags + the config_version reload beacon. */ +CREATE TABLE IF NOT EXISTS config.config_service ( + id smallint NOT NULL PRIMARY KEY DEFAULT 1 CHECK (id = 1), + paused boolean NOT NULL DEFAULT FALSE, + capture_plans boolean NOT NULL DEFAULT TRUE, + mcp_enabled boolean NOT NULL DEFAULT FALSE, + mcp_port integer NOT NULL DEFAULT 5152, + config_version bigint NOT NULL DEFAULT 0, + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + updated_by text +); + +/* --- B. Command plane: the Viewer enqueues, the service (Stage 2) claims/executes/reports. --- */ + +/* 6. config_command — the imperative queue. GENERATED ALWAYS AS IDENTITY (a natural queue key that + needs no sequence USAGE grant for admin INSERTs, unlike serial). */ +CREATE TABLE IF NOT EXISTS config.config_command ( + command_id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + created_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + requested_by text, + command_type text NOT NULL, + target_server_id integer, + args_json jsonb, + status text NOT NULL DEFAULT 'pending', + claimed_at timestamp, + completed_at timestamp, + result_status text, + result_json jsonb, + service_instance text +); +CREATE INDEX IF NOT EXISTS idx_config_command_status ON config.config_command (status); + +/* --- C. The config_version reload beacon (bump triggers). --- */ + +/* Statement-level bump on the four desired-state tables: any write increments the beacon so the + Viewer can never forget to signal. Targets config_service by qualified name (SECURITY INVOKER — + both writers, the owner during seed and admin via the Viewer, hold UPDATE on config_service). */ +CREATE OR REPLACE FUNCTION config.config_bump_version() RETURNS trigger +LANGUAGE plpgsql AS $bump$ +BEGIN + UPDATE config.config_service + SET config_version = config_version + 1, + updated_at = (now() AT TIME ZONE 'UTC') + WHERE id = 1; + RETURN NULL; +END; +$bump$; + +/* Direct writes to config_service (pause/capture/mcp) self-bump the beacon without recursion: the + BEFORE-UPDATE trigger increments NEW.config_version only when the writer did not already change it + (so the config_bump_version UPDATE above, which sets config_version explicitly, is not doubled). */ +CREATE OR REPLACE FUNCTION config.config_service_bump() RETURNS trigger +LANGUAGE plpgsql AS $svc$ +BEGIN + IF NEW.config_version = OLD.config_version THEN + NEW.config_version := OLD.config_version + 1; + END IF; + NEW.updated_at := (now() AT TIME ZONE 'UTC'); + RETURN NEW; +END; +$svc$; + +DROP TRIGGER IF EXISTS trg_bump_monitored_servers ON config.config_monitored_servers; +CREATE TRIGGER trg_bump_monitored_servers + AFTER INSERT OR UPDATE OR DELETE ON config.config_monitored_servers + FOR EACH STATEMENT EXECUTE FUNCTION config.config_bump_version(); + +DROP TRIGGER IF EXISTS trg_bump_alert_settings ON config.config_alert_settings; +CREATE TRIGGER trg_bump_alert_settings + AFTER INSERT OR UPDATE OR DELETE ON config.config_alert_settings + FOR EACH STATEMENT EXECUTE FUNCTION config.config_bump_version(); + +DROP TRIGGER IF EXISTS trg_bump_notification ON config.config_notification; +CREATE TRIGGER trg_bump_notification + AFTER INSERT OR UPDATE OR DELETE ON config.config_notification + FOR EACH STATEMENT EXECUTE FUNCTION config.config_bump_version(); + +DROP TRIGGER IF EXISTS trg_bump_collector_schedules ON config.config_collector_schedules; +CREATE TRIGGER trg_bump_collector_schedules + AFTER INSERT OR UPDATE OR DELETE ON config.config_collector_schedules + FOR EACH STATEMENT EXECUTE FUNCTION config.config_bump_version(); + +DROP TRIGGER IF EXISTS trg_service_self_bump ON config.config_service; +CREATE TRIGGER trg_service_self_bump + BEFORE UPDATE ON config.config_service + FOR EACH ROW EXECUTE FUNCTION config.config_service_bump(); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (17, 'config-control-plane', now()::timestamp); +-- ===BATCH=== V18 alert-delivery-mode + +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS delivery_mode text NOT NULL DEFAULT 'Summary'; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS per_event_max integer NOT NULL DEFAULT 5; +ALTER TABLE config.config_monitored_servers ADD COLUMN IF NOT EXISTS alert_delivery_mode_override text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (18, 'alert-delivery-mode', now()::timestamp); +-- ===BATCH=== V19 analysis-state-marker + +CREATE TABLE IF NOT EXISTS collect.analysis_state ( + server_id integer NOT NULL PRIMARY KEY, + insufficient_data boolean NOT NULL DEFAULT FALSE, + message text, + analysis_time timestamp NOT NULL +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (19, 'analysis-state-marker', now()::timestamp); +-- ===BATCH=== V20 alert-tuning-knobs + +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_max_results integer NOT NULL DEFAULT 5; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_exclude_sp_server_diagnostics boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_exclude_wait_for boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_exclude_backups boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_exclude_misc_waits boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS long_running_query_exclude_cdc boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings ADD COLUMN IF NOT EXISTS notify_connection_changes boolean NOT NULL DEFAULT TRUE; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (20, 'alert-tuning-knobs', now()::timestamp); +-- ===BATCH=== V21 default-trace-events-collector + +CREATE TABLE IF NOT EXISTS collect.default_trace_events ( + default_trace_event_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_name text, + event_class integer, + spid integer, + database_name text, + database_id integer, + login_name text, + host_name text, + application_name text, + object_name text, + filename text, + integer_data bigint, + integer_data_2 bigint, + text_data text, + session_login_name text, + error_number integer, + severity integer, + state integer, + event_sequence bigint, + duration_us bigint, + end_time timestamp +); + +CREATE INDEX IF NOT EXISTS idx_default_trace_events_time ON collect.default_trace_events(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (21, 'default-trace-events-collector', now()::timestamp); +-- ===BATCH=== V22 index-object-stats-latest-index + +CREATE INDEX IF NOT EXISTS idx_index_object_stats_latest ON collect.index_object_stats (server_id, database_id, object_id, index_id, collection_time DESC); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (22, 'index-object-stats-latest-index', now()::timestamp); +-- ===BATCH=== V23 collection-log-hypertable + +/* V23: best-effort UPGRADE fast-path that converts collect.collection_log to a TimescaleDB hypertable + compresses + it, mirroring the collector hypertables. GUARDED on the extension (plain PostgreSQL skips it, keeping the table a + heap with batched-DELETE retention) and wrapped in EXCEPTION WHEN OTHERS so it can NEVER abort the startup-critical + migration. The AUTHORITATIVE conversion is TimescaleSupport.EnsureCollectionLogHypertableAsync at runtime (after + CREATE EXTENSION), which is the proven-live path and self-heals a fresh store this guard skipped. collection_log is + NOT in the collector catalog, so the runtime catalog loops never touch it. */ +DO $$ +BEGIN + IF EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') THEN + PERFORM create_hypertable('collect.collection_log', by_range('collection_time', INTERVAL '1 days'), if_not_exists => true, migrate_data => true); + ALTER TABLE collect.collection_log SET (timescaledb.compress, timescaledb.compress_segmentby = 'server_id'); + PERFORM add_compression_policy('collect.collection_log', compress_after => INTERVAL '1 days', if_not_exists => true); + END IF; +EXCEPTION WHEN OTHERS THEN + RAISE WARNING 'V23: deferred collection_log hypertable conversion to the runtime path (%): %', SQLSTATE, SQLERRM; +END +$$; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (23, 'collection-log-hypertable', now()::timestamp); +-- ===BATCH=== V24 job-history-collector + +CREATE TABLE IF NOT EXISTS collect.job_history ( + job_history_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + instance_id bigint, + job_id text, + job_name text, + job_enabled boolean, + category_name text, + step_id integer, + step_name text, + run_status integer, + run_status_desc text, + run_datetime timestamp, + run_duration_seconds bigint, + retries_attempted integer, + message text +); + +CREATE INDEX IF NOT EXISTS idx_job_history_time ON collect.job_history(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (24, 'job-history-collector', now()::timestamp); +-- ===BATCH=== V25 agent-status-collector + +CREATE TABLE IF NOT EXISTS collect.agent_status ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + agent_running boolean, + agent_status_desc text, + agent_startup_desc text, + next_scheduled_run timestamp +); + +CREATE INDEX IF NOT EXISTS idx_agent_status_time ON collect.agent_status(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (25, 'agent-status-collector', now()::timestamp); +-- ===BATCH=== V26 generic-webhook-channel + +ALTER TABLE config.config_notification ADD COLUMN IF NOT EXISTS generic_url text NOT NULL DEFAULT ''; +ALTER TABLE config.config_notification ADD COLUMN IF NOT EXISTS generic_headers text NOT NULL DEFAULT ''; +ALTER TABLE config.config_notification ADD COLUMN IF NOT EXISTS generic_body_template text NOT NULL DEFAULT ''; +ALTER TABLE config.config_notification ADD COLUMN IF NOT EXISTS generic_proxy text NOT NULL DEFAULT ''; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (26, 'generic-webhook-channel', now()::timestamp); +-- ===BATCH=== V27 deadlocks-database-name + +ALTER TABLE deadlocks ADD COLUMN IF NOT EXISTS database_name text; +CREATE OR REPLACE VIEW v_deadlocks AS SELECT * FROM deadlocks; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (27, 'deadlocks-database-name', now()::timestamp); +-- ===BATCH=== V28 query-store-replica-role + +ALTER TABLE query_store_stats ADD COLUMN IF NOT EXISTS replica_role text; +CREATE OR REPLACE VIEW v_query_store_stats AS SELECT * FROM query_store_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (28, 'query-store-replica-role', now()::timestamp); +-- ===BATCH=== V29 long-query-completions-collector + +CREATE TABLE IF NOT EXISTS collect.long_query_completions ( + long_query_completion_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_time timestamp, + event_type text, + database_id integer, + database_name text, + session_id integer, + client_app_name text, + client_pid integer, + nt_username text, + server_principal_name text, + query_hash text, + event_sequence bigint, + duration_microseconds bigint, + cpu_time_microseconds bigint, + physical_reads bigint, + logical_reads bigint, + writes bigint, + row_count bigint, + result text, + statement_text text, + object_name text +); + +CREATE INDEX IF NOT EXISTS idx_long_query_completions_time ON collect.long_query_completions(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (29, 'long-query-completions-collector', now()::timestamp); +-- ===BATCH=== V30 web-dashboard-config + +ALTER TABLE config.config_service ADD COLUMN IF NOT EXISTS web_enabled boolean NOT NULL DEFAULT FALSE; +ALTER TABLE config.config_service ADD COLUMN IF NOT EXISTS web_port integer NOT NULL DEFAULT 5153; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (30, 'web-dashboard-config', now()::timestamp); +-- ===BATCH=== V31 custom-views-table + +CREATE TABLE IF NOT EXISTS config.custom_views ( + id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + name text NOT NULL UNIQUE, + definition jsonb NOT NULL, + description text, + version integer NOT NULL DEFAULT 1, + created_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + updated_by text +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (31, 'custom-views-table', now()::timestamp); +-- ===BATCH=== V32 server-tags + +CREATE TABLE IF NOT EXISTS config.server_tags ( + id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + name text NOT NULL, + parent_id integer REFERENCES config.server_tags(id) ON DELETE CASCADE, + sort_order integer NOT NULL DEFAULT 0, + created_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC') +); + +CREATE UNIQUE INDEX IF NOT EXISTS ux_server_tags_parent_name + ON config.server_tags (COALESCE(parent_id, 0), lower(name)); + +CREATE TABLE IF NOT EXISTS config.server_tag_map ( + server_id integer NOT NULL, + tag_id integer NOT NULL REFERENCES config.server_tags(id) ON DELETE CASCADE, + PRIMARY KEY (server_id, tag_id) +); + +CREATE INDEX IF NOT EXISTS idx_server_tag_map_tag + ON config.server_tag_map (tag_id); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (32, 'server-tags', now()::timestamp); +-- ===BATCH=== V33 connection-alert-refire + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS notify_connection_down_at_startup boolean NOT NULL DEFAULT false, + ADD COLUMN IF NOT EXISTS connection_refire_minutes integer NOT NULL DEFAULT 0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (33, 'connection-alert-refire', now()::timestamp); +-- ===BATCH=== V34 availability-group-collectors + +CREATE TABLE IF NOT EXISTS collect.ag_replica_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + ag_name text, + replica_server_name text, + role_desc text, + operational_state_desc text, + connected_state_desc text, + recovery_health_desc text, + synchronization_health_desc text, + availability_mode_desc text, + failover_mode_desc text, + endpoint_url text +); + +CREATE INDEX IF NOT EXISTS idx_ag_replica_states_time ON collect.ag_replica_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS collect.ag_database_replica_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + ag_name text, + database_name text, + replica_server_name text, + is_local boolean, + synchronization_state_desc text, + last_hardened_lsn text, + last_commit_lsn text, + log_send_queue_size bigint, + redo_queue_size bigint, + log_send_rate bigint, + redo_rate bigint, + is_suspended boolean, + suspend_reason_desc text, + availability_mode_desc text, + secondary_lag_seconds bigint +); + +CREATE INDEX IF NOT EXISTS idx_ag_database_replica_states_time ON collect.ag_database_replica_states(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (34, 'availability-group-collectors', now()::timestamp); +-- ===BATCH=== V35 availability-group-alerts + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS notify_ag_health boolean NOT NULL DEFAULT true, + ADD COLUMN IF NOT EXISTS ag_lag_alert_seconds integer NOT NULL DEFAULT 300, + ADD COLUMN IF NOT EXISTS ag_redo_queue_alert_kb bigint NOT NULL DEFAULT 0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (35, 'availability-group-alerts', now()::timestamp); +-- ===BATCH=== V36 ag-latency-columns + +ALTER TABLE collect.ag_database_replica_states + ADD COLUMN IF NOT EXISTS last_commit_time timestamp, + ADD COLUMN IF NOT EXISTS last_hardened_time timestamp, + ADD COLUMN IF NOT EXISTS last_redone_time timestamp, + ADD COLUMN IF NOT EXISTS last_received_time timestamp, + ADD COLUMN IF NOT EXISTS est_redo_completion_time_min double precision, + ADD COLUMN IF NOT EXISTS est_send_drain_time_min double precision; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (36, 'ag-latency-columns', now()::timestamp); +-- ===BATCH=== V37 ag-local-replica-and-disconnect-refire + +ALTER TABLE collect.ag_replica_states + ADD COLUMN IF NOT EXISTS is_local boolean; + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS ag_disconnect_refire_minutes integer NOT NULL DEFAULT 0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (37, 'ag-local-replica-and-disconnect-refire', now()::timestamp); +-- ===BATCH=== V38 query-payload-dimensions +/* V38: hash-keyed dimension tables for query_stats / procedure_stats payloads (#1767). + query_text/query_plan_xml stored inline per row were 94% of a 250 GB field store; + a measured 1-hour window held 3,166 MB of payload across 23 MB of distinct content. + ZERO-REWRITE: the inline columns stay, new rows leave them NULL, readers coalesce, + and raw retention ages the inline copies out on its own. */ + +CREATE TABLE IF NOT EXISTS query_text_dim ( + digest bytea NOT NULL PRIMARY KEY, + query_text text NOT NULL, + last_seen timestamp NOT NULL +); +CREATE INDEX IF NOT EXISTS idx_query_text_dim_last_seen ON query_text_dim(last_seen); + +CREATE TABLE IF NOT EXISTS query_plan_dim ( + digest bytea NOT NULL PRIMARY KEY, + query_plan_xml text NULL, + query_plan_gz bytea NULL, + last_seen timestamp NOT NULL +); +CREATE INDEX IF NOT EXISTS idx_query_plan_dim_last_seen ON query_plan_dim(last_seen); + +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_text_digest bytea; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_digest bytea; +ALTER TABLE procedure_stats ADD COLUMN IF NOT EXISTS query_plan_digest bytea; +/* Pre-adds for the payload-resolving view below: it names every payload column the + collector has today, and a store replaying this rung may predate the ALTER that adds + one of them. Idempotent, so this is a no-op wherever they already exist. */ +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS database_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS creation_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS last_execution_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_clr_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_text text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sql_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_generation_num bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sample_interval_seconds integer; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS host_object_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; +ALTER TABLE query_plan_dim ADD COLUMN IF NOT EXISTS query_plan_gz bytea; + +/* v_query_stats resolves each row's payload: the inline column for rows written before + the dimension tables existed, the dimension row for every row written since (#1767). + Column list generated from the collector definition so it can never go stale. */ +CREATE OR REPLACE VIEW v_query_stats AS +SELECT + f.collection_id, + f.collection_time, + f.server_id, + f.server_name, + f.database_name, + f.query_hash, + f.query_plan_hash, + f.creation_time, + f.last_execution_time, + f.execution_count, + f.total_worker_time, + f.total_elapsed_time, + f.total_logical_reads, + f.total_logical_writes, + f.total_physical_reads, + f.total_clr_time, + f.total_rows, + f.total_spills, + f.min_worker_time, + f.max_worker_time, + f.min_elapsed_time, + f.max_elapsed_time, + f.min_physical_reads, + f.max_physical_reads, + f.min_rows, + f.max_rows, + f.min_dop, + f.max_dop, + f.min_grant_kb, + f.max_grant_kb, + f.min_used_grant_kb, + f.max_used_grant_kb, + f.min_ideal_grant_kb, + f.max_ideal_grant_kb, + f.min_reserved_threads, + f.max_reserved_threads, + f.min_used_threads, + f.max_used_threads, + f.min_spills, + f.max_spills, + COALESCE(f.query_text, qtd.query_text) AS query_text, + COALESCE(f.query_plan_xml, qpd.query_plan_xml) AS query_plan_xml, + f.sql_handle, + f.plan_handle, + f.delta_execution_count, + f.delta_worker_time, + f.delta_elapsed_time, + f.delta_logical_reads, + f.delta_logical_writes, + f.delta_physical_reads, + f.delta_rows, + f.delta_spills, + f.plan_generation_num, + f.sample_interval_seconds, + f.host_object_name, + f.query_plan_xml_bytes, + f.query_text_digest, + f.query_plan_digest, + qpd.query_plan_gz +FROM query_stats AS f +LEFT JOIN query_text_dim AS qtd ON qtd.digest = f.query_text_digest +LEFT JOIN query_plan_dim AS qpd ON qpd.digest = f.query_plan_digest +; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (38, 'query-payload-dimensions', now()::timestamp); +-- ===BATCH=== V39 dim-feeding-fact-floor-indexes + +CREATE INDEX IF NOT EXISTS ix_query_stats_digest_floor + ON query_stats (collection_time) + WHERE query_text_digest IS NOT NULL OR query_plan_digest IS NOT NULL; + +CREATE INDEX IF NOT EXISTS ix_procedure_stats_digest_floor + ON procedure_stats (collection_time) + WHERE query_plan_digest IS NOT NULL; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (39, 'dim-feeding-fact-floor-indexes', now()::timestamp); +-- ===BATCH=== V40 blocking-wait-threshold + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS blocking_wait_seconds_threshold integer NOT NULL DEFAULT 0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (40, 'blocking-wait-threshold', now()::timestamp); +-- ===BATCH=== V41 query-store-interval-identity + +ALTER TABLE query_store_stats ADD COLUMN IF NOT EXISTS runtime_stats_interval_id bigint; +ALTER TABLE query_store_stats ADD COLUMN IF NOT EXISTS interval_start_time_utc timestamp; +CREATE OR REPLACE VIEW v_query_store_stats AS SELECT * FROM query_store_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (41, 'query-store-interval-identity', now()::timestamp); +-- ===BATCH=== V42 pagerduty-webhook + +ALTER TABLE config.config_notification + ADD COLUMN IF NOT EXISTS pagerduty_routing_key text NOT NULL DEFAULT '', + ADD COLUMN IF NOT EXISTS pagerduty_use_eu_region boolean NOT NULL DEFAULT FALSE; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (42, 'pagerduty-webhook', now()::timestamp); +-- ===BATCH=== V43 pagerduty-proxy + +ALTER TABLE config.config_notification + ADD COLUMN IF NOT EXISTS pagerduty_proxy text NOT NULL DEFAULT ''; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (43, 'pagerduty-proxy', now()::timestamp); +-- ===BATCH=== V44 collector-state + +CREATE TABLE IF NOT EXISTS collect.collector_state ( + server_id integer NOT NULL, + collector_name text NOT NULL, + state_key text NOT NULL, + state_value text NOT NULL, + updated_at timestamp NOT NULL, + PRIMARY KEY (server_id, collector_name, state_key) +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (44, 'collector-state', now()::timestamp); +-- ===BATCH=== V46 plan-correction-collector + +CREATE TABLE IF NOT EXISTS collect.plan_correction ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + force_last_good_plan_desired_state text, + force_last_good_plan_actual_state text, + force_last_good_plan_reason text, + create_index_actual_state text, + drop_index_actual_state text, + recommendation_name text, + recommendation_type text, + recommendation_state text, + recommendation_state_reason text, + recommendation_reason text, + valid_since timestamp, + last_refresh timestamp, + score integer, + query_id bigint, + query_text text, + regressed_plan_id bigint, + last_good_plan_id bigint, + last_good_plan_forcing_type text, + last_good_plan_is_forced boolean, + last_good_plan_force_failure_reason text, + regressed_plan_execution_count bigint, + regressed_plan_cpu_time_average_ms double precision, + regressed_plan_error_count bigint, + last_good_plan_execution_count bigint, + last_good_plan_cpu_time_average_ms double precision, + last_good_plan_error_count bigint, + estimated_gain_seconds double precision, + is_executable_action boolean, + is_revertable_action boolean, + execute_action_initiated_by text, + execute_action_initiated_time timestamp, + execute_action_start_time timestamp, + execute_action_duration_seconds double precision, + revert_action_initiated_by text, + revert_action_initiated_time timestamp, + revert_action_start_time timestamp, + revert_action_duration_seconds double precision, + implementation_script text +); + +CREATE INDEX IF NOT EXISTS idx_plan_correction_time ON collect.plan_correction(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (46, 'plan-correction-collector', now()::timestamp); +-- ===BATCH=== V47 pvs-stats + +CREATE TABLE IF NOT EXISTS collect.pvs_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + database_id integer, + is_accelerated_database_recovery_on boolean, + pvs_filegroup_id smallint, + persistent_version_store_size_mb numeric(19,2), + online_index_version_store_size_mb numeric(19,2), + database_data_size_mb numeric(19,2), + current_aborted_transaction_count bigint, + oldest_active_transaction_id bigint, + oldest_aborted_transaction_id bigint, + min_transaction_timestamp bigint, + online_index_min_transaction_timestamp bigint, + secondary_low_water_mark bigint, + offrow_version_cleaner_start_time timestamp, + offrow_version_cleaner_end_time timestamp, + aborted_version_cleaner_start_time timestamp, + aborted_version_cleaner_end_time timestamp, + pvs_off_row_page_skipped_low_water_mark bigint, + pvs_off_row_page_skipped_transaction_not_cleaned bigint, + pvs_off_row_page_skipped_oldest_active_xdesid bigint, + pvs_off_row_page_skipped_min_useful_xts bigint, + pvs_off_row_page_skipped_oldest_snapshot bigint, + pvs_off_row_page_skipped_oldest_aborted_xdesid bigint +); + +CREATE INDEX IF NOT EXISTS idx_pvs_stats_time ON collect.pvs_stats(server_id, collection_time); + +CREATE OR REPLACE VIEW v_pvs_stats AS SELECT * FROM pvs_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (47, 'pvs-stats', now()::timestamp); +-- ===BATCH=== V48 pvs-pressure-alert + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS pvs_enabled boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS pvs_threshold_percent integer NOT NULL DEFAULT 40; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS pvs_floor_gb integer NOT NULL DEFAULT 1; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (48, 'pvs-pressure-alert', now()::timestamp); +-- ===BATCH=== V49 database-state-alert + +CREATE TABLE IF NOT EXISTS collect.database_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + database_id integer, + state_desc text, + is_in_standby boolean +); + +CREATE INDEX IF NOT EXISTS idx_database_states_time ON collect.database_states(server_id, collection_time); + +CREATE TABLE IF NOT EXISTS config.database_state_expected ( + server_id integer NOT NULL, + database_name text NOT NULL, + expected_state text NOT NULL, + is_user_override boolean NOT NULL DEFAULT false, + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + PRIMARY KEY (server_id, database_name) +); + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS database_state_enabled boolean NOT NULL DEFAULT true; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (49, 'database-state-alert', now()::timestamp); +-- ===BATCH=== V50 server-tag-colour + +ALTER TABLE config.server_tags + ADD COLUMN IF NOT EXISTS colour text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (50, 'server-tag-colour', now()::timestamp); +-- ===BATCH=== V51 query-stats-host-object + +ALTER TABLE query_stats + ADD COLUMN IF NOT EXISTS host_object_name text; +DROP VIEW IF EXISTS v_query_stats; + +ALTER TABLE query_plan_dim + ADD COLUMN IF NOT EXISTS query_plan_gz bytea; +ALTER TABLE query_plan_dim + ALTER COLUMN query_plan_xml DROP NOT NULL; +/* Pre-adds for the payload-resolving view below: it names every payload column the + collector has today, and a store replaying this rung may predate the ALTER that adds + one of them. Idempotent, so this is a no-op wherever they already exist. */ +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS database_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS creation_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS last_execution_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_clr_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_text text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sql_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_generation_num bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sample_interval_seconds integer; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS host_object_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; + +/* v_query_stats resolves each row's payload: the inline column for rows written before + the dimension tables existed, the dimension row for every row written since (#1767). + Column list generated from the collector definition so it can never go stale. */ +CREATE OR REPLACE VIEW v_query_stats AS +SELECT + f.collection_id, + f.collection_time, + f.server_id, + f.server_name, + f.database_name, + f.query_hash, + f.query_plan_hash, + f.creation_time, + f.last_execution_time, + f.execution_count, + f.total_worker_time, + f.total_elapsed_time, + f.total_logical_reads, + f.total_logical_writes, + f.total_physical_reads, + f.total_clr_time, + f.total_rows, + f.total_spills, + f.min_worker_time, + f.max_worker_time, + f.min_elapsed_time, + f.max_elapsed_time, + f.min_physical_reads, + f.max_physical_reads, + f.min_rows, + f.max_rows, + f.min_dop, + f.max_dop, + f.min_grant_kb, + f.max_grant_kb, + f.min_used_grant_kb, + f.max_used_grant_kb, + f.min_ideal_grant_kb, + f.max_ideal_grant_kb, + f.min_reserved_threads, + f.max_reserved_threads, + f.min_used_threads, + f.max_used_threads, + f.min_spills, + f.max_spills, + COALESCE(f.query_text, qtd.query_text) AS query_text, + COALESCE(f.query_plan_xml, qpd.query_plan_xml) AS query_plan_xml, + f.sql_handle, + f.plan_handle, + f.delta_execution_count, + f.delta_worker_time, + f.delta_elapsed_time, + f.delta_logical_reads, + f.delta_logical_writes, + f.delta_physical_reads, + f.delta_rows, + f.delta_spills, + f.plan_generation_num, + f.sample_interval_seconds, + f.host_object_name, + f.query_plan_xml_bytes, + f.query_text_digest, + f.query_plan_digest, + qpd.query_plan_gz +FROM query_stats AS f +LEFT JOIN query_text_dim AS qtd ON qtd.digest = f.query_text_digest +LEFT JOIN query_plan_dim AS qpd ON qpd.digest = f.query_plan_digest +; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (51, 'query-stats-host-object', now()::timestamp); +-- ===BATCH=== V52 finding-drilldown-json + +ALTER TABLE analysis_findings + ADD COLUMN IF NOT EXISTS drill_down_json text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (52, 'finding-drilldown-json', now()::timestamp); +-- ===BATCH=== V53 store-self-metrics + +CREATE TABLE IF NOT EXISTS collect.store_metrics ( + metric_time timestamp NOT NULL, + object_name text NOT NULL, + object_kind text NOT NULL, + total_bytes bigint, + compressed_before_bytes bigint, + compressed_after_bytes bigint, + chunk_count integer, + row_count bigint, + enabled_server_count integer +); + +CREATE INDEX IF NOT EXISTS idx_store_metrics_time ON collect.store_metrics(metric_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (53, 'store-self-metrics', now()::timestamp); +-- ===BATCH=== V54 plan-dim-gzip + +ALTER TABLE query_plan_dim + ADD COLUMN IF NOT EXISTS query_plan_gz bytea; +ALTER TABLE query_plan_dim + ALTER COLUMN query_plan_xml DROP NOT NULL; +/* Pre-adds for the payload-resolving view below: it names every payload column the + collector has today, and a store replaying this rung may predate the ALTER that adds + one of them. Idempotent, so this is a no-op wherever they already exist. */ +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS database_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS creation_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS last_execution_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_clr_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_text text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sql_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_generation_num bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sample_interval_seconds integer; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS host_object_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; + +/* v_query_stats resolves each row's payload: the inline column for rows written before + the dimension tables existed, the dimension row for every row written since (#1767). + Column list generated from the collector definition so it can never go stale. */ +CREATE OR REPLACE VIEW v_query_stats AS +SELECT + f.collection_id, + f.collection_time, + f.server_id, + f.server_name, + f.database_name, + f.query_hash, + f.query_plan_hash, + f.creation_time, + f.last_execution_time, + f.execution_count, + f.total_worker_time, + f.total_elapsed_time, + f.total_logical_reads, + f.total_logical_writes, + f.total_physical_reads, + f.total_clr_time, + f.total_rows, + f.total_spills, + f.min_worker_time, + f.max_worker_time, + f.min_elapsed_time, + f.max_elapsed_time, + f.min_physical_reads, + f.max_physical_reads, + f.min_rows, + f.max_rows, + f.min_dop, + f.max_dop, + f.min_grant_kb, + f.max_grant_kb, + f.min_used_grant_kb, + f.max_used_grant_kb, + f.min_ideal_grant_kb, + f.max_ideal_grant_kb, + f.min_reserved_threads, + f.max_reserved_threads, + f.min_used_threads, + f.max_used_threads, + f.min_spills, + f.max_spills, + COALESCE(f.query_text, qtd.query_text) AS query_text, + COALESCE(f.query_plan_xml, qpd.query_plan_xml) AS query_plan_xml, + f.sql_handle, + f.plan_handle, + f.delta_execution_count, + f.delta_worker_time, + f.delta_elapsed_time, + f.delta_logical_reads, + f.delta_logical_writes, + f.delta_physical_reads, + f.delta_rows, + f.delta_spills, + f.plan_generation_num, + f.sample_interval_seconds, + f.host_object_name, + f.query_plan_xml_bytes, + f.query_text_digest, + f.query_plan_digest, + qpd.query_plan_gz +FROM query_stats AS f +LEFT JOIN query_text_dim AS qtd ON qtd.digest = f.query_text_digest +LEFT JOIN query_plan_dim AS qpd ON qpd.digest = f.query_plan_digest +; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (54, 'plan-dim-gzip', now()::timestamp); +-- ===BATCH=== V55 self-alert-knobs + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS self_disk_free_warn_percent integer NOT NULL DEFAULT 10; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS collection_stale_minutes integer NOT NULL DEFAULT 30; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS collection_failure_threshold integer NOT NULL DEFAULT 10; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS disk_critical_free_percent integer NOT NULL DEFAULT 3; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS disk_critical_free_gb integer NOT NULL DEFAULT 2; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS analysis_notify_cooldown_minutes integer NOT NULL DEFAULT 360; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (55, 'self-alert-knobs', now()::timestamp); +-- ===BATCH=== V56 store-metrics-background-jobs + +ALTER TABLE collect.store_metrics + ADD COLUMN IF NOT EXISTS last_run_duration_ms bigint; +ALTER TABLE collect.store_metrics + ADD COLUMN IF NOT EXISTS schedule_interval_ms bigint; +ALTER TABLE collect.store_metrics + ADD COLUMN IF NOT EXISTS total_runs bigint; +ALTER TABLE collect.store_metrics + ADD COLUMN IF NOT EXISTS total_failures bigint; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (56, 'store-metrics-background-jobs', now()::timestamp); +-- ===BATCH=== V57 store-job-cadence-knob + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS store_job_cadence_warn_percent integer NOT NULL DEFAULT 25; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (57, 'store-job-cadence-knob', now()::timestamp); +-- ===BATCH=== V58 qs-backfill-switch + +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS query_store_backfill_enabled boolean NOT NULL DEFAULT TRUE; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (58, 'qs-backfill-switch', now()::timestamp); +-- ===BATCH=== V59 collector-memory-knobs + +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS query_store_text_budget_mb integer NOT NULL DEFAULT 64; +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS max_concurrent_sweeps integer NOT NULL DEFAULT 4; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (59, 'collector-memory-knobs', now()::timestamp); +-- ===BATCH=== V60 database-state-edge-memory + +ALTER TABLE config.database_state_expected + ADD COLUMN IF NOT EXISTS last_alerted_state text; +ALTER TABLE config.database_state_expected + ADD COLUMN IF NOT EXISTS last_alerted_at timestamp; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (60, 'database-state-edge-memory', now()::timestamp); +-- ===BATCH=== V61 incident-occurrence-counters + +CREATE TABLE IF NOT EXISTS config.incident_occurrences ( + server_id integer NOT NULL, + metric_name text NOT NULL, + dedup_key text NOT NULL, + total_occurrences bigint NOT NULL, + observed_window_count integer NOT NULL, + incident_started_at timestamp NOT NULL, + last_observed_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + PRIMARY KEY (server_id, metric_name, dedup_key) +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (61, 'incident-occurrence-counters', now()::timestamp); +-- ===BATCH=== V62 plan-xml-compression-knob + +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS plan_xml_compression text NOT NULL DEFAULT 'gzip'; +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_constraint + WHERE conname = 'config_service_plan_xml_compression_check' + ) THEN + ALTER TABLE config.config_service + ADD CONSTRAINT config_service_plan_xml_compression_check + CHECK (plan_xml_compression IN ('gzip', 'none')); + END IF; +END $$; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (62, 'plan-xml-compression-knob', now()::timestamp); +-- ===BATCH=== V63 pg-wait-stats + +CREATE TABLE IF NOT EXISTS collect.pg_wait_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + wait_type_id integer, + wait_event_id bigint, + wait_type text, + wait_event text, + waits bigint, + wait_time_us bigint, + delta_waits bigint, + delta_wait_time_us bigint +); + +CREATE INDEX IF NOT EXISTS idx_pg_wait_stats_time + ON collect.pg_wait_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (63, 'pg-wait-stats', now()::timestamp); +-- ===BATCH=== V64 pg-statement-stats + +CREATE TABLE IF NOT EXISTS collect.pg_statement_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + queryid bigint, + database_id bigint, + user_id bigint, + toplevel boolean, + calls bigint, + total_exec_time_ms double precision, + min_exec_time_ms double precision, + max_exec_time_ms double precision, + mean_exec_time_ms double precision, + rows_returned bigint, + shared_blks_hit bigint, + shared_blks_read bigint, + shared_blks_dirtied bigint, + shared_blks_written bigint, + temp_blks_read bigint, + temp_blks_written bigint, + blk_read_time_ms double precision, + blk_write_time_ms double precision, + storage_blks_read bigint, + orcache_blks_hit bigint, + storage_blk_read_time_ms double precision, + orcache_blk_read_time_ms double precision, + wal_records bigint, + wal_fpi bigint, + wal_bytes bigint, + total_exec_peakmem_bytes bigint, + max_exec_peakmem_bytes bigint, + delta_calls bigint, + delta_total_exec_time_ms bigint, + delta_rows bigint +); + +CREATE INDEX IF NOT EXISTS idx_pg_statement_stats_time + ON collect.pg_statement_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (64, 'pg-statement-stats', now()::timestamp); +-- ===BATCH=== V65 pg-wraparound-stats + +CREATE TABLE IF NOT EXISTS collect.pg_wraparound_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + frozen_xid_age bigint, + min_multixid_age bigint, + autovacuum_freeze_max_age bigint, + autovacuum_multixact_freeze_max_age bigint, + pct_toward_emergency_vacuum double precision, + pct_toward_wraparound double precision, + pct_toward_multixact_emergency double precision, + pct_toward_multixact_wraparound double precision, + xids_remaining bigint, + multixids_remaining bigint, + allows_connections boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_wraparound_stats_time + ON collect.pg_wraparound_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (65, 'pg-wraparound-stats', now()::timestamp); +-- ===BATCH=== V66 pg-xmin-horizon + +CREATE TABLE IF NOT EXISTS collect.pg_xmin_horizon ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + source text, + xmin_age bigint, + holder text, + detail text, + is_winner boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_xmin_horizon_time + ON collect.pg_xmin_horizon(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (66, 'pg-xmin-horizon', now()::timestamp); +-- ===BATCH=== V67 pg-replication-slots + +CREATE TABLE IF NOT EXISTS collect.pg_replication_slot_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + slot_name text, + slot_type text, + plugin text, + database_name text, + is_active boolean, + active_pid bigint, + is_temporary boolean, + two_phase boolean, + wal_status text, + safe_wal_size_bytes bigint, + retained_wal_bytes bigint, + xmin_age bigint, + catalog_xmin_age bigint, + inactive_since timestamp, + invalidation_reason text, + conflicting boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_replication_slot_stats_time + ON collect.pg_replication_slot_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (67, 'pg-replication-slots', now()::timestamp); +-- ===BATCH=== V68 pg-autovacuum-stats + +CREATE TABLE IF NOT EXISTS collect.pg_autovacuum_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + live_tuples bigint, + dead_tuples bigint, + mods_since_analyze bigint, + inserts_since_vacuum bigint, + vacuum_threshold bigint, + insert_vacuum_threshold bigint, + analyze_threshold bigint, + autovacuum_disabled boolean, + total_bytes bigint, + last_vacuum timestamp, + last_autovacuum timestamp, + last_analyze timestamp, + last_autoanalyze timestamp, + vacuum_count bigint, + autovacuum_count bigint, + analyze_count bigint, + autoanalyze_count bigint +); + +CREATE INDEX IF NOT EXISTS idx_pg_autovacuum_stats_time + ON collect.pg_autovacuum_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (68, 'pg-autovacuum-stats', now()::timestamp); +-- ===BATCH=== V69 pg-io-stats + +CREATE TABLE IF NOT EXISTS collect.pg_io_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + backend_type text, + object_type text, + context text, + reads bigint, + read_time_ms double precision, + writes bigint, + write_time_ms double precision, + writebacks bigint, + writeback_time_ms double precision, + extends bigint, + extend_time_ms double precision, + op_bytes bigint, + hits bigint, + evictions bigint, + reuses bigint, + fsyncs bigint, + fsync_time_ms double precision, + stats_reset timestamp, + read_bytes numeric(28,0), + write_bytes numeric(28,0), + extend_bytes numeric(28,0) +); + +CREATE INDEX IF NOT EXISTS idx_pg_io_stats_time + ON collect.pg_io_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (69, 'pg-io-stats', now()::timestamp); +-- ===BATCH=== V70 monitored-server-engine + +ALTER TABLE config.config_monitored_servers + ADD COLUMN IF NOT EXISTS engine text NOT NULL DEFAULT 'sqlserver'; + +ALTER TABLE config.config_monitored_servers + ADD COLUMN IF NOT EXISTS port integer NOT NULL DEFAULT 0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (70, 'monitored-server-engine', now()::timestamp); +-- ===BATCH=== V71 pg-blocking-edges + +CREATE TABLE IF NOT EXISTS collect.pg_blocking_edges ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + blocked_backend_id bigint, + blocked_pid integer, + blocking_backend_id bigint, + blocking_pid integer, + database_name text, + blocked_username text, + blocked_application_name text, + blocked_client_addr text, + blocked_state text, + blocked_wait_event_type text, + blocked_wait_event text, + blocked_query text, + blocked_xact_duration_ms bigint, + blocked_query_duration_ms bigint, + blocking_username text, + blocking_application_name text, + blocking_client_addr text, + blocking_state text, + blocking_wait_event_type text, + blocking_wait_event text, + blocking_query text, + blocking_xact_duration_ms bigint, + blocking_query_duration_ms bigint, + blocked_pid_count integer, + blocking_is_idle_in_transaction boolean, + query_text_may_be_truncated boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_blocking_edges_time + ON collect.pg_blocking_edges(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (71, 'pg-blocking-edges', now()::timestamp); +-- ===BATCH=== V72 query-store-plan-map + +CREATE TABLE IF NOT EXISTS collect.query_store_plan_map ( + server_id integer NOT NULL, + database_name text NOT NULL, + plan_id bigint NOT NULL, + digest bytea NOT NULL, + plan_hash text, + last_seen timestamp NOT NULL, + PRIMARY KEY (server_id, database_name, plan_id) +); +CREATE INDEX IF NOT EXISTS idx_query_store_plan_map_last_seen + ON collect.query_store_plan_map(last_seen); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (72, 'query-store-plan-map', now()::timestamp); +-- ===BATCH=== V73 pg-statement-text + +CREATE TABLE IF NOT EXISTS collect.pg_statement_text ( + server_id integer NOT NULL, + queryid bigint NOT NULL, + query_text text NOT NULL, + first_seen timestamp NOT NULL, + last_seen timestamp NOT NULL, + PRIMARY KEY (server_id, queryid) +); +CREATE INDEX IF NOT EXISTS idx_pg_statement_text_last_seen + ON collect.pg_statement_text(last_seen); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (73, 'pg-statement-text', now()::timestamp); +-- ===BATCH=== V74 query-store-text +CREATE TABLE IF NOT EXISTS collect.query_store_text ( + server_id integer NOT NULL, + database_name text NOT NULL, + query_id bigint NOT NULL, + query_sql_text text, + last_seen timestamp NOT NULL, + PRIMARY KEY (server_id, database_name, query_id) +); +CREATE INDEX IF NOT EXISTS idx_query_store_text_last_seen + ON collect.query_store_text(last_seen); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (74, 'query-store-text', now()::timestamp); +-- ===BATCH=== V75 plan-content-retention-knob + +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS plan_content_retention_days integer NOT NULL DEFAULT 21; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (75, 'plan-content-retention-knob', now()::timestamp); +-- ===BATCH=== V76 query-store-health + +CREATE TABLE IF NOT EXISTS collect.query_store_health ( + config_id bigint NOT NULL, + capture_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + actual_state text, + desired_state text, + readonly_reason integer, + current_storage_size_mb bigint, + max_storage_size_mb bigint, + size_based_cleanup_mode text, + stale_query_threshold_days bigint, + max_plans_per_query bigint, + interval_length_minutes bigint +); + +CREATE INDEX IF NOT EXISTS idx_query_store_health_time ON collect.query_store_health(server_id, capture_time); + +CREATE OR REPLACE VIEW v_query_store_health AS SELECT * FROM query_store_health; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (76, 'query-store-health', now()::timestamp); +-- ===BATCH=== V77 activity-driven-plan-fetch + +ALTER TABLE collect.query_store_plan_map ALTER COLUMN digest DROP NOT NULL; + +ALTER TABLE collect.query_store_text ADD COLUMN IF NOT EXISTS query_hash text; + +DELETE FROM collector_state WHERE collector_name = 'query_store_plan_xml' AND state_key LIKE 'planwm:%'; +DELETE FROM collector_state WHERE collector_name = 'query_store_text' AND state_key LIKE 'textwm:%'; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (77, 'activity-driven-plan-fetch', now()::timestamp); +-- ===BATCH=== V78 compose-statement-timeout + +ALTER TABLE config.config_service + ADD COLUMN IF NOT EXISTS compose_statement_timeout_seconds integer NOT NULL DEFAULT 15; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (78, 'compose-statement-timeout', now()::timestamp); +-- ===BATCH=== V79 file-growth-alert + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS file_growth_enabled boolean NOT NULL DEFAULT false, + ADD COLUMN IF NOT EXISTS file_growth_rise_mb integer NOT NULL DEFAULT 10240, + ADD COLUMN IF NOT EXISTS file_growth_volume_percent integer NOT NULL DEFAULT 60, + ADD COLUMN IF NOT EXISTS file_growth_lookback_minutes integer NOT NULL DEFAULT 60; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (79, 'file-growth-alert', now()::timestamp); +-- ===BATCH=== V80 collection-log-fanout-rollup + +ALTER TABLE collect.collection_log + ADD COLUMN IF NOT EXISTS fanout_item_count integer, + ADD COLUMN IF NOT EXISTS slowest_item text, + ADD COLUMN IF NOT EXISTS slowest_item_ms integer; + +/* Postgres FREEZES a view's SELECT * column list at CREATE, so the passthrough every read goes through + would keep serving eleven columns forever — the V14 lesson, and the reason it exists. Appending is the + one alteration CREATE OR REPLACE VIEW permits, which is exactly what an ADD COLUMN produces. */ +CREATE OR REPLACE VIEW collect.v_collection_log AS SELECT * FROM collect.collection_log; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (80, 'collection-log-fanout-rollup', now()::timestamp); +-- ===BATCH=== V81 tempdb-max-size + +ALTER TABLE collect.tempdb_stats + ADD COLUMN IF NOT EXISTS max_size_mb numeric(18,2); + +/* Postgres FREEZES a view's SELECT * column list at CREATE, so the V4 passthrough the analysis fact + collector reads would keep serving the twelve columns it had forever — the V14 lesson, restated by V80. + Appending is the one alteration CREATE OR REPLACE VIEW permits, which is exactly what an ADD COLUMN + produces. */ +CREATE OR REPLACE VIEW collect.v_tempdb_stats AS SELECT * FROM collect.tempdb_stats; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (81, 'tempdb-max-size', now()::timestamp); +-- ===BATCH=== V82 server-engine-kind + +ALTER TABLE collect.servers + ADD COLUMN IF NOT EXISTS engine_kind text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (82, 'server-engine-kind', now()::timestamp); +-- ===BATCH=== V83 pg-database-stats + +CREATE TABLE IF NOT EXISTS collect.pg_database_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + xact_commit bigint, + xact_rollback bigint, + blks_read bigint, + blks_hit bigint, + temp_files bigint, + temp_bytes bigint, + deadlocks bigint, + stats_reset timestamp +); + +CREATE INDEX IF NOT EXISTS idx_pg_database_stats_time + ON collect.pg_database_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (83, 'pg-database-stats', now()::timestamp); +-- ===BATCH=== V84 pg-index-usage-stats + +CREATE TABLE IF NOT EXISTS collect.pg_index_usage_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + index_name text, + index_scans bigint, + tuples_read bigint, + tuples_fetched bigint, + blocks_read bigint, + blocks_hit bigint, + index_bytes bigint, + table_bytes bigint, + is_unique boolean, + is_primary_key boolean, + is_valid boolean, + is_ready boolean, + is_replica_identity boolean, + is_partial boolean, + is_expression boolean, + supports_constraint boolean, + index_method text, + column_count integer, + index_definition text, + last_scan timestamp, + stats_reset timestamp +); + +CREATE INDEX IF NOT EXISTS idx_pg_index_usage_stats_time + ON collect.pg_index_usage_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (84, 'pg-index-usage-stats', now()::timestamp); +-- ===BATCH=== V85 pg-table-bloat-stats + +CREATE TABLE IF NOT EXISTS collect.pg_table_bloat_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + heap_bytes bigint, + heap_pages bigint, + toast_bytes bigint, + index_bytes bigint, + live_tuples bigint, + dead_tuples bigint, + mods_since_analyze bigint, + last_analyzed timestamp, + estimated_tuple_bytes double precision, + estimated_heap_pages bigint, + fillfactor integer, + bloat_bytes_estimate bigint, + bloat_pct_estimate numeric(5,2), + estimate_unavailable boolean, + alignment_bytes integer, + pgstattuple_available boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_table_bloat_stats_time + ON collect.pg_table_bloat_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (85, 'pg-table-bloat-stats', now()::timestamp); +-- ===BATCH=== V86 pg-session-states + +CREATE TABLE IF NOT EXISTS collect.pg_session_states ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + backend_id bigint, + pid integer, + database_name text, + username text, + application_name text, + client_addr text, + backend_type text, + state text, + wait_event_type text, + wait_event text, + command_tag text, + query_id bigint, + state_duration_ms bigint, + xact_duration_ms bigint, + query_duration_ms bigint, + backend_duration_ms bigint, + xmin_age bigint, + xid_age bigint, + horizon_age bigint, + is_idle_in_transaction boolean, + is_horizon_holder boolean, + state_is_redacted boolean, + total_sessions integer, + active_sessions integer, + idle_in_transaction_sessions integer, + reportable_sessions integer +); + +CREATE INDEX IF NOT EXISTS idx_pg_session_states_time + ON collect.pg_session_states(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (86, 'pg-session-states', now()::timestamp); +-- ===BATCH=== V87 pg-plan-capture-readiness + +CREATE TABLE IF NOT EXISTS collect.pg_plan_capture_readiness ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + facet text, + is_satisfied boolean, + observed text, + detail text +); + +CREATE INDEX IF NOT EXISTS idx_pg_plan_capture_readiness_time + ON collect.pg_plan_capture_readiness(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (87, 'pg-plan-capture-readiness', now()::timestamp); +-- ===BATCH=== V88 pg-write-stats + +CREATE TABLE IF NOT EXISTS collect.pg_write_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + num_timed bigint, + num_requested bigint, + num_done bigint, + restartpoints_timed bigint, + restartpoints_req bigint, + restartpoints_done bigint, + checkpoint_write_time_ms double precision, + checkpoint_sync_time_ms double precision, + buffers_written_checkpoint bigint, + slru_written bigint, + checkpointer_stats_reset timestamp, + buffers_clean bigint, + maxwritten_clean bigint, + buffers_alloc bigint, + buffers_backend bigint, + buffers_backend_fsync bigint, + bgwriter_stats_reset timestamp, + wal_records bigint, + wal_fpi bigint, + wal_bytes numeric(38,0), + wal_buffers_full bigint, + wal_write bigint, + wal_sync bigint, + wal_write_time_ms double precision, + wal_sync_time_ms double precision, + wal_stats_reset timestamp +); + +CREATE INDEX IF NOT EXISTS idx_pg_write_stats_time + ON collect.pg_write_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (88, 'pg-write-stats', now()::timestamp); +-- ===BATCH=== V89 pg-extension-availability + +CREATE TABLE IF NOT EXISTS collect.pg_extension_availability ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + extension_name text, + state text, + installed_version text, + default_version text, + is_monitoring_relevant boolean, + comment text +); + +CREATE INDEX IF NOT EXISTS idx_pg_extension_availability_time + ON collect.pg_extension_availability(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (89, 'pg-extension-availability', now()::timestamp); +-- ===BATCH=== V90 pg-lock-stats + +CREATE TABLE IF NOT EXISTS collect.pg_lock_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + lock_type text, + mode text, + granted boolean, + relation_oid bigint, + relation_name text, + backend_count bigint, + oldest_wait_ms double precision +); + +CREATE INDEX IF NOT EXISTS idx_pg_lock_stats_time + ON collect.pg_lock_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (90, 'pg-lock-stats', now()::timestamp); +-- ===BATCH=== V91 pg-column-stats + +CREATE TABLE IF NOT EXISTS collect.pg_column_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + column_name text, + n_distinct double precision, + null_frac double precision, + avg_width integer, + correlation double precision, + top_value_frequency double precision, + common_value_count integer +); + +CREATE INDEX IF NOT EXISTS idx_pg_column_stats_time + ON collect.pg_column_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (91, 'pg-column-stats', now()::timestamp); +-- ===BATCH=== V92 pg-replication-stats + +CREATE TABLE IF NOT EXISTS collect.pg_replication_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + application_name text, + client_addr text, + state text, + sync_state text, + sync_priority integer, + sent_bytes_behind bigint, + write_bytes_behind bigint, + flush_bytes_behind bigint, + replay_bytes_behind bigint, + write_lag_ms double precision, + flush_lag_ms double precision, + replay_lag_ms double precision, + backend_start timestamp +); + +CREATE INDEX IF NOT EXISTS idx_pg_replication_stats_time + ON collect.pg_replication_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (92, 'pg-replication-stats', now()::timestamp); +-- ===BATCH=== V93 pg-buffer-usage + +CREATE TABLE IF NOT EXISTS collect.pg_buffer_usage ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + relation_name text, + relation_kind text, + buffers bigint, + dirty_buffers bigint, + avg_usage_count double precision, + pool_buffers_total bigint, + pool_buffers_used bigint +); + +CREATE INDEX IF NOT EXISTS idx_pg_buffer_usage_time + ON collect.pg_buffer_usage(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (93, 'pg-buffer-usage', now()::timestamp); +-- ===BATCH=== V94 pg-index-bloat + +CREATE TABLE IF NOT EXISTS collect.pg_index_bloat ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + index_name text, + index_bytes bigint, + tree_level integer, + internal_pages bigint, + leaf_pages bigint, + empty_pages bigint, + deleted_pages bigint, + avg_leaf_density double precision, + leaf_fragmentation double precision, + skipped_reason text, + index_pages bigint, + table_rows bigint, + fillfactor integer, + est_tuple_bytes bigint, + est_leaf_pages bigint, + est_bloat_pct double precision, + est_reclaimable_bytes bigint, + pgstattuple_available boolean +); + +CREATE INDEX IF NOT EXISTS idx_pg_index_bloat_time + ON collect.pg_index_bloat(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (94, 'pg-index-bloat', now()::timestamp); +-- ===BATCH=== V95 pg-per-database-attribution + +ALTER TABLE collect.pg_column_stats + ADD COLUMN IF NOT EXISTS database_name text; + +ALTER TABLE collect.pg_index_bloat + ADD COLUMN IF NOT EXISTS database_name text; + +ALTER TABLE collect.pg_extension_availability + ADD COLUMN IF NOT EXISTS database_name text; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (95, 'pg-per-database-attribution', now()::timestamp); +-- ===BATCH=== V96 pg-wait-sampling + +CREATE TABLE IF NOT EXISTS collect.pg_wait_sampling ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + event_type text, + event text, + query_id bigint, + sample_count bigint, + profile_period_ms integer, + backend_count integer +); + +CREATE INDEX IF NOT EXISTS idx_pg_wait_sampling_time + ON collect.pg_wait_sampling(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (96, 'pg-wait-sampling', now()::timestamp); +-- ===BATCH=== V97 pg-kernel-stats + +CREATE TABLE IF NOT EXISTS collect.pg_kernel_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + query_id bigint, + exec_user_time_ms double precision, + exec_system_time_ms double precision, + plan_cpu_time_ms double precision, + exec_read_bytes bigint, + exec_write_bytes bigint, + minor_faults bigint, + major_faults bigint, + stats_since timestamp +); + +CREATE INDEX IF NOT EXISTS idx_pg_kernel_stats_time + ON collect.pg_kernel_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (97, 'pg-kernel-stats', now()::timestamp); +-- ===BATCH=== V98 pg-predicate-stats + +CREATE TABLE IF NOT EXISTS collect.pg_predicate_stats ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text, + schema_name text, + table_name text, + column_name text, + operator text, + query_id bigint, + sample_count bigint, + rows_evaluated bigint, + rows_filtered bigint, + worst_estimate_error_ratio double precision, + sample_rate double precision +); + +CREATE INDEX IF NOT EXISTS idx_pg_predicate_stats_time + ON collect.pg_predicate_stats(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (98, 'pg-predicate-stats', now()::timestamp); +-- ===BATCH=== V99 pg-plan-capture + +CREATE TABLE IF NOT EXISTS collect.pg_plan_capture ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + query_id bigint, + plan_hash text, + duration_ms double precision, + node_count integer, + top_node_type text, + plan_json text +); + +CREATE INDEX IF NOT EXISTS idx_pg_plan_capture_time + ON collect.pg_plan_capture(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (99, 'pg-plan-capture', now()::timestamp); +-- ===BATCH=== V100 pg-major-version + +ALTER TABLE collect.servers + ADD COLUMN IF NOT EXISTS postgres_major_version integer; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (100, 'pg-major-version', now()::timestamp); +-- ===BATCH=== V101 pg18-io-bytes + +ALTER TABLE collect.pg_io_stats + ADD COLUMN IF NOT EXISTS read_bytes numeric(28,0), + ADD COLUMN IF NOT EXISTS write_bytes numeric(28,0), + ADD COLUMN IF NOT EXISTS extend_bytes numeric(28,0); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (101, 'pg18-io-bytes', now()::timestamp); +-- ===BATCH=== V102 pg-server-config + +CREATE TABLE IF NOT EXISTS collect.pg_server_config ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + name text, + setting text, + unit text, + category text, + context text, + vartype text, + source text, + boot_val text, + reset_val text, + sourcefile text, + sourceline integer, + pending_restart boolean, + short_desc text +); + +CREATE INDEX IF NOT EXISTS idx_pg_server_config_time + ON collect.pg_server_config(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (102, 'pg-server-config', now()::timestamp); +-- ===BATCH=== V103 pg-deadlocks + +CREATE TABLE IF NOT EXISTS collect.pg_deadlocks ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + occurred_at timestamp, + victim_pid integer, + participant_count integer, + deadlock_hash text, + lock_modes text, + resources text, + victim_statement text, + graph_text text +); + +CREATE INDEX IF NOT EXISTS idx_pg_deadlocks_time + ON collect.pg_deadlocks(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (103, 'pg-deadlocks', now()::timestamp); +-- ===BATCH=== V104 pg-deadlock-identity-index + +CREATE INDEX IF NOT EXISTS idx_pg_deadlocks_identity + ON collect.pg_deadlocks(server_id, deadlock_hash); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (104, 'pg-deadlock-identity-index', now()::timestamp); +-- ===BATCH=== V105 collector-cost + +CREATE TABLE IF NOT EXISTS collect.collector_cost +( + metric_time timestamp NOT NULL, + server_id integer NOT NULL, + database_name text, + collector_name text NOT NULL, + run_count integer NOT NULL, + total_sql_ms bigint NOT NULL, + max_sql_ms bigint NOT NULL, + total_storage_ms bigint NOT NULL, + total_rows bigint NOT NULL +); + +CREATE INDEX IF NOT EXISTS idx_collector_cost_time + ON collect.collector_cost(metric_time); + +CREATE INDEX IF NOT EXISTS idx_collector_cost_lookup + ON collect.collector_cost(server_id, collector_name, metric_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (105, 'collector-cost', now()::timestamp); +-- ===BATCH=== V106 pg-cpu-utilization + +CREATE TABLE IF NOT EXISTS collect.pg_cpu_utilization ( + collection_id bigint NOT NULL, + collection_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + sample_time timestamp, + cpu_percent double precision, + acu_utilization_percent double precision, + serverless_capacity_acu double precision, + max_configured_acu double precision +); + +CREATE INDEX IF NOT EXISTS idx_pg_cpu_utilization_time + ON collect.pg_cpu_utilization(server_id, collection_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (106, 'pg-cpu-utilization', now()::timestamp); +-- ===BATCH=== V107 plan-force-actions + +CREATE TABLE IF NOT EXISTS collect.plan_force_actions +( + action_id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + action_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + database_name text NOT NULL, + query_id bigint NOT NULL, + plan_id bigint NOT NULL, + action text NOT NULL, + mode text NOT NULL, + decision text NOT NULL, + reasons text NOT NULL DEFAULT '', + regression_factor numeric(19,2) NOT NULL DEFAULT 0, + latest_cpu_per_exec_us numeric(19,2) NOT NULL DEFAULT 0, + best_cpu_per_exec_us numeric(19,2) NOT NULL DEFAULT 0, + replica_role text, + parameter_sensitivity_cofired boolean NOT NULL DEFAULT FALSE, + outcome text NOT NULL, + detail text, + related_action_id bigint +); + +CREATE INDEX IF NOT EXISTS idx_plan_force_actions_time + ON collect.plan_force_actions(server_id, action_time); + +CREATE INDEX IF NOT EXISTS idx_plan_force_actions_query + ON collect.plan_force_actions(server_id, database_name, query_id, action_time); + +ALTER TABLE config.config_monitored_servers + ADD COLUMN IF NOT EXISTS plan_force_bot_enabled boolean NOT NULL DEFAULT FALSE; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (107, 'plan-force-actions', now()::timestamp); +-- ===BATCH=== V108 collection-log-phase-split + +ALTER TABLE collect.collection_log + ADD COLUMN IF NOT EXISTS sql_open_ms integer, + ADD COLUMN IF NOT EXISTS sql_drain_ms integer, + ADD COLUMN IF NOT EXISTS watermark_ms integer; + +/* Postgres FREEZES a view's SELECT * column list at CREATE, so without this refresh the passthrough every + read goes through would keep serving the pre-V108 column list forever and the new columns would be + invisible to an UPGRADED store while working fine on a fresh one - the V14 lesson, and V80's too. */ +CREATE OR REPLACE VIEW collect.v_collection_log AS SELECT * FROM collect.collection_log; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (108, 'collection-log-phase-split', now()::timestamp); +-- ===BATCH=== V109 collection-log-drain-forensics + +ALTER TABLE collect.collection_log + ADD COLUMN IF NOT EXISTS drain_rows_read bigint, + ADD COLUMN IF NOT EXISTS drain_bytes_read bigint, + ADD COLUMN IF NOT EXISTS drain_last_read_ms integer, + ADD COLUMN IF NOT EXISTS target_session_id integer, + ADD COLUMN IF NOT EXISTS sweep_peer_max_ms integer; + +/* Postgres FREEZES a view's SELECT * column list at CREATE, so without this refresh the passthrough every + read goes through would keep serving the pre-V109 column list forever - invisible on an UPGRADED store + while working fine on a fresh one. The V14 lesson, V80's, and V108's. */ +CREATE OR REPLACE VIEW collect.v_collection_log AS SELECT * FROM collect.collection_log; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (109, 'collection-log-drain-forensics', now()::timestamp); +-- ===BATCH=== V110 collection-log-fetch-phase-sums + +ALTER TABLE collect.collection_log + ADD COLUMN IF NOT EXISTS plan_fetch_probe_ms integer, + ADD COLUMN IF NOT EXISTS plan_fetch_target_ms integer, + ADD COLUMN IF NOT EXISTS plan_fetch_write_ms integer, + ADD COLUMN IF NOT EXISTS plan_fetch_ids_attempted integer, + ADD COLUMN IF NOT EXISTS plan_fetch_probe_ids integer, + ADD COLUMN IF NOT EXISTS text_fetch_probe_ms integer, + ADD COLUMN IF NOT EXISTS text_fetch_target_ms integer, + ADD COLUMN IF NOT EXISTS text_fetch_write_ms integer, + ADD COLUMN IF NOT EXISTS text_fetch_ids_attempted integer, + ADD COLUMN IF NOT EXISTS text_fetch_probe_ids integer; + +/* Postgres FREEZES a view's SELECT * column list at CREATE, so without this refresh the passthrough every + read goes through would keep serving the pre-V110 column list forever - invisible on an UPGRADED store + while working fine on a fresh one. The V14 lesson, V80's, V108's and V109's. */ +CREATE OR REPLACE VIEW collect.v_collection_log AS SELECT * FROM collect.collection_log; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (110, 'collection-log-fetch-phase-sums', now()::timestamp); +-- ===BATCH=== V111 store-log-self-monitoring + +CREATE TABLE IF NOT EXISTS collect.store_log_events +( + capture_time timestamp NOT NULL, + event_class text NOT NULL, + severity text NOT NULL, + occurrences integer NOT NULL, + message_text text, + sample_line text +); + +CREATE INDEX IF NOT EXISTS idx_store_log_events_time + ON collect.store_log_events(capture_time); + +CREATE INDEX IF NOT EXISTS idx_store_log_events_class + ON collect.store_log_events(event_class, capture_time); + +CREATE TABLE IF NOT EXISTS collect.store_log_captures +( + capture_time timestamp NOT NULL, + log_file text NOT NULL, + bytes_read bigint NOT NULL, + bytes_pending bigint NOT NULL, + lines_read integer NOT NULL, + entries_read integer NOT NULL, + offset_reset boolean NOT NULL, + groups_dropped integer NOT NULL +); + +CREATE INDEX IF NOT EXISTS idx_store_log_captures_time + ON collect.store_log_captures(capture_time); + +CREATE TABLE IF NOT EXISTS config.store_log_read_marker +( + log_file text NOT NULL PRIMARY KEY, + byte_offset bigint NOT NULL, + last_size bigint NOT NULL, + updated_at timestamp NOT NULL +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (111, 'store-log-self-monitoring', now()::timestamp); +-- ===BATCH=== V112 collector-stall-wait-probes + +CREATE TABLE IF NOT EXISTS collect.collector_stall_probes +( + probe_time timestamp NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + collector_name text NOT NULL, + outcome text NOT NULL, + budget_ms integer NOT NULL, + trigger_elapsed_ms integer NOT NULL, + trigger_rows_read bigint, + trigger_bytes_read bigint, + trigger_last_read_ms integer, + connect_ms integer, + query_ms integer, + waiting_task_count bigint, + distinct_wait_types integer, + top_wait_type text, + top_wait_total_ms bigint, + top_wait_max_ms bigint, + wait_summary text, + scheduler_count integer, + runnable_tasks bigint, + work_queue_length bigint, + pending_disk_io bigint, + max_runnable_tasks integer, + error_message text +); + +/* The read is newest-first per server, and the retention DELETE is by time alone, so one index serves both. + Not UNIQUE: two collectors on one server can stall in the same millisecond, and a unique key would drop + the second sample - the one that proves the degradation is not confined to a single collector. */ +CREATE INDEX IF NOT EXISTS idx_collector_stall_probes_time + ON collect.collector_stall_probes(server_id, probe_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (112, 'collector-stall-wait-probes', now()::timestamp); +-- ===BATCH=== V113 remediation-credential-and-actor + +ALTER TABLE config.config_monitored_servers + ADD COLUMN IF NOT EXISTS remediation_username text; + +ALTER TABLE config.config_monitored_servers + ADD COLUMN IF NOT EXISTS remediation_encrypted_password text; + +ALTER TABLE collect.plan_force_actions + ADD COLUMN IF NOT EXISTS actor text NOT NULL DEFAULT 'bot'; + +ALTER TABLE collect.plan_force_actions + ALTER COLUMN actor DROP DEFAULT; + +/* The review read is (server_id, actor, action) with an ordering on action_time, and it is the read the + own-forces-only invariant rests on, so it gets its own index rather than riding + idx_plan_force_actions_time - which leads with server_id but knows nothing about the actor and would + make every pending-review scan read the operator's rows to discard them. */ +CREATE INDEX IF NOT EXISTS idx_plan_force_actions_actor + ON collect.plan_force_actions(server_id, actor, action, action_time); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (113, 'remediation-credential-and-actor', now()::timestamp); +-- ===BATCH=== V114 pg-index-bloat-estimate-columns + +ALTER TABLE collect.pg_index_bloat + ADD COLUMN IF NOT EXISTS index_pages bigint, + ADD COLUMN IF NOT EXISTS table_rows bigint, + ADD COLUMN IF NOT EXISTS fillfactor integer, + ADD COLUMN IF NOT EXISTS est_tuple_bytes bigint, + ADD COLUMN IF NOT EXISTS est_leaf_pages bigint, + ADD COLUMN IF NOT EXISTS est_bloat_pct double precision, + ADD COLUMN IF NOT EXISTS est_reclaimable_bytes bigint, + ADD COLUMN IF NOT EXISTS pgstattuple_available boolean; + +DELETE FROM collect.collector_state +WHERE collector_name = 'pg_index_bloat' +AND state_key LIKE 'rotate:%'; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (114, 'pg-index-bloat-estimate-columns', now()::timestamp); +-- ===BATCH=== V115 pg-cpu-capacity-headroom + +ALTER TABLE collect.pg_cpu_utilization + ADD COLUMN IF NOT EXISTS acu_utilization_percent double precision, + ADD COLUMN IF NOT EXISTS serverless_capacity_acu double precision, + ADD COLUMN IF NOT EXISTS max_configured_acu double precision; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (115, 'pg-cpu-capacity-headroom', now()::timestamp); +-- ===BATCH=== V116 custom-alert-core + +CREATE TABLE IF NOT EXISTS config.custom_alert_rules ( + id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + name text NOT NULL UNIQUE, + definition jsonb NOT NULL, + description text, + enabled boolean NOT NULL DEFAULT TRUE, + version integer NOT NULL DEFAULT 1, + created_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + updated_by text +); + +CREATE TABLE IF NOT EXISTS config.custom_alert_state ( + rule_id bigint NOT NULL REFERENCES config.custom_alert_rules (id) ON DELETE CASCADE, + server_id integer NOT NULL, + rule_version integer NOT NULL, + consecutive_breaches integer NOT NULL DEFAULT 0, + consecutive_clears integer NOT NULL DEFAULT 0, + firing boolean NOT NULL DEFAULT FALSE, + fired_severity text, + last_evaluated_at timestamp, + next_due_at timestamp, + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + PRIMARY KEY (rule_id, server_id) +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (116, 'custom-alert-core', now()::timestamp); +-- ===BATCH=== V117 mute-rules-reload-beacon + +DROP TRIGGER IF EXISTS trg_bump_mute_rules ON config.config_mute_rules; +CREATE TRIGGER trg_bump_mute_rules + AFTER INSERT OR UPDATE OR DELETE ON config.config_mute_rules + FOR EACH STATEMENT EXECUTE FUNCTION config.config_bump_version(); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (117, 'mute-rules-reload-beacon', now()::timestamp); +-- ===BATCH=== V118 builtin-alert-persistence + +CREATE TABLE IF NOT EXISTS config.alert_persistence_state ( + server_id integer NOT NULL, + metric_name text NOT NULL, + consecutive_breaches integer NOT NULL DEFAULT 0, + consecutive_clears integer NOT NULL DEFAULT 0, + firing boolean NOT NULL DEFAULT FALSE, + last_observed_sample_at timestamp, + updated_at timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC'), + PRIMARY KEY (server_id, metric_name) +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (118, 'builtin-alert-persistence', now()::timestamp); +-- ===BATCH=== V119 retention-hold-ratio-knobs + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS retention_hold_warn_ratio double precision NOT NULL DEFAULT 2.0; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS retention_hold_critical_ratio double precision NOT NULL DEFAULT 4.0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (119, 'retention-hold-ratio-knobs', now()::timestamp); +-- ===BATCH=== V120 deadlock-rate-band-knobs + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS deadlock_warn_per_hour double precision NOT NULL DEFAULT 5.0; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS deadlock_critical_per_hour double precision NOT NULL DEFAULT 20.0; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (120, 'deadlock-rate-band-knobs', now()::timestamp); +-- ===BATCH=== V121 oversized-plan-backlog + +ALTER TABLE query_stats + ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; +ALTER TABLE procedure_stats + ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; +DROP VIEW IF EXISTS v_query_stats; + +CREATE TABLE IF NOT EXISTS collect.oversized_plan_backlog +( + server_id integer NOT NULL, + collector_name text NOT NULL, + plan_handle text NOT NULL, + sql_handle text NOT NULL, + statement_start_offset integer NOT NULL, + statement_end_offset integer NOT NULL, + database_name text, + query_hash text, + observed_bytes bigint NOT NULL, + first_seen_at timestamp NOT NULL, + last_seen_at timestamp NOT NULL, + plan_xml text, + captured_at timestamp, + expired_at timestamp, + last_attempt_at timestamp, + attempt_count integer NOT NULL DEFAULT 0, + CONSTRAINT pk_oversized_plan_backlog PRIMARY KEY + ( + server_id, + collector_name, + plan_handle, + sql_handle, + statement_start_offset, + statement_end_offset + ) +); + +ALTER TABLE query_plan_dim + ADD COLUMN IF NOT EXISTS query_plan_gz bytea; +ALTER TABLE query_plan_dim + ALTER COLUMN query_plan_xml DROP NOT NULL; +/* Pre-adds for the payload-resolving view below: it names every payload column the + collector has today, and a store replaying this rung may predate the ALTER that adds + one of them. Idempotent, so this is a no-op wherever they already exist. */ +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS database_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_hash text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS creation_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS last_execution_time timestamp; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_clr_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS total_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_dop bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_ideal_grant_kb bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_reserved_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_used_threads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS min_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS max_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_text text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sql_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_handle text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_execution_count bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_worker_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_elapsed_time bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_logical_writes bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_physical_reads bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_rows bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS delta_spills bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS plan_generation_num bigint; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS sample_interval_seconds integer; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS host_object_name text; +ALTER TABLE query_stats ADD COLUMN IF NOT EXISTS query_plan_xml_bytes bigint; + +/* v_query_stats resolves each row's payload: the inline column for rows written before + the dimension tables existed, the dimension row for every row written since (#1767). + Column list generated from the collector definition so it can never go stale. */ +CREATE OR REPLACE VIEW v_query_stats AS +SELECT + f.collection_id, + f.collection_time, + f.server_id, + f.server_name, + f.database_name, + f.query_hash, + f.query_plan_hash, + f.creation_time, + f.last_execution_time, + f.execution_count, + f.total_worker_time, + f.total_elapsed_time, + f.total_logical_reads, + f.total_logical_writes, + f.total_physical_reads, + f.total_clr_time, + f.total_rows, + f.total_spills, + f.min_worker_time, + f.max_worker_time, + f.min_elapsed_time, + f.max_elapsed_time, + f.min_physical_reads, + f.max_physical_reads, + f.min_rows, + f.max_rows, + f.min_dop, + f.max_dop, + f.min_grant_kb, + f.max_grant_kb, + f.min_used_grant_kb, + f.max_used_grant_kb, + f.min_ideal_grant_kb, + f.max_ideal_grant_kb, + f.min_reserved_threads, + f.max_reserved_threads, + f.min_used_threads, + f.max_used_threads, + f.min_spills, + f.max_spills, + COALESCE(f.query_text, qtd.query_text) AS query_text, + COALESCE(f.query_plan_xml, qpd.query_plan_xml) AS query_plan_xml, + f.sql_handle, + f.plan_handle, + f.delta_execution_count, + f.delta_worker_time, + f.delta_elapsed_time, + f.delta_logical_reads, + f.delta_logical_writes, + f.delta_physical_reads, + f.delta_rows, + f.delta_spills, + f.plan_generation_num, + f.sample_interval_seconds, + f.host_object_name, + f.query_plan_xml_bytes, + f.query_text_digest, + f.query_plan_digest, + qpd.query_plan_gz +FROM query_stats AS f +LEFT JOIN query_text_dim AS qtd ON qtd.digest = f.query_text_digest +LEFT JOIN query_plan_dim AS qpd ON qpd.digest = f.query_plan_digest +; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (121, 'oversized-plan-backlog', now()::timestamp); +-- ===BATCH=== V122 pg-deadlock-blocking-count-knobs + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS pg_deadlock_count_threshold integer NOT NULL DEFAULT 1; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS pg_blocking_count_threshold integer NOT NULL DEFAULT 1; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (122, 'pg-deadlock-blocking-count-knobs', now()::timestamp); +-- ===BATCH=== V123 fleet-sweep-state + +CREATE TABLE IF NOT EXISTS collect.fleet_sweep_runs +( + sweep_id bigint NOT NULL, + swept_at timestamp NOT NULL, + span_start timestamp NOT NULL, + span_end timestamp NOT NULL, + previous_sweep_id bigint, + alerts_enabled boolean NOT NULL, + servers_expected integer NOT NULL, + servers_reported integer NOT NULL, + instruments_alive boolean NOT NULL, + instrument_liveness_json text NOT NULL, + report_json text NOT NULL, + CONSTRAINT pk_fleet_sweep_runs PRIMARY KEY (sweep_id) +); + +CREATE TABLE IF NOT EXISTS collect.fleet_sweep_server_verdicts +( + sweep_id bigint NOT NULL, + server_id integer NOT NULL, + server_name text NOT NULL, + band text NOT NULL, + previous_band text, + band_reason text, + verdict_json text, + CONSTRAINT pk_fleet_sweep_server_verdicts PRIMARY KEY (sweep_id, server_id) +); + +CREATE TABLE IF NOT EXISTS collect.fleet_sweep_would_have_paged +( + sweep_id bigint NOT NULL, + server_id integer NOT NULL, + alert_family text NOT NULL, + evidence_json text NOT NULL, + CONSTRAINT pk_fleet_sweep_would_have_paged PRIMARY KEY (sweep_id, server_id, alert_family) +); + +CREATE TABLE IF NOT EXISTS collect.fleet_sweep_watch_items +( + server_id integer NOT NULL, + item_key text NOT NULL, + condition text NOT NULL, + state text NOT NULL, + consecutive_hits integer NOT NULL DEFAULT 0, + consecutive_misses integer NOT NULL DEFAULT 0, + first_seen_sweep_id bigint NOT NULL, + last_seen_sweep_id bigint NOT NULL, + opened_sweep_id bigint, + closed_sweep_id bigint, + first_seen_at timestamp NOT NULL, + last_seen_at timestamp NOT NULL, + evidence_json text, + CONSTRAINT pk_fleet_sweep_watch_items PRIMARY KEY (server_id, item_key) +); +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (123, 'fleet-sweep-state', now()::timestamp); +-- ===BATCH=== V124 fleet-sweep-cadence-knobs + +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS fleet_sweep_enabled boolean NOT NULL DEFAULT TRUE; +ALTER TABLE config.config_alert_settings + ADD COLUMN IF NOT EXISTS fleet_sweep_interval_minutes integer NOT NULL DEFAULT 60; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (124, 'fleet-sweep-cadence-knobs', now()::timestamp); +-- ===BATCH=== V125 collector-database-scope + +ALTER TABLE config.config_collector_schedules + ADD COLUMN IF NOT EXISTS databases text[]; +INSERT INTO darling_schema_version (version, name, applied_at) VALUES (125, 'collector-database-scope', now()::timestamp);