Wolfgang.Extensions.Logging.Data.EntityFramework6 0.2.1

Wolfgang.Extensions.Logging.Data

Extension methods on ILogger for logging DbConnection, DbCommand, and other System.Data types — with credential redaction baked in so passwords never reach the log.

📦 Installation

dotnet add package Wolfgang.Extensions.Logging.Data

NuGet Package: Wolfgang.Extensions.Logging.Data

📄 License

This project is licensed under the MIT License. See the LICENSE file for details.

📚 Documentation

• GitHub Repository: https://github.com/Chris-Wolfgang/Extensions-Logging-Data
• API Documentation: https://Chris-Wolfgang.github.io/Extensions-Logging-Data/
• CHANGELOG: CHANGELOG.md
• Contributing Guide: CONTRIBUTING.md
• Architecture Decision Records: docs/adr/
• Reproducible builds (independent verification): docs/REPRODUCIBLE-BUILDS.md
• Migration guides: docs/migrations/
• Disaster recovery runbook: docs/DISASTER-RECOVERY.md
• DocFX Version Picker Troubleshooting: docs/DOCFX-VERSION-PICKER.md

🚀 Quick Start

using System.Data.SqlClient;
using Microsoft.Extensions.Logging;
using Wolfgang.Extensions.Logging.Data;

ILogger logger = /* … your DI-resolved ILogger … */;

using var connection = new SqlConnection(connectionString);
await connection.OpenAsync();

// Logs one structured entry: ConnectionType, Database, DataSource,
// ServerVersion, State, ConnectionTimeout, ConnectionString — with
// Password / Pwd keys removed before the entry is written.
logger.LogDbConnection(connection);

Want it at a different level than the default Information? Pass one:

logger.LogDbConnection(connection, LogLevel.Debug);

✨ Features

DbCommand logging is also available via ILogger.LogCommandText(...) (command text + parameter snapshot with opt-in redaction) and ILogger.LogDbCommand(DbCommand, ...) (logs a live command directly). The library is intentionally narrow and grows one type at a time as needed.

Trimming / Native AOT: LogDbConnection, LogDbCommand, and the IReadOnlyDictionary<string, object?> overloads of LogCommandText are trim- and AOT-safe (verified by a PublishAot smoke in CI). The anonymous-object LogCommandText(..., object parameters, ...) overloads reflect over the parameter's runtime properties and are marked [RequiresUnreferencedCode] — in trimmed/AOT apps use the dictionary overload instead.

🪵 Entity Framework 6 companion

The optional Wolfgang.Extensions.Logging.Data.EntityFramework6 package wires these extension methods into the EF6 interceptor pipeline so a legacy EF6 app logs every command, connection, and transaction event with no per-query call sites. Register once at startup:

// At application startup, before any DbContext is used:
EntityFramework6Logging.AddLoggingInterceptors(
    logger,
    excludedParameterNames: new[] { "password" },   // optional — redacted in logged commands
    level: LogLevel.Information);                    // optional — defaults to Information

From then on, every DbContext in the process logs:

• Commands — text + parameter snapshot (redacted), via LogDbCommand.
• Connections — open/close lifecycle, with connection-string redaction, via LogDbConnection.
• Transactions — commit / rollback.
• Failures — surfaced at LogLevel.Error from the EF6 interception context.

DbInterception.Add is process-global and not idempotent, so AddLoggingInterceptors is a no-op if called again with the same logger instance. Targets net462; net48; netstandard2.1.

dotnet add package Wolfgang.Extensions.Logging.Data.EntityFramework6

🎯 Supported Frameworks

This repo ships two packages, each with its own TFM matrix:

net462 is included so the library is usable from .NET Framework 4.6.2+ application hosts (existing System.Data.SqlClient consumers, classic web apps).

See each package's NuGet page for the authoritative per-TFM compatibility matrix.

🔍 Code Quality & Static Analysis

This project enforces strict code quality standards through 7 specialized analyzers and async-first custom rules:

1. Microsoft.CodeAnalysis.NetAnalyzers — built-in .NET analyzers for correctness and performance
2. Roslynator.Analyzers — advanced refactoring and code quality rules
3. AsyncFixer — async/await best practices and anti-pattern detection
4. Microsoft.VisualStudio.Threading.Analyzers — thread safety and async patterns
5. Microsoft.CodeAnalysis.BannedApiAnalyzers — prevents usage of banned synchronous APIs
6. Meziantou.Analyzer — comprehensive code quality rules
7. SonarAnalyzer.CSharp — industry-standard code analysis

Async-First Enforcement

The repo uses BannedSymbols.txt to prohibit blocking APIs:

• ❌ Task.Wait(), Task.Result — use await
• ❌ Thread.Sleep() — use await Task.Delay()
• ❌ Synchronous file I/O (File.ReadAllText) — use async equivalents
• ❌ Synchronous stream operations — use ReadAsync() / WriteAsync()
• ❌ Parallel.For / Parallel.ForEach — use Task.WhenAll() or Parallel.ForEachAsync()
• ❌ Obsolete APIs (WebClient, BinaryFormatter)

🛠️ Building from Source

Prerequisites

• .NET 10.0 SDK (also need .NET 8 / 9 SDKs to run the full multi-targeting test matrix)
• Optional: PowerShell Core for the formatting / build helper scripts

Build steps

# Clone
git clone https://github.com/Chris-Wolfgang/Extensions-Logging-Data.git
cd Extensions-Logging-Data

# Restore + build + test
dotnet restore
dotnet build --configuration Release
dotnet test  --configuration Release

# Format (PowerShell Core)
pwsh ./scripts/format.ps1

Building documentation locally

# Install DocFX once
dotnet tool update -g docfx

# Build + serve
cd docfx_project
docfx metadata
docfx build --serve   # http://localhost:8080

🤝 Contributing

Contributions are welcome — see CONTRIBUTING.md for code quality standards, build and test instructions, pull request guidelines, and analyzer configuration details.

🙏 Acknowledgments

• Microsoft.Extensions.Logging — the ILogger abstraction this library extends
• System.Data.Common.DbConnectionStringBuilder — the parser the redaction logic is built around
• The broader Wolfgang.Extensions.* family for the canonical CI / docs / packaging patterns this repo inherits