Release v3.1.0

.gitattributes

@@ -1,5 +1,8 @@
 * text=auto eol=crlf
 
+# Shell scripts must stay LF (this repo uses Git Bash) — CRLF breaks them.
+*.sh text eol=lf
+
 # Explicit binary markers (prevent text mis-detection / corruption):
 *.png binary
 *.jpg binary

.github/PULL_REQUEST_TEMPLATE.md

@@ -9,7 +9,6 @@ A clear description of the change and why it's being made.
 - [ ] Lite Tests
 - [ ] SQL collection scripts
 - [ ] CLI Installer
-- [ ] GUI Installer
 - [ ] Documentation
 
 ## How was this tested?

.github/workflows/build.yml

@@ -230,7 +230,9 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           VERSION: ${{ steps.version.outputs.VERSION }}
         run: |
-          dotnet tool install -g vpk
+          # Pin vpk to the Velopack library version (keep in sync with the Velopack
+          # PackageReference in Dashboard.csproj / PerformanceMonitorLite.csproj).
+          dotnet tool install -g vpk --version 1.2.0
           New-Item -ItemType Directory -Force -Path releases/velopack-dashboard
           New-Item -ItemType Directory -Force -Path releases/velopack-lite
 

Dashboard.Tests/AlertDeliveryModeOverrideTests.cs

@@ -0,0 +1,46 @@
+/*
+ * Performance Monitor Dashboard
+ * Copyright (c) 2026 Darling Data, LLC
+ * Licensed under the MIT License - see LICENSE file for details
+ */
+
+using System.Text.Json;
+using PerformanceMonitor.Notifications;
+using PerformanceMonitorDashboard.Models;
+using Xunit;
+
+namespace PerformanceMonitorDashboard.Tests;
+
+/// <summary>
+/// #1236 per-server alert delivery override persists on <see cref="ServerConnection"/> (servers.json,
+/// same WriteIndented options ServerManager uses). A pre-#1236 file with no field inherits the global.
+/// The shared precedence rule (<see cref="AlertDeliveryModeResolver"/>) is covered in Lite.Tests.
+/// </summary>
+public class AlertDeliveryModeOverrideTests
+{
+    private static readonly JsonSerializerOptions s_jsonOptions = new() { WriteIndented = true };
+
+    [Fact]
+    public void Override_RoundTripsThroughJson()
+    {
+        var server = new ServerConnection { ServerName = "S1", AlertDeliveryModeOverride = AlertNotificationMode.PerEvent };
+        var back = JsonSerializer.Deserialize<ServerConnection>(JsonSerializer.Serialize(server, s_jsonOptions), s_jsonOptions);
+        Assert.Equal(AlertNotificationMode.PerEvent, back!.AlertDeliveryModeOverride);
+    }
+
+    [Fact]
+    public void NullOverride_RoundTripsAsNull()
+    {
+        var server = new ServerConnection { ServerName = "S1", AlertDeliveryModeOverride = null };
+        var back = JsonSerializer.Deserialize<ServerConnection>(JsonSerializer.Serialize(server, s_jsonOptions), s_jsonOptions);
+        Assert.Null(back!.AlertDeliveryModeOverride);
+    }
+
+    [Fact]
+    public void LegacyServersJson_WithoutField_InheritsGlobal()
+    {
+        // A servers.json written before #1236 has no AlertDeliveryModeOverride property -> null -> inherit.
+        var back = JsonSerializer.Deserialize<ServerConnection>("{\"ServerName\":\"S1\",\"DisplayName\":\"S1\"}", s_jsonOptions);
+        Assert.Null(back!.AlertDeliveryModeOverride);
+    }
+}

Dashboard.Tests/AlertMetricClassifierTests.cs

