How to have audit logs in same transaction as changed entities when using DbContextHelper

[ccollinsbt]

I want the audit logs to be in the same transaction as the entity they are logging.

I know there is a note in the docs about overriding OnsScopeCreated(), etc. However, that seems to assume you are inheriting from the AuditDbContext. I am not doing this. I'm just using the DbContextHelper.

I have all of my entities logging, but the audit items come in later and end up in a different transaction.

How do I do this if I'm not inheriting from AuditDbContext? I found Audit.Core.Configuration.AddOnSavingAction and Audit.Core.Configuration.AddOnCreatedAction, which I think might be the way to do it, but the docs say to put my custom saving logic in there, and seem to say that I have to bypass my data provider, but I'm using a custom AuditDataProvider, so I don't want to use a null provider.

Is there any way to do this?

Thanks!

[thepirat000]

Can you provide more details about your configuration and your custom audit data provider?

[thepirat000]

The following example demonstrates how to implement a custom data provider that reuses the DbContext instance to persist audit records generated by Audit.EntityFramework.Core into a dedicated audit table.

The YourDbContext class utilizes an audit helper instead of inheriting from AuditDbContext. It overrides the SaveChanges and SaveChangesAsync methods to begin a transaction before saving changes. Additionally, it defines two custom methods: SaveAuditChanges and SaveAuditChangesAsync, which persist changes while bypassing the audit logic. These methods are invoked from the custom data provider to ensure that audit entries are saved without triggering additional audit processing.

The CustomDataProvider class inherits from the base AuditDataProvider and overrides InsertEvent and InsertEventAsync. These methods extract the same DbContext instance from the audit event, add the audit entry to the Audits table, save the changes using the custom bypass methods, and commit the transaction.

This pattern ensures that both the audited entity changes and their corresponding audit records are saved using the same transactional context.

public class YourDbContext : DbContext
{
    private readonly DbContextHelper _helper = new DbContextHelper();
    private readonly IAuditDbContext _auditContext;

    public DbSet<OrderEntity> Orders { get; set; }
    public DbSet<AuditEventEntity> Audits { get; set; }

    public YourDbContext()
    {
        _auditContext = new DefaultAuditContext(this);
        _helper.SetConfig(_auditContext);
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(...);
    }

    public override int SaveChanges(bool acceptAllChangesOnSuccess)
    {
        return _helper.SaveChanges(_auditContext, () =>
        {
            // Begin a transaction before saving
            this.Database.BeginTransaction();

            return base.SaveChanges(acceptAllChangesOnSuccess);
        });
    }
    
    public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default(CancellationToken))
    {
        return await _helper.SaveChangesAsync(_auditContext, async () =>
        {
            // Begin a transaction
            await this.Database.BeginTransactionAsync(cancellationToken);
            
            return await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
        }, cancellationToken);
    }

    // Custom save changes method that bypasses the audit process, call this method to save the Audit entities
    public int SaveAuditChanges(bool acceptAllChangesOnSuccess = true)
    {
        return base.SaveChanges(acceptAllChangesOnSuccess);
    }

    public Task<int> SaveAuditChangesAsync(bool acceptAllChangesOnSuccess = true, CancellationToken cancellationToken = default)
    {
        return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
    }
}

public class CustomDataProvider : AuditDataProvider
{
    public override object InsertEvent(AuditEvent auditEvent)
    {
        // Get the DbContext from the EF AuditEvent
        var dbContext = GetDbContext(auditEvent);

        // Insert the audit event into the database
        dbContext.Audits.Add(new AuditEventEntity
        {
            AuditData = auditEvent.ToJson()
            //...
        });

        dbContext.SaveAuditChanges();

        // Commit the transaction
        dbContext.Database.CurrentTransaction?.Commit();

        return null;
    }

    public override async Task<object> InsertEventAsync(AuditEvent auditEvent, CancellationToken cancellationToken = default)
    {
        // Get the DbContext from the EF AuditEvent
        var dbContext = GetDbContext(auditEvent);

        // Insert the audit event into the database
        dbContext.Audits.Add(new AuditEventEntity
        {
            AuditData = auditEvent.ToJson()
            //...
        });

        // Save the audit (we want to bypass)
        await dbContext.SaveAuditChangesAsync(cancellationToken: cancellationToken);

        // Commit the transaction
        if (dbContext.Database.CurrentTransaction != null)
        {
            await dbContext.Database.CurrentTransaction.CommitAsync(cancellationToken: cancellationToken);
        }

        return null;
    }

    private static YourDbContext GetDbContext(AuditEvent auditEvent)
    {
        return auditEvent.GetEntityFrameworkEvent().GetDbContext() as YourDbContext;
    }
}

public class OrderEntity
{
    public int Id { get; set; }
    public double Amount { get; set; }
}

[AuditIgnore]
public class AuditEventEntity
{
    public int Id { get; set; }
    public string AuditData { get; set; }
}

[ccollinsbt]

