DEV Community: Alex

Thanks to your great feedback, v5.3 is here! 🚀 Now with automatic Correlation ID propagation on outgoing HTTP calls, structured metrics (StatusCode, ElapsedMs), and verified secret masking benchmarks across all sinks.

Alex — Sun, 11 Oct 2026 09:04:17 +0000

Alex

Oct 6

One ILogger<T>, 10 sinks, secrets masked everywhere: LoggerHelper + HttpHelper for .NET (and a playground to try them)

#dotnet #csharp #logging #docker

5 min read

One ILogger, 10 sinks, secrets masked everywhere: LoggerHelper + HttpHelper for .NET (and a playground to try them)

Alex — Tue, 06 Oct 2026 13:03:48 +0000

Every .NET backend team encounters the exact same operational dilemmas:

Routing headaches: We want Information in the Console, Warning in Seq/Elasticsearch, Error in SQL Server, and Fatal instant alerts to Telegram or Email.
Configuration bloat: Achieving this with plain Serilog requires sub-loggers, verbose C# filters, and redeploying code just to adjust log destinations.
Data security nightmares: Passwords, JWTs, Bearer tokens, or credit cards accidentally ending up in log aggregators (violating GDPR / PCI-DSS).
Sink failure cascading: One unreachable database sink shouldn't crash the startup of the entire web API.
HTTP resiliency & tracing boilerplate: Standard HttpClient needs Polly retries, per-call timeouts, header masking, and correlation IDs glued together over and over again.

To solve this once and for all across microservices, I maintain two high-performance, MIT-licensed NuGet packages: CSharpEssentials.LoggerHelper and CSharpEssentials.HttpHelper (now updated to v5.3.1, supporting .NET 8, 9, and 10).

1. LoggerHelper: Native ILogger Meets Declarative Routing

CSharpEssentials.LoggerHelper acts as a high-level orchestrator on top of Serilog and registers as a standard ILoggerProvider.

💡 Zero Application Code Changes: If your services already inject ILogger<T>, you do not touch a single line of business logic.

Modular "Pay-Only-For-What-You-Use" Sinks

Install the core plus only the sink packages you actually need:

🖥️ Console (CSharpEssentials.LoggerHelper.Sink.Console)
📁 File (with tenant/property folder splitting)
📊 Seq & Elasticsearch
🗄️ SQL Server, PostgreSQL, MySQL / MariaDB
📱 Telegram & Email
⚙️ Hangfire Console

Sinks register themselves automatically via .NET [ModuleInitializer].

Declarative Routing in 5 Lines of JSON

No more hand-crafted sub-loggers. Just declare your routes in appsettings.json:

{
  "LoggerHelper": {
    "ApplicationName": "OrderService",
    "Routes": [
      { "Sink": "Console", "Levels": ["Debug", "Information", "Warning"] },
      { "Sink": "Seq",     "Levels": ["Information", "Warning", "Error"] },
      { "Sink": "MSSqlServer", "Levels": ["Error", "Fatal"] },
      { "Sink": "Telegram",    "Levels": ["Fatal"] }
    ]
  }
}

Or configure it with the type-safe Fluent API in Program.cs:

builder.Services.AddLoggerHelper(b => b
    .WithApplicationName("OrderService")
    .AddRoute("Console", LogEventLevel.Information, LogEventLevel.Warning)
    .AddRoute("Seq", LogEventLevel.Information, LogEventLevel.Warning, LogEventLevel.Error)
    .AddRoute("Telegram", LogEventLevel.Fatal)
    .EnableSensitiveDataMasking(o => {
        o.Presets = ["Email", "CreditCard", "BearerToken", "JwtToken"];
        o.SensitiveProperties = ["Password", "ApiKey"];
    })
);

Automatic Sensitive Data Masking

Masking is implemented as an enricher executed once per log event before routing. Both template properties and the rendered message string are sanitized automatically.

// Application Code:
_logger.LogInformation("User {Email} logged in with token {BearerToken}", email, token);

// Sinks receive:
// "User alice@***.com logged in with token ***MASKED***"

2. HttpHelper v5.3: Resilient HttpClient with Zero Exceptions

Pairing logging with outgoing HTTP calls is where real-world systems shine. CSharpEssentials.HttpHelper wraps IHttpClientFactory with an ergonomic fluent pipeline:

