Code cleanup

Author: KeelMatrix

.editorconfig

@@ -1,14 +1,20 @@
-# Top level EditorConfig file
+# Top-level EditorConfig
 # For more information, see https://aka.ms/editorconfigdocs
 
 root = true
 
+# =====================================================================================
+# Global language settings
+# =====================================================================================
+
 [*.cs]
+# Encoding & formatting
 charset = utf-8
 indent_style = space
 indent_size = 4
 insert_final_newline = true
 
+# Code style
 # Organize usings
 dotnet_sort_system_directives_first = true
 
@@ -21,56 +27,64 @@ dotnet_style_qualification_for_event = false:suggestion
 # New line options
 csharp_new_line_before_open_brace = all:suggestion
 
+# Analyzer: ignore IDE0130 (Namespace does not match folder structure)
+dotnet_diagnostic.IDE0130.severity = none
+
+[*.{cs,vb}]
+dotnet_code_quality.CA1826.exclude_ordefault_methods = true
+
 [*.{csproj,props,targets}]
 indent_style = space
 indent_size = 2
 
-# ---------------------------
-# Analyzer severities
+# (we continue to rely on: EnableNETAnalyzers=true, AnalysisLevel=8.0-recommended)
+
+# =====================================================================================
+# Analyzer severities (global)
+# =====================================================================================
+
 # Public API analyzers
 dotnet_diagnostic.RS0016.severity = error   # Add new APIs to Unshipped
 dotnet_diagnostic.RS0017.severity = error   # Mark APIs as obsolete/removed
 dotnet_diagnostic.RS0025.severity = error   # Duplicate member in the public API file
 dotnet_diagnostic.RS0037.severity = error   # The generated public API file is not up to date
 
-[*.{cs,vb}]
-dotnet_code_quality.CA1826.exclude_ordefault_methods = true
+# =====================================================================================
+# Per-project severity settings
+# =====================================================================================
 
