Rollup reads stop at the window end instead of adding the hour or day that starts there (#4859)

A rollup bucket is stamped at its start. Nine reads over the hourly rollups, and the daily one for Custom Views, bounded the window end with bucket <= end. A window that ended exactly on a bucket start also took the whole bucket that begins there, which lies after the window. A Queries tab range older than raw retention whose To was 14:00 summed the 14:00-15:00 hour too. A Custom View on the daily tier that ended at midnight summed the next day.

- These reads now stop before the window end. They are the Queries and Procedures tabs' hourly tier and the top queries and top procedures tools' hourly reads. The hourly and bucketed hourly duration trends and the Query Store trend's rollup arm also stop there. So do one query's hourly history and Custom Views on a rollup route.
- A window end inside a bucket reads as before, with that bucket counted whole. Raw reads keep their inclusive end, because a raw sample is stamped when it was taken.
- The served-span note no longer claims the next hour for an end exactly on the hour.
- The first-bucket probes keep their inclusive end on purpose. They only locate where the served span starts.

Author: erikdarlingdata

Darling/Darling.Tests/DarlingMcpTrendToolsTests.cs

@@ -415,7 +415,10 @@ public void DurationTrendHourlySql_ReadsTheRollup_BucketsByIt_ProjectsTheSharedS
         Assert.DoesNotContain("FROM " + rawTable + "\n", sql, StringComparison.Ordinal);
         Assert.DoesNotContain("collection_time >=", sql, StringComparison.Ordinal);
         Assert.Contains("bucket >= $2", sql, StringComparison.Ordinal);
-        Assert.Contains("bucket <= $3", sql, StringComparison.Ordinal);
+        /* A bucket is stamped at its START, so the window end is exclusive: `bucket <= $3` would take the whole
+           hour that begins at an end falling on the hour (RollupWindowEndBoundTests pins the same for every rollup read). */
+        Assert.Contains("bucket < $3", sql, StringComparison.Ordinal);
+        Assert.DoesNotContain("bucket <= $3", sql, StringComparison.Ordinal);
         Assert.Contains("GROUP BY bucket", sql, StringComparison.Ordinal);
 
         /* Since #3897 the rollup's hours are gathered into $4-minute buckets on the shared origin; the columns and

Darling/Darling.Tests/HourlyAttributionSpanTests.cs

@@ -48,6 +48,31 @@ public void Hourly_ShareDividesByTheServedSpan_NotTheRequestedWindow()
         Assert.NotEqual(served.AttributedCpuRatio, requested.AttributedCpuRatio);
     }
 
+    [Fact]
+    public void Hourly_OnTheHourAsOf_DividesByExactlyTheHoursBeforeIt()
+    {
+        // An on-the-hour as_of divides N hours of CPU by N hours, not N+1 (#4859): the read stops before the hour
+        // that begins at as_of, so that hour is not in the denominator. The ceiling sits above as_of, so it does
+        // not cut the span.
+        var start = Day.AddHours(10);
+        var asOf = Day.AddHours(14);
+        var (from, to, _) = DarlingMcpDataTools.HourlyAttributionSpan(true, start, asOf, Day.AddHours(10), Day.AddHours(18));
+
+        Assert.Equal(Day.AddHours(10), from);
+        Assert.Equal(Day.AddHours(14), to);
+
+        // 25% of 8 cores over exactly 4 hours = 28,800 CPU-seconds; 21,600 ranked seconds is 0.75.
+        var served = CpuAttribution.Compute(21600, from, to, 240, from, to, 25, 8);
+        Assert.Equal(28800, served.SqlCpuSecondsInWindow);
+        Assert.Equal(0.75, served.AttributedCpuRatio);
+
+        // Contrast: an as_of 20 minutes into the hour still counts the bucket holding it whole, so the span ends
+        // at the top of the next hour.
+        var (_, unalignedTo, _) = DarlingMcpDataTools.HourlyAttributionSpan(
+            true, start, Day.AddHours(14).AddMinutes(20), Day.AddHours(10), Day.AddHours(18));
+        Assert.Equal(Day.AddHours(15), unalignedTo);
+    }
+
     [Fact]
     public void Hourly_NullCeiling_SaysUnknown_NotThatNoSpanWasServed()
     {

Darling/Darling.Tests/HourlyWindowEdgesTests.cs

@@ -33,16 +33,30 @@ public void AlignedStart_HasNoLeadingSentence()
         Assert.DoesNotContain("partial hour", note, StringComparison.Ordinal);
     }
 
-    [Theory]
-    [InlineData(20)]
-    [InlineData(0)]
-    public void End_CountsTheWholeHourPastAsOf(int minute)
+    [Fact]
+    public void UnalignedEnd_CountsTheWholeHourPastAsOf()
     {
-        var end = Aligned.AddHours(4).AddMinutes(minute);
+        var end = Aligned.AddHours(4).AddMinutes(20);
         var note = HourlyWindowEdges.Note(Aligned, Aligned, end, Aligned.AddHours(9));
         Assert.Contains("up to " + Aligned.AddHours(5).ToString("o"), note, StringComparison.Ordinal);
     }
 
+    /// <summary>The hourly reads stop BEFORE the window end (<c>bucket &lt; end</c>), so an end exactly on the
+    /// hour no longer takes the hour that begins there: the served span ends at the window end and the note
+    /// claims nothing past it. (This case used to be pinned as "counts the whole hour", when the bound was
+    /// <c>bucket &lt;= end</c>.)</summary>
+    [Fact]
+    public void AlignedEnd_StopsAtTheEnd_AndCountsNothingPastAsOf()
+    {
+        var end = Aligned.AddHours(4);
+        var note = HourlyWindowEdges.Note(Aligned, Aligned, end, Aligned.AddHours(9));
+        Assert.DoesNotContain("included whole", note, StringComparison.Ordinal);
+        Assert.DoesNotContain("counted past", note, StringComparison.Ordinal);
+
+        var (_, servedEnd) = HourlyWindowEdges.ServedSpan(Aligned, Aligned, end, Aligned.AddHours(9));
+        Assert.Equal(end, servedEnd);
+    }
+
     [Fact]
     public void EndCutAtTheCeiling_SaysNothingAfterItWasRead()
     {

Darling/Darling.Tests/QueryStoreTrendRoutingTests.cs

@@ -184,7 +184,10 @@ public void RollupTrendSql_ServesTheRollup_AndPartitionsAtTheBoundary(bool withD
         /* The partition seam: rollup buckets strictly BELOW $4 (load-bearing against a refresh landing
            between the probe and the read), raw points at or above it. */
         Assert.Contains("bucket >= $2", sql, StringComparison.Ordinal);
-        Assert.Contains("bucket <= $3", sql, StringComparison.Ordinal);
+        /* The window end is exclusive too: a bucket is stamped at its START, so `bucket <= $3` would take the
+           whole hour that begins at an end falling on the hour. */
+        Assert.Contains("bucket < $3", sql, StringComparison.Ordinal);
+        Assert.DoesNotContain("bucket <= $3", sql, StringComparison.Ordinal);
         Assert.Contains("bucket < $4", sql, StringComparison.Ordinal);
         Assert.Contains("interval_start_time_utc >= $4", sql, StringComparison.Ordinal);