MCP tool audit fixes: spills, empty reasons, FinOps, dropped databases, object stats (#5633)

Darling/Darling.Tests/AnalysisWindowEmptyRuleParityTests.cs

@@ -33,7 +33,7 @@ namespace Darling.Tests;
 [Trait("Reads", "Lite")]
 public sealed class AnalysisWindowEmptyRuleParityTests
 {
-    private const string PassEntry = "public async Task<List<AnalysisFinding>> AnalyzeAsync(AnalysisContext context)";
+    private const string PassEntry = "public async Task<List<AnalysisFinding>> AnalyzeAsync(AnalysisContext context";
     private const string UnobservedBranch = "if (context.ObservedDurationMs <= 0)";
     private const string ObservedZeroBranch = "if (facts.Count == 0)";
     private const string PartialCaveat = "if (context.Coverage is { IsPartial: true } partial)";

Darling/Darling.Tests/AuditConfigEditionNameTests.cs

@@ -64,7 +64,7 @@ public void AuditConfig_AsksTheEngineQuestion_BeforeItSaysTheConfigCollectorMayN
         Assert.True(gate < body.LastIndexOf("\"no_config_data\"", StringComparison.Ordinal));
 
         /* The private edition switch is gone: the tool names an edition through the shared table only. */
-        Assert.Contains("AuditEditionName(edition)", body, StringComparison.Ordinal);
+        Assert.Contains("AuditEditionLabel(propertiesRow?.Edition, edition)", body, StringComparison.Ordinal);
         Assert.DoesNotContain("(HADR)", body, StringComparison.Ordinal);
         Assert.DoesNotContain("Azure Synapse serverless\"", body, StringComparison.Ordinal);
     }

Darling/Darling.Tests/AzureSiblingSizePayloadTests.cs

@@ -103,7 +103,10 @@ public void TheLatestSnapshotSql_SelectsTheFileId_AsTheColumnTheReaderMapsLast()
     {
         var sql = DarlingObjectStatsReader.DatabaseSizeLatestSql;
 
-        Assert.Matches(new Regex(@"volume_free_mb,\s*file_id\s*FROM v_database_size_stats"), sql);
+        /* #5633 item 6 appended the percent-growth pair AFTER file_id, so file_id is no longer the last column. The
+           reader maps by ordinal (file_id at 11, then is_percent_growth 12, growth_pct 13); this pins that exact
+           order, so a column slipped in before file_id would shift the mapping and fail here. */
+        Assert.Matches(new Regex(@"volume_free_mb,\s*file_id,\s*is_percent_growth,\s*CAST\(growth_pct AS double precision\) AS growth_pct\s*FROM v_database_size_stats"), sql);
     }
 
     [Fact]

Darling/Darling.Tests/AzureSqlDatabaseMemoryScopeTests.cs

@@ -410,14 +410,14 @@ public void CpuRightSizingRecommendation_OnAzureSqlDatabase_NamesTheVcores_InThe
     [InlineData(3)]
     [InlineData(8)]
     [InlineData(0)]
-    public void CpuRightSizingRecommendation_OffAzureSqlDatabase_KeepsTheWordCores(int engineEdition)
+    public void CpuRightSizingRecommendation_OffAzureSqlDatabase_SaysLogicalCpus(int engineEdition)
     {
         var rec = ViewerDataService.BuildCpuRightSizingRecommendation(CpuRow(engineEdition), monthlyCost: 1_000m);
 
         Assert.NotNull(rec);
-        Assert.StartsWith("CPU over-provisioned (32 cores, P95 = ", rec!.Finding, StringComparison.Ordinal);
-        Assert.Contains("across 32 cores. Consider reducing to ~", rec.Detail, StringComparison.Ordinal);
-        Assert.EndsWith(" cores.", rec.Detail, StringComparison.Ordinal);
+        Assert.StartsWith("CPU over-provisioned (32 logical CPUs, P95 = ", rec!.Finding, StringComparison.Ordinal);
+        Assert.Contains("across 32 logical CPUs. Consider reducing to ~", rec.Detail, StringComparison.Ordinal);
+        Assert.EndsWith(" logical CPUs.", rec.Detail, StringComparison.Ordinal);
         Assert.DoesNotContain("vCores", rec.Finding + rec.Detail, StringComparison.Ordinal);
         Assert.True(rec.EstMonthlySavings > 0, "a server with a budget still gets its savings estimate");
     }

Darling/Darling.Tests/AzureSqlDatabaseOwnFiguresTests.cs

@@ -422,13 +422,13 @@ public void CpuCountUnit_IsVcoresOnAzureSqlDatabase_AndCpusEverywhereElse()
     }
 
     [Fact]