No Transport Exceptions: Network failures, DNS drops, and timeouts are mapped to clean 408 RequestTimeout, 502 BadGateway, or 500 InternalServerError responses instead of unhandled crashes.
Exponential Backoff & Rate Limiting: Built-in sliding-window rate limiters and Polly retry policies.
Built-in Mocking (IHttpMockScenario): Unit and integration test HTTP clients without launching WireMock or local servers.

🆕 What's New in v5.3: Hot-Reload Logging & Correlation ID

In v5.3, outgoing HTTP calls integrate natively with the LoggerHelper pipeline:

{
  "HttpHelperLogging": {
    "LogRequests": [ "*" ],
    "CorrelationIdHeader": "X-Correlation-ID"
  }
}

Live Hot-Reload: Turn request logging on/off per client name at runtime via IOptionsMonitor without restarting the process.
Automatic Correlation: Propagates an end-to-end CorrelationId across retries (and downstream microservices).
Sanitized Logs: Automatically masks headers like Authorization: Bearer ***MASKED***.

var response = await factory.CreateOrGet("payment-gateway")
    .addRetryCondition(r => (int)r.StatusCode >= 500, retryCount: 3, backoffFactor: 2)
    .addTimeout(TimeSpan.FromSeconds(5))
    .SendAsync("https://api.gateway.com/charge", HttpMethod.Post, new JsonContentBuilder(), payload);

3. Experience It Live: The Interactive Playground

Reading about architecture is good, but testing it live is better. The repository includes an interactive Playground (/playground.html in the Demo project) that builds pipelines on the fly:

(Watch the playground live recording: testing multi-sink routing, instant secret masking, and flaky HTTP retry flows)

What you can test in the Playground:

Live Multi-Sink Dispatch: Check Console, File, Seq, Postgres, SQL Server, and Telegram checkboxes, pick individual minimum levels, and see which sink accepted or filtered the event.
- 💡 Zero Local Setup needed: Console and File work immediately with no dependencies.
- 🐳 No need to install databases locally: To test the external sinks (Seq, Elasticsearch, SQL Server, PostgreSQL), you don't need to install anything on your machine — the repository includes a ready-made Docker Compose setup that spins up all of them in isolated containers with one command!
- 📱 Telegram: Just set your bot token via dotnet user-secrets to receive instant push alerts.
Instant Secret Masking: Type a credit card, password, or custom regex (ORD-\d+) and inspect the sanitized event payload in real time.
End-to-End E-Commerce Scenario: Run the multi-step order scenario (Login ➡️ Order ➡️ Flaky Payment: Timeout ➡️ 503 ➡️ 200 Success). Watch every retry attempt get logged with the same CorrelationId!
Generated C# Fluent Code Preview: The right panel automatically prints the exact C# code required to reproduce what you just clicked.

4. Run the Playground in 3 Commands

You can run the entire environment (including Seq, Elasticsearch, and databases in Docker) right now:

# 1. Clone the repo
git clone https://github.com/alexbypa/CSharp.Essentials.git
cd CSharp.Essentials/src/CSharpEssentials.LoggerHelper.Demo/docker

# 2. Start the sinks in Docker
cp .env.example .env
docker compose up -d

# 3. Launch the Demo app
cd ..
dotnet run

Then open http://localhost:5123/playground.html in your browser!

5. Summary & Benchmarks

