From 5ac4a9962e66351830f5ceaa9b0a1e6c000bbf93 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:16:01 -0400
Subject: [PATCH 1/3] Database Sizes: show the Hyperscale log file as n/a (log
 service) and leave it out of allocated totals

On Azure SQL Database Hyperscale, sys.database_files reports the LOG file at about 1 TB (1,046,528 MB) while the data file reports its real allocation. The log lives in Hyperscale's log service, so that figure is not storage the database holds or pays for (Hyperscale bills allocated data storage). Database Sizes in both apps showed the database at 1,056,768 MB allocated against 315 MB used.

The Azure SQL Database branch of the database_size_stats collector now detects Hyperscale from DATABASEPROPERTYEX(DB_NAME(), 'Edition') and stores a NULL size, growth and ceiling for the LOG row only. The data file keeps its size, and used space and the VLF count stay as collected. SQL Server, Managed Instance and non-Hyperscale Azure SQL Database are unchanged.

Lite's DuckDB store drops NOT NULL from database_size_stats.total_size_mb (schema v67); Darling's Postgres store already held it nullable. Every reader in both apps passes the NULL through instead of reading it as 0: the Database Sizes grid words it as n/a (log service) and sorts it last, the allocated and free totals, the cost share and the utilization chart leave it out, and get_database_sizes returns null with a short note in both apps. The web Database Sizes table shows that note.
---
 .../DatabaseSizeLatestPlanShapeLiveTests.cs   |   2 +-
 .../Darling.Tests/HyperscaleLogSizeTests.cs   | 189 ++++++++++
 .../Mcp/DarlingMcpObjectStatsTools.cs         |  81 ++--
 .../Mcp/DarlingObjectStatsReader.cs           |   8 +-
 .../wwwroot/js/pages/server-tabs.js           |   5 +-
 .../FinOpsTab.Loaders.cs                      |   9 +-
 .../FinOpsTab.xaml                            |   2 +-
 ...iewerDataService.FinOps.Recommendations.cs |   2 +-
 .../ViewerDataService.FinOps.Storage.cs       |  10 +-
 .../ViewerDataService.FinOps.cs               |  22 +-
 Lite.Tests/AgedDatabaseMigrationTests.cs      |  49 +++
 Lite.Tests/DuckDbSchemaEquivalenceTests.cs    |   7 +
 Lite.Tests/HyperscaleLogSizeTests.cs          | 354 ++++++++++++++++++
 Lite/Controls/FinOpsTab.xaml                  |   3 +-
 Lite/Controls/FinOpsTab.xaml.cs               |   9 +-
 Lite/Database/DuckDbInitializer.cs            |  40 +-
 Lite/Database/DuckDbSchemaGenerator.cs        |   7 +-
 Lite/Mcp/McpServerInfoTools.cs                |  80 ++--
 .../LocalDataService.FinOps.Inventory.cs      |   8 +-
 ...LocalDataService.FinOps.Recommendations.cs |   2 +-
 Lite/Services/LocalDataService.FinOps.cs      |  22 +-
 Lite/Services/LocalDataService.ServerInfo.cs  |  16 +-
 .../DatabaseSizeStatsCollector.cs             |  67 +++-
 .../HyperscaleLogSize.cs                      |  32 ++
 24 files changed, 936 insertions(+), 90 deletions(-)
 create mode 100644 Darling/Darling.Tests/HyperscaleLogSizeTests.cs
 create mode 100644 Lite.Tests/HyperscaleLogSizeTests.cs
 create mode 100644 PerformanceMonitor.Common/HyperscaleLogSize.cs

