Logging Exceptions into Database with ASP.NET Core

Overview

Proper exception logging is critical for maintaining application reliability and debugging issues in production. This tutorial demonstrates how to implement a database logger using Exception Filters in ASP.NET Core MVC projects.

Step 1: Create the LogEntry Model

First, create a model to represent exception log entries in the database:

1
public class LogEntry
2
{
3
    public int Id { get; set; }
4
    public DateTime TimeStamp { get; set; }
5
    public string RequestId { get; set; }
6
    public string Message { get; set; }
7
    public string Type { get; set; }
8
    public string Source { get; set; }
9
    public string StackTrace { get; set; }
10
    public string RequestPath { get; set; }
11
    public string User { get; set; }
12
    public string ActionDescriptor { get; set; }
13
    public string IpAddress { get; set; }
14
}

This model captures all essential exception information for debugging and auditing purposes.

Step 2: Create a Separate LogDbContext

Create a separate DbContext specifically for exception logging:

1
public class LogDbContext : DbContext
2
{
3
    public LogDbContext(DbContextOptions<LogDbContext> options)
4
        : base(options)
5
    {
6
    }
7

8
    public DbSet<LogEntry> LogEntries { get; set; }
9

10
    protected override void OnModelCreating(ModelBuilder builder)
11
    {
12
        base.OnModelCreating(builder);
13
    }
14
}

Step 3: Create the Exception Filter

Now create an exception filter to catch and log exceptions to the database:

1
public class DblExceptionFilter : ExceptionFilterAttribute
2
{
3
    private readonly LogDbContext _context;
4

5
    public DblExceptionFilter(LogDbContext context)
6
    {
7
        _context = context;
8
    }
9

10
    public override void OnException(ExceptionContext context)
11
    {
12
        LogEntry log = new LogEntry
13
        {
14
            TimeStamp = DateTime.UtcNow,
15
            ActionDescriptor = context.ActionDescriptor.DisplayName,
16
            IpAddress = context.HttpContext.Connection.RemoteIpAddress.ToString(),
17
            Message = context.Exception.Message,
18
            RequestId = Activity.Current?.Id ?? context.HttpContext.TraceIdentifier,
19
            RequestPath = context.HttpContext.Request.Path,
20
            Source = context.Exception.Source,
21
            StackTrace = context.Exception.StackTrace,
22
            Type = context.Exception.GetType().ToString(),
23
            User = context.HttpContext.User.Identity.Name
24
        };
25

26
        _context.LogEntries.Add(log);
27
        _context.SaveChanges();
28

29
        base.OnException(context);
30
    }
31
}

This filter captures comprehensive exception details including the timestamp, request information, user, and full stack trace.

Step 4: Register the Filter in Startup

Add the DblExceptionFilter to the service collection in your Startup.cs:

1
public void ConfigureServices(IServiceCollection services)
2
{
3
    // ... other services ...
4

5
    services.AddScoped<DblExceptionFilter>();
6

7
    // ... remaining services ...
8
}

Step 5: Create a Base Controller

Create a BaseController class that applies the filter to all controllers:

1
using System;
2
using ExceptionDbLogger.Filters;
3
using Microsoft.AspNetCore.Mvc;
4

5
namespace ExceptionDbLogger.Controllers
6
{
7
    [ServiceFilter(typeof(DblExceptionFilter))]
8
    public class BaseController : Controller
9
    {
10
    }
11
}

Implementation

Inherit all your custom controllers from BaseController:

1
public class YourController : BaseController
2
{
3
    public IActionResult Index()
4
    {
5
        // Your controller logic
6
        return View();
7
    }
8
}

Now any unhandled exceptions that occur in YourController will be automatically logged to the database.

Benefits of This Approach

• Centralized Logging: All exceptions are logged to a single database table
• Request Context: Captures user, IP address, request path, and request ID
• Audit Trail: Maintains a complete history of exceptions for analysis
• Easy Debugging: Stack traces are stored for detailed error investigation
• Scalable: Add the filter to any controller by inheriting from BaseController

Complete Example

For a complete working implementation, check out the source code on GitHub.

Database Schema

You’ll also need to create a database table to store the log entries:

1
CREATE TABLE LogEntries (
2
    Id INT PRIMARY KEY IDENTITY(1,1),
3
    TimeStamp DATETIME NOT NULL,
4
    RequestId NVARCHAR(MAX),
5
    Message NVARCHAR(MAX),
6
    Type NVARCHAR(MAX),
7
    Source NVARCHAR(MAX),
8
    StackTrace NVARCHAR(MAX),
9
    RequestPath NVARCHAR(MAX),
10
    User NVARCHAR(MAX),
11
    ActionDescriptor NVARCHAR(MAX),
12
    IpAddress NVARCHAR(MAX)
13
);

Conclusion

This exception logging approach provides a robust way to track and diagnose issues in production. By maintaining a separate DbContext and using a base controller, you ensure that all unhandled exceptions are consistently logged without risking the loss of log data.

If you have any questions or run into issues with the implementation, feel free to ask in the comments below!