pvNugsLoggerNc10Abstractions 10.0.0

pvNugsLoggerNc10Abstractions

A comprehensive .NET Core 10 logging abstraction library that provides structured, contextual logging with support for multiple output destinations, user contexts, and typed logging capabilities.

Features

• Multiple Output Destinations: Support for console, SQL, and hybrid logging configurations
• Contextual Logging: Track user, company, and topic contexts across log entries
• Structured Logging: Detailed metadata for each log entry including machine name, method name, and line numbers
• Severity Levels: Comprehensive severity level system compatible with Microsoft's LogLevel
• Method Result Tracking: Built-in support for tracking method execution results and notifications
• Base Implementation: Ready-to-use abstract base class for creating custom logging implementations
• Async Support: Both synchronous and asynchronous logging methods
• Unit Testing Support: Specialized interfaces for testing logging behavior

Installation

Install via NuGet Package Manager:

Install-Package pvNugsLoggerNc10Abstractions

Or via .NET CLI:

dotnet add package pvNugsLoggerNc10Abstractions

Requirements

• .NET Core 10.0 or higher
• C# 13.0 or higher

Core Components

Logger Services

• ILoggerService: The main logging interface that provides comprehensive logging functionality
• BaseLoggerService: Abstract base class implementing ILoggerService with core functionality
• IConsoleLoggerService: Specialized service for console output
• IHybridLoggerService: Combines multiple logging outputs
• IUTestLoggerService: Specialized service for unit testing scenarios

Log Writers

• ILogWriter: Base interface for writing log entries to various destinations
• IConsoleLogWriter: Specialized writer for console output
• IUTestLogWriter: Writer with additional capabilities for testing scenarios

Method Results

• IMethodResult: Tracks method execution status and notifications
• IMethodResultNotification: Represents individual notifications within results

Data Structures

• ILoggerServiceRow: Represents a structured log entry with metadata
• SeverityEnu: Defines available logging severity levels
• SqlRoleEnu: Defines SQL database access roles

Basic Usage

Using Existing Implementations

public class ExampleService
{
    private readonly ILoggerService _logger;

    public ExampleService(ILoggerService logger)
    {
        _logger = logger;
    }

    public async Task DoSomethingAsync()
    {
        // Set context for subsequent log entries
        _logger.SetUser("user123", "company456");
        _logger.SetTopic("ImportantOperation");

        try
        {
            _logger.Log("Starting operation", SeverityEnu.Info);

            // Perform some work...

            await _logger.LogAsync(
                new[] { "Step 1 complete", "Step 2 complete" },
                SeverityEnu.Debug);
        }
        catch (Exception ex)
        {
            await _logger.LogAsync(ex);
            throw;
        }
    }
}

Creating Custom Implementations

public class CustomLoggerService : BaseLoggerService
{
    public CustomLoggerService(SeverityEnu minLevel, params ILogWriter[] logWriters)
        : base(minLevel, logWriters)
    {
    }

    // BaseLoggerService provides all the core functionality.
    // Override specific methods if needed for custom behavior.
}

public class CustomLogWriter : ILogWriter
{
    public void WriteLog(string? userId, string? companyId, string? topic,
        SeverityEnu severity, string machineName, string memberName,
        string filePath, int lineNumber, string message, DateTime dateUtc)
    {
        // Implement your custom log writing logic.
    }

    public async Task WriteLogAsync(string? userId, string? companyId, string? topic,
        SeverityEnu severity, string machineName, string memberName,
        string filePath, int lineNumber, string message, DateTime dateUtc)
    {
        // Implement your custom async log writing logic.
        await Task.CompletedTask;
    }

    public void Dispose() { }
    public ValueTask DisposeAsync() => ValueTask.CompletedTask;
}

Unit Testing

public class LoggingTests
{
    private readonly IUTestLogWriter _logWriter;
    private readonly IUTestLoggerService _logger;

    [Fact]
    public void ShouldLogError()
    {
        _logger.Log("Test error", SeverityEnu.Error);

        Assert.True(_logWriter.Contains("Test error"));
        var logEntry = _logWriter.FindLastMatchingRow("Test error");
        Assert.Equal(SeverityEnu.Error, logEntry.Severity);
    }
}

Available Implementations

This abstractions package provides the foundation for logging implementations.

Companion implementation packages for the .NET Core 10 line can be documented here as they are published.

Microsoft.Extensions.Logging Integration

The BaseLoggerService implements the Microsoft.Extensions.Logging.ILogger interface, making it compatible with .NET Core 10 logging and dependency injection.