Plinth.Logging.Host 1.8.1

README

Plinth.Logging.Host

Logging utilities for hosted applications and services

Provides simple logging configuration for console applications, Windows services, and Azure Functions using the Plinth logging ecosystem.

Components

• StaticLogManagerSetup - Utility for configuring logging in Program.cs
  • Supports Console, Debug, and File logging
  • Supports Azure Functions with single-threaded logging contexts
• FileLogging - Simple file logging provider with append and rolling file support

👉 For sophisticated logging scenarios, use Plinth.Logging.NLog instead.

Usage

1. Console Logging

Configure logging to the console with sensible defaults:

using Plinth.Logging.Host;

class Program
{
    static void Main(string[] args)
    {
        var log = StaticLogManagerSetup.ConfigureForConsoleLogging();

        log.Info("Application started");
        log.Debug("Debug information");
        log.Warn("Warning message");
        log.Error("Error occurred");
    }
}

With custom formatting:

var log = StaticLogManagerSetup.ConfigureForConsoleLogging(
    minLevel: LogLevel.Debug,
    configAction: c =>
    {
        c.ColorBehavior = LoggerColorBehavior.Enabled;
        c.SingleLine = true;
        c.TimestampFormat = "yyyy-MM-dd HH:mm:ss ";
    });

2. Debug Logging

Configure logging to debug output (useful for unit tests and debugging):

var log = StaticLogManagerSetup.ConfigureForDebugLogging(LogLevel.Debug);

log.Debug("This will appear in debug output");

3. File Logging

Simple file logging with optional rolling files:

var log = StaticLogManagerSetup.ConfigureForFileLogging(
    minLevel: LogLevel.Information,
    filePath: "app.log");

log.Info("This will be written to app.log");

With rolling file options:

var options = new FileLoggerOptions
{
    Append = true,
    FileSizeLimitBytes = 10 * 1024 * 1024,  // 10 MB
    MaxRollingFiles = 5  // Keep up to 5 log files
};

var log = StaticLogManagerSetup.ConfigureForFileLogging(
    minLevel: LogLevel.Information,
    filePath: "app.log",
    options: options);

4. Configuration from appsettings.json

Load logging configuration from your appsettings.json file:

var log = StaticLogManagerSetup.FromAppSettings();

// Or specify custom paths
var log = StaticLogManagerSetup.FromAppSettings(
    configRoot: "Logging",
    appSettings: "appsettings.json");

Example appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "System": "Warning",
      "Microsoft": "Warning"
    },
    "Console": {
      "IncludeScopes": true
    },
    "Debug": { },
    "File": {
      "Path": "logs/app.log",
      "Append": true,
      "MinLevel": "Information",
      "FileSizeLimitBytes": 10485760,
      "MaxRollingFiles": 5
    }
  }
}

👉 Include "Console", "Debug", or "File" sections to enable those providers.

5. Custom IConfiguration

Use with a custom configuration source:

var config = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddJsonFile($"appsettings.{environment}.json", optional: true)
    .Build();

var log = StaticLogManagerSetup.FromAppSettings(config, "Logging");

6. Azure Functions Single-Thread Logging

For Azure Functions where you're passed an ILogger:

public class MyFunction
{
    [FunctionName("MyFunction")]
    public async Task Run(
        [TimerTrigger("0 */5 * * * *")] TimerInfo timer,
        ILogger logger)
    {
        // Configure Plinth to use the Azure Functions logger
        StaticLogManagerSetup.ConfigureForSingleThread(logger);

        // Now all Plinth components will use the Azure Functions logger
        var myService = new MyService();
        await myService.DoWork();
    }
}

public class MyService
{
    private static readonly ILogger log = StaticLogManager.GetLogger();

    public async Task DoWork()
    {
        log.Info("This will log through Azure Functions logger");
    }
}

Or with ILoggerFactory:

public class MyFunction
{
    private readonly ILoggerFactory _loggerFactory;

    public MyFunction(ILoggerFactory loggerFactory)
    {
        _loggerFactory = loggerFactory;
    }

    [FunctionName("MyFunction")]
    public async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo timer)
    {
        StaticLogManagerSetup.ConfigureForSingleThread(_loggerFactory);

        // All Plinth components can now log
        var myService = new MyService();
        await myService.DoWork();
    }
}

FileLoggerOptions

Configure file logging behavior:

public class FileLoggerOptions
{
    // Append to existing file (true) or overwrite (false)
    public bool Append { get; set; } = true;

    // Enable rolling files when file reaches this size (0 = disabled)
    public long FileSizeLimitBytes { get; set; } = 0;

    // Maximum number of rolling files to keep (0 = unlimited)
    public int MaxRollingFiles { get; set; } = 0;
}

Rolling File Behavior

When FileSizeLimitBytes is set:

• Logger creates new files when the limit is reached
• Files are named: app.log, app1.log, app2.log, etc.

When MaxRollingFiles is also set:

• Logger reuses old files after reaching the limit
• Example with MaxRollingFiles = 3: creates app.log, app1.log, app2.log, then overwrites app.log

Using with Plinth Ecosystem

All loggers configured with StaticLogManagerSetup work seamlessly with the Plinth ecosystem:

using Plinth.Logging.Host;

class Program
{
    static void Main()
    {
        var log = StaticLogManagerSetup.ConfigureForConsoleLogging();

        log.Info("Application started");

        // Use Plinth's logging extensions
        using (log.LogExecTiming("Initialization"))
        {
            // Timed code block
            Initialize();
        }

        log.Info("Application ready");
    }
}

Best Practices

1. Choose the Right Logger

   • Use Console logging for development and simple CLI tools
   • Use File logging for Windows services and simple applications
   • Use NLog (via Plinth.Logging.NLog) for production applications with complex logging needs
   • Use Debug logging only for unit tests and debugging

2. Azure Functions

   • Always use ConfigureForSingleThread() to integrate with Azure Functions logging
   • This ensures logs appear in Application Insights and the Azure Portal

3. Configuration

   • Use appsettings.json for production deployments
   • Different environments can have different logging levels
   • File logging should use rolling files to prevent disk space issues

4. Log Levels

   • Use Information as the default minimum level for production
   • Use Debug for development environments
   • Avoid Trace in production (too verbose)

5. Rolling Files

   • Always set MaxRollingFiles when using FileSizeLimitBytes
   • Typical values: 10 MB per file, keep 10 files (100 MB total)