-    public void CpuCoreNoun_IsVcoresOnAzureSqlDatabase_AndCoresEverywhereElse()
+    public void CpuCoreNoun_IsVcoresOnAzureSqlDatabase_AndLogicalCpusEverywhereElse()
     {
         /* The FinOps CPU right-sizing text prints the utilization read's count: the vCores on an Azure SQL Database, which it
            names the way the utilization card does, and a CPU count everywhere else, in the word it has always used. */
         Assert.Equal("vCores", ServerHardwareScope.CpuCoreNoun(5));
         foreach (var engineEdition in new int?[] { 1, 2, 3, 4, 8, null })
-            Assert.Equal("cores", ServerHardwareScope.CpuCoreNoun(engineEdition));
+            Assert.Equal("logical CPUs", ServerHardwareScope.CpuCoreNoun(engineEdition));
     }
 
     [Fact]

Darling/Darling.Tests/CiComposeWorkerSizingTests.cs

@@ -43,6 +43,8 @@ public sealed class CiComposeWorkerSizingTests
     /* The product's formula, restated ONCE — same as CiClusterWorkerSizingTests. Both this test and the
        compose file are re-derived from the live catalog count on every run, so neither can be right about
        a stale hypertable count. */
+    /* The compose file keeps the FLOOR (hypertables + 2): a container has no host-RAM figure to size from, and
+       a 2 GB container is at the floor of the managed RAM rule anyway (#5633 item 14). */
     private static int ExpectedBackgroundWorkers => TimescaleSupport.HypertableCount + 2;
 
     private static int ExpectedWorkerProcesses => 3 + ExpectedBackgroundWorkers + 8;

Darling/Darling.Tests/CollectionCaveatsParityTests.cs

