Release 3.6.0

.gitattributes

@@ -16,3 +16,14 @@
 *.parquet binary
 *.zip binary
 *.duckdb binary
+
+# A captured PostgreSQL log is a FIXTURE of real bytes: the parser keys on the exact line endings
+# and the tab-indented continuation, so line-ending normalisation would change what it is evidence of.
+Darling/Darling.Tests/Fixtures/auto_explain_real_block.txt -text
+
+# The PostgreSQL verification rig runs INSIDE Linux containers. A Dockerfile whose RUN lines carry a
+# trailing CR breaks the shell that executes them, and the seed is fed to psql in the container the same
+# way - so these keep LF regardless of the repo-wide eol=crlf default.
+tools/pg-verification-rig/Dockerfile text eol=lf
+tools/pg-verification-rig/*.yml text eol=lf
+tools/pg-verification-rig/*.sql text eol=lf

Darling/Darling.Tests/AgAlertPolicyTests.cs

@@ -6,6 +6,7 @@
  * Licensed under the MIT License. See LICENSE file in the project root for full license information.
  */
 
+using System;
 using PerformanceMonitor.Common;
 using Xunit;
 
@@ -81,6 +82,102 @@ public void DecideConnection_AlreadyDisconnectedAtFirstSighting_StaysSilent_ButI
         Assert.Equal(AgConnectionDecision.Reconnected, AgAlertPolicy.DecideConnection("DISCONNECTED", "CONNECTED"));
     }
 
+    /* ---------------- #2426: the disconnect re-fire ---------------- */
+
+    private static readonly DateTime Noon = new(2026, 8, 20, 12, 0, 0, DateTimeKind.Utc);
+
+    [Theory]
+    [InlineData("CONNECTED", "DISCONNECTED", AgConnectionDecision.Disconnected)]
+    [InlineData("DISCONNECTED", "CONNECTED", AgConnectionDecision.Reconnected)]
+    [InlineData("DISCONNECTED", "DISCONNECTED", AgConnectionDecision.None)]
+    [InlineData("CONNECTED", "CONNECTED", AgConnectionDecision.None)]
+    [InlineData(null, "DISCONNECTED", AgConnectionDecision.None)]
+    [InlineData("CONNECTED", null, AgConnectionDecision.None)]
+    public void DecideConnection_RefireOff_IsTheEdgeOnlyOverloadExactly(
+        string? previous, string? current, AgConnectionDecision expected)
+    {
+        /* The shipped default, and the whole matrix rather than one case: null, zero and a negative all
+           mean OFF, and off has to be byte-for-byte the two-argument behavior or an upgrade would start
+           re-alerting on a knob nobody set. */
+        Assert.Equal(expected, AgAlertPolicy.DecideConnection(previous, current, null, null, Noon));
+        Assert.Equal(expected, AgAlertPolicy.DecideConnection(previous, current, TimeSpan.Zero, null, Noon));
+        Assert.Equal(expected, AgAlertPolicy.DecideConnection(previous, current, TimeSpan.FromMinutes(-5), null, Noon));
+    }
+
+    [Fact]
+    public void DecideConnection_StillDisconnected_WaitsOutTheWindow_ThenSaysItAgain()
+    {
+        var refire = TimeSpan.FromMinutes(10);
+
+        /* Announced at noon: inside the window there is nothing new to say. */
+        Assert.Equal(
+            AgConnectionDecision.None,
+            AgAlertPolicy.DecideConnection("DISCONNECTED", "DISCONNECTED", refire, Noon, Noon.AddMinutes(9)));
+
+        /* At the boundary, and still hours later — the point of the knob is that a week-long outage does
+           not read like a blip. */
+        Assert.Equal(
+            AgConnectionDecision.StillDisconnected,
+            AgAlertPolicy.DecideConnection("DISCONNECTED", "DISCONNECTED", refire, Noon, Noon.AddMinutes(10)));
+        Assert.Equal(
+            AgConnectionDecision.StillDisconnected,
+            AgAlertPolicy.DecideConnection("DISCONNECTED", "DISCONNECTED", refire, Noon, Noon.AddHours(8)));
+    }
+
+    [Fact]
+    public void DecideConnection_ARealEdgeOutranksARefire()
+    {
+        var refire = TimeSpan.FromMinutes(10);
+
+        /* The edge that OPENS the outage announces as Disconnected even though the window is trivially due
+           on it, or the caller would have two reasons to announce the same sweep. */
+        Assert.Equal(
+            AgConnectionDecision.Disconnected,
+            AgAlertPolicy.DecideConnection("CONNECTED", "DISCONNECTED", refire, null, Noon));
+
+        /* And a recovery is a recovery whatever the clock says. */
+        Assert.Equal(
+            AgConnectionDecision.Reconnected,
+            AgAlertPolicy.DecideConnection("DISCONNECTED", "CONNECTED", refire, Noon.AddHours(-9), Noon));
+    }
+
+    [Fact]
+    public void DecideConnection_NoStampIsDueNow_SoARestartMidOutageStillReAnnounces()
+    {
+        var refire = TimeSpan.FromMinutes(10);
+
+        /* Both apps hold this edge state in memory, so a restart during a week-long outage sees a replica
+           already DISCONNECTED with no record of it ever having been announced. Rule 1's silent baseline
+           would make that silence permanent, which is the exact failure the knob exists to prevent — so
+           with re-fire ON, and only then, a first sighting announces. */
+        Assert.Equal(
+            AgConnectionDecision.StillDisconnected,
+            AgAlertPolicy.DecideConnection(null, "DISCONNECTED", refire, null, Noon));
+        Assert.Equal(
+            AgConnectionDecision.StillDisconnected,
+            AgAlertPolicy.DecideConnection("DISCONNECTED", "DISCONNECTED", refire, null, Noon));
+
+        /* With it off, rule 1 governs unchanged. */
+        Assert.Equal(
+            AgConnectionDecision.None,
+            AgAlertPolicy.DecideConnection(null, "DISCONNECTED", null, null, Noon));
+    }
+
+    [Fact]
+    public void DecideConnection_ARefireStillNeedsAnExactDisconnected()
+    {
+        var refire = TimeSpan.FromMinutes(10);
+
+        /* Same rule the edge follows, and it matters more here: a re-fire pages repeatedly, so a state
+           string the product never learned to interpret must not become a standing page. */
+        Assert.Equal(
+            AgConnectionDecision.None,
+            AgAlertPolicy.DecideConnection("SOMETHING_NEW", "SOMETHING_NEW", refire, null, Noon));
+        Assert.Equal(
+            AgConnectionDecision.None,
+            AgAlertPolicy.DecideConnection("CONNECTED", null, refire, null, Noon));
+    }
+
     /* ---------------- suspension ---------------- */
 
     [Theory]

