Analysis facts, drill-downs and anomaly counts for blocking and deadlocks count events by when they happened, in both apps

Darling/Darling.Tests/AnomalyTileWindowEndTests.cs

@@ -30,10 +30,10 @@ namespace Darling.Tests;
 public sealed class AnomalyTileWindowEndTests
 {
     /// <summary>The closed spelling of the window end: a boundary sample is read.</summary>
-    private const string ClosedEnd = "collection_time <= $3";
+    private static readonly string[] ClosedEnds = ["collection_time <= $3", "event_time <= $3", "deadlock_time <= $3"];
 
     /// <summary>The open spelling of the window end: a boundary sample is left for the next window.</summary>
-    private const string OpenEnd = "collection_time < $3";
+    private static readonly string[] OpenEnds = ["collection_time < $3", "event_time < $3", "deadlock_time < $3"];
 
     /// <summary>The floor: at least these 11 reads end their window at $3 (three that were already open, eight that were closed). A read added later must use the open end too, which the closed-spelling check above guards.</summary>
     private const int WindowReads = 11;
@@ -45,8 +45,11 @@ public void EveryWindowRead_ExcludesTheWindowEnd(string relative)
     {
         var source = ReadSource(relative);
 
-        Assert.DoesNotContain(ClosedEnd, source, StringComparison.Ordinal);
-        var found = CountOccurrences(source, OpenEnd);
+        foreach (var closed in ClosedEnds)
+            Assert.DoesNotContain(closed, source, StringComparison.Ordinal);
+        /* The blocking and deadlock counts window on the event time (event_time / deadlock_time), the rest on collection_time; all are open-ended. */
+        var found = 0;
+        foreach (var open in OpenEnds) found += CountOccurrences(source, open);
         Assert.True(found >= WindowReads, $"Expected at least {WindowReads} reads ending at $3 with the open spelling, found {found}.");
     }
 

Darling/Darling.Tests/BlockingChainReadsFloorTests.cs

@@ -0,0 +1,25 @@
+using System;
+using PerformanceMonitor.Darling.Analysis;
+using Xunit;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// The two blocking-chain reads window on the report's own time like their siblings, so they also carry the
+/// partition-column floor on <c>collection_time</c> (no upper side: a late-collected report still counts). Without
+/// it every retained chunk of <c>blocked_process_reports</c> is opened to answer a window.
+/// </summary>
+public sealed class BlockingChainReadsFloorTests
+{
+    [Theory]
+    [InlineData("fact")]
+    [InlineData("drill-down")]
+    public void ChainReads_CarryTheCollectionTimeFloor_AndNoUpperCollectionTimeBound(string read)
+    {
+        var sql = read == "fact" ? PgFactCollector.BlockingChainSql : PgDrillDownCollector.ReconstructedChainsSql;
+
+        Assert.Contains("event_time >= $2", sql, StringComparison.Ordinal);
+        Assert.Contains("collection_time >= $4", sql, StringComparison.Ordinal);
+        Assert.DoesNotContain("collection_time <", sql, StringComparison.Ordinal);
+    }
+}

Darling/Darling.Tests/DarlingEventBaselineCoveredDaysTests.cs

@@ -175,14 +175,16 @@ private static string EventBaselineBody(string source, string product)
         return source[start..(end + End.Length)];
     }
 
-    /// <summary>One provider's call of <c>EventBaselineSql</c> from a metric's arm: collector, log, event source, count.</summary>
-    private static (string Collector, string Log, string Events, string Count) ArmCall(string source, string metric, string product)
+    /// <summary>One provider's call of <c>EventBaselineSql</c> from a metric's arm: collector, log, event source, count,
+    /// and the event column when the arm wraps the call in Lite's <c>OnEventTime</c> (null when it does not).</summary>
+    private static (string Collector, string Log, string Events, string Count, string? EventColumn) ArmCall(string source, string metric, string product)
     {
         var match = Regex.Match(
             source,
-            @"MetricNames\." + metric + @" => EventBaselineSql\(""([^""]+)"", ""([^""]+)"", ""([^""]+)"", ""([^""]+)""\)");
+            @"MetricNames\." + metric + @" => (?:OnEventTime\()?EventBaselineSql\(""([^""]+)"", ""([^""]+)"", ""([^""]+)"", ""([^""]+)""\)(?:, ""([^""]+)""\))?");
         Assert.True(match.Success, $"{product}'s {metric} arm no longer calls EventBaselineSql with four literal arguments");
-        return (match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value, match.Groups[4].Value);
+        return (match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value, match.Groups[4].Value,
+            match.Groups[5].Success ? match.Groups[5].Value : null);
     }
 
     /// <summary>
@@ -192,6 +194,11 @@ private static (string Collector, string Log, string Events, string Count) ArmCa
     /// product. What may differ is the four arguments, and those are pinned pairwise: the same collector name in both,
     /// each product's log source the twin of the other's (<c>v_collection_log</c> is Lite's view over the table),
     /// Lite's event source the view over the collector's own table and Darling's the collector's baseline aggregate.
+    ///
+    /// <para>One deliberate difference rides OUTSIDE the shared body: Lite wraps its two arms in <c>OnEventTime</c>,
+    /// which moves the <c>events</c> CTE onto the time the event happened, while Darling's arms read the continuous
+    /// aggregate, which must bucket the hypertable's own <c>collection_time</c>. Pinned per arm, so the wrapper cannot
+    /// quietly vanish from Lite or appear in Darling.</para>
     /// </summary>
     [Fact]
     public void TheTwoProducts_CarryTheSameEventBaselineBody_AndTheSameCollectors()
@@ -227,6 +234,8 @@ public void TheTwoProducts_CarryTheSameEventBaselineBody_AndTheSameCollectors()
             Assert.Equal(aggregate, darlingCall.Events);
             Assert.Equal("COUNT(*)", liteCall.Count);
             Assert.Equal("SUM(event_count)", darlingCall.Count);
+            Assert.Equal(metric == "Blocking" ? "event_time" : "deadlock_time", liteCall.EventColumn);
+            Assert.Null(darlingCall.EventColumn);
         }
     }
 }