Is it possible to save audit events as part of Entity Framework transaction?

[voroninp]

My aggregate is publishing events.
I don't want to audit the entities (thus not using Audit EF package), but I want to save published events as audit events within the same transaction.

Is it possible?

[thepirat000]

I don't understand the issue, you have to provide more information, and a code sample explaining what are you trying to accomplish and what you've tried so far.

What do you mean by "My aggregate is publishing events"?

[thepirat000]

I believe I understand now, if my assumptions are correct, you should be able to do something like this:

await using (var transaction = await dbContext.Database.BeginTransactionAsync())
{
    await dbContext.SaveChangesAsync();

    await StoreCustomAuditEventsAsync(dbContext); 

    await transaction.CommitAsync();
}

The transaction will not be committed if either SaveChanges or PublishEvents fails.

[voroninp]

But will Audit.NET data provider enlist in this transaction?

[thepirat000]

Not automatically, but it depends on the data provider you plan to use and the location where the events are stored. Are the audit events going to be stored in the same database as your data?

[voroninp]

Yes, the same database. My initial assumption was that EF provider supports this, but then I saw the following comment:

Store EntityFramework audit events in the same EF context. (This data provider can only be used for Entity Framework audits)

[thepirat000]

I'm creating a generic DbContext Data Provider to enable the storage of AuditEvents using an Entity Framework DbContext. This provider will support storing any type of AuditEvent and should align well with your use case. I'll let you know once it's released

[thepirat000]

The latest version 27.3.1 includes a new DbContext DataProvider as a generic audit data provider that uses Entity Framework Core to write audit events. It allows mapping audit events to a specific entity in a DbContext.

I think this can be helpful for your use case.

---

In the following example, the MyService class handles database operations and logs an audit event within a single transaction through its ExecuteAsync method.

The MyAuditLogger is responsible for generating custom logs. It leverages the injected IAuditScopeFactory to create and persist custom audit events. Its LogAsync method utilizes the new DbContextDataProvider to save the audit event, reusing the existing DbContext instance consequently ensuring they are part of the same transaction.

The MyDbContext serves as an example DbContext that manages data (Orders) while also storing audit events (AuditLogs).

using Audit.Core;
using Audit.EntityFramework.Providers;

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

// *************
// Startup Code:
// *************

// Register the services
var serviceProvider = new ServiceCollection()
    .AddScoped<IMyService, MyService>()
    .AddScoped<IMyAuditLogger, MyAuditLogger>()
    .AddSingleton<IAuditScopeFactory, AuditScopeFactory>()
    .AddDbContextFactory<MyDbContext>()
    .BuildServiceProvider();


// ***************************************
// Simulate a MyService.ExecuteAsync call:
// ***************************************
var service = serviceProvider.GetService<IMyService>();
await service.ExecuteAsync();


// *************
// Service Code:
// *************
public interface IMyService
{
    Task ExecuteAsync();
}

public class MyService : IMyService
{
    private readonly IDbContextFactory<MyDbContext> _contextFactory;
    private readonly IMyAuditLogger _auditLogger;

    public MyService(IDbContextFactory<MyDbContext> contextFactory, IMyAuditLogger auditLogger)
    {
        _contextFactory = contextFactory;
        _auditLogger = auditLogger;
    }

    public async Task ExecuteAsync()
    {
        // Create a new DbContext instance
        await using var dbContext = await _contextFactory.CreateDbContextAsync();

        // Start a new transaction
        await using var tran = await dbContext.Database.BeginTransactionAsync();

        // Add a new Order
        await dbContext.Orders.AddAsync(new Order()
        {
            OrderDate = DateTime.Now,
            OrderStatus = "C",
            OrderLines =
            [
                new OrderLine() { ProductCode = "A1", Quantity = 2 },
                new OrderLine() { ProductCode = "B2", Quantity = 3 }
            ]
        });

        // Save the database changes
        await dbContext.SaveChangesAsync();

        // Log the audit event within the same transaction
        await _auditLogger.LogAsync("LogTest", new { CustomField = "Test" }, dbContext);

        // Commit the transaction
        await tran.CommitAsync();

    }
}

public interface IMyAuditLogger
{
    Task LogAsync(string eventType, object customFields, MyDbContext dbContext);
}

public class MyAuditLogger : IMyAuditLogger
{
    private readonly IAuditScopeFactory _auditScopeFactory;

    public MyAuditLogger(IAuditScopeFactory auditScopeFactory)
    {
        _auditScopeFactory = auditScopeFactory;
    }

    // Your custom log method
    public async Task LogAsync(string eventType, object customFields, MyDbContext dbContext)
    {
        // Logic is similar to the static AuditScope.LogAsync(), but using the audit scope factory
        // and setting the data provider to save the audit logs using MyDbContext and AuditLog

        await _auditScopeFactory.CreateAsync(f => f
            .EventType(eventType)
            .ExtraFields(customFields)
            .IsCreateAndSave()
            .DataProvider(new DbContextDataProvider<MyDbContext, AuditLog>(c => c
                .DbContext(dbContext)
                .Mapper((auditEvent, auditLog) =>
                {
                    auditLog.AuditDate = DateTime.Now;
                    auditLog.Data = auditEvent.ToJson();
                }))));
    }
}

// Sample DbContext including Orders and AuditLogs
public class MyDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("data source=localhost;initial catalog=Audit_10;integrated security=true;Encrypt=False;");
    }

    public DbSet<Order> Orders { get; set; }

    public DbSet<AuditLog> AuditLogs { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    public string OrderStatus { get; set; }

    public List<OrderLine> OrderLines { get; set; }
}

public class OrderLine
{
    public int Id { get; set; }
    public int Quantity { set; get; }
    public string ProductCode { set; get; }
    public int OrderId { get; set; }
    public Order Order { get; set; }
}


public class AuditLog
{
    public int Id { get; set; }
    public DateTime AuditDate { get; set; }
    public string Data { get; set; }
}

Hope it helps

[voroninp]

Does it use context's SaveChanges or raw sql under the hood? Because if it uses SaveChanges then it risks persisting other tracked entities.

Is it possible to change the behavior to just attaching audit events to the change tracker, so they are saved on call to SaveChanges?

[thepirat000]

Yes, the DbContextDataProvider indeed calls SaveChanges.

Additionally, the SqlDataProvider available in the Audit.NET.SqlServer package can be utilized. It also leverages a DbContext but operates with raw SQL.

Regarding your last question, I believe you can simply use Entity Framework for that purpose—you might not even need the Audit library, correct?

public async Task ExecuteAsync()
{
    await using var dbContext = await _contextFactory.CreateDbContextAsync();

    await dbContext.Orders.AddAsync(new Order()
    {
        OrderDate = DateTime.Now,
        OrderStatus = "C"
    });

    await dbContext.AuditLogs.AddAsync(new AuditLog()
    {
        AuditDate = DateTime.Now,
        Data = "event data..."
    });

    await dbContext.SaveChangesAsync();
}

[voroninp]

Regarding your last question, I believe you can simply use Entity Framework for that purpose—you might not even need the Audit library, correct?

Yes and no. I like that Audit.Net produces audit events containing environment information. I'd like to use this machinery as it already exists in your library.