-# (we continue to rely on: EnableNETAnalyzers=true, AnalysisLevel=8.0-recommended)
-
-# ---------------------------
-# Per-project severity settings:
-
-# test projects under /tests
+# tests/*
 [tests/**.cs]
-dotnet_diagnostic.CA1707.severity = none   # disable “no underscores in identifiers” for test names
-dotnet_diagnostic.CS1591.severity = none   # disable “missing XML documentation” for test code
+dotnet_diagnostic.CA1707.severity = none   # allow underscores in identifiers (test names)
+dotnet_diagnostic.CS1591.severity = none   # missing XML docs off in tests
 dotnet_diagnostic.IDE0290.severity = none  # disable “Use primary constructor”
 
-# sample apps under /samples
+# samples/*
 [samples/**.cs]
-dotnet_diagnostic.CS1591.severity = none   # disable “missing XML documentation” for sample code
+dotnet_diagnostic.CS1591.severity = none   # missing XML docs off in samples
 
-# tools/KeelMatrix.QueryWatch.Cli
+# tools/KeelMatrix.QueryWatch.Cli/*
 [tools/KeelMatrix.QueryWatch.Cli/**.cs]
-dotnet_diagnostic.RCS1194.severity = none  # disable Roslynator rule RCS1194 (style/constructor guideline)
-dotnet_diagnostic.S3871.severity = none    # disable Sonar rule S3871 (exception/immutability guideline)
-dotnet_diagnostic.CS1591.severity = none   # disable “missing XML documentation” for CLI code
+dotnet_diagnostic.RCS1194.severity = none  # Roslynator: constructor guideline
+dotnet_diagnostic.S3871.severity = none    # Sonar: exception/immutability guideline
+dotnet_diagnostic.CS1591.severity = none   # missing XML docs off in CLI
 
-# Core library — src/KeelMatrix.QueryWatch
+# src/KeelMatrix.QueryWatch/*
 [src/KeelMatrix.QueryWatch/**.cs]
-dotnet_diagnostic.CA1510.severity = none   # disable “prefer ArgumentNullException.ThrowIfNull” requirement
-dotnet_diagnostic.CA1513.severity = none   # disable “prefer nameof(...) in exceptions” requirement
-dotnet_diagnostic.CA2249.severity = none   # disable “Use 'string.Contains' instead of 'string.IndexOf' to improve readability”
-dotnet_diagnostic.IDE0290.severity = none  # disable “Use primary constructor”
-dotnet_diagnostic.RCS1001.severity = none  # disable “Add braces to if statement”
+dotnet_diagnostic.CA1510.severity = none   # prefer ThrowIfNull
+dotnet_diagnostic.CA1513.severity = none   # prefer nameof(...) in exceptions
+dotnet_diagnostic.CA2249.severity = none   # prefer string.Contains over IndexOf
+dotnet_diagnostic.IDE0290.severity = none  # “Use primary constructor”
+dotnet_diagnostic.RCS1001.severity = none  # “Add braces to if statement”
 
-# Project: Contracts — src/KeelMatrix.QueryWatch.Contracts
+# src/KeelMatrix.QueryWatch.Contracts/*
 [src/KeelMatrix.QueryWatch.Contracts/**.cs]
-dotnet_diagnostic.CS1591.severity = none   # disable “missing XML documentation” for public contracts
+dotnet_diagnostic.CS1591.severity = none   # missing XML docs off for public contracts
 
-# ---------------------------
-# Debug-Release specific severity settings:
+# =====================================================================================
+# Configuration-specific severity settings
+# (Order matters: these come last to override above where applicable)
+# =====================================================================================
 
 # In Debug: suppress CS1591 across the board (keep the build clean)
 [*.cs]

bench/KeelMatrix.QueryWatch.Benchmarks/RecordThroughputBench.cs

@@ -1,6 +1,5 @@
 // Microbenchmarks for write-path contention in QueryWatchSession.
 // Compares production "lock + copy-on-stop" vs an alternative "ConcurrentQueue + snapshot".
-#nullable enable
 using System.Collections.Concurrent;
 using BenchmarkDotNet.Attributes;
 
@@ -19,31 +18,31 @@ public class RecordThroughputBench {
         [Params(2_000)]
         public int EventsPerThread { get; set; } = 2_000;
 
-        private KeelMatrix.QueryWatch.QueryWatchOptions _optsNoText = null!;
+        private QueryWatchOptions _optsNoText = null!;
 
         [GlobalSetup]
         public void Setup() {
-            _optsNoText = new KeelMatrix.QueryWatch.QueryWatchOptions {
+            _optsNoText = new QueryWatchOptions {
                 CaptureSqlText = false // exercise the hot path without redaction overhead
             };
         }
 
         [Benchmark(Baseline = true, Description = "lock[List] + copy-on-stop (production)")]
-        public KeelMatrix.QueryWatch.QueryWatchReport LockList() {
-            var session = new KeelMatrix.QueryWatch.QueryWatchSession(_optsNoText);
+        public QueryWatchReport LockList() {
+            QueryWatchSession session = new(_optsNoText);
             RunWorkers(Threads, EventsPerThread, () => session.Record("SELECT 1", TimeSpan.FromMilliseconds(1)));
             return session.Stop();
         }
 
         [Benchmark(Description = "ConcurrentQueue + snapshot (alternative)")]
-        public KeelMatrix.QueryWatch.QueryWatchReport ConcurrentQueueSnapshot() {
-            var session = new ConcurrentQueueSession(_optsNoText);
+        public QueryWatchReport ConcurrentQueueSnapshot() {
+            ConcurrentQueueSession session = new(_optsNoText);
             RunWorkers(Threads, EventsPerThread, () => session.Record("SELECT 1", TimeSpan.FromMilliseconds(1)));
             return session.Stop();
         }
 
         private static void RunWorkers(int threads, int eventsPerThread, Action action) {
-            var tasks = new Task[threads];
+            Task[] tasks = new Task[threads];
             for (int t = 0; t < threads; t++) {
                 tasks[t] = Task.Run(() => {
                     for (int i = 0; i < eventsPerThread; i++) action();
@@ -54,16 +53,11 @@ private static void RunWorkers(int threads, int eventsPerThread, Action action)
     }
 
     // Minimal alternative session used only for benchmarking.
-    internal sealed class ConcurrentQueueSession {
-        private readonly ConcurrentQueue<KeelMatrix.QueryWatch.QueryEvent> _q = new();
-        private readonly KeelMatrix.QueryWatch.QueryWatchOptions _options;
+    internal sealed class ConcurrentQueueSession(QueryWatchOptions options) {
+        private readonly ConcurrentQueue<QueryEvent> _q = new();
+        private readonly QueryWatchOptions _options = options ?? throw new ArgumentNullException(nameof(options));
         private int _stopped; // 0=running,1=stopped
         private readonly DateTimeOffset _startedAt = DateTimeOffset.UtcNow;
-        private DateTimeOffset? _stoppedAt;
-
-        public ConcurrentQueueSession(KeelMatrix.QueryWatch.QueryWatchOptions options) {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-        }
 
         public void Record(string commandText, TimeSpan duration) {
             if (Volatile.Read(ref _stopped) != 0)
@@ -73,30 +67,27 @@ public void Record(string commandText, TimeSpan duration) {
             string text = string.Empty;
             if (_options.CaptureSqlText) {
                 text = commandText ?? string.Empty;
-                foreach (var r in _options.Redactors) text = r.Redact(text);
+                foreach (IQueryTextRedactor r in _options.Redactors) text = r.Redact(text);
             }
 
             // second check to minimize recording after stop (not strictly needed for the benchmark)
             if (Volatile.Read(ref _stopped) != 0)
                 throw new InvalidOperationException("Session has been stopped; cannot record new events.");
 
             // FIX: use the public 3-arg ctor; the 4-arg (with meta) is internal
-            var ev = new KeelMatrix.QueryWatch.QueryEvent(text, duration, DateTimeOffset.UtcNow);
+            QueryEvent ev = new(text, duration, DateTimeOffset.UtcNow);
             _q.Enqueue(ev);
         }
 
-        public KeelMatrix.QueryWatch.QueryWatchReport Stop() {
-            var now = DateTimeOffset.UtcNow;
-            if (Interlocked.CompareExchange(ref _stopped, 1, 0) == 0) {
-                _stoppedAt = now;
-            }
-            else {
-                throw new InvalidOperationException("Session has already been stopped.");
-            }
+        public QueryWatchReport Stop() {
+            DateTimeOffset now = DateTimeOffset.UtcNow;
+            DateTimeOffset? _stoppedAt = Interlocked.CompareExchange(ref _stopped, 1, 0) == 0
+                ? (DateTimeOffset?)now
+                : throw new InvalidOperationException("Session has already been stopped.");
 
-            var arr = _q.ToArray();
-            var list = new List<KeelMatrix.QueryWatch.QueryEvent>(arr);
-            return KeelMatrix.QueryWatch.QueryWatchReport.CreateSnapshot(list, _options, _startedAt, _stoppedAt ?? now);
+            QueryEvent[] arr = [.. _q];
+            List<QueryEvent> list = [.. arr];
+            return QueryWatchReport.CreateSnapshot(list, _options, _startedAt, _stoppedAt ?? now);
         }
     }
 }

bench/KeelMatrix.QueryWatch.Redaction.Benchmarks/CiAwareConfig.cs

@@ -4,13 +4,13 @@
 namespace KeelMatrix.QueryWatch.Redaction.Benchmarks {
     internal sealed class CiAwareConfig : ManualConfig {
         public CiAwareConfig() {
-            AddLogger([.. DefaultConfig.Instance.GetLoggers()]);
-            AddColumnProvider([.. DefaultConfig.Instance.GetColumnProviders()]);
-            AddDiagnoser([.. DefaultConfig.Instance.GetDiagnosers()]);
+            _ = AddLogger([.. DefaultConfig.Instance.GetLoggers()]);
+            _ = AddColumnProvider([.. DefaultConfig.Instance.GetColumnProviders()]);
+            _ = AddDiagnoser([.. DefaultConfig.Instance.GetDiagnosers()]);
 
             bool isCi = Environment.GetEnvironmentVariable("CI") is not null;
             if (!isCi) {
-                AddExporter(JsonExporter.FullCompressed);
+                _ = AddExporter(JsonExporter.FullCompressed);
             }
         }
     }

samples/Ado.Sqlite/Program.cs

@@ -4,47 +4,47 @@
 using Microsoft.Data.Sqlite;
 
 // Plain ADO.NET + SQLite sample
-var artifacts = Path.Combine(AppContext.BaseDirectory, "artifacts");
+string artifacts = Path.Combine(AppContext.BaseDirectory, "artifacts");
 Directory.CreateDirectory(artifacts);
-var outJson = Path.Combine(artifacts, "qwatch.ado.json");
+string outJson = Path.Combine(artifacts, "qwatch.ado.json");
 
-using var q = QueryWatchScope.Start(
+using QueryWatchScope q = QueryWatchScope.Start(
     maxQueries: 50,
     maxAverage: TimeSpan.FromMilliseconds(200),
     exportJsonPath: outJson,
     sampleTop: 50);
 
 // In-memory SQLite needs the connection to stay open for the DB to persist.
-using var raw = new SqliteConnection("Data Source=:memory:");
+using SqliteConnection raw = new("Data Source=:memory:");
 await raw.OpenAsync();
 
 // Wrap the provider connection so all commands record into the QueryWatch session.
-using var conn = new QueryWatchConnection(raw, q.Session);
+using QueryWatchConnection conn = new(raw, q.Session);
 
 // Create schema (we include a harmless SQL comment with an email to show masking)
 using (var cmd = conn.CreateCommand()) {
     cmd.CommandText = Redaction.Apply("/* contact: [email protected] */ CREATE TABLE Users(Id INTEGER PRIMARY KEY, Name TEXT NOT NULL);");
-    await cmd.ExecuteNonQueryAsync();
+    _ = await cmd.ExecuteNonQueryAsync();
 }
 
 // Insert a few rows (we also redact parameter strings defensively)
 for (int i = 0; i < 5; i++) {
     using var ins = conn.CreateCommand();
-    var email = $"user{i}@example.com"; // demo PII-like value (will be masked in CommandText)
+    string email = $"user{i}@example.com"; // demo PII-like value (will be masked in CommandText)
     ins.CommandText = Redaction.Apply($"/* email: {email} */ INSERT INTO Users(Name) VALUES ($name);");
 
     var p = ins.CreateParameter();
     p.ParameterName = "$name";
     p.Value = Redaction.Param("User_" + i); // if your JSON ever includes parameters, this stays safe
-    ins.Parameters.Add(p);
+    _ = ins.Parameters.Add(p);
 
-    await ins.ExecuteNonQueryAsync();
+    _ = await ins.ExecuteNonQueryAsync();
 }
 
 // Query back
 using (var select = conn.CreateCommand()) {
     select.CommandText = Redaction.Apply("SELECT COUNT(*) FROM Users WHERE Name LIKE 'User_%';");
-    var count = Convert.ToInt32(await select.ExecuteScalarAsync(), System.Globalization.CultureInfo.InvariantCulture);
+    int count = Convert.ToInt32(await select.ExecuteScalarAsync(), System.Globalization.CultureInfo.InvariantCulture);
     Console.WriteLine($"Users in DB: {count}");
 }
 