@@ -0,0 +1,80 @@
+using PerformanceMonitor.Common;
+using Xunit;
+
+namespace PerformanceMonitorDashboard.Tests;
+
+/// <summary>
+/// #1225: the shared metric-name classifier that both apps' Alert History grids and the Dashboard
+/// sidebar Alert badge rely on. Locks in the resolution suffix set (Cleared/Resolved/Restored) —
+/// the "Restored" cases (Capture/Server Restored) are the ones the old duplicated inline copies
+/// missed — plus the critical (Deadlock/Poison) and warning buckets, over the metric names the
+/// alert engines actually emit.
+/// </summary>
+public class AlertMetricClassifierTests
+{
+    [Theory]
+    [InlineData("Blocking Cleared")]
+    [InlineData("Deadlocks Cleared")]
+    [InlineData("Poison Waits Cleared")]
+    [InlineData("Long-Running Queries Cleared")]
+    [InlineData("Long-Running Jobs Cleared")]
+    [InlineData("CPU Resolved")]
+    [InlineData("TempDB Space Resolved")]
+    [InlineData("Volume Free Space Resolved")]
+    [InlineData("Capture Restored")]
+    [InlineData("Server Restored")]
+    public void IsResolution_True_ForEveryResolutionNotice(string metric)
+    {
+        Assert.True(AlertMetricClassifier.IsResolution(metric));
+        Assert.False(AlertMetricClassifier.IsWarning(metric)); // a resolution notice is never a warning
+    }
+
+    [Theory]
+    [InlineData("Blocking Detected")]
+    [InlineData("Deadlocks Detected")]
+    [InlineData("High CPU")]
+    [InlineData("Poison Wait")]
+    [InlineData("Long-Running Query")]
+    [InlineData("TempDB Space")]
+    [InlineData("Volume Free Space")]
+    [InlineData("Long-Running Job")]
+    [InlineData("Failed Agent Job")]
+    [InlineData("Capture Down")]
+    [InlineData("Server Unreachable")]
+    public void IsResolution_False_ForActionableAlerts(string metric)
+    {
+        Assert.False(AlertMetricClassifier.IsResolution(metric));
+    }
+
+    [Theory]
+    [InlineData("Deadlocks Detected")]
+    [InlineData("Poison Wait")]
+    public void IsCritical_True_ForDeadlockAndPoison(string metric)
+    {
+        Assert.True(AlertMetricClassifier.IsCritical(metric));
+    }
+
+    [Theory]
+    [InlineData("Blocking Detected")]
+    [InlineData("High CPU")]
+    [InlineData("Long-Running Query")]
+    public void IsWarning_True_ForOrdinaryActionableAlerts(string metric)
+    {
+        Assert.True(AlertMetricClassifier.IsWarning(metric));
+        Assert.False(AlertMetricClassifier.IsCritical(metric));
+        Assert.False(AlertMetricClassifier.IsResolution(metric));
+    }
+
+    [Fact]
+    public void Classifiers_AreFalse_ForNullOrEmpty()
+    {
+        Assert.False(AlertMetricClassifier.IsResolution(null));
+        Assert.False(AlertMetricClassifier.IsResolution(""));
+        Assert.False(AlertMetricClassifier.IsCritical(null));
+        Assert.False(AlertMetricClassifier.IsCritical(""));
+        // IsWarning is the complement of the two signals, so an absent name defaults to warning —
+        // matching the long-standing display behavior this classifier replaced.
+        Assert.True(AlertMetricClassifier.IsWarning(null));
+        Assert.True(AlertMetricClassifier.IsWarning(""));
+    }
+}

