Msb.Logger 1.0.3

MsbLogger

A lightweight, flexible logging library for .NET applications supporting console output, file logging, and database persistence via PostgreSQL,MSSQL,MYSQL,SQLite. Works both with and without Dependency Injection.

Features

• Dual usage modes — static (Logger) API for simple apps; DI-friendly IAppLogger for ASP.NET Core
• Multiple sinks — console, file (CSV), and PostgreSQL database
• Selective DB logging — choose which log levels persist to the database
• Session tagging — attach a session identifier to any log entry
• Queue-based logging — optional async buffered writes for high-throughput scenarios
• Structured CSV output — timestamped logs with caller context (area, method, line)

Manual Table Creation

Msb.Logger automatically creates the application_logs table when the application starts. If automatic table creation fails (for example, due to insufficient database permissions), create the table manually using the schema below.

Log Levels

Getting Started

Without Dependency Injection

Suitable for console apps, Windows Forms, WPF, or any non-DI context.

Logger.Configure(builder =>
{
    builder
        .UseDatabase(() => new NpgsqlConnection(
            "server=localhost;port=5432;database=my_app;user id=postgres;password=***"))
        .AddConsole()
        .WithSessionClearing()        // clears session data after each log entry
        .SetLogDirectory("Logs")
        .EnableDbLevels(LogType.Critical, LogType.Error);
        // .EnableQueueLogger();      // enable async queue; exit
});

Logger.SetSession("MySession");
Logger.Log("This is an error message", LogType.Error);

Logger.SetSession("MySession");
Logger.Log("This is a critical message", LogType.Critical);

Logger.Info("This is an info message");
Logger.Error("This is an error message");

try
{
    // your code
}
catch (Exception ex)
{
    Logger.Log(ex);
}

With Dependency Injection (ASP.NET Core)

Register IAppLogger in Program.cs or Startup.cs:

builder.Services.AddScoped<IAppLogger>(sp =>
    new MsbLoggerBuilder()
        .Create()
        .UseDatabase(() => new NpgsqlConnection(
            "server=localhost;port=5432;database=my_app;user id=postgres;password=***"))
        .EnableDbLevels(LogType.Error, LogType.Critical)
        .AddConsole()
        .WithSessionClearing()
       // .EnableQueueLogger()    // enable async queue;
        .Build());

Inject and use in your classes:

public class MyService
{
    private readonly IAppLogger _logger;

    public MyService(IAppLogger logger)
    {
        _logger = logger;
    }

    public void DoWork()
    {
        _logger.SetSession("MySession");
        _logger.Log("This is an error message", LogType.Error);

        _logger.SetSession("MySession");
        _logger.Log("This is a critical message", LogType.Critical);

        _logger.Info("This is an info message");
        _logger.Error("This is an error message");

        try
        {
            // your code
        }
        catch (Exception ex)
        {
            _logger.Log(ex);
        }
    }
}

Configuration Options

Convenience Methods

Both the static Logger and IAppLogger expose shorthand methods:

Logger.Info("message");    // LogType.Information
Logger.Error("message");   // LogType.Error
Logger.Log(exception);     // logs exception details automatically
Logger.Log("message", LogType.Warning);  // explicit level

CSV Log Format

Logs written to file use the following CSV structure:

DateTime,Area,Method,Line,Type,Message,Session
"2026-06-14 00:15:23.639","Form1",".ctor",18,"Information","hello",""
"2026-06-14 00:16:22.513","Form1",".ctor",18,"Information","hello",""

Log files are stored in the directory specified by .SetLogDirectory() (default: Logs/).

Important Notes

• Queue logger flush — when .EnableQueueLogger() is active` before your application exits to ensure all buffered log entries are written to the database.
• Session lifecycle — .WithSessionClearing() resets the session after every log call. Omitting it keeps the session value set by SetSession() for the entire application lifetime.
• DB level filtering — only the levels passed to .EnableDbLevels() are written to PostgreSQL; all levels still write to the console and file sinks.
• Credentials — avoid hard-coding database passwords in source code; prefer environment variables or secrets management.