samples/Ado.Sqlite/Redaction.cs

@@ -4,14 +4,20 @@ namespace Ado.Sqlite {
     /// <summary>
     /// Simple redaction helper for the sample (emails + long hex tokens)
     /// </summary>
-    internal static class Redaction {
+    internal static partial class Redaction {
         // Very small demo rules; expand as needed
-        private static readonly Regex Email = new(@"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}", RegexOptions.Compiled);
-        private static readonly Regex HexToken = new(@"\b[0-9a-f]{32,}\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+        private static readonly Regex Email = EmailRegex();
+        private static readonly Regex HexToken = HexTokenRegex();
 
         public static string Apply(string input) =>
             HexToken.Replace(Email.Replace(input, "***"), "***");
 
         public static object Param(object? v) => v is string s ? Apply(s) : v ?? DBNull.Value;
+
+        [GeneratedRegex(@"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}", RegexOptions.Compiled)]
+        private static partial Regex EmailRegex();
+
+        [GeneratedRegex(@"\b[0-9a-f]{32,}\b", RegexOptions.IgnoreCase | RegexOptions.Compiled, "en-US")]
+        private static partial Regex HexTokenRegex();
     }
 }

samples/Dapper.Sqlite/Program.cs

@@ -5,18 +5,18 @@
 using Microsoft.Data.Sqlite;
 
 // Dapper + SQLite sample (async + transactions)
-var artifacts = Path.Combine(AppContext.BaseDirectory, "artifacts");
+string artifacts = Path.Combine(AppContext.BaseDirectory, "artifacts");
 Directory.CreateDirectory(artifacts);
-var outJson = Path.Combine(artifacts, "qwatch.dapper.json");
+string outJson = Path.Combine(artifacts, "qwatch.dapper.json");
 
-using var q = QueryWatchScope.Start(
+using QueryWatchScope q = QueryWatchScope.Start(
     maxQueries: 50,
     maxAverage: TimeSpan.FromMilliseconds(200),
     exportJsonPath: outJson,
     sampleTop: 50);
 
 // Create an in-memory DB
-using var raw = new SqliteConnection("Data Source=:memory:");
+using SqliteConnection raw = new("Data Source=:memory:");
 await raw.OpenAsync();
 
 // Wrap with QueryWatch (returns QueryWatchConnection under the hood for SQLite)
@@ -28,8 +28,8 @@
 // Insert in a transaction (exercise Transaction wrapper + async APIs)
 using (var tx = await conn.BeginTransactionAsync()) {
     for (int i = 0; i < 3; i++) {
-        var email = $"user{i}@example.com"; // will be redacted in CommandText
-        await conn.ExecuteAsync(
+        string email = $"user{i}@example.com"; // will be redacted in CommandText
+        _ = await conn.ExecuteAsync(
             Redaction.Apply($"/* email: {email} */ INSERT INTO Users(Name) VALUES (@name);"),
             new { name = Redaction.Param("User_" + i) },
             transaction: tx);
@@ -38,7 +38,7 @@ await conn.ExecuteAsync(
 }
 
 // Query back (async)
-var total = await conn.ExecuteScalarAsync<int>(Redaction.Apply("SELECT COUNT(*) FROM Users WHERE Name LIKE 'User_%';"));
+int total = await conn.ExecuteScalarAsync<int>(Redaction.Apply("SELECT COUNT(*) FROM Users WHERE Name LIKE 'User_%';"));
 Console.WriteLine($"Users in DB: {total}");
 
 Console.WriteLine($"QueryWatch JSON written to: {outJson}");

samples/Dapper.Sqlite/Redaction.cs

@@ -4,14 +4,20 @@ namespace DapperSample {
     /// <summary>
     /// Simple redaction helper for the sample (emails + long hex tokens)
     /// </summary>
-    internal static class Redaction {
+    internal static partial class Redaction {
         // Very small demo rules; expand as needed
-        private static readonly Regex Email = new(@"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}", RegexOptions.Compiled);
-        private static readonly Regex HexToken = new(@"\b[0-9a-f]{32,}\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+        private static readonly Regex Email = EmailRegex();
+        private static readonly Regex HexToken = HexTokenRegex();
 
         public static string Apply(string input) =>
             HexToken.Replace(Email.Replace(input, "***"), "***");
 
         public static object Param(object? v) => v is string s ? Apply(s) : v ?? DBNull.Value;
+
+        [GeneratedRegex(@"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}", RegexOptions.Compiled)]
+        private static partial Regex EmailRegex();
+
+        [GeneratedRegex(@"\b[0-9a-f]{32,}\b", RegexOptions.IgnoreCase | RegexOptions.Compiled, "en-US")]
+        private static partial Regex HexTokenRegex();
     }
 }

samples/EFCore.Sqlite/AppDbContext.cs

@@ -5,8 +5,8 @@ public sealed class AppDbContext : DbContext {
         public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
         public DbSet<User> Users => Set<User>();
         protected override void OnModelCreating(ModelBuilder modelBuilder) {
-            modelBuilder.Entity<User>().HasKey(u => u.Id);
-            modelBuilder.Entity<User>().Property(u => u.Name).IsRequired();
+            _ = modelBuilder.Entity<User>().HasKey(u => u.Id);
+            _ = modelBuilder.Entity<User>().Property(u => u.Name).IsRequired();
             base.OnModelCreating(modelBuilder);
         }
     }