Thanks for that. it makes sense.

However, I have another problem on top of this. The auditing I am doing logs the EntityFramework changes, but it also audits access to some other parts of the system (readonly only type things). For those items, I write the audit logs manually into entity framework as opposed to doing it via my DataProvider.

In these cases, the only things being written are audit logs, and because my audit log table has AuditIgnore, I'm assuming there is no Audit event created, and the data provider never gets called. As a result, the transaction never gets committed.

Instead, I tried doing the following, just so I had a way to commit the transaction if the custom data provider never gets called (and I pulled out :

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            Audit.Core.Configuration.AddCustomAction(ActionType.OnScopeCreated, async (scope) =>
            {
                if (scope.GetEntityFrameworkEvent().GetDbContext().Database.CurrentTransaction == null)
                {
                    await scope.GetEntityFrameworkEvent().GetDbContext().Database.BeginTransactionAsync();
                }
            });
            Audit.Core.Configuration.AddCustomAction(ActionType.OnScopeDisposed, async (scope) =>
            {
                var db = scope.GetEntityFrameworkEvent().GetDbContext().Database;
                if(db.CurrentTransaction?.GetDbTransaction()?.Connection?.State.HasFlag(System.Data.ConnectionState.Open) ?? false)
                {
                    await db.CommitTransactionAsync();
                }
            });
            Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaved, async (scope) =>
            {
                var db = scope.GetEntityFrameworkEvent().GetDbContext().Database;
                if(db.CurrentTransaction?.GetDbTransaction()?.Connection?.State.HasFlag(System.Data.ConnectionState.Open) ?? false)
                {
                    await db.CommitTransactionAsync();
                }
            });

            //base.OnConfiguring(optionsBuilder);
        }

        public override int SaveChanges()
        {
                return _helper.SaveChanges(_auditDbContext, () => base.SaveChanges());
        }

        public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
        {
                return await _helper.SaveChangesAsync(_auditDbContext, () => base.SaveChangesAsync(), cancellationToken);
        }

However, I notice that the OnScopeCreated gets called multiple times (I think I counted 11 times when there were only 3 entities to be written to the DB, other than the audit logs). Why would it get called that many times?

I expected there just to be one AuditScope that contained all of the entities that would be saved at that time, but perhaps I am misunderstanding what it is?

The above seems to work, but I'm not sure I'm doing the right thing, and having to add a bunch of checks to see if a transaction already exists seems weird. What do you think?

[thepirat000]

Ensure that OnConfiguring(DbContextOptionsBuilder optionsBuilder) is not being invoked multiple times.

In fact, calls to Audit.Core.Configuration.AddCustomAction should be placed either in your application's startup logic or in a static constructor to guarantee they are registered only once.

[ccollinsbt]

Thanks again.

I moved those out to a static constructor, but then I had a requirement to create an execution strategy and run the transaction inside of it. Since I couldn't do this as an ambient transaction, and have the writes distributed in different places, I ended up removing those and just creating the transaction in the SaveChanges method on the DbContext.

This seems messy though, so do you see any other way to do it?

Basically, I am assuming that GetModifiedEntries > 0 indicates to me that the DataProvider will be triggered to create my audit log, in which case I create a transaction. Otherwise, I don't even call the _helper, and just call my base SaveChanges (without a transaction):

        public override int SaveChanges()
        {
            if (_helper.GetModifiedEntries(_auditDbContext).Count > 0)
            {
                var strategy = Database.CreateExecutionStrategy();
                strategy.Execute(() =>
                {
                    using var transaction = Database.BeginTransaction();
                    var result = _helper.SaveChanges(_auditDbContext, () => base.SaveChanges());
                    transaction.Commit();

                    return result;
                });

                return -1;
            }
            else
            {
                return base.SaveChanges();
            }
        }

Is the best approach to using execution strategies along with the auditing?

[thepirat000]

I think your code looks good overall.

The only suggestion I have is to override the SaveChanges and SaveChangesAsync overloads that accept a boolean parameter (int SaveChanges(bool acceptAllChangesOnSuccess) and Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)), instead. Otherwise, calling yourDbContext.SaveChanges(true) would bypass the audit logic.

Note that the parameterless SaveChanges() and SaveChangesAsync(CancellationToken) methods internally call SaveChanges(true) and SaveChangesAsync(true, cancellationToken), respectively.

Also, I'm not sure why you're returning -1 you could simply return the result of SaveChanges.

public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
    if (_helper.GetModifiedEntries(_auditContext).Count > 0)
    {
        var strategy = Database.CreateExecutionStrategy();
        var result = strategy.Execute(() =>
        {
            using var transaction = Database.BeginTransaction();
            var result = _helper.SaveChanges(_auditContext, () => base.SaveChanges(acceptAllChangesOnSuccess));
            transaction.Commit();

            return result;
        });

        return result;
    }

    return base.SaveChanges(acceptAllChangesOnSuccess);
}

public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default(CancellationToken))
{
    // Async version...
}