Darling/Darling.Tests/AlertEngineTests.cs

@@ -1052,6 +1052,12 @@ public async Task TempDb_FiresAtThreshold_AndResolutionCarriesTheCurrentPercent(
         h.Settings.TempDbSpaceEnabled = true;
         var engine = h.Build();
 
+        /* #2515: 1000 MB total and NO MaxSizeMb, which is deliberate and stays that way. The fixture predates
+           the ceiling, so it describes a tempdb whose cap was never measured — and that is exactly the case
+           where the denominator remains the allocation. It does NOT imply a 1000 MB cap; if it did, this pin
+           would have to move, and the fact that it does not is the guarantee that no existing on-prem or RDS
+           target with an unlimited (or uncollected) tempdb sees its number change. The capped case gets its
+           own test below rather than being folded in here. */
         h.Adapter.TempDb = new TempDbSpaceInfo { TotalReservedMb = 800, UnallocatedMb = 200 }; /* 80% used */
         await engine.EvaluateServerAsync(Harness.Snapshot());
         var fired = Assert.Single(h.Deliverer.Outcomes);
@@ -1066,6 +1072,36 @@ public async Task TempDb_FiresAtThreshold_AndResolutionCarriesTheCurrentPercent(
         Assert.Equal("SRV-A: tempdb usage back to 20%", resolution.Message);  /* :461,:464 */
     }
 
+    /// <summary>
+    /// #2515, through the ENGINE rather than the arithmetic: the Azure shape from the issue must not fire, and
+    /// the same allocation without a ceiling must. Same 59.75 MB of reserved tempdb in both, same 80% default —
+    /// the only difference is whether the collector could see how far the files are allowed to grow.
+    ///
+    /// <para>This is the assertion the whole change exists for. <see cref="TempDbCeilingStoreTests"/> proves
+    /// the arithmetic and the store round-trip; this proves the alert engine's decision follows it, which is
+    /// what actually pages someone.</para>
+    /// </summary>
+    [Fact]
+    public async Task TempDb_TheAzureCeiling_SuppressesTheAlert_ThatTheAllocationWouldFire()
+    {
+        var h = new Harness();
+        h.Settings.TempDbSpaceEnabled = true;
+        Assert.Equal(80, h.Settings.TempDbSpaceThresholdPercent);
+        var engine = h.Build();
+
+        /* GP_S_Gen5_2 with one ~57 MB #temp table: 62.44 MB allocated, 65,536 MB of headroom behind it. */
+        h.Adapter.TempDb = new TempDbSpaceInfo { TotalReservedMb = 59.75, UnallocatedMb = 2.69, MaxSizeMb = 65_536 };
+        await engine.EvaluateServerAsync(Harness.Snapshot());
+        Assert.Empty(h.Deliverer.Outcomes);
+
+        /* The identical snapshot with the ceiling unmeasured is the pre-#2515 reading, and it pages. */
+        h.Adapter.TempDb = new TempDbSpaceInfo { TotalReservedMb = 59.75, UnallocatedMb = 2.69 };
+        await engine.EvaluateServerAsync(Harness.Snapshot());
+        var fired = Assert.Single(h.Deliverer.Outcomes);
+        Assert.Equal("tempdb Space", fired.MetricName);
+        Assert.Equal("96% used (60 MB)", fired.CurrentValue);
+    }
+
     /* ---------------- low disk ---------------- */
 
     [Fact]