Feature	Serilog Alone	Refit / Polly Raw	LoggerHelper + HttpHelper
Native `ILogger<T>`	✅	N/A	✅ (Zero code refactor)
Multi-sink JSON routing	❌ (requires C# code)	N/A	✅ (5 lines of JSON)
Sensitive Data Masking	⚠️ (manual enrichers)	❌	✅ (Pre-configured presets)
Sink Failure Isolation	❌ (can crash host)	N/A	✅ (`ILogErrorStore`)
HTTP No-Exception Contract	N/A	❌	✅ (`408`/`502`/`500` status codes)
Outgoing Request Correlation	⚠️ (manual setup)	⚠️ (manual setup)	✅ (Automatic propagation)
Interactive Playground	❌	❌	✅ (`playground.html`)

Honest Performance Overhead

LoggerHelper is an orchestrator, not a replacement. In our BenchmarkDotNet runs (.NET 9), baseline framework overhead is ~590 ns vs ~180 ns for Serilog directly. For real-world web APIs handling business workloads, this difference is negligible, but you gain maintainability, security, and developer ergonomics.

Get Started on NuGet & GitHub

📦 Core Logger: CSharpEssentials.LoggerHelper on NuGet
🌐 Resilient HTTP: CSharpEssentials.HttpHelper on NuGet
⭐ GitHub Repository: alexbypa/CSharp.Essentials

If you find this useful for your .NET projects, leave a star on GitHub and let me know your thoughts in the comments!

LoggerHelper

Alex — Sat, 10 May 2025 19:48:10 +0000

🚀 Introducing CSharpEssentials.LoggerHelper: A Modular and Powerful Logger for .NET Developers

In the world of software development, structured and reliable logging is crucial for debugging, monitoring, and maintaining applications.

Today, I'm excited to introduce CSharpEssentials.LoggerHelper, a lightweight, modular library built on top of Serilog, designed to make logging in .NET applications easier, cleaner, and more powerful.

📦 What is LoggerHelper?

LoggerHelper is a wrapper around Serilog that allows you to configure multi-sink logging quickly and flexibly, without having to write complex boilerplate code.

It helps you set up a professional logging system with:

Console
File
PostgreSQL
Telegram

… and it's easy to extend with your own custom sinks!

🌟 Key Features

✅ Modular Configuration

With the LoggerBuilder, you can configure exactly the sinks you need — no unnecessary setup.

✅ Standardized Log Format

Every log automatically includes essential fields like:

Action
IdTransaction
ApplicationName
MachineName

✅ .NET 8 Compatible

Built for modern applications, ready for production.

✅ Lightweight and Performant

No heavy dependencies, only the essentials.

✅ Telegram Notifications

Receive critical logs directly on Telegram in real-time!

🛠️ How to Install

You can install LoggerHelper directly from NuGet:

dotnet add package CSharpEssentials.LoggerHelper

Or visit the NuGet page.

🚀 Quick Start Example

Here’s how simple it is to set up:

Define your logging configuration in appsettings.json:

{
  "LoggerHelper": {
    "ApplicationName": "MyApp",
    "Sinks": {
      "Console": {
        "Enabled": true
      },
      "File": {
        "Enabled": true,
        "Path": "logs/log-.txt"
      },
      "PostgreSQL": {
        "Enabled": true,
        "ConnectionString": "your-connection-string"
      },
      "Telegram": {
        "Enabled": true,
        "BotToken": "your-bot-token",
        "ChatId": "your-chat-id"
      }
    }
  }
}

Initialize the logger in your Program.cs:

var logger = LoggerBuilder.BuildFromConfiguration(configuration);

Now the logger will automatically configure all the sinks based on your appsettings.json file.

logger.Information("Application started successfully!");

You can enable or disable sinks dynamically just by changing the settings — no need to modify the code!

📌 Important

LoggerHelper is designed to be configuration-driven, keeping your application code clean and letting you control the behavior through simple settings.

🧩 Extending LoggerHelper

LoggerHelper is designed to be easily extendable.

If you want to add a new sink or customize your logs:

You can create your own extension methods.
You can inject contextual properties dynamically.
You can customize the enrichment to match your domain requirements.

✨ Why Use LoggerHelper Instead of Raw Serilog?

Less Setup: No more cluttered Program.cs with tons of configuration.
Consistency: Always log the most critical context fields automatically.
Flexibility: Add or remove sinks in a modular way.
Productivity: Focus on your business logic — not on writing logger configuration.

📚 Documentation & GitHub

You can find full examples, usage tips, and source code on GitHub:

👉 https://github.com/alexbypa/CSharp.Essentials

Feel free to open issues, suggest improvements, or contribute!

🔥 Conclusion

If you're looking for a clean, modular, and extensible logging solution for your .NET projects,

CSharpEssentials.LoggerHelper is made for you.

It’s simple enough for small applications, yet powerful enough for enterprise-grade systems.

If you find it useful, consider leaving a ⭐ on GitHub — it really helps the project grow!

💬 Have questions or suggestions? Feel free to leave a comment below! I'd love to hear your feedback.