diff --git a/Darling/Darling.Tests/DatabaseSizeLatestPlanShapeLiveTests.cs b/Darling/Darling.Tests/DatabaseSizeLatestPlanShapeLiveTests.cs
index 6928c21fc..a2b2c46fe 100644
--- a/Darling/Darling.Tests/DatabaseSizeLatestPlanShapeLiveTests.cs
+++ b/Darling/Darling.Tests/DatabaseSizeLatestPlanShapeLiveTests.cs
@@ -208,7 +208,7 @@ private static async Task<List<string>> ReadOldLatestAsync(NpgsqlConnection conn
 
     private static List<string> FormatViewerLatest(List<DatabaseSizeRow> rows) => rows.Select(r => string.Join("|",
         r.DatabaseName, r.FileTypeDesc, r.FileName,
-        r.TotalSizeMb.ToString(CultureInfo.InvariantCulture),
+        r.TotalSizeMb?.ToString(CultureInfo.InvariantCulture) ?? "",
         r.UsedSizeMb?.ToString(CultureInfo.InvariantCulture) ?? "",
         r.VolumeMountPoint ?? "",
         r.VolumeTotalMb?.ToString(CultureInfo.InvariantCulture) ?? "",
diff --git a/Darling/Darling.Tests/HyperscaleLogSizeTests.cs b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
new file mode 100644
index 000000000..6e3c24ef5
--- /dev/null
+++ b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
@@ -0,0 +1,189 @@
+/*
+ * 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.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service.Mcp;
+using PerformanceMonitor.Darling.Storage;
+using PerformanceMonitor.Darling.Viewer;
+using Xunit;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// Azure SQL Database Hyperscale keeps its transaction log in the log service. <c>sys.database_files</c> still lists a
+/// LOG row for it, sized at about 1 TB (1,046,528 MB), which is not storage the database holds or pays for: Hyperscale
+/// bills allocated data storage. The rule these pins hold, in Darling's half: the collector (shared with Lite) stores a
+/// NULL size for that one row, the Postgres store keeps it NULL, every reader shows it as "n/a (log service)", and it
+/// stays out of every allocated total. The data file keeps its real size. SQL Server, Managed Instance and
+/// non-Hyperscale Azure SQL Database are unchanged. Lite's <c>HyperscaleLogSize*Tests</c> are the twins.
+/// </summary>
+public sealed class HyperscaleLogSizeTests
+{
+    private static CollectorContext Context(bool azure) => new()
+    {
+        ServerId = 42,
+        ServerName = "test-server",
+        CollectionTime = new DateTime(2026, 9, 30, 12, 0, 0, DateTimeKind.Utc),
+        Deltas = new CollectorDeltaCalculator(),
+        Target = new CollectorTargetInfo { IsAzureSqlDb = azure },
+    };
+
+    [Fact]
+    public void AzureSqlDbQuery_NullsTheSizeOfTheHyperscaleLogRowOnly_AndKeepsTheRealSizeOtherwise()
+    {
+        var text = DatabaseSizeStatsCollector.Instance.BuildQuery(Context(azure: true)).Text;
+
+        Assert.Contains("CONVERT(nvarchar(64), DATABASEPROPERTYEX(DB_NAME(), N'Edition')) = N'Hyperscale'", text, StringComparison.Ordinal);
+        Assert.Matches(new Regex(@"is_log_service =\s*CASE\s*WHEN @is_hyperscale = 1\s*AND\s+df\.type = 1 /\*LOG\*/\s*THEN CONVERT\(bit, 1\)\s*ELSE CONVERT\(bit, 0\)"), text);
+        Assert.Matches(new Regex(@"total_size_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)\s*ELSE CONVERT\(decimal\(19,2\), df\.size \* 8\.0 / 1024\.0\)\s*END"), text);
+        Assert.Matches(new Regex(@"max_size_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)"), text);
+        Assert.Matches(new Regex(@"auto_growth_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)"), text);
+        Assert.Contains("CONVERT(decimal(19,2), FILEPROPERTY(df.name, N'SpaceUsed') * 8.0 / 1024.0)", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void OnPremQuery_IsUnchanged_NoHyperscaleBranch()
+    {
+        var text = DatabaseSizeStatsCollector.Instance.BuildQuery(Context(azure: false)).Text;
+
+        Assert.DoesNotContain("Hyperscale", text, StringComparison.Ordinal);
+        Assert.DoesNotContain("is_log_service", text, StringComparison.Ordinal);
+        Assert.Contains("CONVERT(decimal(19,2), df.size * 8.0 / 1024.0)", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void PostgresStore_KeepsTotalSizeNullable()
+    {
+        /* Postgres emits every payload column nullable, so the NULL size needs no migration here; this holds it
+           that way (Lite's DuckDB store needed its v67 rung for the same row). */
+        var ddl = PgSchemaGenerator.CreateTable(DatabaseSizeStatsCollector.Instance);
+
+        var line = ddl.Split('\n').Single(l => l.TrimStart().StartsWith("total_size_mb ", StringComparison.Ordinal));
+        Assert.DoesNotContain("NOT NULL", line, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ViewerRow_HyperscaleLogRow_ReadsAsNotApplicable_AndOutOfTheAllocatedTotals_WhileTheDataRowCounts()
+    {
+        var rows = new List<DatabaseSizeRow>
+        {
+            new() { DatabaseName = "hsdb", FileTypeDesc = "ROWS", FileName = "hsdb_data", TotalSizeMb = 10_240m, UsedSizeMb = 315m },
+            new() { DatabaseName = "hsdb", FileTypeDesc = "LOG", FileName = "hsdb_log", TotalSizeMb = null, UsedSizeMb = 40m },
+        };
+
+        Assert.Null(rows[1].FreeSpaceMb);
+        Assert.Null(rows[1].UsedPct);
+        Assert.Equal(40m, rows[1].UsedSizeMb);
+
+        Assert.Equal(10_240m, DatabaseSizeRow.AllocatedTotalMb(rows));
+        Assert.Equal(10_240m - 315m, DatabaseSizeRow.FreeTotalMb(rows));
+
+        /* Unchanged: a non-Hyperscale database (or a SQL Server one) has a real size on its log row, which counts. */
+        var plain = new List<DatabaseSizeRow>
+        {
+            new() { FileTypeDesc = "ROWS", TotalSizeMb = 100m, UsedSizeMb = 10m },
+            new() { FileTypeDesc = "LOG", TotalSizeMb = 50m, UsedSizeMb = 5m },
+        };
+        Assert.Equal(150m, DatabaseSizeRow.AllocatedTotalMb(plain));
+        Assert.Equal(135m, DatabaseSizeRow.FreeTotalMb(plain));
+        Assert.Equal(10.0m, plain[0].UsedPct);
+    }
+
+    [Fact]
+    public void ViewerGrid_WordsANullSize_AsTheSharedHyperscaleText_AndSortsNullSizesLast()
+    {
+        Assert.Equal("n/a (log service)", HyperscaleLogSize.Display);
+
+        var xaml = File.ReadAllText(Path.Combine(RepoRoot(), "Darling", "PerformanceMonitor.Darling.Viewer", "FinOpsTab.xaml"));
+        Assert.Contains("{Binding TotalSizeMb, StringFormat=N2, TargetNullValue='" + HyperscaleLogSize.Display + "'}", xaml, StringComparison.Ordinal);
+
+        /* Postgres sorts NULL first under DESC, which would put the log-service row at the top of a grid whose
+           lead is the biggest files. */
+        Assert.Contains("ORDER BY total_size_mb DESC NULLS LAST,", ViewerDataService.DatabaseSizeLatestSql, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ViewerUtilizationChart_UsedIsSummedOnlyOverTheFilesWhoseSizeCounts()
+    {
+        Assert.Contains("SUM(CASE WHEN total_size_mb IS NOT NULL THEN used_size_mb END) AS used_mb", ViewerDataService.DatabaseSizeSummarySql, StringComparison.Ordinal);
+    }
+
+    private static DarlingObjectStatsReader.DatabaseSizeRow SizeRow(string database, string name, string fileType, double? total, double used, double? growth, double? max) =>
+        new(new DateTime(2026, 9, 30, 12, 0, 0, DateTimeKind.Utc), database, name, fileType, total, used, growth, max, null, null, null);
+
+    [Fact]
+    public void GetDatabaseSizesPayload_HyperscaleLogFile_IsNullWithTheNote_AndOutOfTheDatabaseTotal()
+    {
+        var rows = new[]
+        {
+            SizeRow("hsdb", "hsdb_data", "ROWS", 10_240, 315, 1_024, 4_194_304),
+            SizeRow("hsdb", "hsdb_log", "LOG", null, 40, null, null),
+            SizeRow("plain", "plain_data", "ROWS", 100, 10, 64, -1),
+            SizeRow("plain", "plain_log", "LOG", 50, 5, 64, 2_097_152),
+        };
+
+        using var doc = JsonDocument.Parse(DarlingMcpObjectStatsTools.DatabaseSizesPayload("srv", rows));
+        var root = doc.RootElement;
+
+        Assert.Equal(HyperscaleLogSize.Note, root.GetProperty("note").GetString());
+
+        var hs = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "hsdb");
+        Assert.Equal(10_240d, hs.GetProperty("total_size_mb").GetDouble());
+        var hsLog = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "LOG");
+        Assert.Equal(JsonValueKind.Null, hsLog.GetProperty("total_size_mb").ValueKind);
+        Assert.Equal(JsonValueKind.Null, hsLog.GetProperty("auto_growth_mb").ValueKind);
+        Assert.Equal(JsonValueKind.Null, hsLog.GetProperty("max_size_mb").ValueKind);
+        Assert.Equal(40d, hsLog.GetProperty("used_size_mb").GetDouble());
+        var hsData = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "ROWS");
+        Assert.Equal(10_240d, hsData.GetProperty("total_size_mb").GetDouble());
+
+        /* Unchanged: a database whose log row carries a real size counts it. */
+        var plain = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "plain");
+        Assert.Equal(150d, plain.GetProperty("total_size_mb").GetDouble());
+    }
+
+    [Fact]
+    public void GetDatabaseSizesPayload_NoLogServiceFile_HasNoNote_AndTheSameShapeAsBefore()
+    {
+        var rows = new[]
+        {
+            SizeRow("plain", "plain_data", "ROWS", 100, 10, 64, -1),
+            SizeRow("plain", "plain_log", "LOG", 50, 5, 64, 2_097_152),
+        };
+
+        using var doc = JsonDocument.Parse(DarlingMcpObjectStatsTools.DatabaseSizesPayload("srv", rows));
+        var root = doc.RootElement;
+
+        Assert.False(root.TryGetProperty("note", out _));
+        Assert.Equal(new[] { "server", "captured_at", "file_count", "databases" }, root.EnumerateObject().Select(p => p.Name).ToArray());
+        Assert.Equal(150d, root.GetProperty("databases")[0].GetProperty("total_size_mb").GetDouble());
+    }
+
+    [Fact]
+    public void WebDatabaseSizesTable_RendersTheReadsNote()
+    {
+        var js = File.ReadAllText(Path.Combine(RepoRoot(), "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js"));
+
+        /* The table() helper's ninth argument is the noteKey: the read's own note rides above the rows. */
+        var block = js.Substring(js.IndexOf("\"Database Sizes\",", StringComparison.Ordinal));
+        block = block.Substring(0, block.IndexOf("),", StringComparison.Ordinal));
+        Assert.Contains("\"get_database_sizes\"", block, StringComparison.Ordinal);
+        Assert.Matches(new Regex("1,\\s*\"note\""), block);
+    }
+
+    private static string RepoRoot([CallerFilePath] string thisFile = "")
+        => Path.GetFullPath(Path.Combine(Path.GetDirectoryName(thisFile)!, "..", ".."));
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
index 419f4e06b..702a8e8dd 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
@@ -341,38 +341,71 @@ public static async Task<string> GetDatabaseSizes(
                 return await DarlingEngineCapability.NotCollectedStatusAsync(postgres, resolved.ServerId, resolved.ServerName, "database_size_stats", cancellationToken)
                     ?? McpHelpers.Status("unavailable", "No database size data available. The size collector may not have run yet.");
 
+            return DatabaseSizesPayload(resolved.ServerName, rows);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            return McpHelpers.FormatError("get_database_sizes", ex);
+        }
+    }
+
+    /// <summary>
+    /// The get_database_sizes payload, shaped apart from the read so it can be pinned without a store. A file with
+    /// no allocated size (the LOG file of an Azure SQL Database Hyperscale database, which lives in the log
+    /// service) keeps a null <c>total_size_mb</c> and adds nothing to its database's total; the payload then
+    /// carries <see cref="HyperscaleLogSize.Note"/>. Lite's twin gives the same words and shape.
+    /// </summary>
+    internal static string DatabaseSizesPayload(string serverName, IReadOnlyList<DarlingObjectStatsReader.DatabaseSizeRow> rows)
+    {
+        var databases = rows
+            .GroupBy(r => r.DatabaseName)
+            .Select(g => new
+            {
+                database_name = g.Key,
+                /* A file with no allocated size (the Hyperscale log file, in the log service) adds nothing,
+                   so a Hyperscale database's total is its data file alone. */
+                total_size_mb = g.Sum(r => r.TotalSizeMb ?? 0),
+                used_size_mb = g.Sum(r => r.UsedSizeMb ?? 0),
+                files = g.Select(r => new
+                {
+                    file_name = r.FileName,
+                    file_type = r.FileTypeDesc,
+                    total_size_mb = r.TotalSizeMb,
+                    used_size_mb = r.UsedSizeMb,
+                    auto_growth_mb = r.AutoGrowthMb,
+                    max_size_mb = r.MaxSizeMb,
+                    volume_mount_point = r.VolumeMountPoint,
+                    volume_total_mb = r.VolumeTotalMb,
+                    volume_free_mb = r.VolumeFreeMb
+                })
+            })
+            .ToList();
+
+        /* A null total_size_mb is the Hyperscale log file, whose size is n/a (log service) rather than a
+           storage figure. The note rides only on a payload that has one, so every other server's shape is
+           unchanged. Lite's get_database_sizes says the same, in the same words. */
+        if (rows.Any(r => r.TotalSizeMb is null))
+        {
             return JsonSerializer.Serialize(new
             {
-                server = resolved.ServerName,
+                server = serverName,
                 /* #3653: captured_at, the #3637 census's one spelling for a latest read's stamp - see
                    DarlingMcpDataTools.GetServerProperties for why it is a cut-over and not an alias. */
                 captured_at = rows[0].CollectionTime.ToString("o"),
                 file_count = rows.Count,
-                databases = rows
-                    .GroupBy(r => r.DatabaseName)
-                    .Select(g => new
-                    {
-                        database_name = g.Key,
-                        total_size_mb = g.Sum(r => r.TotalSizeMb),
-                        used_size_mb = g.Sum(r => r.UsedSizeMb ?? 0),
-                        files = g.Select(r => new
-                        {
-                            file_name = r.FileName,
-                            file_type = r.FileTypeDesc,
-                            total_size_mb = r.TotalSizeMb,
-                            used_size_mb = r.UsedSizeMb,
-                            auto_growth_mb = r.AutoGrowthMb,
-                            max_size_mb = r.MaxSizeMb,
-                            volume_mount_point = r.VolumeMountPoint,
-                            volume_total_mb = r.VolumeTotalMb,
-                            volume_free_mb = r.VolumeFreeMb
-                        })
-                    })
+                note = HyperscaleLogSize.Note,
+                databases
             }, McpHelpers.JsonOptions);
         }
-        catch (Exception ex) when (ex is not OperationCanceledException)
+
+        return JsonSerializer.Serialize(new
         {
-            return McpHelpers.FormatError("get_database_sizes", ex);
-        }
+            server = serverName,
+            /* #3653: captured_at, the #3637 census's one spelling for a latest read's stamp - see
+               DarlingMcpDataTools.GetServerProperties for why it is a cut-over and not an alias. */
+            captured_at = rows[0].CollectionTime.ToString("o"),
+            file_count = rows.Count,
+            databases
+        }, McpHelpers.JsonOptions);
     }
 }
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingObjectStatsReader.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingObjectStatsReader.cs
index 9c831dee8..4220abf5f 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingObjectStatsReader.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingObjectStatsReader.cs
@@ -110,9 +110,10 @@ public sealed record IndexLockingRow(
         double ReservedMb, long TotalRows, long RowLockWaitCount, long RowLockWaitInMs, long PageLockWaitCount,
         long PageLockWaitInMs, long IndexLockPromotionCount, long PageLatchWaitInMs, long PageIoLatchWaitInMs);
 
-    /// <summary>One database file's latest size snapshot.</summary>
+    /// <summary>One database file's latest size snapshot. <c>TotalSizeMb</c> is null for the LOG file of an Azure SQL
+    /// Database Hyperscale database (the log service): see <see cref="PerformanceMonitor.Common.HyperscaleLogSize"/>.</summary>
     public sealed record DatabaseSizeRow(
-        DateTime CollectionTime, string DatabaseName, string? FileName, string? FileTypeDesc, double TotalSizeMb,
+        DateTime CollectionTime, string DatabaseName, string? FileName, string? FileTypeDesc, double? TotalSizeMb,
         double? UsedSizeMb, double? AutoGrowthMb, double? MaxSizeMb, string? VolumeMountPoint, double? VolumeTotalMb, double? VolumeFreeMb);
 
     /* ─────────────────────────── table / index sizes + growth ─────────────────────────── */
@@ -558,7 +559,8 @@ public static async Task<List<DatabaseSizeRow>> GetLatestDatabaseSizesAsync(
                 reader.IsDBNull(1) ? "" : reader.GetString(1),
                 reader.IsDBNull(2) ? null : reader.GetString(2),
                 reader.IsDBNull(3) ? null : reader.GetString(3),
-                reader.IsDBNull(4) ? 0 : reader.GetDouble(4),
+                /* NULL is the Hyperscale log file: it stays null, never 0. */
+                reader.IsDBNull(4) ? null : reader.GetDouble(4),
                 reader.IsDBNull(5) ? null : reader.GetDouble(5),
                 reader.IsDBNull(6) ? null : reader.GetDouble(6),
                 reader.IsDBNull(7) ? null : reader.GetDouble(7),
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
index 2e948c309..c68707051 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
@@ -1039,6 +1039,8 @@ export const SERVER_TABS = [
         span: 2,
         emptyText: "No tempdb samples in this window.",
       }),
+      /* `noteKey` carries the read's own note when a Hyperscale log file is in the snapshot: its size is n/a
+         (log service) and it is left out of these totals, so the page says so instead of looking short. */
       table(
         "Database Sizes",
         "get_database_sizes",
@@ -1047,7 +1049,8 @@ export const SERVER_TABS = [
         DB_SIZE_COLUMNS,
         SNAPSHOT,
         "No database sizes in the latest snapshot.",
-        1
+        1,
+        "note"
       ),
       table(
         "Table & Index Sizes",
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
index 1c3b5dbca..aaa22c27c 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
@@ -195,8 +195,8 @@ private async Task LoadFinOpsUtilizationAsync()
 
             /* Free space % for the storage health score, from the latest database sizes. */
             var dbSizes = await _dataService.GetDatabaseSizeLatestAsync(_server.ServerId);
-            var totalStorageMb = dbSizes.Sum(d => d.TotalSizeMb);
-            var totalFreeMb = dbSizes.Sum(d => d.FreeSpaceMb ?? 0m);
+            var totalStorageMb = DatabaseSizeRow.AllocatedTotalMb(dbSizes);
+            var totalFreeMb = DatabaseSizeRow.FreeTotalMb(dbSizes);
             data.FreeSpacePct = totalStorageMb > 0 ? totalFreeMb / totalStorageMb * 100m : 100m;
         }
 
@@ -375,11 +375,12 @@ private async Task LoadFinOpsDatabaseSizesAsync()
         /* Proportional cost share by size (mirrors Lite's LoadDatabaseSizesAsync). */
         if (_server.MonthlyCostUsd > 0 && data.Count > 0)
         {
-            var totalMb = data.Sum(d => d.TotalSizeMb);
+            /* A row with no allocated size (the Hyperscale log file, in the log service) takes no share. */
+            var totalMb = DatabaseSizeRow.AllocatedTotalMb(data);
             if (totalMb > 0)
             {
                 foreach (var d in data)
-                    d.MonthlyCostShare = (d.TotalSizeMb / totalMb) * _server.MonthlyCostUsd;
+                    d.MonthlyCostShare = ((d.TotalSizeMb ?? 0m) / totalMb) * _server.MonthlyCostUsd;
             }
         }
 
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
index f35536041..cdf0e491d 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
@@ -661,7 +661,7 @@
                                     <DataGridTextColumn Binding="{Binding DatabaseName}" Width="160"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="DatabaseName" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Database" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
                                     <DataGridTextColumn Binding="{Binding FileTypeDesc}" Width="80"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="FileTypeDesc" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="File Type" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
                                     <DataGridTextColumn Binding="{Binding FileName}" Width="160"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="FileName" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="File Name" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
-                                    <DataGridTextColumn Binding="{Binding TotalSizeMb, StringFormat=N2}" Width="110" ElementStyle="{StaticResource NumericCell}"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="TotalSizeMb" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Total Size MB" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
+                                    <DataGridTextColumn Binding="{Binding TotalSizeMb, StringFormat=N2, TargetNullValue='n/a (log service)'}" Width="110" ElementStyle="{StaticResource NumericCell}"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="TotalSizeMb" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Total Size MB" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
                                     <DataGridTextColumn Binding="{Binding UsedSizeMb, StringFormat=N2}" Width="110" ElementStyle="{StaticResource NumericCell}"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="UsedSizeMb" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Used Size MB" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
                                     <DataGridTextColumn Binding="{Binding FreeSpaceMb, StringFormat=N2}" Width="110" ElementStyle="{StaticResource NumericCell}"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="FreeSpaceMb" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Free Space MB" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
                                     <DataGridTextColumn Binding="{Binding UsedPct, StringFormat=N1}" Width="70" ElementStyle="{StaticResource NumericCell}"><DataGridTextColumn.Header><StackPanel Orientation="Horizontal"><Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="UsedPct" Click="FilterButton_Click" Margin="0,0,4,0"/><TextBlock Text="Used %" FontWeight="Bold" VerticalAlignment="Center"/></StackPanel></DataGridTextColumn.Header></DataGridTextColumn>
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Recommendations.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Recommendations.cs
index 13c5e562d..1ff57e341 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Recommendations.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Recommendations.cs
@@ -528,7 +528,7 @@ public async Task<List<RecommendationRow>> GetRecommendationsAsync(int serverId,
                 if (monthlyCost > 0)
                 {
                     var allDbSizes = await GetDatabaseSizeLatestAsync(serverId, cancellationToken);
-                    var totalMb = allDbSizes.Sum(d => d.TotalSizeMb);
+                    var totalMb = DatabaseSizeRow.AllocatedTotalMb(allDbSizes);
                     if (totalMb > 0)
                         costShare = (idleDbs.Sum(d => d.TotalSizeMb) / totalMb) * monthlyCost;
                 }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
index 5477e71a5..7acd07120 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
@@ -185,7 +185,7 @@ FROM v_database_size_stats
 FROM v_database_size_stats
 WHERE server_id = $1
 AND   collection_time = $2
-ORDER BY total_size_mb DESC, database_name, file_type_desc, file_name";
+ORDER BY total_size_mb DESC NULLS LAST, database_name, file_type_desc, file_name";
 
     public async Task<List<DatabaseSizeRow>> GetDatabaseSizeLatestAsync(int serverId, CancellationToken cancellationToken = default)
     {
@@ -209,7 +209,9 @@ public async Task<List<DatabaseSizeRow>> GetDatabaseSizeLatestAsync(int serverId
                 DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
                 FileTypeDesc = reader.IsDBNull(1) ? "" : reader.GetString(1),
                 FileName = reader.IsDBNull(2) ? "" : reader.GetString(2),
-                TotalSizeMb = reader.IsDBNull(3) ? 0m : Convert.ToDecimal(reader.GetValue(3)),
+                /* NULL is the Hyperscale log file (the log service): it stays null, never 0, so the grid shows
+                   n/a (log service) instead of a size and the allocated totals leave it out. */
+                TotalSizeMb = reader.IsDBNull(3) ? null : Convert.ToDecimal(reader.GetValue(3)),
                 UsedSizeMb = reader.IsDBNull(4) ? null : Convert.ToDecimal(reader.GetValue(4)),
                 VolumeMountPoint = reader.IsDBNull(5) ? null : reader.GetString(5),
                 VolumeTotalMb = reader.IsDBNull(6) ? null : Convert.ToDecimal(reader.GetValue(6)),
@@ -231,7 +233,9 @@ public async Task<List<DatabaseSizeRow>> GetDatabaseSizeLatestAsync(int serverId
 SELECT
     database_name,
     SUM(total_size_mb) AS total_mb,
-    SUM(used_size_mb) AS used_mb
+    /* Used is summed only over the files whose size counts, so used and allocated stay on one footing: the
+       Hyperscale log file (NULL size, the log service) is in neither. */
+    SUM(CASE WHEN total_size_mb IS NOT NULL THEN used_size_mb END) AS used_mb
 FROM v_database_size_stats
 WHERE server_id = $1
 AND   collection_time = $2
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.cs
index 54d9c4b29..0969d8ec2 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.cs
@@ -10,6 +10,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using PerformanceMonitor.Analysis.Baselines;
+using PerformanceMonitor.Common;
 
 namespace PerformanceMonitor.Darling.Viewer;
 
@@ -209,10 +210,25 @@ public sealed class DatabaseSizeRow
     public string DatabaseName { get; set; } = "";
     public string FileTypeDesc { get; set; } = "";
     public string FileName { get; set; } = "";
-    public decimal TotalSizeMb { get; set; }
+
+    /// <summary>
+    /// The file's allocated size. Null for the LOG file of an Azure SQL Database Hyperscale database: that log
+    /// lives in the log service, so the size <c>sys.database_files</c> reports is not storage the database holds
+    /// or pays for. The grid shows <see cref="HyperscaleLogSize.Display"/> for it, and <see cref="AllocatedTotalMb"/>
+    /// leaves it out of every allocated total. Lite's <c>DatabaseSizeRow</c> is the twin of this.
+    /// </summary>
+    public decimal? TotalSizeMb { get; set; }
     public decimal? UsedSizeMb { get; set; }
-    public decimal? FreeSpaceMb => UsedSizeMb.HasValue ? TotalSizeMb - UsedSizeMb.Value : null;
-    public decimal? UsedPct => UsedSizeMb.HasValue && TotalSizeMb > 0 ? Math.Round(UsedSizeMb.Value * 100m / TotalSizeMb, 1) : null;
+    public decimal? FreeSpaceMb => UsedSizeMb.HasValue && TotalSizeMb.HasValue ? TotalSizeMb.Value - UsedSizeMb.Value : null;
+    public decimal? UsedPct => UsedSizeMb.HasValue && TotalSizeMb > 0 ? Math.Round(UsedSizeMb.Value * 100m / TotalSizeMb.Value, 1) : null;
+
+    /// <summary>The allocated total over <paramref name="rows"/>: a row with no allocated size (the Hyperscale log
+    /// file) adds nothing, so the data file alone is what a Hyperscale database holds.</summary>
+    public static decimal AllocatedTotalMb(IEnumerable<DatabaseSizeRow> rows) => rows.Sum(r => r.TotalSizeMb ?? 0m);
+
+    /// <summary>The free space over <paramref name="rows"/>, on the same footing as <see cref="AllocatedTotalMb"/>:
+    /// only a row that has an allocation has free space in it.</summary>
+    public static decimal FreeTotalMb(IEnumerable<DatabaseSizeRow> rows) => rows.Sum(r => r.FreeSpaceMb ?? 0m);
     public string? VolumeMountPoint { get; set; }
     public decimal? VolumeTotalMb { get; set; }
     public decimal? VolumeFreeMb { get; set; }
diff --git a/Lite.Tests/AgedDatabaseMigrationTests.cs b/Lite.Tests/AgedDatabaseMigrationTests.cs
index 20e3cf940..84785adcc 100644
--- a/Lite.Tests/AgedDatabaseMigrationTests.cs
+++ b/Lite.Tests/AgedDatabaseMigrationTests.cs
@@ -183,6 +183,55 @@ database_size_stats is exactly this index/column shape. */
         Assert.Equal(1L, Convert.ToInt64(await countCmd.ExecuteScalarAsync()));
     }
 
+    /// <summary>
+    /// v67 drops NOT NULL from database_size_stats.total_size_mb so the Hyperscale log row, which the collector
+    /// now stores with a NULL size (the log service is not allocated storage), can be appended without losing the
+    /// whole batch. Same #2748 dependency trap as v48 and v57: a prior startup persisted
+    /// idx_database_size_stats_time, and DuckDB's ALTER COLUMN refuses on a table with ANY index. Seeds that
+    /// precondition at v66 and asserts the upgrade completes AND the NULL-size row is actually insertable.
+    /// </summary>
+    [Fact]
+    public async Task UpgradeFromV66_DropsTotalSizeMbNotNull_EvenWithAPreExistingIndex()
+    {
+        using (var seed = new DuckDBConnection($"Data Source={_dbPath}"))
+        {
+            await seed.OpenAsync();
+            await ExecAsync(seed, "CREATE TABLE schema_version (version INTEGER NOT NULL)");
+            await ExecAsync(seed, "INSERT INTO schema_version VALUES (66)");
+            await ExecAsync(seed, @"CREATE TABLE database_size_stats (
+                server_id INTEGER NOT NULL,
+                collection_time TIMESTAMP NOT NULL,
+                database_name VARCHAR NOT NULL,
+                database_id INTEGER,
+                file_id INTEGER,
+                file_type_desc VARCHAR NOT NULL,
+                file_name VARCHAR NOT NULL,
+                physical_name VARCHAR,
+                total_size_mb DECIMAL(19,2) NOT NULL
+            )");
+            await ExecAsync(seed, "INSERT INTO database_size_stats VALUES (1, current_timestamp, 'hsdb', 5, 1, 'ROWS', 'hsdb_data', 'hsdb.mdf', 10240.00)");
+            await ExecAsync(seed, "CREATE INDEX idx_database_size_stats_time ON database_size_stats(server_id, collection_time)");
+        }
+
+        var initializer = new DuckDbInitializer(_dbPath);
+        await initializer.InitializeAsync();
+
+        using var verify = new DuckDBConnection($"Data Source={_dbPath}");
+        await verify.OpenAsync();
+
+        /* The real assertion: the Hyperscale log row (real name, NULL size) must be insertable now. */
+        await ExecAsync(verify, "INSERT INTO database_size_stats VALUES (1, current_timestamp, 'hsdb', 5, 2, 'LOG', 'hsdb_log', 'hsdb.ldf', NULL)");
+
+        using var countCmd = verify.CreateCommand();
+        countCmd.CommandText = "SELECT COUNT(*) FROM database_size_stats WHERE total_size_mb IS NULL";
+        Assert.Equal(1L, Convert.ToInt64(await countCmd.ExecuteScalarAsync()));
+
+        /* And the data row the database already held kept its size. */
+        using var keptCmd = verify.CreateCommand();
+        keptCmd.CommandText = "SELECT total_size_mb FROM database_size_stats WHERE file_id = 1";
+        Assert.Equal(10240.00m, Convert.ToDecimal(await keptCmd.ExecuteScalarAsync()));
+    }
+
     private static async Task ExecAsync(DuckDBConnection connection, string sql)
     {
         using var cmd = connection.CreateCommand();
diff --git a/Lite.Tests/DuckDbSchemaEquivalenceTests.cs b/Lite.Tests/DuckDbSchemaEquivalenceTests.cs
index 62d2cc1ce..d62f36592 100644
--- a/Lite.Tests/DuckDbSchemaEquivalenceTests.cs
+++ b/Lite.Tests/DuckDbSchemaEquivalenceTests.cs
@@ -152,6 +152,12 @@ fail until the oracle is extended by hand. That is the whole point of an oracle.
     /// always held these columns nullable; this brings Lite's DuckDB store to the same shape.
     /// <see cref="DuckDbInitializer"/>'s v57 migration drops the constraint on existing
     /// databases.</para>
+    ///
+    /// <para>Schema v67: <c>database_size_stats.total_size_mb</c> dropped NOT NULL. On Azure SQL Database
+    /// Hyperscale the LOG file lives in the log service, so the collector stores NULL for its size instead
+    /// of the roughly 1 TB <c>sys.database_files</c> reports, and every reader shows it as n/a and keeps it
+    /// out of the allocated totals. Darling's Postgres store always held the column nullable.
+    /// <see cref="DuckDbInitializer"/>'s v67 migration drops the constraint on existing databases.</para>
     /// </summary>
     private static readonly HashSet<string> IntentionalStorageDivergences = new(StringComparer.Ordinal)
     {
@@ -161,6 +167,7 @@ fail until the oracle is extended by hand. That is the whole point of an oracle.
         "database_size_stats.database_id",
         "database_size_stats.file_id",
         "database_size_stats.physical_name",
+        "database_size_stats.total_size_mb",
     };
 
     /// <summary>
diff --git a/Lite.Tests/HyperscaleLogSizeTests.cs b/Lite.Tests/HyperscaleLogSizeTests.cs
new file mode 100644
index 000000000..d699d59ca
--- /dev/null
+++ b/Lite.Tests/HyperscaleLogSizeTests.cs
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using Lite.Tests.Helpers;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+using PerformanceMonitorLite.Database;
+using PerformanceMonitorLite.Mcp;
+using PerformanceMonitorLite.Services;
+using PerformanceMonitorLite.Tests;
+using Xunit;
+
+namespace Lite.Tests;
+
+/// <summary>
+/// Azure SQL Database Hyperscale keeps its transaction log in the log service. <c>sys.database_files</c> still lists a
+/// LOG row for it, sized at about 1 TB (1,046,528 MB), which is not storage the database holds or pays for: Hyperscale
+/// bills allocated data storage. The rule these pins hold: the collector stores a NULL size for that one row, every
+/// reader shows it as "n/a (log service)", and it stays out of every allocated total. The data file keeps its real
+/// size. SQL Server, Managed Instance and non-Hyperscale Azure SQL Database are unchanged.
+/// </summary>
+public sealed class HyperscaleLogSizeCollectorTests
+{
+    private static readonly RecordingCollectorDeltaCalculator s_deltas = new();
+
+    private static string AzureQuery() =>
+        DatabaseSizeStatsCollector.Instance.BuildQuery(CollectorTestContext.Make(s_deltas, isAzureSqlDb: true)).Text;
+
+    [Fact]
+    public void AzureSqlDb_Query_DetectsHyperscaleFromTheEditionOfTheCurrentDatabase()
+    {
+        var text = AzureQuery();
+
+        /* DATABASEPROPERTYEX needs only the current database, so it adds no permission on the Azure path. It
+           returns sql_variant, hence the CONVERT. */
+        Assert.Contains("CONVERT(nvarchar(64), DATABASEPROPERTYEX(DB_NAME(), N'Edition')) = N'Hyperscale'", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AzureSqlDb_Query_NullsTheSizeOfTheHyperscaleLogRowOnly_AndKeepsTheRealSizeOtherwise()
+    {
+        var text = AzureQuery();
+
+        /* The LOG row (type 1) of a Hyperscale database is the only row the decision names. */
+        Assert.Matches(new Regex(@"is_log_service =\s*CASE\s*WHEN @is_hyperscale = 1\s*AND\s+df\.type = 1 /\*LOG\*/\s*THEN CONVERT\(bit, 1\)\s*ELSE CONVERT\(bit, 0\)", RegexOptions.Singleline), text);
+
+        /* Its size is NULL; every other file keeps the size sys.database_files reports. */
+        Assert.Matches(new Regex(@"total_size_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)\s*ELSE CONVERT\(decimal\(19,2\), df\.size \* 8\.0 / 1024\.0\)\s*END", RegexOptions.Singleline), text);
+
+        /* The log service has no growth setting or ceiling to report either, so they go NULL with the size and
+           cannot read as a real 2 TB cap or a real growth step beside "n/a (log service)". */
+        Assert.Matches(new Regex(@"auto_growth_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)", RegexOptions.Singleline), text);
+        Assert.Matches(new Regex(@"max_size_mb =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(decimal\(19,2\), NULL\)", RegexOptions.Singleline), text);
+        Assert.Matches(new Regex(@"is_percent_growth =\s*CASE\s*WHEN ls\.is_log_service = 1\s*THEN CONVERT\(bit, NULL\)", RegexOptions.Singleline), text);
+        Assert.Matches(new Regex(@"growth_pct =\s*CASE\s*WHEN ls\.is_log_service = 0\s*AND\s+df\.is_percent_growth = 1", RegexOptions.Singleline), text);
+
+        /* Used space and the VLF count stay as collected: neither feeds an allocated total. */
+        Assert.Contains("CONVERT(decimal(19,2), FILEPROPERTY(df.name, N'SpaceUsed') * 8.0 / 1024.0)", text, StringComparison.Ordinal);
+        Assert.Contains("vlf_count =", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void OnPrem_Query_IsUnchanged_NoHyperscaleBranch()
+    {
+        /* SQL Server and Managed Instance take the on-prem text; it has no Hyperscale branch and still reports
+           every file at the size the engine gives it. */
+        var plan = DatabaseSizeStatsCollector.Instance.BuildQuery(CollectorTestContext.Make(s_deltas));
+
+        Assert.DoesNotContain("Hyperscale", plan.Text, StringComparison.Ordinal);
+        Assert.DoesNotContain("is_log_service", plan.Text, StringComparison.Ordinal);
+        Assert.Contains("CONVERT(decimal(19,2), df.size * 8.0 / 1024.0)", plan.Text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ReadAsync_NullTotalSize_IsKeptNull_AndDoesNotKillTheBatch()
+    {
+        /* The Hyperscale log row: size, growth and ceiling NULL, used space as collected. An unguarded
+           GetDecimal on ordinal 6 threw here and lost the whole batch (the #3262 shape). */
+        using var reader = new FakeCollectorDataReader(
+            new object[]
+            {
+                "hsdb", 5, 1, "ROWS", "hsdb_data", @"D:\hsdb.mdf", 10240.00m, 315.25m,
+                128.00m, 4194304.00m, "FULL", DBNull.Value, "ONLINE", DBNull.Value, DBNull.Value, DBNull.Value,
+                0, DBNull.Value, DBNull.Value,
+            },
+            new object[]
+            {
+                "hsdb", 5, 2, "LOG", "hsdb_log", @"D:\hsdb.ldf", DBNull.Value, 40.50m,
+                DBNull.Value, DBNull.Value, "FULL", DBNull.Value, "ONLINE", DBNull.Value, DBNull.Value, DBNull.Value,
+                DBNull.Value, DBNull.Value, 4,
+            });
+
+        var rows = await DatabaseSizeStatsCollector.Instance.ReadAsync(reader, CollectorTestContext.Make(s_deltas, isAzureSqlDb: true), CancellationToken.None);
+
+        Assert.Equal(2, rows.Count);
+        Assert.Equal(10240.00m, rows[0].TotalSizeMb);
+        Assert.Null(rows[1].TotalSizeMb);
+        Assert.Null(rows[1].AutoGrowthMb);
+        Assert.Null(rows[1].MaxSizeMb);
+        Assert.Equal(40.50m, rows[1].UsedSizeMb);
+        Assert.Equal(4, rows[1].VlfCount);
+
+        var writer = new RecordingCollectorRowWriter();
+        DatabaseSizeStatsCollector.Instance.WritePayload(rows[1], writer, CollectorTestContext.Make(s_deltas, isAzureSqlDb: true));
+        Assert.Equal(19, writer.Values.Count);
+        Assert.Null(writer.Values[6]);
+    }
+}
+
+/// <summary>
+/// The readers: a Hyperscale log row reads as a null size (which the grid words as "n/a (log service)"), stays out of
+/// every allocated total, and the data row counts. A non-Hyperscale database, whose log row carries a real size, is
+/// unchanged. Runs against a real DuckDB, so it also proves the store accepts the NULL size on a fresh database.
+/// </summary>
+public sealed class HyperscaleLogSizeReadTests : IClassFixture<SharedDuckDbFixture>, IDisposable
+{
+    private const int ServerId = 4901;
+
+    private readonly DuckDbInitializer _duckDb;
+    private DuckDBConnection? _seedConn;
+    private long _nextId = 1;
+
+    public HyperscaleLogSizeReadTests(SharedDuckDbFixture fixture)
+    {
+        fixture.ResetData();
+        _duckDb = fixture.DuckDb;
+    }
+
+    public void Dispose() => _seedConn?.Dispose();
+
+    private static readonly DateTime Collected = DateTime.SpecifyKind(
+        new DateTime(DateTime.UtcNow.Ticks - (DateTime.UtcNow.Ticks % TimeSpan.TicksPerMinute)), DateTimeKind.Unspecified);
+
+    private async Task SeedAsync(string database, int fileId, string fileType, string fileName, double? total, double? used, double? autoGrowth, double? max)
+    {
+        using var readLock = _duckDb.AcquireReadLock();
+        _seedConn ??= _duckDb.CreateConnection();
+        if (_seedConn.State != System.Data.ConnectionState.Open) await _seedConn.OpenAsync();
+        using var cmd = _seedConn.CreateCommand();
+        cmd.CommandText = @"
+INSERT INTO database_size_stats
+    (collection_id, collection_time, server_id, server_name, database_name, database_id, file_id, file_type_desc,
+     file_name, physical_name, total_size_mb, used_size_mb, auto_growth_mb, max_size_mb)
+VALUES ($1, $2, $3, 'HsSrv', $4, 7, $5, $6, $7, $8, $9, $10, $11, $12)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId++ });
+        cmd.Parameters.Add(new DuckDBParameter { Value = Collected });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = database });
+        cmd.Parameters.Add(new DuckDBParameter { Value = fileId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = fileType });
+        cmd.Parameters.Add(new DuckDBParameter { Value = fileName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = @"C:\" + fileName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = (object?)total ?? DBNull.Value });
+        cmd.Parameters.Add(new DuckDBParameter { Value = (object?)used ?? DBNull.Value });
+        cmd.Parameters.Add(new DuckDBParameter { Value = (object?)autoGrowth ?? DBNull.Value });
+        cmd.Parameters.Add(new DuckDBParameter { Value = (object?)max ?? DBNull.Value });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task SeedHyperscaleAndPlainAsync()
+    {
+        /* Hyperscale: the data file reports its real allocation; the log row's size, growth and ceiling are NULL
+           (the log service), its used space as collected. */
+        await SeedAsync("hsdb", 1, "ROWS", "hsdb_data", 10_240, 315, 1_024, 4_194_304);
+        await SeedAsync("hsdb", 2, "LOG", "hsdb_log", null, 40, null, null);
+
+        /* A non-Hyperscale database: both files carry a real size and count. */
+        await SeedAsync("plain", 1, "ROWS", "plain_data", 100, 10, 64, -1);
+        await SeedAsync("plain", 2, "LOG", "plain_log", 50, 5, 64, 2_097_152);
+    }
+
+    [Fact]
+    public async Task DatabaseSizesGrid_HyperscaleLogRow_IsNull_AndOutOfTheAllocatedTotals_WhileTheDataRowCounts()
+    {
+        await SeedHyperscaleAndPlainAsync();
+        var service = new LocalDataService(_duckDb);
+
+        var rows = await service.GetDatabaseSizeLatestAsync(ServerId);
+        var hsData = Assert.Single(rows, r => r.DatabaseName == "hsdb" && r.FileTypeDesc == "ROWS");
+        var hsLog = Assert.Single(rows, r => r.DatabaseName == "hsdb" && r.FileTypeDesc == "LOG");
+
+        Assert.Equal(10_240m, hsData.TotalSizeMb);
+        Assert.Equal(10_240m - 315m, hsData.FreeSpaceMb);
+
+        /* Null, never 0: the grid words null as n/a (log service), and 0 would read as a real empty log. */
+        Assert.Null(hsLog.TotalSizeMb);
+        Assert.Null(hsLog.FreeSpaceMb);
+        Assert.Null(hsLog.UsedPct);
+        Assert.Equal(40m, hsLog.UsedSizeMb);
+
+        var hsRows = rows.Where(r => r.DatabaseName == "hsdb").ToList();
+        Assert.Equal(10_240m, DatabaseSizeRow.AllocatedTotalMb(hsRows));
+        Assert.Equal(10_240m - 315m, DatabaseSizeRow.FreeTotalMb(hsRows));
+
+        /* Unchanged: the non-Hyperscale log row counts at its real size. */
+        var plainRows = rows.Where(r => r.DatabaseName == "plain").ToList();
+        Assert.Equal(150m, DatabaseSizeRow.AllocatedTotalMb(plainRows));
+        Assert.All(plainRows, r => Assert.NotNull(r.TotalSizeMb));
+
+        Assert.Equal(10_390m, DatabaseSizeRow.AllocatedTotalMb(rows));
+    }
+
+    [Fact]
+    public async Task UtilizationChart_HyperscaleDatabase_AllocatesTheDataFileOnly_AndUsedStaysOnTheSameFooting()
+    {
+        await SeedHyperscaleAndPlainAsync();
+        var service = new LocalDataService(_duckDb);
+
+        var summary = await service.GetDatabaseSizeSummaryAsync(ServerId);
+
+        var hs = Assert.Single(summary, r => r.DatabaseName == "hsdb");
+        Assert.Equal(10_240m, hs.TotalMb);
+        Assert.Equal(315m, hs.UsedMb);
+
+        var plain = Assert.Single(summary, r => r.DatabaseName == "plain");
+        Assert.Equal(150m, plain.TotalMb);
+        Assert.Equal(15m, plain.UsedMb);
+    }
+
+    [Fact]
+    public async Task GetDatabaseSizesTool_Read_PassesTheNullSizeGrowthAndCeilingThroughAsNull()
+    {
+        await SeedHyperscaleAndPlainAsync();
+        var service = new LocalDataService(_duckDb);
+
+        var rows = await service.GetLatestDatabaseSizeStatsAsync(ServerId);
+
+        var hsLog = Assert.Single(rows, r => r.DatabaseName == "hsdb" && r.FileTypeDesc == "LOG");
+        Assert.Null(hsLog.TotalSizeMb);
+        Assert.Null(hsLog.AutoGrowthMb);
+        Assert.Null(hsLog.MaxSizeMb);
+
+        var hsData = Assert.Single(rows, r => r.DatabaseName == "hsdb" && r.FileTypeDesc == "ROWS");
+        Assert.Equal(10_240d, hsData.TotalSizeMb);
+
+        var plainLog = Assert.Single(rows, r => r.DatabaseName == "plain" && r.FileTypeDesc == "LOG");
+        Assert.Equal(50d, plainLog.TotalSizeMb);
+        Assert.Equal(64d, plainLog.AutoGrowthMb);
+        Assert.Equal(2_097_152d, plainLog.MaxSizeMb);
+    }
+
+    [Fact]
+    public void Row_WithoutAnAllocation_ReadsAsNotApplicable_WithoutThrowing()
+    {
+        var log = new DatabaseSizeRow { FileTypeDesc = "LOG", TotalSizeMb = null, UsedSizeMb = 40m };
+        Assert.Null(log.FreeSpaceMb);
+        Assert.Null(log.UsedPct);
+
+        /* A valued row is unchanged. */
+        var data = new DatabaseSizeRow { FileTypeDesc = "ROWS", TotalSizeMb = 200m, UsedSizeMb = 50m };
+        Assert.Equal(150m, data.FreeSpaceMb);
+        Assert.Equal(25.0m, data.UsedPct);
+    }
+
+    [Fact]
+    public void TheGridWordsANullSize_AsTheSharedHyperscaleText()
+    {
+        Assert.Equal("n/a (log service)", HyperscaleLogSize.Display);
+
+        var xaml = File.ReadAllText(Path.Combine(RepoRoot(), "Lite", "Controls", "FinOpsTab.xaml"));
+        Assert.Contains("{Binding TotalSizeMb, StringFormat='{}{0:N2}', TargetNullValue='" + HyperscaleLogSize.Display + "'}", xaml, StringComparison.Ordinal);
+    }
+
+    private static DatabaseSizeStatsRow SizeRow(string database, string name, string fileType, double? total, double used, double? growth, double? max) => new()
+    {
+        DatabaseName = database,
+        FileName = name,
+        FileTypeDesc = fileType,
+        TotalSizeMb = total,
+        UsedSizeMb = used,
+        AutoGrowthMb = growth,
+        MaxSizeMb = max,
+        CollectionTime = new DateTime(2026, 9, 30, 12, 0, 0, DateTimeKind.Utc),
+    };
+
+    [Fact]
+    public void GetDatabaseSizesPayload_HyperscaleLogFile_IsNullWithTheNote_AndOutOfTheDatabaseTotal()
+    {
+        var rows = new[]
+        {
+            SizeRow("hsdb", "hsdb_data", "ROWS", 10_240, 315, 1_024, 4_194_304),
+            SizeRow("hsdb", "hsdb_log", "LOG", null, 40, null, null),
+            SizeRow("plain", "plain_data", "ROWS", 100, 10, 64, -1),
+            SizeRow("plain", "plain_log", "LOG", 50, 5, 64, 2_097_152),
+        };
+
+        using var doc = System.Text.Json.JsonDocument.Parse(McpServerInfoTools.DatabaseSizesPayload("srv", rows));
+        var root = doc.RootElement;
+
+        /* The one short note, in the shared words, and only because a log-service file is present. */
+        Assert.Equal(HyperscaleLogSize.Note, root.GetProperty("note").GetString());
+
+        var hs = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "hsdb");
+        Assert.Equal(10_240d, hs.GetProperty("total_size_mb").GetDouble());
+        var hsLog = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "LOG");
+        Assert.Equal(System.Text.Json.JsonValueKind.Null, hsLog.GetProperty("total_size_mb").ValueKind);
+        Assert.Equal(System.Text.Json.JsonValueKind.Null, hsLog.GetProperty("auto_growth_mb").ValueKind);
+        Assert.Equal(System.Text.Json.JsonValueKind.Null, hsLog.GetProperty("max_size_mb").ValueKind);
+        Assert.Equal(40d, hsLog.GetProperty("used_size_mb").GetDouble());
+        var hsData = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "ROWS");
+        Assert.Equal(10_240d, hsData.GetProperty("total_size_mb").GetDouble());
+
+        /* Unchanged: a database whose log row carries a real size counts it. */
+        var plain = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "plain");
+        Assert.Equal(150d, plain.GetProperty("total_size_mb").GetDouble());
+    }
+
+    [Fact]
+    public void GetDatabaseSizesPayload_NoLogServiceFile_HasNoNote_AndTheSameShapeAsBefore()
+    {
+        var rows = new[]
+        {
+            SizeRow("plain", "plain_data", "ROWS", 100, 10, 64, -1),
+            SizeRow("plain", "plain_log", "LOG", 50, 5, 64, 2_097_152),
+        };
+
+        using var doc = System.Text.Json.JsonDocument.Parse(McpServerInfoTools.DatabaseSizesPayload("srv", rows));
+        var root = doc.RootElement;
+
+        Assert.False(root.TryGetProperty("note", out _));
+        Assert.Equal(new[] { "server", "captured_at", "file_count", "databases" }, root.EnumerateObject().Select(p => p.Name).ToArray());
+        Assert.Equal(150d, root.GetProperty("databases")[0].GetProperty("total_size_mb").GetDouble());
+    }
+
+    [Fact]
+    public void TheSharedNote_NamesTheWordsTheGridShows()
+    {
+        Assert.Contains("Azure SQL Database Hyperscale", HyperscaleLogSize.Note, StringComparison.Ordinal);
+        Assert.Contains(HyperscaleLogSize.Display, HyperscaleLogSize.Note, StringComparison.Ordinal);
+    }
+
+    private static string RepoRoot()
+    {
+        var directory = new DirectoryInfo(AppContext.BaseDirectory);
+        while (directory is not null && !File.Exists(Path.Combine(directory.FullName, "PerformanceMonitor.sln")))
+        {
+            directory = directory.Parent;
+        }
+
+        return directory?.FullName ?? throw new InvalidOperationException("PerformanceMonitor.sln not found above the test output directory.");
+    }
+}
diff --git a/Lite/Controls/FinOpsTab.xaml b/Lite/Controls/FinOpsTab.xaml
index 2a94b44e0..fb028f429 100644
--- a/Lite/Controls/FinOpsTab.xaml
+++ b/Lite/Controls/FinOpsTab.xaml
@@ -1215,7 +1215,8 @@
                                     </StackPanel>
                                 </DataGridTextColumn.Header>
                             </DataGridTextColumn>
-                            <DataGridTextColumn Binding="{Binding TotalSizeMb, StringFormat='{}{0:N2}'}" Width="110">
+                            <!-- TargetNullValue: a null size is the Hyperscale log file, which lives in the log service. The words are HyperscaleLogSize.Display; a Lite.Tests pin holds them together. -->
+                            <DataGridTextColumn Binding="{Binding TotalSizeMb, StringFormat='{}{0:N2}', TargetNullValue='n/a (log service)'}" Width="110">
                                 <DataGridTextColumn.Header>
                                     <StackPanel Orientation="Horizontal">
                                         <Button Style="{DynamicResource ColumnFilterButtonStyle}" Tag="TotalSizeMb" Click="FilterButton_Click" Margin="0,0,4,0"/>
diff --git a/Lite/Controls/FinOpsTab.xaml.cs b/Lite/Controls/FinOpsTab.xaml.cs
index d2a9287a9..3349db149 100644
--- a/Lite/Controls/FinOpsTab.xaml.cs
+++ b/Lite/Controls/FinOpsTab.xaml.cs
@@ -311,8 +311,8 @@ private async System.Threading.Tasks.Task LoadUtilizationAsync(int serverId)
                 // Compute free space % for health score from database sizes
                 var dbSizes = await Task.Run(() => _dataService.GetDatabaseSizeLatestAsync(serverId));
                 if (_loads.Superseded(nameof(LoadUtilizationAsync), gen)) return;
-                var totalStorageMb = dbSizes.Sum(d => d.TotalSizeMb);
-                var totalFreeMb = dbSizes.Sum(d => (d.FreeSpaceMb ?? 0m));
+                var totalStorageMb = DatabaseSizeRow.AllocatedTotalMb(dbSizes);
+                var totalFreeMb = DatabaseSizeRow.FreeTotalMb(dbSizes);
                 data.FreeSpacePct = totalStorageMb > 0 ? totalFreeMb / totalStorageMb * 100m : 100m;
             }
 
@@ -559,11 +559,12 @@ private async System.Threading.Tasks.Task LoadDatabaseSizesAsync(int serverId)
             // Compute proportional cost shares
             if (_currentServerMonthlyCost > 0 && data.Count > 0)
             {
-                var totalMb = data.Sum(d => d.TotalSizeMb);
+                /* A row with no allocated size (the Hyperscale log file, in the log service) takes no share. */
+                var totalMb = DatabaseSizeRow.AllocatedTotalMb(data);
                 if (totalMb > 0)
                 {
                     foreach (var d in data)
-                        d.MonthlyCostShare = (d.TotalSizeMb / totalMb) * _currentServerMonthlyCost;
+                        d.MonthlyCostShare = ((d.TotalSizeMb ?? 0m) / totalMb) * _currentServerMonthlyCost;
                 }
             }
 
diff --git a/Lite/Database/DuckDbInitializer.cs b/Lite/Database/DuckDbInitializer.cs
index 14654c260..4c37b81bf 100644
--- a/Lite/Database/DuckDbInitializer.cs
+++ b/Lite/Database/DuckDbInitializer.cs
@@ -353,7 +353,7 @@ public void Dispose()
     /// <summary>
     /// Current schema version. Increment this when schema changes require table rebuilds.
     /// </summary>
-    internal const int CurrentSchemaVersion = 66;
+    internal const int CurrentSchemaVersion = 67;
 
     private readonly string _archivePath;
 
@@ -2328,6 +2328,44 @@ rebuilds every v_ view on start (CreateArchiveViewsAsync, called after this). No
 
             await AddMissingColumnsAsync(connection, AddedColumnsForVersion(66));
         }
+
+        if (fromVersion < 67)
+        {
+            /* v67: drop NOT NULL from database_size_stats.total_size_mb. On Azure SQL Database Hyperscale the
+                    LOG file lives in the log service: sys.database_files sizes it at about 1 TB, which is not
+                    storage the database holds or pays for (Hyperscale bills allocated DATA storage). The
+                    collector now stores NULL for that one row, every reader shows it as n/a (log service), and
+                    it stays out of every allocated total. An existing database has to have the constraint
+                    dropped or the appender fails that row and the whole batch with it. New databases get it
+                    from the generator; Darling's Postgres store always held the column nullable. Column type
+                    and ordinal are unchanged, so the positional appender and old parquet are unaffected.
+                    Nothing to backfill: rows collected before the upgrade keep the size the engine reported,
+                    and NULL is the honest value only for rows collected from here on. */
+            _logger?.LogInformation("Running migration to v67: database_size_stats.total_size_mb becomes nullable (Hyperscale log file)");
+
+            /* Same trap as v48 (#2748) and v57: DuckDB's ALTER COLUMN refuses on a table with ANY index, even
+               one naming none of the altered columns. Drop it first; Schema.GetAllIndexStatements()'s loop
+               (called unconditionally right after migrations, inside this same InitializeAsync) recreates it. */
+            try
+            {
+                await ExecuteNonQueryAsync(connection, "DROP INDEX IF EXISTS idx_database_size_stats_time");
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogWarning("Migration to v67 could not drop idx_database_size_stats_time ahead of the ALTER (non-fatal, the ALTER below may still fail): {Error}", ex.Message);
+            }
+
+            try
+            {
+                await ExecuteNonQueryAsync(connection, "ALTER TABLE database_size_stats ALTER COLUMN total_size_mb DROP NOT NULL");
+            }
+            catch (Exception ex)
+            {
+                /* Already nullable, or the table does not exist yet (a fresh install creates it correctly
+                   from the generator) - neither is fatal. */
+                _logger?.LogWarning("Migration to v67 on total_size_mb encountered an error (non-fatal): {Error}", ex.Message);
+            }
+        }
     }
 
     /// <summary>
diff --git a/Lite/Database/DuckDbSchemaGenerator.cs b/Lite/Database/DuckDbSchemaGenerator.cs
index baa39ac24..0fadca6cd 100644
--- a/Lite/Database/DuckDbSchemaGenerator.cs
+++ b/Lite/Database/DuckDbSchemaGenerator.cs
@@ -240,7 +240,12 @@ the same shape as #1591's server_properties hardware columns. Schema v57 drops t
                constraint on existing databases. */
             ["database_size_stats.file_type_desc"] = "NOT NULL",
             ["database_size_stats.file_name"] = "NOT NULL",
-            ["database_size_stats.total_size_mb"] = "NOT NULL",
+            /* total_size_mb is deliberately NULLABLE: the LOG file of an Azure SQL Database Hyperscale
+               database lives in the log service, so the collector stores NULL for its size rather than
+               the ~1 TB sys.database_files reports, and every reader shows it as n/a and keeps it out
+               of the allocated totals. NOT NULL here would fail the appender on that row and lose the
+               whole batch -- the same shape as the sibling-row columns above. Schema v67 drops the
+               constraint on existing databases. */
             ["index_object_stats.database_name"] = "NOT NULL",
             ["index_object_stats.database_id"] = "NOT NULL",
             ["index_object_stats.schema_name"] = "NOT NULL",
diff --git a/Lite/Mcp/McpServerInfoTools.cs b/Lite/Mcp/McpServerInfoTools.cs
index 6108e750d..a86163413 100644
--- a/Lite/Mcp/McpServerInfoTools.cs
+++ b/Lite/Mcp/McpServerInfoTools.cs
@@ -82,37 +82,69 @@ public static async Task<string> GetDatabaseSizes(
                 return await McpEngineCapability.NotCollectedStatusAsync(dataService, resolved.ServerId, resolved.ServerName, "database_size_stats")
                     ?? McpHelpers.Status("unavailable", "No database size data available. The size collector may not have run yet.");
 
+            return DatabaseSizesPayload(resolved.ServerName, rows);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_database_sizes", ex);
+        }
+    }
+
+    /// <summary>
+    /// The get_database_sizes payload, shaped apart from the read so it can be pinned without a store. A file with
+    /// no allocated size (the LOG file of an Azure SQL Database Hyperscale database, which lives in the log
+    /// service) keeps a null <c>total_size_mb</c> and adds nothing to its database's total; the payload then
+    /// carries <see cref="HyperscaleLogSize.Note"/>. Darling's twin gives the same words and shape.
+    /// </summary>
+    internal static string DatabaseSizesPayload(string serverName, IReadOnlyList<DatabaseSizeStatsRow> rows)
+    {
+        var databases = rows
+            .GroupBy(r => r.DatabaseName)
+            .Select(g => new
+            {
+                database_name = g.Key,
+                /* A file with no allocated size (the Hyperscale log file, in the log service) adds nothing,
+                   so a Hyperscale database's total is its data file alone. */
+                total_size_mb = g.Sum(r => r.TotalSizeMb ?? 0),
+                used_size_mb = g.Sum(r => r.UsedSizeMb),
+                files = g.Select(r => new
+                {
+                    file_name = r.FileName,
+                    file_type = r.FileTypeDesc,
+                    total_size_mb = r.TotalSizeMb,
+                    used_size_mb = r.UsedSizeMb,
+                    auto_growth_mb = r.AutoGrowthMb,
+                    max_size_mb = r.MaxSizeMb,
+                    volume_mount_point = r.VolumeMountPoint,
+                    volume_total_mb = r.VolumeTotalMb,
+                    volume_free_mb = r.VolumeFreeMb
+                })
+            })
+            .ToList();
+
+        /* A null total_size_mb is the Hyperscale log file, whose size is n/a (log service) rather than a
+           storage figure. The note rides only on a payload that has one, so every other server's shape is
+           unchanged. */
+        if (rows.Any(r => r.TotalSizeMb is null))
+        {
             return JsonSerializer.Serialize(new
             {
-                server = resolved.ServerName,
+                server = serverName,
                 /* #3653: captured_at - see GetServerProperties above for why it is a cut-over, not an alias. */
                 captured_at = rows[0].CollectionTime.ToString("o"),
                 file_count = rows.Count,
-                databases = rows
-                    .GroupBy(r => r.DatabaseName)
-                    .Select(g => new
-                    {
-                        database_name = g.Key,
-                        total_size_mb = g.Sum(r => r.TotalSizeMb),
-                        used_size_mb = g.Sum(r => r.UsedSizeMb),
-                        files = g.Select(r => new
-                        {
-                            file_name = r.FileName,
-                            file_type = r.FileTypeDesc,
-                            total_size_mb = r.TotalSizeMb,
-                            used_size_mb = r.UsedSizeMb,
-                            auto_growth_mb = r.AutoGrowthMb,
-                            max_size_mb = r.MaxSizeMb,
-                            volume_mount_point = r.VolumeMountPoint,
-                            volume_total_mb = r.VolumeTotalMb,
-                            volume_free_mb = r.VolumeFreeMb
-                        })
-                    })
+                note = HyperscaleLogSize.Note,
+                databases
             }, McpHelpers.JsonOptions);
         }
-        catch (Exception ex)
+
+        return JsonSerializer.Serialize(new
         {
-            return McpHelpers.FormatError("get_database_sizes", ex);
-        }
+            server = serverName,
+            /* #3653: captured_at - see GetServerProperties above for why it is a cut-over, not an alias. */
+            captured_at = rows[0].CollectionTime.ToString("o"),
+            file_count = rows.Count,
+            databases
+        }, McpHelpers.JsonOptions);
     }
 }
diff --git a/Lite/Services/LocalDataService.FinOps.Inventory.cs b/Lite/Services/LocalDataService.FinOps.Inventory.cs
index b3f28c541..f129adca8 100644
--- a/Lite/Services/LocalDataService.FinOps.Inventory.cs
+++ b/Lite/Services/LocalDataService.FinOps.Inventory.cs
@@ -57,7 +57,9 @@ FROM v_database_size_stats
                 DatabaseName = reader.IsDBNull(0) ? "" : reader.GetString(0),
                 FileTypeDesc = reader.IsDBNull(1) ? "" : reader.GetString(1),
                 FileName = reader.IsDBNull(2) ? "" : reader.GetString(2),
-                TotalSizeMb = reader.IsDBNull(3) ? 0m : Convert.ToDecimal(reader.GetValue(3)),
+                /* NULL is the Hyperscale log file (the log service): it stays null, never 0, so the grid shows
+                   n/a (log service) instead of a size and the allocated totals leave it out. */
+                TotalSizeMb = reader.IsDBNull(3) ? null : Convert.ToDecimal(reader.GetValue(3)),
                 UsedSizeMb = reader.IsDBNull(4) ? null : Convert.ToDecimal(reader.GetValue(4)),
                 VolumeMountPoint = reader.IsDBNull(5) ? null : reader.GetString(5),
                 VolumeTotalMb = reader.IsDBNull(6) ? null : Convert.ToDecimal(reader.GetValue(6)),
@@ -86,7 +88,9 @@ public async Task<List<DatabaseSizeSummaryRow>> GetDatabaseSizeSummaryAsync(int
 SELECT
     database_name,
     SUM(total_size_mb) AS total_mb,
-    SUM(used_size_mb) AS used_mb
+    /* Used is summed only over the files whose size counts, so used and allocated stay on one footing: the
+       Hyperscale log file (NULL size, the log service) is in neither. */
+    SUM(CASE WHEN total_size_mb IS NOT NULL THEN used_size_mb END) AS used_mb
 FROM v_database_size_stats
 WHERE server_id = $1
 AND   collection_time = (
diff --git a/Lite/Services/LocalDataService.FinOps.Recommendations.cs b/Lite/Services/LocalDataService.FinOps.Recommendations.cs
index d01fdc9b7..f0344bea5 100644
--- a/Lite/Services/LocalDataService.FinOps.Recommendations.cs
+++ b/Lite/Services/LocalDataService.FinOps.Recommendations.cs
@@ -481,7 +481,7 @@ ORDER BY
                 if (monthlyCost > 0)
                 {
                     var allDbSizes = await GetDatabaseSizeLatestAsync(serverId);
-                    var totalMb = allDbSizes.Sum(d => d.TotalSizeMb);
+                    var totalMb = DatabaseSizeRow.AllocatedTotalMb(allDbSizes);
                     if (totalMb > 0)
                         costShare = (idleDbs.Sum(d => d.TotalSizeMb) / totalMb) * monthlyCost;
                 }
diff --git a/Lite/Services/LocalDataService.FinOps.cs b/Lite/Services/LocalDataService.FinOps.cs
index 355a527a7..55ad34357 100644
--- a/Lite/Services/LocalDataService.FinOps.cs
+++ b/Lite/Services/LocalDataService.FinOps.cs
@@ -10,6 +10,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using PerformanceMonitor.Analysis.Baselines;
+using PerformanceMonitor.Common;
 using PerformanceMonitor.Ui;
 
 namespace PerformanceMonitorLite.Services;
@@ -196,10 +197,25 @@ public class DatabaseSizeRow
     public string DatabaseName { get; set; } = "";
     public string FileTypeDesc { get; set; } = "";
     public string FileName { get; set; } = "";
-    public decimal TotalSizeMb { get; set; }
+
+    /// <summary>
+    /// The file's allocated size. Null for the LOG file of an Azure SQL Database Hyperscale database: that log
+    /// lives in the log service, so the size <c>sys.database_files</c> reports is not storage the database holds
+    /// or pays for. The grid shows <see cref="HyperscaleLogSize.Display"/> for it, and <see cref="AllocatedTotalMb"/>
+    /// leaves it out of every allocated total.
+    /// </summary>
+    public decimal? TotalSizeMb { get; set; }
     public decimal? UsedSizeMb { get; set; }
-    public decimal? FreeSpaceMb => UsedSizeMb.HasValue ? TotalSizeMb - UsedSizeMb.Value : null;
-    public decimal? UsedPct => UsedSizeMb.HasValue && TotalSizeMb > 0 ? Math.Round(UsedSizeMb.Value * 100m / TotalSizeMb, 1) : null;
+    public decimal? FreeSpaceMb => UsedSizeMb.HasValue && TotalSizeMb.HasValue ? TotalSizeMb.Value - UsedSizeMb.Value : null;
+    public decimal? UsedPct => UsedSizeMb.HasValue && TotalSizeMb > 0 ? Math.Round(UsedSizeMb.Value * 100m / TotalSizeMb.Value, 1) : null;
+
+    /// <summary>The allocated total over <paramref name="rows"/>: a row with no allocated size (the Hyperscale log
+    /// file) adds nothing, so the data file alone is what a Hyperscale database holds.</summary>
+    public static decimal AllocatedTotalMb(IEnumerable<DatabaseSizeRow> rows) => rows.Sum(r => r.TotalSizeMb ?? 0m);
+
+    /// <summary>The free space over <paramref name="rows"/>, on the same footing as <see cref="AllocatedTotalMb"/>:
+    /// only a row that has an allocation has free space in it.</summary>
+    public static decimal FreeTotalMb(IEnumerable<DatabaseSizeRow> rows) => rows.Sum(r => r.FreeSpaceMb ?? 0m);
     public string? VolumeMountPoint { get; set; }
     public decimal? VolumeTotalMb { get; set; }
     public decimal? VolumeFreeMb { get; set; }
diff --git a/Lite/Services/LocalDataService.ServerInfo.cs b/Lite/Services/LocalDataService.ServerInfo.cs
index bfa6d9ee2..ff758f31c 100644
--- a/Lite/Services/LocalDataService.ServerInfo.cs
+++ b/Lite/Services/LocalDataService.ServerInfo.cs
@@ -163,10 +163,12 @@ FROM v_database_size_stats
                 FileName = reader.IsDBNull(1) ? "" : reader.GetString(1),
                 FileTypeDesc = reader.IsDBNull(2) ? "" : reader.GetString(2),
                 PhysicalName = reader.IsDBNull(3) ? "" : reader.GetString(3),
-                TotalSizeMb = reader.IsDBNull(4) ? 0 : ToDouble(reader.GetValue(4)),
+                /* NULL size, growth and ceiling are the Hyperscale log file (the log service): they stay null so
+                   get_database_sizes says so, the same as Darling's twin, instead of reporting a size of 0. */
+                TotalSizeMb = reader.IsDBNull(4) ? null : ToDouble(reader.GetValue(4)),
                 UsedSizeMb = reader.IsDBNull(5) ? 0 : ToDouble(reader.GetValue(5)),
-                AutoGrowthMb = reader.IsDBNull(6) ? 0 : ToDouble(reader.GetValue(6)),
-                MaxSizeMb = reader.IsDBNull(7) ? 0 : ToDouble(reader.GetValue(7)),
+                AutoGrowthMb = reader.IsDBNull(6) ? null : ToDouble(reader.GetValue(6)),
+                MaxSizeMb = reader.IsDBNull(7) ? null : ToDouble(reader.GetValue(7)),
                 VolumeMountPoint = reader.IsDBNull(8) ? "" : reader.GetString(8),
                 VolumeTotalMb = reader.IsDBNull(9) ? 0 : ToDouble(reader.GetValue(9)),
                 VolumeFreeMb = reader.IsDBNull(10) ? 0 : ToDouble(reader.GetValue(10)),
@@ -250,10 +252,12 @@ public class DatabaseSizeStatsRow
     public string FileName { get; set; } = "";
     public string FileTypeDesc { get; set; } = "";
     public string PhysicalName { get; set; } = "";
-    public double TotalSizeMb { get; set; }
+    /// <summary>Null for the LOG file of an Azure SQL Database Hyperscale database (the log service): see
+    /// <see cref="PerformanceMonitor.Common.HyperscaleLogSize"/>. The growth and ceiling are null with it.</summary>
+    public double? TotalSizeMb { get; set; }
     public double UsedSizeMb { get; set; }
-    public double AutoGrowthMb { get; set; }
-    public double MaxSizeMb { get; set; }
+    public double? AutoGrowthMb { get; set; }
+    public double? MaxSizeMb { get; set; }
     public string VolumeMountPoint { get; set; } = "";
     public double VolumeTotalMb { get; set; }
     public double VolumeFreeMb { get; set; }
diff --git a/PerformanceMonitor.Collectors/DatabaseSizeStatsCollector.cs b/PerformanceMonitor.Collectors/DatabaseSizeStatsCollector.cs
index da0563076..cf25d0a5d 100644
--- a/PerformanceMonitor.Collectors/DatabaseSizeStatsCollector.cs
+++ b/PerformanceMonitor.Collectors/DatabaseSizeStatsCollector.cs
@@ -49,6 +49,10 @@ private DatabaseSizeStatsCollector()
     /// sibling arm (#2643) deliberately emits them as NULL: <c>sys.resource_stats</c> has no
     /// per-file breakdown, so a sibling row carries a database name and a total size and honestly
     /// nothing else. Both stores hold the columns nullable (#3262).
+    ///
+    /// <para><c>TotalSizeMb</c> is nullable for one row: the LOG file of an Azure SQL Database Hyperscale
+    /// database, whose size is not allocated storage (the log lives in the log service). See
+    /// <see cref="PerformanceMonitor.Common.HyperscaleLogSize"/>.</para>
     /// </summary>
     public readonly record struct Row(
         string DatabaseName,
@@ -57,7 +61,7 @@ public readonly record struct Row(
         string FileTypeDesc,
         string FileName,
         string? PhysicalName,
-        decimal TotalSizeMb,
+        decimal? TotalSizeMb,
         decimal? UsedSizeMb,
         decimal? AutoGrowthMb,
         decimal? MaxSizeMb,
@@ -235,6 +239,25 @@ WHERE DB_NAME() = N'master' still fails with 208 on every user database, which i
     private const string AzureSqlDbQueryText = @"
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
+/* Hyperscale keeps its transaction log in the log service, and sys.database_files still lists a LOG row for it,
+   sized at about 1 TB (1,046,528 MB) - the ceiling on the log's ACTIVE portion, not storage the database holds
+   or pays for. Hyperscale bills allocated DATA storage only (Microsoft Learn, 'What is the Hyperscale service
+   tier?'), so that row's size, growth and ceiling are not reported: a NULL here becomes 'n/a (log service)' in
+   every reader and stays out of every allocated total. The data file keeps its real size.
+
+   DATABASEPROPERTYEX needs only the current database, so this adds no permission to the Azure path. Learn's
+   DATABASEPROPERTYEX page describes Edition as 'the database edition or service tier' and its list of returned
+   values does not name Hyperscale; the tier string itself is the one Learn shows for
+   sys.database_service_objectives.edition (which needs dbmanager, so it is not usable here). CONVERT because
+   DATABASEPROPERTYEX returns sql_variant, the same way Recovery is read below. */
+DECLARE
+    @is_hyperscale bit =
+        CASE
+            WHEN CONVERT(nvarchar(64), DATABASEPROPERTYEX(DB_NAME(), N'Edition')) = N'Hyperscale'
+            THEN 1
+            ELSE 0
+        END;
+
 DECLARE
     @database_sizes TABLE
 (
@@ -269,17 +292,25 @@ vlf_count integer NULL
     file_name = df.name,
     physical_name = df.physical_name,
     total_size_mb =
-        CONVERT(decimal(19,2), df.size * 8.0 / 1024.0),
+        CASE
+            WHEN ls.is_log_service = 1
+            THEN CONVERT(decimal(19,2), NULL)
+            ELSE CONVERT(decimal(19,2), df.size * 8.0 / 1024.0)
+        END,
     used_size_mb =
         CONVERT(decimal(19,2), FILEPROPERTY(df.name, N'SpaceUsed') * 8.0 / 1024.0),
     auto_growth_mb =
         CASE
+            WHEN ls.is_log_service = 1
+            THEN CONVERT(decimal(19,2), NULL)
             WHEN df.is_percent_growth = 1
             THEN CONVERT(decimal(19,2), NULL)
             ELSE CONVERT(decimal(19,2), df.growth * 8.0 / 1024.0)
         END,
     max_size_mb =
         CASE
+            WHEN ls.is_log_service = 1
+            THEN CONVERT(decimal(19,2), NULL)
             WHEN df.max_size = -1
             THEN CONVERT(decimal(19,2), -1)
             WHEN df.max_size = 268435456
@@ -299,12 +330,34 @@ ELSE CONVERT(decimal(19,2), df.max_size * 8.0 / 1024.0)
     volume_free_mb =
         CONVERT(decimal(19,2), NULL),
     is_percent_growth =
-        df.is_percent_growth,
+        CASE
+            WHEN ls.is_log_service = 1
+            THEN CONVERT(bit, NULL)
+            ELSE df.is_percent_growth
+        END,
     growth_pct =
-        CASE WHEN df.is_percent_growth = 1 THEN df.growth ELSE NULL END,
+        CASE
+            WHEN ls.is_log_service = 0
+            AND  df.is_percent_growth = 1
+            THEN df.growth
+            ELSE NULL
+        END,
     vlf_count =
         CASE WHEN df.type = 1 /*LOG*/ THEN (SELECT CONVERT(integer, COUNT_BIG(*)) FROM sys.dm_db_log_info(DB_ID()) AS li WHERE li.file_id = df.file_id) ELSE NULL END
-FROM sys.database_files AS df;
+FROM sys.database_files AS df
+CROSS APPLY
+(
+    /* The one place that decides which row is the log service's: the LOG row (type 1) of a Hyperscale
+       database. Used space and the VLF count stay as collected - neither feeds an allocated total. */
+    SELECT
+        is_log_service =
+            CASE
+                WHEN @is_hyperscale = 1
+                AND  df.type = 1 /*LOG*/
+                THEN CONVERT(bit, 1)
+                ELSE CONVERT(bit, 0)
+            END
+) AS ls;
 
 /* The sibling databases, on the one connection that can see them. Newest sample per database: the older
    ones are a growth series worth having later, and taking them all would multiply every database by the
@@ -458,7 +511,9 @@ public override async ValueTask<List<Row>> ReadAsync(DbDataReader reader, Collec
                 reader.GetString(3),
                 reader.GetString(4),
                 reader.IsDBNull(5) ? null : reader.GetString(5),
-                reader.GetDecimal(6),
+                /* Ordinal 6 is NULL on the Hyperscale log row (the log service is not allocated storage);
+                   an unguarded GetDecimal here would kill the whole batch the way #3262 did. */
+                reader.IsDBNull(6) ? null : reader.GetDecimal(6),
                 reader.IsDBNull(7) ? null : reader.GetDecimal(7),
                 reader.IsDBNull(8) ? null : reader.GetDecimal(8),
                 reader.IsDBNull(9) ? null : reader.GetDecimal(9),
diff --git a/PerformanceMonitor.Common/HyperscaleLogSize.cs b/PerformanceMonitor.Common/HyperscaleLogSize.cs
new file mode 100644
index 000000000..af64013be
--- /dev/null
+++ b/PerformanceMonitor.Common/HyperscaleLogSize.cs
@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+namespace PerformanceMonitor.Common;
+
+/// <summary>
+/// The one spelling of how Database Sizes treats the transaction log on Azure SQL Database Hyperscale, shared by
+/// Lite and Darling so both apps say the same thing.
+///
+/// <para>On Hyperscale, <c>sys.database_files</c> reports the LOG file at about 1 TB (1,046,528 MB) while the data
+/// file reports its real allocation. The log lives in Hyperscale's log service, so that figure is not storage the
+/// database holds or pays for: Microsoft Learn, "What is the Hyperscale service tier?", says Hyperscale bills
+/// <i>allocated data storage</i>, allocated automatically from 10 GB, and the Hyperscale FAQ calls the log
+/// "practically infinite", with only its active portion capped at 1 TB. The collector therefore stores a NULL
+/// <c>total_size_mb</c> for that one row, and every reader shows <see cref="Display"/> where the size would be and
+/// leaves the row out of every allocated total.</para>
+/// </summary>
+public static class HyperscaleLogSize
+{
+    /// <summary>What a grid cell or web table shows where a Hyperscale log file's size would be.</summary>
+    public const string Display = "n/a (log service)";
+
+    /// <summary>The short note a Database Sizes MCP payload carries beside a null <c>total_size_mb</c>.</summary>
+    public const string Note =
+        "total_size_mb is null for a log file on Azure SQL Database Hyperscale: the log lives in the log service, "
+        + "so its size is n/a (log service) and it is left out of every allocated total.";
+}

From 7dd0f20cfcf4fc92bbac4aee40fbc87c221f5d40 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:27:27 -0400
Subject: [PATCH 2/3] get_database_sizes: sum a database's used space over the
 same files as its total

---
 Darling/Darling.Tests/HyperscaleLogSizeTests.cs               | 2 ++
 .../Mcp/DarlingMcpObjectStatsTools.cs                         | 4 ++--
 Lite.Tests/HyperscaleLogSizeTests.cs                          | 2 ++
 Lite/Mcp/McpServerInfoTools.cs                                | 4 ++--
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Darling/Darling.Tests/HyperscaleLogSizeTests.cs b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
index 6e3c24ef5..b06b3e223 100644
--- a/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
+++ b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
@@ -142,6 +142,8 @@ public void GetDatabaseSizesPayload_HyperscaleLogFile_IsNullWithTheNote_AndOutOf
 
         var hs = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "hsdb");
         Assert.Equal(10_240d, hs.GetProperty("total_size_mb").GetDouble());
+        /* Used sums over the same files as the total, so the log file's own used space (40) stays out of it. */
+        Assert.Equal(315d, hs.GetProperty("used_size_mb").GetDouble());
         var hsLog = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "LOG");
         Assert.Equal(JsonValueKind.Null, hsLog.GetProperty("total_size_mb").ValueKind);
         Assert.Equal(JsonValueKind.Null, hsLog.GetProperty("auto_growth_mb").ValueKind);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
index 702a8e8dd..2173f4b3e 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpObjectStatsTools.cs
@@ -363,9 +363,9 @@ internal static string DatabaseSizesPayload(string serverName, IReadOnlyList<Dar
             {
                 database_name = g.Key,
                 /* A file with no allocated size (the Hyperscale log file, in the log service) adds nothing,
-                   so a Hyperscale database's total is its data file alone. */
+                   so a Hyperscale database's total is its data file alone, and used sums over the same files. */
                 total_size_mb = g.Sum(r => r.TotalSizeMb ?? 0),
-                used_size_mb = g.Sum(r => r.UsedSizeMb ?? 0),
+                used_size_mb = g.Where(r => r.TotalSizeMb is not null).Sum(r => r.UsedSizeMb ?? 0),
                 files = g.Select(r => new
                 {
                     file_name = r.FileName,
diff --git a/Lite.Tests/HyperscaleLogSizeTests.cs b/Lite.Tests/HyperscaleLogSizeTests.cs
index d699d59ca..ed390d2c8 100644
--- a/Lite.Tests/HyperscaleLogSizeTests.cs
+++ b/Lite.Tests/HyperscaleLogSizeTests.cs
@@ -304,6 +304,8 @@ public void GetDatabaseSizesPayload_HyperscaleLogFile_IsNullWithTheNote_AndOutOf
 
         var hs = root.GetProperty("databases").EnumerateArray().Single(d => d.GetProperty("database_name").GetString() == "hsdb");
         Assert.Equal(10_240d, hs.GetProperty("total_size_mb").GetDouble());
+        /* Used sums over the same files as the total, so the log file's own used space (40) stays out of it. */
+        Assert.Equal(315d, hs.GetProperty("used_size_mb").GetDouble());
         var hsLog = hs.GetProperty("files").EnumerateArray().Single(f => f.GetProperty("file_type").GetString() == "LOG");
         Assert.Equal(System.Text.Json.JsonValueKind.Null, hsLog.GetProperty("total_size_mb").ValueKind);
         Assert.Equal(System.Text.Json.JsonValueKind.Null, hsLog.GetProperty("auto_growth_mb").ValueKind);
diff --git a/Lite/Mcp/McpServerInfoTools.cs b/Lite/Mcp/McpServerInfoTools.cs
index 149449c44..a11183d70 100644
--- a/Lite/Mcp/McpServerInfoTools.cs
+++ b/Lite/Mcp/McpServerInfoTools.cs
@@ -122,9 +122,9 @@ internal static string DatabaseSizesPayload(string serverName, IReadOnlyList<Dat
             {
                 database_name = g.Key,
                 /* A file with no allocated size (the Hyperscale log file, in the log service) adds nothing,
-                   so a Hyperscale database's total is its data file alone. */
+                   so a Hyperscale database's total is its data file alone, and used sums over the same files. */
                 total_size_mb = g.Sum(r => r.TotalSizeMb ?? 0),
-                used_size_mb = g.Sum(r => r.UsedSizeMb),
+                used_size_mb = g.Where(r => r.TotalSizeMb is not null).Sum(r => r.UsedSizeMb),
                 files = g.Select(r => new
                 {
                     file_name = r.FileName,

From 3ea35a5525cc1731fad2b007fbd5a697ecfa9f9f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Wed, 30 Sep 2026 20:14:06 -0400
Subject: [PATCH 3/3] Storage Growth leaves the Hyperscale log file out of the
 7-day and 30-day sizes too

Rows stored before the collector wrote NULL for the Hyperscale log row still hold its ~1 TB. With only the latest sum leaving the log out, a Hyperscale database read as a drop of about 99%.

- One predicate leaves out any file whose row in the latest snapshot has no size. Both apps' Storage Growth queries apply it to the latest, 7-day and 30-day sums alike. It runs at read time, so the old rows need no migration.
- A file that is gone from the latest snapshot has no row there, so it still counts on the past side, as shrinkage.
- FileIoStatsCollector.NoSizeLabel points at HyperscaleLogSize.Display, so one constant owns "n/a (log service)".
- The get_database_sizes note, which the web Database Sizes table shows, is in plain words and names no field.
---
 .../Darling.Tests/HyperscaleLogSizeTests.cs   |  62 ++++++++
 .../ViewerDataService.FinOps.Storage.cs       |  69 +++++++--
 Lite.Tests/HyperscaleLogSizeTests.cs          | 142 +++++++++++++++++-
 .../LocalDataService.FinOps.StorageGrowth.cs  |  96 ++++++++----
 .../FileIoStatsCollector.cs                   |   4 +-
 .../HyperscaleLogSize.cs                      |  13 +-
 6 files changed, 336 insertions(+), 50 deletions(-)

diff --git a/Darling/Darling.Tests/HyperscaleLogSizeTests.cs b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
index b06b3e223..ec1c02252 100644
--- a/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
+++ b/Darling/Darling.Tests/HyperscaleLogSizeTests.cs
@@ -121,6 +121,63 @@ public void ViewerUtilizationChart_UsedIsSummedOnlyOverTheFilesWhoseSizeCounts()
         Assert.Contains("SUM(CASE WHEN total_size_mb IS NOT NULL THEN used_size_mb END) AS used_mb", ViewerDataService.DatabaseSizeSummarySql, StringComparison.Ordinal);
     }
 
+    /// <summary>
+    /// Storage Growth: history collected before the collector stored NULL for the Hyperscale log row still holds its
+    /// ~1 TB. Summed on the past side only, it read as a -99% drop. One predicate leaves any file whose latest row has
+    /// no size out of the latest, 7-day and 30-day sums alike. Lite's <c>HyperscaleLogSizeReadTests</c> run the twin
+    /// query on a real store (the ~0 growth, the dropped file that still counts as shrinkage); this store is
+    /// PostgreSQL, whose tests are live-only, so here the text is the proof. It also holds the latest side, where the
+    /// predicate drops only the NULL rows SUM already skips and no behaviour could show it missing.
+    /// </summary>
+    [Fact]
+    public void ViewerStorageGrowth_AppliesOnePredicateToTheLatestAnd7dAnd30dSums()
+    {
+        var sql = ViewerDataService.StorageGrowthSql;
+        const string predicate = "NOT EXISTS ( SELECT 1 FROM log_service_files AS ls WHERE ls.database_name = s.database_name AND ls.file_id = s.file_id )";
+
+        foreach (var sum in new[] { "latest", "past_7d", "past_30d" })
+        {
+            Assert.True(Squash(CteBody(sql, sum)).Contains(predicate, StringComparison.Ordinal), $"The {sum} sum does not leave the log-service file out.");
+        }
+
+        /* The files it drops are the ones whose row in the LATEST snapshot ($2, the literal the latest CTE binds, so
+           the #4245 plan shape holds) has no size. */
+        var files = Squash(CteBody(sql, "log_service_files"));
+        Assert.Contains("collection_time = $2", files, StringComparison.Ordinal);
+        Assert.Contains("AND total_size_mb IS NULL", files, StringComparison.Ordinal);
+    }
+
+    private static string Squash(string sql) => Regex.Replace(sql, @"\s+", " ").Trim();
+
+    /// <summary>The body of one CTE of a WITH statement: the text inside its <c>name AS ( ... )</c>.</summary>
+    private static string CteBody(string sql, string name)
+    {
+        var head = "\n" + name + " AS (";
+        var start = sql.IndexOf(head, StringComparison.Ordinal);
+        if (start < 0)
+        {
+            head = "WITH " + name + " AS (";
+            start = sql.IndexOf(head, StringComparison.Ordinal);
+        }
+
+        Assert.True(start >= 0, $"The SQL has no CTE named {name}.");
+        var open = start + head.Length - 1;
+        var depth = 0;
+        for (var i = open; i < sql.Length; i++)
+        {
+            if (sql[i] == '(')
+            {
+                depth++;
+            }
+            else if (sql[i] == ')' && --depth == 0)
+            {
+                return sql.Substring(open + 1, i - open - 1);
+            }
+        }
+
+        throw new InvalidOperationException($"The CTE {name} is never closed.");
+    }
+
     private static DarlingObjectStatsReader.DatabaseSizeRow SizeRow(string database, string name, string fileType, double? total, double used, double? growth, double? max) =>
         new(new DateTime(2026, 9, 30, 12, 0, 0, DateTimeKind.Utc), database, name, fileType, total, used, growth, max, null, null, null);
 
@@ -184,6 +241,11 @@ public void WebDatabaseSizesTable_RendersTheReadsNote()
         block = block.Substring(0, block.IndexOf("),", StringComparison.Ordinal));
         Assert.Contains("\"get_database_sizes\"", block, StringComparison.Ordinal);
         Assert.Matches(new Regex("1,\\s*\"note\""), block);
+
+        /* That note is HyperscaleLogSize.Note, and people read it on the page: plain words, no JSON field name
+           (every one has an underscore). */
+        Assert.Contains(HyperscaleLogSize.Display, HyperscaleLogSize.Note, StringComparison.Ordinal);
+        Assert.DoesNotContain("_", HyperscaleLogSize.Note, StringComparison.Ordinal);
     }
 
     private static string RepoRoot([CallerFilePath] string thisFile = "")
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
index 7acd07120..86baf4ae3 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.FinOps.Storage.cs
@@ -409,34 +409,71 @@ public async Task<List<TempdbSummaryRow>> GetTempdbSummaryAsync(int serverId, Ca
     /// qualifying snapshot (a database younger than 7 or 30 days) binds SQL NULL, which the CTE's equality
     /// turns into zero rows — the LEFT JOIN below already treats that as "no prior snapshot", unchanged from
     /// before this fix. $1 server_id, $2 latest collection_time, $3 collection_time at or before 7d ago,
-    /// $4 collection_time at or before 30d ago (either of the last two may be null).</summary>
+    /// $4 collection_time at or before 30d ago (either of the last two may be null).
+    ///
+    /// <para>A file whose row in the latest snapshot has no size is left out of all three sums, by one predicate
+    /// (the <c>NOT EXISTS</c> against <c>log_service_files</c>) repeated in each. That file is the log of an Azure
+    /// SQL Database Hyperscale database (<see cref="HyperscaleLogSize"/>). Its older rows can still hold the ~1 TB
+    /// that sys.database_files reported before the collector stored NULL for it, and summing them on the past side
+    /// alone read as a -99% drop. The rule is applied at read time, so it covers history collected before the
+    /// change without rewriting it. On the latest side it drops only the rows SUM already skips. A file that is
+    /// gone from the latest snapshot has no row there, so it still counts on the past side, as shrinkage.
+    /// <c>log_service_files</c> binds the same literal <c>$2</c> as the latest CTE, so the #4245 plan shape
+    /// holds. Lite's <c>LocalDataService.StorageGrowthSql</c> is the twin.</para></summary>
     public const string StorageGrowthSql = @"
-WITH latest AS (
+WITH log_service_files AS (
     SELECT
         database_name,
-        SUM(total_size_mb) AS current_size_mb
+        file_id
     FROM v_database_size_stats
     WHERE server_id = $1
     AND   collection_time = $2
-    GROUP BY database_name
+    AND   total_size_mb IS NULL
+),
+latest AS (
+    SELECT
+        s.database_name,
+        SUM(s.total_size_mb) AS current_size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = $2
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 ),
 past_7d AS (
     SELECT
-        database_name,
-        SUM(total_size_mb) AS size_mb
-    FROM v_database_size_stats
-    WHERE server_id = $1
-    AND   collection_time = $3
-    GROUP BY database_name
+        s.database_name,
+        SUM(s.total_size_mb) AS size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = $3
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 ),
 past_30d AS (
     SELECT
-        database_name,
-        SUM(total_size_mb) AS size_mb
-    FROM v_database_size_stats
-    WHERE server_id = $1
-    AND   collection_time = $4
-    GROUP BY database_name
+        s.database_name,
+        SUM(s.total_size_mb) AS size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = $4
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 )
 SELECT
     l.database_name,
diff --git a/Lite.Tests/HyperscaleLogSizeTests.cs b/Lite.Tests/HyperscaleLogSizeTests.cs
index ed390d2c8..9e113301c 100644
--- a/Lite.Tests/HyperscaleLogSizeTests.cs
+++ b/Lite.Tests/HyperscaleLogSizeTests.cs
@@ -143,7 +143,7 @@ public HyperscaleLogSizeReadTests(SharedDuckDbFixture fixture)
     private static readonly DateTime Collected = DateTime.SpecifyKind(
         new DateTime(DateTime.UtcNow.Ticks - (DateTime.UtcNow.Ticks % TimeSpan.TicksPerMinute)), DateTimeKind.Unspecified);
 
-    private async Task SeedAsync(string database, int fileId, string fileType, string fileName, double? total, double? used, double? autoGrowth, double? max)
+    private async Task SeedAsync(string database, int fileId, string fileType, string fileName, double? total, double? used, double? autoGrowth, double? max, DateTime? at = null)
     {
         using var readLock = _duckDb.AcquireReadLock();
         _seedConn ??= _duckDb.CreateConnection();
@@ -155,7 +155,7 @@ INSERT INTO database_size_stats
      file_name, physical_name, total_size_mb, used_size_mb, auto_growth_mb, max_size_mb)
 VALUES ($1, $2, $3, 'HsSrv', $4, 7, $5, $6, $7, $8, $9, $10, $11, $12)";
         cmd.Parameters.Add(new DuckDBParameter { Value = _nextId++ });
-        cmd.Parameters.Add(new DuckDBParameter { Value = Collected });
+        cmd.Parameters.Add(new DuckDBParameter { Value = at ?? Collected });
         cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
         cmd.Parameters.Add(new DuckDBParameter { Value = database });
         cmd.Parameters.Add(new DuckDBParameter { Value = fileId });
@@ -229,6 +229,141 @@ public async Task UtilizationChart_HyperscaleDatabase_AllocatesTheDataFileOnly_A
         Assert.Equal(15m, plain.UsedMb);
     }
 
+    /* The size sys.database_files reports for a Hyperscale log file. History collected before the collector stored
+       NULL for that row still holds it, and the store keeps 90 days of it. */
+    private const double LogServiceMb = 1_046_528;
+
+    /// <summary>
+    /// 31 and 8 days ago, before the change: the Hyperscale log row holds the ~1 TB. Now it is NULL. Beside it, a
+    /// database whose log row has a real size and the same file_id, and whose second data file was dropped this week.
+    /// </summary>
+    private async Task SeedGrowthHistoryAsync()
+    {
+        foreach (var daysAgo in new[] { 31, 8 })
+        {
+            var at = Collected.AddDays(-daysAgo);
+            await SeedAsync("hsdb", 1, "ROWS", "hsdb_data", daysAgo == 31 ? 10_000 : 10_100, 300, 1_024, -1, at);
+            await SeedAsync("hsdb", 2, "LOG", "hsdb_log", LogServiceMb, 40, 1_024, 1_048_576, at);
+
+            await SeedAsync("plain", 1, "ROWS", "plain_data", 1_000, 10, 64, -1, at);
+            await SeedAsync("plain", 3, "ROWS", "plain_data2", 500, 5, 64, -1, at);
+            await SeedAsync("plain", 2, "LOG", "plain_log", 200, 5, 64, 2_097_152, at);
+        }
+
+        await SeedAsync("hsdb", 1, "ROWS", "hsdb_data", 10_240, 315, 1_024, -1);
+        await SeedAsync("hsdb", 2, "LOG", "hsdb_log", null, 40, null, null);
+
+        await SeedAsync("plain", 1, "ROWS", "plain_data", 1_000, 10, 64, -1);
+        await SeedAsync("plain", 2, "LOG", "plain_log", 260, 5, 64, 2_097_152);
+    }
+
+    [Fact]
+    public async Task StorageGrowth_HyperscaleHistoryHoldsTheOneTerabyteLogRow_ShowsTheDataFileGrowth_NotA99PercentDrop()
+    {
+        await SeedGrowthHistoryAsync();
+
+        var hs = Assert.Single(await new LocalDataService(_duckDb).GetStorageGrowthAsync(ServerId), r => r.DatabaseName == "hsdb");
+
+        /* The log file is out of all three sums, so each side is the data file alone. Summing the old ~1 TB rows on
+           the past side only read as 10,240 against 1,056,528 MB: -99%. */
+        Assert.Equal(140m, hs.Growth7dMb);
+        Assert.Equal(2.4m, Math.Round(hs.GrowthPct30d, 4));
+        Assert.Equal(240m, hs.Growth30dMb);
+        Assert.Equal(8m, Math.Round(hs.DailyGrowthRateMb, 4));
+        Assert.Equal(10_240m, hs.CurrentSizeMb);
+        Assert.Equal(10_100m, hs.Size7dAgoMb);
+        Assert.Equal(10_000m, hs.Size30dAgoMb);
+    }
+
+    [Fact]
+    public async Task StorageGrowth_AFileGoneFromTheLatestSnapshot_StillCountsAsShrinkage_AndARealLogCounts()
+    {
+        await SeedGrowthHistoryAsync();
+
+        var plain = Assert.Single(await new LocalDataService(_duckDb).GetStorageGrowthAsync(ServerId), r => r.DatabaseName == "plain");
+
+        /* plain_data2 has no row in the latest snapshot, so the rule has nothing to match and its 500 MB stays on the
+           past side: the database shrank. plain_log shares hsdb_log's file_id but has a real size, so it counts on
+           every side (its 60 MB of growth included). */
+        Assert.Equal(1_260m, plain.CurrentSizeMb);
+        Assert.Equal(1_700m, plain.Size7dAgoMb);
+        Assert.Equal(1_700m, plain.Size30dAgoMb);
+        Assert.Equal(-440m, plain.Growth7dMb);
+        Assert.Equal(-440m, plain.Growth30dMb);
+    }
+
+    [Fact]
+    public async Task StorageGrowth_LatestSnapshotStillFromBeforeTheChange_CountsTheLogRowOnBothSides_LikeTheDatabaseSizesGrid()
+    {
+        /* Until the first hourly collection after the upgrade, the latest snapshot still holds the ~1 TB log row. The
+           Database Sizes grid shows that stored figure, and Storage Growth counts it on both sides: growth is still
+           the data file's own. */
+        await SeedAsync("hsdb", 1, "ROWS", "hsdb_data", 10_000, 300, 1_024, -1, Collected.AddDays(-31));
+        await SeedAsync("hsdb", 2, "LOG", "hsdb_log", LogServiceMb, 40, 1_024, 1_048_576, Collected.AddDays(-31));
+        await SeedAsync("hsdb", 1, "ROWS", "hsdb_data", 10_240, 315, 1_024, -1);
+        await SeedAsync("hsdb", 2, "LOG", "hsdb_log", LogServiceMb, 40, 1_024, 1_048_576);
+
+        var service = new LocalDataService(_duckDb);
+        var hs = Assert.Single(await service.GetStorageGrowthAsync(ServerId), r => r.DatabaseName == "hsdb");
+
+        Assert.Equal(10_240m + (decimal)LogServiceMb, hs.CurrentSizeMb);
+        Assert.Equal(240m, hs.Growth7dMb);
+        Assert.Equal(240m, hs.Growth30dMb);
+
+        var grid = await service.GetDatabaseSizeLatestAsync(ServerId);
+        Assert.Equal(hs.CurrentSizeMb, DatabaseSizeRow.AllocatedTotalMb(grid.Where(r => r.DatabaseName == "hsdb").ToList()));
+    }
+
+    [Fact]
+    public void StorageGrowthSql_AppliesOnePredicateToTheLatestAnd7dAnd30dSums()
+    {
+        /* The behaviour pins above cannot show the latest side: there the predicate drops only the NULL rows SUM
+           already skips. The text shows it, and holds all three sums to the same predicate. Darling's
+           ViewerDataService.StorageGrowthSql pin is the twin. */
+        var sql = LocalDataService.StorageGrowthSql;
+        const string predicate = "NOT EXISTS ( SELECT 1 FROM log_service_files AS ls WHERE ls.database_name = s.database_name AND ls.file_id = s.file_id )";
+
+        foreach (var sum in new[] { "latest", "past_7d", "past_30d" })
+        {
+            Assert.True(Squash(CteBody(sql, sum)).Contains(predicate, StringComparison.Ordinal), $"The {sum} sum does not leave the log-service file out.");
+        }
+
+        var files = Squash(CteBody(sql, "log_service_files"));
+        Assert.Contains("collection_time = ( SELECT MAX(collection_time) FROM v_database_size_stats WHERE server_id = $1 )", files, StringComparison.Ordinal);
+        Assert.Contains("AND total_size_mb IS NULL", files, StringComparison.Ordinal);
+    }
+
+    private static string Squash(string sql) => Regex.Replace(sql, @"\s+", " ").Trim();
+
+    /// <summary>The body of one CTE of a WITH statement: the text inside its <c>name AS ( ... )</c>.</summary>
+    private static string CteBody(string sql, string name)
+    {
+        var head = "\n" + name + " AS (";
+        var start = sql.IndexOf(head, StringComparison.Ordinal);
+        if (start < 0)
+        {
+            head = "WITH " + name + " AS (";
+            start = sql.IndexOf(head, StringComparison.Ordinal);
+        }
+
+        Assert.True(start >= 0, $"The SQL has no CTE named {name}.");
+        var open = start + head.Length - 1;
+        var depth = 0;
+        for (var i = open; i < sql.Length; i++)
+        {
+            if (sql[i] == '(')
+            {
+                depth++;
+            }
+            else if (sql[i] == ')' && --depth == 0)
+            {
+                return sql.Substring(open + 1, i - open - 1);
+            }
+        }
+
+        throw new InvalidOperationException($"The CTE {name} is never closed.");
+    }
+
     [Fact]
     public async Task GetDatabaseSizesTool_Read_PassesTheNullSizeGrowthAndCeilingThroughAsNull()
     {
@@ -341,6 +476,9 @@ public void TheSharedNote_NamesTheWordsTheGridShows()
     {
         Assert.Contains("Azure SQL Database Hyperscale", HyperscaleLogSize.Note, StringComparison.Ordinal);
         Assert.Contains(HyperscaleLogSize.Display, HyperscaleLogSize.Note, StringComparison.Ordinal);
+
+        /* People read it above the web Database Sizes table, so it names no JSON field (every one has an underscore). */
+        Assert.DoesNotContain("_", HyperscaleLogSize.Note, StringComparison.Ordinal);
     }
 
     private static string RepoRoot()
diff --git a/Lite/Services/LocalDataService.FinOps.StorageGrowth.cs b/Lite/Services/LocalDataService.FinOps.StorageGrowth.cs
index a9266c9e2..e8d0fe712 100644
--- a/Lite/Services/LocalDataService.FinOps.StorageGrowth.cs
+++ b/Lite/Services/LocalDataService.FinOps.StorageGrowth.cs
@@ -16,22 +16,22 @@ namespace PerformanceMonitorLite.Services;
 public partial class LocalDataService
 {
     /// <summary>
-    /// Gets per-database storage growth trends comparing current size to 7d and 30d ago.
+    /// Per-database size now, 7 days ago and 30 days ago. $1 server_id, $2 the 7-day cutoff, $3 the 30-day cutoff.
+    ///
+    /// <para>A file whose row in the latest snapshot has no size is left out of all three sums, by one predicate
+    /// (the <c>NOT EXISTS</c> against <c>log_service_files</c>) repeated in each. That file is the log of an Azure
+    /// SQL Database Hyperscale database (<see cref="PerformanceMonitor.Common.HyperscaleLogSize"/>). Its older rows
+    /// can still hold the ~1 TB that sys.database_files reported before the collector stored NULL for it, and
+    /// summing them on the past side alone read as a -99% drop. The rule is applied at read time, so it covers
+    /// history collected before the change without rewriting it. On the latest side it drops only the rows SUM
+    /// already skips. A file that is gone from the latest snapshot has no row there, so it still counts on the
+    /// past side, as shrinkage.</para>
     /// </summary>
-    public async Task<List<StorageGrowthRow>> GetStorageGrowthAsync(int serverId)
-    {
-        using var connection = await OpenConnectionAsync();
-        using var command = connection.CreateCommand();
-
-        var now = DateTime.UtcNow;
-        var cutoff7d = now.AddDays(-7);
-        var cutoff30d = now.AddDays(-30);
-
-        command.CommandText = @"
-WITH latest AS (
+    internal const string StorageGrowthSql = @"
+WITH log_service_files AS (
     SELECT
         database_name,
-        SUM(total_size_mb) AS current_size_mb
+        file_id
     FROM v_database_size_stats
     WHERE server_id = $1
     AND   collection_time = (
@@ -39,35 +39,66 @@ SELECT MAX(collection_time)
         FROM v_database_size_stats
         WHERE server_id = $1
     )
-    GROUP BY database_name
+    AND   total_size_mb IS NULL
+),
+latest AS (
+    SELECT
+        s.database_name,
+        SUM(s.total_size_mb) AS current_size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = (
+        SELECT MAX(collection_time)
+        FROM v_database_size_stats
+        WHERE server_id = $1
+    )
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 ),
 past_7d AS (
     SELECT
-        database_name,
-        SUM(total_size_mb) AS size_mb
-    FROM v_database_size_stats
-    WHERE server_id = $1
-    AND   collection_time = (
+        s.database_name,
+        SUM(s.total_size_mb) AS size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = (
         SELECT MAX(collection_time)
         FROM v_database_size_stats
         WHERE server_id = $1
         AND   collection_time <= $2
     )
-    GROUP BY database_name
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 ),
 past_30d AS (
     SELECT
-        database_name,
-        SUM(total_size_mb) AS size_mb
-    FROM v_database_size_stats
-    WHERE server_id = $1
-    AND   collection_time = (
+        s.database_name,
+        SUM(s.total_size_mb) AS size_mb
+    FROM v_database_size_stats AS s
+    WHERE s.server_id = $1
+    AND   s.collection_time = (
         SELECT MAX(collection_time)
         FROM v_database_size_stats
         WHERE server_id = $1
         AND   collection_time <= $3
     )
-    GROUP BY database_name
+    AND   NOT EXISTS (
+        SELECT 1
+        FROM log_service_files AS ls
+        WHERE ls.database_name = s.database_name
+        AND   ls.file_id = s.file_id
+    )
+    GROUP BY s.database_name
 )
 SELECT
     l.database_name,
@@ -93,6 +124,19 @@ FROM latest l
 LEFT JOIN past_30d p30 ON p30.database_name = l.database_name
 ORDER BY growth_30d_mb DESC";
 
+    /// <summary>
+    /// Gets per-database storage growth trends comparing current size to 7d and 30d ago.
+    /// </summary>
+    public async Task<List<StorageGrowthRow>> GetStorageGrowthAsync(int serverId)
+    {
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
+
+        var now = DateTime.UtcNow;
+        var cutoff7d = now.AddDays(-7);
+        var cutoff30d = now.AddDays(-30);
+
+        command.CommandText = StorageGrowthSql;
         command.Parameters.Add(new DuckDBParameter { Value = serverId });
         command.Parameters.Add(new DuckDBParameter { Value = cutoff7d });
         command.Parameters.Add(new DuckDBParameter { Value = cutoff30d });
diff --git a/PerformanceMonitor.Collectors/FileIoStatsCollector.cs b/PerformanceMonitor.Collectors/FileIoStatsCollector.cs
index de154c496..e555d6300 100644
--- a/PerformanceMonitor.Collectors/FileIoStatsCollector.cs
+++ b/PerformanceMonitor.Collectors/FileIoStatsCollector.cs
@@ -52,8 +52,10 @@ public readonly record struct Row(
     /// What every surface that shows a File I/O size says in place of a number when the row has none: the log
     /// file of an Azure SQL Database Hyperscale database (the log lives in the log service, so the file carries
     /// no size the database holds). Both apps' <c>get_file_io_stats</c> payloads and the web table use this text.
+    /// The words belong to <see cref="PerformanceMonitor.Common.HyperscaleLogSize.Display"/>, which Database Sizes
+    /// shows for the same file, so the two surfaces cannot drift apart.
     /// </summary>
-    public const string NoSizeLabel = "n/a (log service)";
+    public const string NoSizeLabel = PerformanceMonitor.Common.HyperscaleLogSize.Display;
 
     /* Azure SQL Database takes the file's size from sys.database_files, not from sys.dm_io_virtual_file_stats.
        On a Hyperscale database size_on_disk_bytes reads about 0.1 MB for the data file and for the log file,
diff --git a/PerformanceMonitor.Common/HyperscaleLogSize.cs b/PerformanceMonitor.Common/HyperscaleLogSize.cs
index af64013be..2008f672a 100644
--- a/PerformanceMonitor.Common/HyperscaleLogSize.cs
+++ b/PerformanceMonitor.Common/HyperscaleLogSize.cs
@@ -9,8 +9,9 @@
 namespace PerformanceMonitor.Common;
 
 /// <summary>
-/// The one spelling of how Database Sizes treats the transaction log on Azure SQL Database Hyperscale, shared by
-/// Lite and Darling so both apps say the same thing.
+/// The one spelling of how Database Sizes and File I/O treat the transaction log on Azure SQL Database Hyperscale,
+/// shared by Lite and Darling so both apps say the same thing. <c>FileIoStatsCollector.NoSizeLabel</c> points at
+/// <see cref="Display"/>; this class owns the words.
 ///
 /// <para>On Hyperscale, <c>sys.database_files</c> reports the LOG file at about 1 TB (1,046,528 MB) while the data
 /// file reports its real allocation. The log lives in Hyperscale's log service, so that figure is not storage the
@@ -25,8 +26,10 @@ public static class HyperscaleLogSize
     /// <summary>What a grid cell or web table shows where a Hyperscale log file's size would be.</summary>
     public const string Display = "n/a (log service)";
 
-    /// <summary>The short note a Database Sizes MCP payload carries beside a null <c>total_size_mb</c>.</summary>
+    /// <summary>The note a Database Sizes read carries when a file in the snapshot has no size: the top-level
+    /// <c>note</c> of both apps' <c>get_database_sizes</c> payload, which the web Database Sizes table shows above
+    /// its rows. Plain words, with no field names, because people read it on the web page.</summary>
     public const string Note =
-        "total_size_mb is null for a log file on Azure SQL Database Hyperscale: the log lives in the log service, "
-        + "so its size is n/a (log service) and it is left out of every allocated total.";
+        "On Azure SQL Database Hyperscale, the transaction log lives in the log service, not in storage the "
+        + "database holds. The log file's size is " + Display + ", and the totals leave it out.";
 }