Dashboard.Tests/BlockingChainLayoutTests.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using PerformanceMonitor.Common;
+using Xunit;
+
+namespace PerformanceMonitorDashboard.Tests;
+
+/// <summary>
+/// Pure unit tests for the shared <see cref="BlockingChainLayout"/> — determinism and no-overlap of the
+/// left-to-right tree/forest placement. No WPF (a constant measure callback supplies node heights).
+/// </summary>
+public class BlockingChainLayoutTests
+{
+    private const double H = 100.0;
+    private static double Measure(BlockingChainNode _) => H;
+
+    private static BlockingChainNode Node(int spid, params BlockingChainNode[] children) =>
+        new() { Spid = spid, Children = children.ToList() };
+
+    // A representative forest: a multi-level tree plus a second apex tree.
+    private static IReadOnlyList<BlockingChainNode> SampleForest() => new[]
+    {
+        Node(1,
+            Node(2, Node(4), Node(5)),
+            Node(3)),
+        Node(10,
+            Node(11),
+            Node(12, Node(13)))
+    };
+
+    private static IEnumerable<BlockingChainNode> Flatten(IReadOnlyList<BlockingChainNode> roots)
+    {
+        foreach (var r in roots)
+            foreach (var n in FlattenOne(r))
+                yield return n;
+    }
+
+    private static IEnumerable<BlockingChainNode> FlattenOne(BlockingChainNode n)
+    {
+        yield return n;
+        foreach (var c in n.Children)
+            foreach (var d in FlattenOne(c))
+                yield return d;
+    }
+
+    [Fact]
+    public void Layout_IsDeterministic_AcrossIdenticalForests()
+    {
+        var a = SampleForest();
+        var b = SampleForest();
+
+        BlockingChainLayout.Layout(a, Measure);
+        BlockingChainLayout.Layout(b, Measure);
+
+        var fa = Flatten(a).ToList();
+        var fb = Flatten(b).ToList();
+        Assert.Equal(fa.Count, fb.Count);
+        for (int i = 0; i < fa.Count; i++)
+        {
+            Assert.Equal(fa[i].Spid, fb[i].Spid);
+            Assert.Equal(fa[i].X, fb[i].X);
+            Assert.Equal(fa[i].Y, fb[i].Y);
+        }
+    }
+
+    [Fact]
+    public void Layout_PlacesDepthByColumn()
+    {
+        var roots = SampleForest();
+        BlockingChainLayout.Layout(roots, Measure);
+
+        double depth0 = BlockingChainLayout.Padding;
+        double depth1 = BlockingChainLayout.Padding + BlockingChainLayout.HorizontalSpacing;
+        double depth2 = BlockingChainLayout.Padding + 2 * BlockingChainLayout.HorizontalSpacing;
+
+        Assert.Equal(depth0, roots[0].X);                 // apex
+        Assert.Equal(depth1, roots[0].Children[0].X);     // direct victim
+        Assert.Equal(depth2, roots[0].Children[0].Children[0].X); // grand-victim
+    }
+
+    [Fact]
+    public void Layout_ProducesNoOverlappingNodes()
+    {
+        var roots = SampleForest();
+        BlockingChainLayout.Layout(roots, Measure);
+
+        var nodes = Flatten(roots).ToList();
+        const double w = BlockingChainLayout.NodeWidth;
+        const double eps = 0.5;
+
+        for (int i = 0; i < nodes.Count; i++)
+        {
+            for (int j = i + 1; j < nodes.Count; j++)
+            {
+                var a = nodes[i];
+                var b = nodes[j];
+                bool overlapX = a.X < b.X + w - eps && b.X < a.X + w - eps;
+                bool overlapY = a.Y < b.Y + H - eps && b.Y < a.Y + H - eps;
+                Assert.False(overlapX && overlapY,
+                    $"SPID {a.Spid} ({a.X},{a.Y}) overlaps SPID {b.Spid} ({b.X},{b.Y})");
+            }
+        }
+    }
+
+    [Fact]
+    public void Layout_ReturnsPositiveExtentCoveringAllNodes()
+    {
+        var roots = SampleForest();
+        var (width, height) = BlockingChainLayout.Layout(roots, Measure);
+
+        Assert.True(width > 0);
+        Assert.True(height > 0);
+
+        var nodes = Flatten(roots).ToList();
+        Assert.True(width >= nodes.Max(n => n.X) + BlockingChainLayout.NodeWidth);
+        Assert.True(height >= nodes.Max(n => n.Y) + H);
+    }
+
+    [Fact]
+    public void Layout_EmptyForest_ReturnsPaddingExtent()
+    {
+        var (width, height) = BlockingChainLayout.Layout(Array.Empty<BlockingChainNode>(), Measure);
+        Assert.True(width > 0);   // padding only
+        Assert.True(height > 0);
+    }
+}