Pro.Volo.Abp.Logging.Serilog.EntityFrameworkCore 1.0.0

ABP Serilog Logging Module

A comprehensive, production-ready ABP module for structured logging with Serilog. Provides database and file logging with automatic user context enrichment, HTTP request tracking, and correlation ID support.

Features

✅ Database Logging - Store logs in your application's database with batching support
✅ File Logging - Configurable file logging with rolling policies and JSON formatting
✅ User Context Enrichment - Automatically capture UserId, UserName, Email, and TenantId
✅ HTTP Request Tracking - Log request path, method, IP address, user agent, and status codes
✅ Correlation IDs - Trace related log entries across requests
✅ Multi-Tenancy Support - Full support for ABP's multi-tenancy features
✅ Performance Optimized - Asynchronous batching for minimal performance impact
✅ Extensible - Easy to add custom enrichers and sinks

Installation

Install the NuGet packages:

# Core module (required)
dotnet add package Volo.Abp.Logging.Serilog

# Entity Framework Core integration (optional, for database logging)
dotnet add package Volo.Abp.Logging.Serilog.EntityFrameworkCore

Quick Start

1. Add Module Dependencies

Add the module dependencies to your ABP module:

[DependsOn(
    typeof(AbpLoggingSerilogModule),
    typeof(AbpLoggingSerilogEntityFrameworkCoreModule) // If using database logging
)]
public class YourModule : AbpModule
{
    // ...
}

2. Configure DbContext (For Database Logging)

Add the LogEntry entity to your DbContext:

using Volo.Abp.Logging.Serilog.EntityFrameworkCore;

public class YourDbContext : AbpDbContext<YourDbContext>
{
    public DbSet<LogEntry> SerilogLogs { get; set; }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        // Configure the LogEntry entity
        builder.ConfigureAbpLoggingSerilog();
    }
}

3. Add Migration

Create and apply a migration to add the logs table:

dotnet ef migrations add AddSerilogLogging
dotnet ef database update

4. Configure appsettings.json

Add configuration to your appsettings.json:

{
  "Serilog": {
    "Abp": {
      "EnableDatabaseLogging": true,
      "EnableFileLogging": true,
      "EnableUserContextEnrichment": true,
      "EnableHttpContextEnrichment": true,
      "EnableRequestLogging": true,
      "MinimumLevel": "Information",
      "File": {
        "Path": "Logs/logs.txt",
        "RollingInterval": "Day",
        "FileSizeLimitBytes": 10485760,
        "RetainedFileCountLimit": 31,
        "OutputFormat": "Json",
        "MinimumLevel": "Information"
      },
      "Database": {
        "MinimumLevel": "Warning",
        "BatchSize": 50,
        "FlushIntervalSeconds": 5,
        "TableName": "SerilogLogs",
        "EnableAutoCleanup": false,
        "RetentionDays": 30
      }
    }
  }
}

Configuration Options

Main Options (AbpSerilogOptions)

File Logging Options (AbpSerilogFileOptions)

Database Logging Options (AbpSerilogDatabaseOptions)

Usage Examples

Basic Logging

public class MyService : ITransientDependency
{
    private readonly ILogger<MyService> _logger;

    public MyService(ILogger<MyService> logger)
    {
        _logger = logger;
    }

    public async Task DoSomethingAsync()
    {
        _logger.LogInformation("Processing started");
        
        try
        {
            // Your code here
            _logger.LogInformation("Processing completed successfully");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Processing failed");
            throw;
        }
    }
}

Structured Logging

_logger.LogInformation(
    "User {UserId} performed {Action} on {EntityType} with ID {EntityId}",
    userId,
    "Update",
    "Product",
    productId
);

Querying Logs from Database

public class LogQueryService : ITransientDependency
{
    private readonly IRepository<LogEntry, Guid> _logRepository;

    public LogQueryService(IRepository<LogEntry, Guid> logRepository)
    {
        _logRepository = logRepository;
    }

    public async Task<List<LogEntry>> GetRecentErrorsAsync()
    {
        return await _logRepository
            .Where(x => x.Level == "Error" && x.Timestamp > DateTime.UtcNow.AddHours(-24))
            .OrderByDescending(x => x.Timestamp)
            .Take(100)
            .ToListAsync();
    }

    public async Task<List<LogEntry>> GetUserLogsAsync(Guid userId)
    {
        return await _logRepository
            .Where(x => x.UserId == userId)
            .OrderByDescending(x => x.Timestamp)
            .ToListAsync();
    }
}

Log Entry Schema

The LogEntry entity includes the following properties:

Core Properties:

• Id (Guid) - Primary key
• Timestamp (DateTime) - When the log was created
• Level (string) - Log level (Verbose, Debug, Information, Warning, Error, Fatal)
• Message (string) - Rendered log message
• MessageTemplate (string) - Message template for structured logging
• Exception (string) - Exception details if present
• Properties (string) - Additional properties as JSON

User Context:

• UserId (Guid?) - ID of the authenticated user
• UserName (string) - Username
• TenantId (Guid?) - Tenant ID for multi-tenant applications

HTTP Request Context:

• CorrelationId (string) - Correlation ID for request tracing
• RequestPath (string) - HTTP request path
• HttpMethod (string) - HTTP method (GET, POST, etc.)
• StatusCode (int?) - HTTP status code
• ClientIp (string) - Client IP address
• UserAgent (string) - User agent string
• ApplicationName (string) - Application name

Extensibility

Creating a Custom Enricher

using Serilog.Core;
using Serilog.Events;
using Volo.Abp.DependencyInjection;

public class CustomEnricher : ILogEventEnricher, ITransientDependency
{
    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
    {
        logEvent.AddPropertyIfAbsent(
            propertyFactory.CreateProperty("CustomProperty", "CustomValue")
        );
    }
}

Then register it in your module:

public override void ConfigureServices(ServiceConfigurationContext context)
{
    context.Services.AddTransient<CustomEnricher>();
    
    // Add to Serilog configuration
    Log.Logger = new LoggerConfiguration()
        .Enrich.With<CustomEnricher>()
        // ... other configuration
        .CreateLogger();
}

Performance Considerations

• Database Logging: Uses batching by default (50 logs per batch, 5-second flush interval) to minimize database calls
• File Logging: Uses async buffered writing with configurable flush intervals
• Enrichers: Lightweight and only execute when logs are actually written
• Middleware: Minimal overhead, can be disabled if not needed

Best Practices

1. Log Levels: Use appropriate log levels

   • Verbose/Debug: Development only
   • Information: General application flow
   • Warning: Unexpected but handled situations
   • Error: Errors and exceptions
   • Fatal: Critical failures

2. Database Logging: Set MinimumLevel to Warning or Error to avoid excessive database writes

3. Retention: Configure RetentionDays and RetainedFileCountLimit to manage disk space

4. Structured Logging: Use message templates with parameters instead of string interpolation

5. Correlation IDs: Use for tracing requests across microservices

Troubleshooting

Logs not appearing in database

1. Ensure EnableDatabaseLogging is set to true
2. Check that the migration was applied
3. Verify the MinimumLevel for database logging
4. Check for exceptions in console output

High database load

1. Increase BatchSize and FlushIntervalSeconds
2. Raise MinimumLevel to Warning or Error
3. Consider using file logging for verbose logs

License

This project is licensed under the MIT License.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Support

For issues and questions, please use the GitHub issue tracker.