Feature/add alert filter by database

Dashboard/MainWindow.xaml.cs

@@ -26,6 +26,7 @@
 using PerformanceMonitorDashboard.Services;
 using System.ComponentModel;
 using System.Windows.Data;
+using System.Xml.Linq;
 
 namespace PerformanceMonitorDashboard
 {
@@ -1065,7 +1066,7 @@ private async Task CheckAllServerAlertsAsync()
                     var connectionString = server.GetConnectionString(_credentialService);
                     var databaseService = new DatabaseService(connectionString);
                     var connStatus = _serverManager.GetConnectionStatus(server.Id);
-                    var health = await databaseService.GetAlertHealthAsync(connStatus.SqlEngineEdition, prefs.LongRunningQueryThresholdMinutes, prefs.LongRunningJobMultiplier, prefs.LongRunningQueryMaxResults, prefs.LongRunningQueryExcludeSpServerDiagnostics, prefs.LongRunningQueryExcludeWaitFor, prefs.LongRunningQueryExcludeBackups, prefs.LongRunningQueryExcludeMiscWaits);
+                    var health = await databaseService.GetAlertHealthAsync(connStatus.SqlEngineEdition, prefs.LongRunningQueryThresholdMinutes, prefs.LongRunningJobMultiplier, prefs.LongRunningQueryMaxResults, prefs.LongRunningQueryExcludeSpServerDiagnostics, prefs.LongRunningQueryExcludeWaitFor, prefs.LongRunningQueryExcludeBackups, prefs.LongRunningQueryExcludeMiscWaits, prefs.AlertExcludedDatabases);
 
                     if (health.IsOnline)
                     {
@@ -1124,7 +1125,7 @@ private async Task EvaluateAlertConditionsAsync(
                         $"{(int)health.TotalBlocked} session(s), longest {(int)health.LongestBlockedSeconds}s",
                         $"{prefs.BlockingThresholdSeconds}s", true, "tray");
 
-                    var blockingContext = await BuildBlockingContextAsync(databaseService);
+                    var blockingContext = await BuildBlockingContextAsync(databaseService, prefs.AlertExcludedDatabases);
 
                     await _emailAlertService.TrySendAlertEmailAsync(
                         "Blocking Detected",
@@ -1152,8 +1153,13 @@ await _emailAlertService.TrySendAlertEmailAsync(
             }
             _previousDeadlockCounts[serverId] = health.DeadlockCount;
 
+            /* Use the database-filtered count when excluded databases are configured,
+               matching how blocking alerts filter before the threshold check.
+               Falls back to the raw delta when no databases are excluded. */
+            var effectiveDeadlockDelta = health.FilteredDeadlockCount ?? deadlockDelta;
+
             bool deadlocksExceeded = prefs.NotifyOnDeadlock
-                && deadlockDelta >= prefs.DeadlockThreshold;
+                && effectiveDeadlockDelta >= prefs.DeadlockThreshold;
 
             if (deadlocksExceeded)
             {
@@ -1162,19 +1168,19 @@ await _emailAlertService.TrySendAlertEmailAsync(
                 {
                     _notificationService?.ShowDeadlockNotification(
                         serverName,
-                        (int)deadlockDelta);
+                        (int)effectiveDeadlockDelta);
                     _lastDeadlockAlert[serverId] = now;
 
                     _emailAlertService.RecordAlert(serverId, serverName, "Deadlocks Detected",
-                        deadlockDelta.ToString(),
+                        effectiveDeadlockDelta.ToString(),
                         prefs.DeadlockThreshold.ToString(), true, "tray");
 
-                    var deadlockContext = await BuildDeadlockContextAsync(databaseService);
+                    var deadlockContext = await BuildDeadlockContextAsync(databaseService, prefs.AlertExcludedDatabases);
 
                     await _emailAlertService.TrySendAlertEmailAsync(
                         "Deadlocks Detected",
                         serverName,
-                        deadlockDelta.ToString(),
+                        effectiveDeadlockDelta.ToString(),
                         prefs.DeadlockThreshold.ToString(),
                         serverId,
                         deadlockContext);
@@ -1264,15 +1270,23 @@ await _emailAlertService.TrySendAlertEmailAsync(
             }
 
             /* Long-running query alerts */
+            var lrqList = health.LongRunningQueries;
+            if (prefs.AlertExcludedDatabases.Count > 0)
+                lrqList = lrqList
+                    .Where(q => string.IsNullOrEmpty(q.DatabaseName) ||
+                        !prefs.AlertExcludedDatabases.Any(e =>
+                            string.Equals(e, q.DatabaseName, StringComparison.OrdinalIgnoreCase)))
+                    .ToList();
+
             bool longRunningTriggered = prefs.NotifyOnLongRunningQueries
-                && health.LongRunningQueries.Count > 0;
+                && lrqList.Count > 0;
 
             if (longRunningTriggered)
             {
                 _activeLongRunningQueryAlert[serverId] = true;
                 if (!_lastLongRunningQueryAlert.TryGetValue(serverId, out var lastAlert) || (now - lastAlert) >= AlertCooldown)
                 {
-                    var worst = health.LongRunningQueries[0];
+                    var worst = lrqList[0];
                     var elapsedMinutes = worst.ElapsedSeconds / 60;
                     var preview = Truncate(worst.QueryText, 80);
                     _notificationService?.ShowLongRunningQueryNotification(
@@ -1283,12 +1297,12 @@ await _emailAlertService.TrySendAlertEmailAsync(
                         $"Session #{worst.SessionId} running {elapsedMinutes}m",
                         $"{prefs.LongRunningQueryThresholdMinutes}m", true, "tray");
 
-                    var lrqContext = BuildLongRunningQueryContext(health.LongRunningQueries);
+                    var lrqContext = BuildLongRunningQueryContext(lrqList);
 
                     await _emailAlertService.TrySendAlertEmailAsync(
                         "Long-Running Query",
                         serverName,
-                        $"{health.LongRunningQueries.Count} query(s), longest {elapsedMinutes}m",
+                        $"{lrqList.Count} query(s), longest {elapsedMinutes}m",
                         $"{prefs.LongRunningQueryThresholdMinutes}m",
                         serverId,
                         lrqContext);
@@ -1388,13 +1402,23 @@ private static string Truncate(string text, int maxLength = 300)
             return text.Length <= maxLength ? text : text.Substring(0, maxLength) + "...";
         }
 
-        private static async Task<AlertContext?> BuildBlockingContextAsync(DatabaseService databaseService)
+        private static async Task<AlertContext?> BuildBlockingContextAsync(DatabaseService databaseService, List<string>? excludedDatabases = null)
         {
             try
             {
                 var events = await databaseService.GetBlockingEventsAsync(hoursBack: 1);
                 if (events == null || events.Count == 0) return null;
 
+                if (excludedDatabases != null && excludedDatabases.Count > 0)
+                {
+                    events = events
+                        .Where(e => string.IsNullOrEmpty(e.DatabaseName) ||
+                            !excludedDatabases.Any(ex =>
+                                string.Equals(ex, e.DatabaseName, StringComparison.OrdinalIgnoreCase)))
+                        .ToList();
+                    if (events.Count == 0) return null;
+                }
+
                 var context = new AlertContext();
                 var firstXml = (string?)null;
 
@@ -1436,13 +1460,20 @@ private static string Truncate(string text, int maxLength = 300)
             }
         }
 
-        private static async Task<AlertContext?> BuildDeadlockContextAsync(DatabaseService databaseService)
+        private static async Task<AlertContext?> BuildDeadlockContextAsync(DatabaseService databaseService, List<string>? excludedDatabases = null)
         {
             try
             {
                 var deadlocks = await databaseService.GetDeadlocksAsync(hoursBack: 1);
                 if (deadlocks == null || deadlocks.Count == 0) return null;
 
+                if (excludedDatabases != null && excludedDatabases.Count > 0)
+                {
+                    deadlocks = deadlocks
+                        .Where(d => !IsDeadlockExcluded(d, excludedDatabases))
+                        .ToList();
+                }
+
                 var context = new AlertContext();
                 var firstGraph = (string?)null;
 
@@ -1496,6 +1527,29 @@ private static string Truncate(string text, int maxLength = 300)
             }
         }
 
+        /// <summary>
+        /// Returns true if a deadlock should be excluded based on the deadlock graph XML.
+        /// A deadlock is only excluded when ALL process nodes have a currentdbname in the excluded list.
+        /// Cross-database deadlocks involving any non-excluded database will still be reported.
+        /// </summary>
+        private static bool IsDeadlockExcluded(DeadlockItem deadlock, List<string> excludedDatabases)
+        {
+            if (string.IsNullOrEmpty(deadlock.DeadlockGraph)) return false;
+            try
+            {
+                var doc = XElement.Parse(deadlock.DeadlockGraph);
+                var dbNames = doc.Descendants("process")
+                    .Select(p => p.Attribute("currentdbname")?.Value)
+                    .Where(n => !string.IsNullOrEmpty(n))
+                    .Cast<string>()
+                    .ToList();
+                if (dbNames.Count == 0) return false;
+                return dbNames.All(db => excludedDatabases.Any(e =>
+                    string.Equals(e, db, StringComparison.OrdinalIgnoreCase)));
+            }
+            catch { return false; }
+        }
+
         private static AlertContext? BuildPoisonWaitContext(List<PoisonWaitDelta> triggeredWaits)
         {
             if (triggeredWaits.Count == 0) return null;

Dashboard/Models/AlertHealthResult.cs

@@ -22,6 +22,15 @@ public class AlertHealthResult
         public long TotalBlocked { get; set; }
         public decimal LongestBlockedSeconds { get; set; }
         public long DeadlockCount { get; set; }
+
+        /// <summary>
+        /// Deadlock count for the alert window filtered by excluded databases.
+        /// Sourced from collect.blocking_deadlock_stats when excluded databases are configured.
+        /// When set, EvaluateAlertConditionsAsync uses this instead of the raw delta
+        /// from the server-wide performance counter, matching how blocking alerts filter.
+        /// Null when no databases are excluded (fall back to raw delta).
+        /// </summary>
+        public long? FilteredDeadlockCount { get; set; }
         public List<PoisonWaitDelta> PoisonWaits { get; set; } = new();
         public List<LongRunningQueryInfo> LongRunningQueries { get; set; } = new();
         public TempDbSpaceInfo? TempDbSpace { get; set; }

Dashboard/Models/UserPreferences.cs

@@ -125,6 +125,9 @@ private static string GetDefaultCsvSeparator()
         // Update check settings
         public bool CheckForUpdatesOnStartup { get; set; } = true;
 
+        // Alert database exclusions
+        public List<string> AlertExcludedDatabases { get; set; } = new();
+
         // Alert suppression (persisted)
         public List<string> SilencedServers { get; set; } = new();
         public List<string> SilencedServerTabs { get; set; } = new();

Dashboard/Services/DatabaseService.NocHealth.cs

@@ -9,6 +9,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Data.SqlClient;
 using PerformanceMonitorDashboard.Helpers;
@@ -129,7 +130,8 @@ public async Task<AlertHealthResult> GetAlertHealthAsync(
             bool excludeSpServerDiagnostics = true,
             bool excludeWaitFor = true,
             bool excludeBackups = true,
-            bool excludeMiscWaits = true)
+            bool excludeMiscWaits = true,
+            IReadOnlyList<string>? excludedDatabases = null)
         {
             var result = new AlertHealthResult();
 
@@ -141,14 +143,20 @@ public async Task<AlertHealthResult> GetAlertHealthAsync(
                 result.IsOnline = true;
 
                 var cpuTask = GetCpuPercentAsync(connection, engineEdition);
-                var blockingTask = GetBlockingValuesAsync(connection);
+                var blockingTask = GetBlockingValuesAsync(connection, excludedDatabases ?? Array.Empty<string>());
                 var deadlockTask = GetDeadlockCountAsync(connection);
+                var filteredDeadlockTask = excludedDatabases?.Count > 0
+                    ? GetFilteredDeadlockCountAsync(connection, excludedDatabases)
+                    : null;
                 var poisonWaitTask = GetPoisonWaitDeltasAsync(connection);
                 var longRunningTask = GetLongRunningQueriesAsync(connection, longRunningQueryThresholdMinutes, longRunningQueryMaxResults, excludeSpServerDiagnostics, excludeWaitFor, excludeBackups, excludeMiscWaits);
                 var tempDbTask = GetTempDbSpaceAsync(connection);
                 var anomalousJobTask = GetAnomalousJobsAsync(connection, longRunningJobMultiplier);
 
-                await Task.WhenAll(cpuTask, blockingTask, deadlockTask, poisonWaitTask, longRunningTask, tempDbTask, anomalousJobTask);
+                var allTasks = filteredDeadlockTask != null
+                    ? new Task[] { cpuTask, blockingTask, deadlockTask, filteredDeadlockTask, poisonWaitTask, longRunningTask, tempDbTask, anomalousJobTask }
+                    : new Task[] { cpuTask, blockingTask, deadlockTask, poisonWaitTask, longRunningTask, tempDbTask, anomalousJobTask };
+                await Task.WhenAll(allTasks);
 
                 var cpuResult = await cpuTask;
                 result.CpuPercent = cpuResult.SqlCpu;
@@ -159,6 +167,8 @@ public async Task<AlertHealthResult> GetAlertHealthAsync(
                 result.LongestBlockedSeconds = blockingResult.LongestBlockedSeconds;
 
                 result.DeadlockCount = await deadlockTask;
+                if (filteredDeadlockTask != null)
+                    result.FilteredDeadlockCount = await filteredDeadlockTask;
                 result.PoisonWaits = await poisonWaitTask;
                 result.LongRunningQueries = await longRunningTask;
                 result.TempDbSpace = await tempDbTask;
@@ -177,22 +187,32 @@ public async Task<AlertHealthResult> GetAlertHealthAsync(
         /// Returns blocking values directly (without writing to a ServerHealthStatus).
         /// Used by GetAlertHealthAsync for lightweight alert checks.
         /// </summary>
-        private async Task<(long TotalBlocked, decimal LongestBlockedSeconds)> GetBlockingValuesAsync(SqlConnection connection)
+        private async Task<(long TotalBlocked, decimal LongestBlockedSeconds)> GetBlockingValuesAsync(SqlConnection connection, IReadOnlyList<string> excludedDatabases)
         {
-            const string query = @"SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+            var dbFilter = "";
+            var dbParams = new List<string>();
+            for (int i = 0; i < excludedDatabases.Count; i++)
+                dbParams.Add($"@exdb{i}");
+            if (dbParams.Count > 0)
+                dbFilter = $"AND DB_NAME(s.dbid) NOT IN ({string.Join(", ", dbParams)})";
+
+            var query = $@"SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 
                 SELECT
                     total_blocked = COUNT_BIG(*),
                     longest_blocked_seconds = ISNULL(MAX(s.waittime), 0) / 1000.0
                 FROM sys.sysprocesses AS s
                 WHERE s.blocked <> 0
                 AND   s.lastwaittype LIKE N'LCK%'
+                {dbFilter}
                 OPTION(MAXDOP 1, RECOMPILE);";
 
             try
             {
                 using var cmd = new SqlCommand(query, connection);
                 cmd.CommandTimeout = 10;
+                for (int i = 0; i < excludedDatabases.Count; i++)
+                    cmd.Parameters.AddWithValue($"@exdb{i}", excludedDatabases[i]);
                 using var reader = await cmd.ExecuteReaderAsync();
 
                 if (await reader.ReadAsync())
@@ -431,6 +451,49 @@ WHERE pc.counter_name LIKE N'Number of Deadlocks/sec%'
             }
         }
 
+        /// <summary>
+        /// Counts recent deadlocks from collect.blocking_deadlock_stats, excluding the specified databases.
+        /// Uses a 5-minute window matching the alert cooldown so each cooldown period
+        /// reflects only deadlocks from non-excluded databases.
+        /// This is the filtered equivalent of GetDeadlockCountAsync, which reads from
+        /// sys.dm_os_performance_counters and cannot be filtered by database.
+        /// </summary>
+        private async Task<long?> GetFilteredDeadlockCountAsync(SqlConnection connection, IReadOnlyList<string> excludedDatabases)
+        {
+            var dbFilter = "";
+            var dbParams = new List<string>();
+            for (int i = 0; i < excludedDatabases.Count; i++)
+                dbParams.Add($"@exdb{i}");
+            if (dbParams.Count > 0)
+                dbFilter = $"AND bds.database_name NOT IN ({string.Join(", ", dbParams)})";
+
+            var query = $@"SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+                SELECT
+                    filtered_deadlock_count =
+                        COALESCE(SUM(bds.deadlock_count_delta), 0)
+                FROM collect.blocking_deadlock_stats AS bds
+                WHERE bds.collection_time >= DATEADD(MINUTE, -5, SYSUTCDATETIME())
+                AND   bds.deadlock_count_delta IS NOT NULL
+                {dbFilter}
+                OPTION(MAXDOP 1, RECOMPILE);";
+
+            try
+            {
+                using var cmd = new SqlCommand(query, connection);
+                cmd.CommandTimeout = 10;
+                for (int i = 0; i < excludedDatabases.Count; i++)
+                    cmd.Parameters.AddWithValue($"@exdb{i}", excludedDatabases[i]);
+                var result = await cmd.ExecuteScalarAsync();
+                return result is long l ? l : (result is int i2 ? (long)i2 : 0);
+            }
+            catch (Exception ex)
+            {
+                Logger.Warning($"Failed to get filtered deadlock count: {ex.Message}");
+                return null; // Fall back to raw delta
+            }
+        }
+
         private async Task GetCollectorStatusAsync(SqlConnection connection, ServerHealthStatus status)
         {
             const string query = @"SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

Dashboard/SettingsWindow.xaml

@@ -267,6 +267,12 @@
                             </StackPanel>
                             <TextBlock x:Name="AlertPreviewText" FontSize="11" FontStyle="Italic" Foreground="Gray"
                                        TextWrapping="Wrap" Margin="0,12,0,0"/>
+                            <!-- Global Alert Filters -->
+                            <TextBlock Text="Global Alert Filters" FontWeight="Bold" FontSize="12" Margin="0,16,0,6"/>
+                            <TextBlock Text="Exclude databases from alerts (comma-separated):" Margin="0,0,0,4"/>
+                            <TextBox x:Name="AlertExcludedDatabasesTextBox" Margin="0,0,0,4"/>
+                            <TextBlock Text="e.g. DBAtools, msdb, tempdb — applies to blocking, deadlock, and long-running query alerts"
+                                       FontSize="11" FontStyle="Italic" Foreground="Gray" TextWrapping="Wrap"/>
                         </StackPanel>
                     </StackPanel>
                 </ScrollViewer>