Lite: CDC exclusion parity with Dashboard (#1096)

Mirror the Dashboard CDC long-running-query exclusion in Lite so both apps
behave identically.

Lite reads collected DuckDB snapshots and stores only statement-level
query text, which can't carry the CDC proc name -- so the detection runs
in the COLLECTOR (against the live server), where the whole batch/object
text and msdb are available, and the result is stored as a per-row flag:

- query_snapshots gains an is_cdc_capture BOOLEAN (schema v28 migration,
  ALTER ... ADD COLUMN IF NOT EXISTS, appended last to match the appender).
- The non-Azure collector template computes is_cdc_capture with the same
  two-tier logic as Dashboard: program_name -> job_id via msdb.dbo.cdc_jobs
  (deferred through sp_executesql in TRY/CATCH), text fallback on the whole
  dest.text when msdb is unreadable. Azure SQL DB has no Agent/msdb, so it
  is hard-coded 0 there.
- GetLongRunningQueriesAsync filters COALESCE(is_cdc_capture, FALSE) = FALSE
  when the new LongRunningQueryExcludeCdc toggle (default on) is set.
- Settings checkbox + App static + JSON load/save, mirroring the existing
  four wait_type exclusion toggles.

The schema-evolution-tolerant archive views (UNION ALL BY NAME +
union_by_name=true) keep old parquet compatible. Collector SQL validated
against SQL 2016: prologue falls back cleanly when cdc_jobs is absent and
the is_cdc_capture column computes without error.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: erikdarlingdata

Lite/App.xaml.cs

@@ -107,6 +107,7 @@ public partial class App : Application
     public static bool AlertLongRunningQueryExcludeWaitFor { get; set; } = true;
     public static bool AlertLongRunningQueryExcludeBackups { get; set; } = true;
     public static bool AlertLongRunningQueryExcludeMiscWaits { get; set; } = true;
+    public static bool AlertLongRunningQueryExcludeCdc { get; set; } = true;
     public static List<string> AlertExcludedDatabases { get; set; } = new();
     public static bool AlertTempDbSpaceEnabled { get; set; } = true;
     public static int AlertTempDbSpaceThresholdPercent { get; set; } = 80;
@@ -463,6 +464,7 @@ public static void LoadAlertSettings()
             if (root.TryGetProperty("alert_long_running_query_exclude_waitfor", out v)) AlertLongRunningQueryExcludeWaitFor = v.GetBoolean();
             if (root.TryGetProperty("alert_long_running_query_exclude_backups", out v)) AlertLongRunningQueryExcludeBackups = v.GetBoolean();
             if (root.TryGetProperty("alert_long_running_query_exclude_misc_waits", out v)) AlertLongRunningQueryExcludeMiscWaits = v.GetBoolean();
+            if (root.TryGetProperty("alert_long_running_query_exclude_cdc", out v)) AlertLongRunningQueryExcludeCdc = v.GetBoolean();
             if (root.TryGetProperty("alert_excluded_databases", out v) && v.ValueKind == System.Text.Json.JsonValueKind.Array)
             {
                 AlertExcludedDatabases = new List<string>();

Lite/Database/DuckDbInitializer.cs

@@ -97,7 +97,7 @@ public void Dispose()
     /// <summary>
     /// Current schema version. Increment this when schema changes require table rebuilds.
     /// </summary>
-    internal const int CurrentSchemaVersion = 27;
+    internal const int CurrentSchemaVersion = 28;
 
     private readonly string _archivePath;
 
@@ -732,6 +732,23 @@ New tables only — no existing table changes needed. Tables created by
                 throw;
             }
         }
+
+        if (fromVersion < 28)
+        {
+            /* v28: Added is_cdc_capture flag to query_snapshots so the long-running query
+                    alert can exclude CDC capture sessions. The collector computes the flag
+                    server-side (program_name -> job_id via msdb.dbo.cdc_jobs, text fallback).
+                    Appended at the end to match the DuckDB appender's positional order. */
+            _logger?.LogInformation("Running migration to v28: adding is_cdc_capture column to query_snapshots");
+            try
+            {
+                await ExecuteNonQueryAsync(connection, "ALTER TABLE query_snapshots ADD COLUMN IF NOT EXISTS is_cdc_capture BOOLEAN DEFAULT false");
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogWarning("Migration to v28 encountered an error (non-fatal): {Error}", ex.Message);
+            }
+        }
     }
 
     /// <summary>

Lite/Database/Schema.cs

@@ -346,7 +346,8 @@ granted_query_memory_gb DECIMAL(18,2),
     host_name VARCHAR,
     program_name VARCHAR,
     open_transaction_count INTEGER,
-    percent_complete DECIMAL(5,2)
+    percent_complete DECIMAL(5,2),
+    is_cdc_capture BOOLEAN DEFAULT false
 )";
 
     public const string CreateTempdbStatsTable = @"