@@ -98,7 +98,7 @@ public void BothPasses_CarryTheFailuresAndTheFactCountsOut_AndBothReadsReturnThe
     {
         foreach (var (sku, source) in Services())
         {
-            var passStart = source.IndexOf("public async Task<List<AnalysisFinding>> AnalyzeAsync(AnalysisContext context)", StringComparison.Ordinal);
+            var passStart = source.IndexOf("public async Task<List<AnalysisFinding>> AnalyzeAsync(AnalysisContext context", StringComparison.Ordinal);
             const string readEntry = "public async Task<(List<Fact> Facts, WindowCoverage? Coverage, CollectionCaveatState Caveats)> CollectAndScoreFactsAsync(";
             var readStart = source.IndexOf(readEntry, passStart, StringComparison.Ordinal);
             var readEnd = source.IndexOf("ComparePeriodsAsync(", readStart, StringComparison.Ordinal);

Darling/Darling.Tests/CollectorRunEmptyReasonTests.cs

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service.Mcp;
+using PerformanceMonitor.Darling.Viewer;
+using Xunit;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// #5633 items 3, 19 and 9. An empty read says WHY from the collector's own run history, and the one shared rule
+/// (<see cref="CollectorRunFacts"/>, <see cref="ConfigValuesMatch"/>) is what every surface calls. Each assertion fails
+/// on the old shape: the old procedure text was returned for every empty page, the old trace-flag text claimed fewer
+/// than two snapshots whatever the log said, and the old match flag was plain equality.
+/// </summary>
+public sealed class CollectorRunEmptyReasonTests
+{
+    private static readonly DateTime Last = new(2026, 10, 12, 8, 30, 0, DateTimeKind.Utc);
+
+    private static string Field(string json, string name) =>
+        JsonDocument.Parse(json).RootElement.GetProperty(name).GetString()!;
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    public void ProcedureStats_BeforeTwoSuccessfulRuns_KeepsTheTwoCyclesReason(int runs)
+    {
+        var json = DarlingMcpDataTools.EmptyProcedureStatsStatus(new CollectorRunFacts(runs, runs, Last, 0), 24);
+
+        Assert.Equal("unavailable", Field(json, "status"));
+        Assert.Contains("two collection cycles", Field(json, "message"), StringComparison.Ordinal);
+    }
+
+    /// <summary>Review L-b: the UTC stamp in these sentences is a custom format, whose ':' is the CURRENT culture's time separator.
+    /// On a host whose culture uses another one the stamp was mangled; the sentences format with the invariant culture.</summary>
+    [Fact]
+    public void TheUtcStamps_UseTheInvariantTimeSeparator_WhateverTheHostCulture()
+    {
+        var odd = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+        odd.DateTimeFormat.TimeSeparator = ".";
+        var saved = CultureInfo.CurrentCulture;
+        try
+        {
+            CultureInfo.CurrentCulture = odd;
+            var gap = new CollectorRunFacts(2, 0, Last, 0).ProcedureStatsEmpty(6).Message;
+            var traceFlags = new CollectorRunFacts(1, 0, Last, 0).NoTraceFlagsEnabled();
+
+            Assert.Contains("2026-10-12 08:30:00 UTC", gap, StringComparison.Ordinal);
+            Assert.Contains("2026-10-12 08:30:00 UTC", traceFlags, StringComparison.Ordinal);
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = saved;
+        }
+    }
+
+    [Fact]
+    public void ProcedureStats_AfterTheCollectorHasRun_SaysNoProcedureExecuted()
+    {
+        var json = DarlingMcpDataTools.EmptyProcedureStatsStatus(new CollectorRunFacts(2, 30, Last, 0), 24);
+
+        Assert.Equal("empty", Field(json, "status"));
+        var message = Field(json, "message");
+        Assert.Contains("No procedure executed in the last 24h", message, StringComparison.Ordinal);
+        Assert.DoesNotContain("two collection cycles", message, StringComparison.Ordinal);
+    }
+
+    /// <summary>#5633 review (finding D): a read that left databases out claims only the ones the server still has, and never says the
+    /// collector "recorded nothing for it". The gap and new-collector branches are unchanged by the count.</summary>
+    [Fact]
+    public void ProcedureStats_AfterALeftOutDatabase_ClaimsOnlyTheDatabasesTheServerStillHas()
+    {
+        var json = DarlingMcpDataTools.EmptyProcedureStatsStatus(new CollectorRunFacts(2, 30, Last, 0), 24, databasesLeftOut: 3);
+
+        Assert.Equal("empty", Field(json, "status"));
+        var message = Field(json, "message");
+        Assert.DoesNotContain("recorded nothing for it", message, StringComparison.Ordinal);
+        Assert.DoesNotContain("matches this request", message, StringComparison.Ordinal);
+        Assert.Contains("No procedure ran in the last 24h in a database this server still has", message, StringComparison.Ordinal);
+        Assert.Contains("3 database(s) the server no longer lists", message, StringComparison.Ordinal);
+        Assert.Equal(new CollectorRunFacts(2, 0, Last, 0).ProcedureStatsEmpty(24).Message, new CollectorRunFacts(2, 0, Last, 0).ProcedureStatsEmpty(24, 3).Message);
+        Assert.Equal(new CollectorRunFacts(1, 1, Last, 0).ProcedureStatsEmpty(24).Message, new CollectorRunFacts(1, 1, Last, 0).ProcedureStatsEmpty(24, 3).Message);
+    }
+
+    [Fact]
+    public void DatabasesLeftOut_ListsTheFirstTwentyNames_AndTheNoteCarriesTheFullCount()
+    {
+        var all = DatabasesLeftOut.Distinct(Enumerable.Range(0, 25).Select(i => $"Db{i:D2}").Concat(new[] { "Db00", " " }));
+
+        Assert.Equal(25, all!.Count);
+        Assert.Equal(20, DatabasesLeftOut.Named(all)!.Count);
+        Assert.Contains("25 in all", DatabasesLeftOut.Note(all), StringComparison.Ordinal);
+        Assert.Null(DatabasesLeftOut.Distinct(new string?[] { null, "" }));
+        Assert.Null(DatabasesLeftOut.Note(null));
+
+        var wrapped = McpHelpers.WithDatabasesLeftOut(McpHelpers.Status("empty", "m"), all)!;
+        using var doc = JsonDocument.Parse(wrapped);
+        Assert.Equal(20, doc.RootElement.GetProperty("databases_left_out").GetArrayLength());
+        Assert.Equal(McpHelpers.Status("empty", "m"), McpHelpers.WithDatabasesLeftOut(McpHelpers.Status("empty", "m"), null));
+    }
+
+    [Fact]
+    public void ProcedureStats_WithNoRunInTheWindow_IsAGapNotAnAllClear()
+    {
+        var json = DarlingMcpDataTools.EmptyProcedureStatsStatus(new CollectorRunFacts(2, 0, Last, 0), 6);
+
+        Assert.Equal("unavailable", Field(json, "status"));
+        Assert.Contains("no successful run inside the last 6h", Field(json, "message"), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TraceFlagChanges_AfterARunThatStoredNothing_SaysNoFlagIsEnabled()
+    {
+        var facts = new CollectorRunFacts(1, null, Last, 0);
+
+        var json = DarlingMcpConfigHistoryTools.NoTraceFlagChanges("srv", 168, 0, McpWindowNotice.Unavailable, facts);
+
+        Assert.Equal("empty", Field(json, "status"));
+        var message = Field(json, "message");
+        Assert.Contains("No trace flags are enabled as of", message, StringComparison.Ordinal);
+        Assert.DoesNotContain("fewer than two", message, StringComparison.Ordinal);
+        Assert.Equal(0, JsonDocument.Parse(json).RootElement.GetProperty("hints").GetProperty("snapshot_count").GetInt32());
+    }
+
+    [Fact]
+    public void TraceFlagChanges_AfterFlagsWereCapturedThenNone_SaysWhyTheRemovalIsNotListed()
+    {
+        var facts = new CollectorRunFacts(2, null, Last, 0);
+
+        var message = Field(DarlingMcpConfigHistoryTools.NoTraceFlagChanges("srv", 168, 1, McpWindowNotice.Unavailable, facts), "message");
+
+        Assert.Contains("No trace flags are enabled as of", message, StringComparison.Ordinal);
+        Assert.Contains("counts as an empty capture", message, StringComparison.Ordinal);
+    }
+
+    [Theory]
+    [InlineData(0, null, 0)]
+    [InlineData(1, 4L, 1)]
+    public void TraceFlagChanges_WithoutAnEmptyRun_KeepTheFewerThanTwoSnapshotsText(long runs, long? rows, int snapshots)
+    {
+        var facts = new CollectorRunFacts(runs, null, runs == 0 ? null : Last, rows);
+
+        var message = Field(DarlingMcpConfigHistoryTools.NoTraceFlagChanges("srv", 168, snapshots, McpWindowNotice.Unavailable, facts), "message");
+
+        Assert.Contains("fewer than two config snapshots", message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TraceFlags_EmptyReadAfterARunThatStoredNothing_SaysNoFlagIsEnabled()
+    {
+        var after = Field(DarlingMcpConfigTools.EmptyTraceFlagsStatus(new CollectorRunFacts(1, null, Last, 0)), "message");
+        var never = Field(DarlingMcpConfigTools.EmptyTraceFlagsStatus(CollectorRunFacts.None), "message");
+
+        Assert.Contains("No trace flags are enabled as of", after, StringComparison.Ordinal);
+        Assert.Contains("config collector has not run yet", never, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RunFactsReaderSql_CountsOnlySuccessfulRuns()
+    {
+        Assert.Contains("status = 'SUCCESS'", DarlingCollectorRunFactsReader.LatestSuccessSql, StringComparison.Ordinal);
+        Assert.Contains("status = 'SUCCESS'", DarlingCollectorRunFactsReader.RunsInWindowSql, StringComparison.Ordinal);
+        Assert.Contains("LIMIT $3", DarlingCollectorRunFactsReader.LatestSuccessSql, StringComparison.Ordinal);
+        /* #5633 review: an as_of read bounds the newest run at the anchor, the same text otherwise. */
+        Assert.Contains("collection_time <= $4", DarlingCollectorRunFactsReader.LatestSuccessAtOrBeforeSql, StringComparison.Ordinal);
+        Assert.Contains("status = 'SUCCESS'", DarlingCollectorRunFactsReader.LatestSuccessAtOrBeforeSql, StringComparison.Ordinal);
+        Assert.Contains("LIMIT $3", DarlingCollectorRunFactsReader.LatestSuccessAtOrBeforeSql, StringComparison.Ordinal);
+    }
+
+    [Theory]
+    [InlineData("min server memory (MB)", 0, 16, true)]
+    [InlineData("min server memory (MB)", 0, 0, true)]
+    [InlineData("min server memory (MB)", 0, 32, false)]
+    [InlineData("min server memory (MB)", 16, 0, false)]
+    [InlineData("max server memory (MB)", 0, 16, false)]
+    [InlineData("max degree of parallelism", 8, 4, false)]
+    public void MinServerMemoryZeroRunsAsSixteen_OnlyForThatSetting_OnEverySurface(string name, long configured, long inUse, bool expected)
+    {
+        Assert.Equal(expected, ConfigValuesMatch.Matches(name, configured, inUse));
+        Assert.Equal(expected, new DarlingCurrentConfigReader.ServerConfigReadRow(name, configured, inUse, true, true).ValuesMatch);
+        Assert.Equal(expected, new ServerConfigRow { ConfigurationName = name, ValueConfigured = configured, ValueInUse = inUse }.ValuesMatch);
+    }
+}