Lite/MainWindow.xaml.cs

@@ -1634,7 +1634,7 @@ await _emailAlertService.TrySendAlertEmailAsync(
         {
             try
             {
-                var longRunning = await _dataService.GetLongRunningQueriesAsync(summary.ServerId, App.AlertLongRunningQueryThresholdMinutes, App.AlertLongRunningQueryMaxResults, App.AlertLongRunningQueryExcludeSpServerDiagnostics, App.AlertLongRunningQueryExcludeWaitFor, App.AlertLongRunningQueryExcludeBackups, App.AlertLongRunningQueryExcludeMiscWaits);
+                var longRunning = await _dataService.GetLongRunningQueriesAsync(summary.ServerId, App.AlertLongRunningQueryThresholdMinutes, App.AlertLongRunningQueryMaxResults, App.AlertLongRunningQueryExcludeSpServerDiagnostics, App.AlertLongRunningQueryExcludeWaitFor, App.AlertLongRunningQueryExcludeBackups, App.AlertLongRunningQueryExcludeMiscWaits, App.AlertLongRunningQueryExcludeCdc);
 
                 if (App.AlertExcludedDatabases.Count > 0)
                 {

Lite/Services/LocalDataService.WaitStats.cs

@@ -436,7 +436,8 @@ public async Task<List<LongRunningQueryInfo>> GetLongRunningQueriesAsync(
         bool excludeSpServerDiagnostics = true,
         bool excludeWaitFor = true,
         bool excludeBackups = true,
-        bool excludeMiscWaits = true)
+        bool excludeMiscWaits = true,
+        bool excludeCdc = true)
     {
         using var connection = await OpenConnectionAsync();
         using var command = connection.CreateCommand();
@@ -451,6 +452,10 @@ public async Task<List<LongRunningQueryInfo>> GetLongRunningQueriesAsync(
             ? "AND r.wait_type NOT IN (N'BACKUPTHREAD', N'BACKUPIO')" : "";
         string miscWaitsFilter = excludeMiscWaits
             ? "AND r.wait_type NOT IN (N'XE_LIVE_TARGET_TVF')" : "";
+        // CDC capture sessions are flagged server-side by the collector (is_cdc_capture). COALESCE
+        // guards pre-migration / archived rows where the column is NULL.
+        string cdcFilter = excludeCdc
+            ? "AND COALESCE(r.is_cdc_capture, FALSE) = FALSE" : "";
         maxResults = Math.Clamp(maxResults, 1, 1000);
 
         command.CommandText = @$"
@@ -473,6 +478,7 @@ AND r.session_id > 50
                     {waitForFilter}
                     {backupsFilter}
                     {miscWaitsFilter}
+                    {cdcFilter}
                     AND r.total_elapsed_time_ms >= $2
                 ORDER BY r.total_elapsed_time_ms DESC
                 LIMIT $3;";

Lite/Services/RemoteCollectorService.QuerySnapshots.cs

@@ -25,6 +25,17 @@ public partial class RemoteCollectorService
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SET LOCK_TIMEOUT 1000;
 
+DECLARE @cdc_capture_jobs TABLE (job_id uniqueidentifier PRIMARY KEY);
+DECLARE @cdc_readable bit = 0;
+BEGIN TRY
+    INSERT @cdc_capture_jobs (job_id)
+    EXEC sys.sp_executesql N'SELECT cj.job_id FROM msdb.dbo.cdc_jobs AS cj WHERE cj.job_type = N''capture'';';
+    SET @cdc_readable = 1;
+END TRY
+BEGIN CATCH
+    SET @cdc_readable = 0;
+END CATCH;
+
 SELECT /* PerformanceMonitorLite */
     der.session_id,
     database_name = d.name,
@@ -68,7 +79,21 @@ WHEN 5 THEN 'Snapshot'
     des.host_name,
     des.program_name,
     des.open_transaction_count,
-    der.percent_complete
+    der.percent_complete,
+    is_cdc_capture =
+        CONVERT(bit,
+            CASE
+                WHEN @cdc_readable = 1
+                     AND des.program_name LIKE N'SQLAgent - TSQL JobStep (Job 0x%'
+                     AND TRY_CONVERT(uniqueidentifier, TRY_CONVERT(binary(16), SUBSTRING(des.program_name, 32, 32), 2))
+                         IN (SELECT j.job_id FROM @cdc_capture_jobs AS j)
+                THEN 1
+                WHEN @cdc_readable = 0
+                     AND dest.text IS NOT NULL
+                     AND (dest.text LIKE N'%sp_MScdc_capture_job%' OR dest.text LIKE N'%sp_cdc_scan%')
+                THEN 1
+                ELSE 0
+            END)
 FROM sys.dm_exec_requests AS der
 JOIN sys.dm_exec_sessions AS des
     ON des.session_id = der.session_id
@@ -174,7 +199,9 @@ WHEN 5 THEN 'Snapshot'
     des.host_name,
     des.program_name,
     des.open_transaction_count,
-    der.percent_complete
+    der.percent_complete,
+    /* Azure SQL Database has no SQL Agent / msdb.dbo.cdc_jobs (CDC there is scheduler-based), so no capture job to exclude. */
+    is_cdc_capture = CONVERT(bit, 0)
 FROM #req AS der
 JOIN sys.dm_exec_sessions AS des
     ON des.session_id = der.session_id
@@ -300,6 +327,7 @@ clause is "" so nothing changes. */
                    .AppendValue(reader.IsDBNull(22) ? (string?)null : reader.GetString(22))                /* program_name */
                    .AppendValue(reader.IsDBNull(23) ? 0 : Convert.ToInt32(reader.GetValue(23)))            /* open_transaction_count */
                    .AppendValue(reader.IsDBNull(24) ? 0m : Convert.ToDecimal(reader.GetValue(24)))        /* percent_complete */
+                   .AppendValue(!reader.IsDBNull(25) && Convert.ToBoolean(reader.GetValue(25)))           /* is_cdc_capture */
                    .EndRow();
 
                 rowsCollected++;

Lite/Windows/SettingsWindow.xaml

@@ -211,6 +211,9 @@
                           Foreground="{DynamicResource ForegroundBrush}" Margin="20,0,0,4"/>
                 <CheckBox x:Name="LrqExcludeMiscWaitsCheckBox"
                           Content="Exclude miscellaneous waits (XE_LIVE_TARGET_TVF)"
+                          Foreground="{DynamicResource ForegroundBrush}" Margin="20,0,0,4"/>
+                <CheckBox x:Name="LrqExcludeCdcCheckBox"
+                          Content="Exclude CDC capture jobs (sp_MScdc_capture_job, sp_cdc_scan)"
                           Foreground="{DynamicResource ForegroundBrush}" Margin="20,0,0,0"/>
                 <StackPanel Orientation="Horizontal" Margin="20,6,0,0">
                     <CheckBox x:Name="AlertTempDbSpaceCheckBox" Content="TempDB space usage over" VerticalAlignment="Center"

Lite/Windows/SettingsWindow.xaml.cs

@@ -593,6 +593,7 @@ private void LoadAlertSettings()
         LrqExcludeWaitForCheckBox.IsChecked = App.AlertLongRunningQueryExcludeWaitFor;
         LrqExcludeBackupsCheckBox.IsChecked = App.AlertLongRunningQueryExcludeBackups;
         LrqExcludeMiscWaitsCheckBox.IsChecked = App.AlertLongRunningQueryExcludeMiscWaits;
+        LrqExcludeCdcCheckBox.IsChecked = App.AlertLongRunningQueryExcludeCdc;
         AlertExcludedDatabasesBox.Text = string.Join(", ", App.AlertExcludedDatabases);
         AlertTempDbSpaceCheckBox.IsChecked = App.AlertTempDbSpaceEnabled;
         AlertTempDbSpaceThresholdBox.Text = App.AlertTempDbSpaceThresholdPercent.ToString();
@@ -642,6 +643,7 @@ private bool SaveAlertSettings()
         App.AlertLongRunningQueryExcludeWaitFor = LrqExcludeWaitForCheckBox.IsChecked == true;
         App.AlertLongRunningQueryExcludeBackups = LrqExcludeBackupsCheckBox.IsChecked == true;
         App.AlertLongRunningQueryExcludeMiscWaits = LrqExcludeMiscWaitsCheckBox.IsChecked == true;
+        App.AlertLongRunningQueryExcludeCdc = LrqExcludeCdcCheckBox.IsChecked == true;
         App.AlertExcludedDatabases = AlertExcludedDatabasesBox.Text
             .Split(',')
             .Select(s => s.Trim())
@@ -709,6 +711,7 @@ private bool SaveAlertSettings()
             root["alert_long_running_query_exclude_waitfor"] = App.AlertLongRunningQueryExcludeWaitFor;
             root["alert_long_running_query_exclude_backups"] = App.AlertLongRunningQueryExcludeBackups;
             root["alert_long_running_query_exclude_misc_waits"] = App.AlertLongRunningQueryExcludeMiscWaits;
+            root["alert_long_running_query_exclude_cdc"] = App.AlertLongRunningQueryExcludeCdc;
             var dbArray = new System.Text.Json.Nodes.JsonArray();
             foreach (var db in App.AlertExcludedDatabases) dbArray.Add(db);
             root["alert_excluded_databases"] = dbArray;