Generating multiple audit events

[daneel3001]

Assuming that an operation is targeting one or many entities, the entire set may contain one or many entities under the auditing scope.
Is there a recommended approach to achieve this using Audit.Net ?

The options I see possible are:

• AuditScope which unfortunately work only by giving the reference to the audited entity
• Using EntityFramework with subsequent transformation of the generated audit events

[thepirat000]

Could you provide additional context? What specific operations are you aiming to audit, and what is the desired outcome?

[daneel3001]

Here is a description of the scenario:

• I would like that Audit events are emitted for a specific set of entities
• Those entities are related to each other through various relationships, 1-1, 1-many, many-many
• An API backend is responsible in handling an operation which data accessed via Entity Framework

Example of a model, and we can say that each of these entities represent "aggregate roots"

• A Task is assigned to a Person
• A Task is related to an object it is for, example a Marketing Campaign

I may have a backend operation which within the same transaction update information about the Marketing Campaign and assign a Task to it.
However, in terms of audit events, I would like distinct audit event to be generated:

• One for the Marketing Campaign
• One for the Task

The Marketing Campaign audit may say that some state may have changed, and for the Task it may say that one Task got added to the Marketing Campaign.

[thepirat000]

For your use case, the best option might be to use Audit.EntityFramework.Core for generating audit events and a custom data provider with the logic to inspect the changes and store multiple logs.

The approach will depend on how you configure audit generation and where you plan to store the audit events.

Provide more context if you need additional assistance.

Below is an example that makes several assumptions, but it demonstrates how you can implement the solution:

public class MyDbContext : AuditDbContext
{
    public DbSet<MarketingCampaign> MarketingCampaigns { get; set; }
    public DbSet<MarketingCampaignTask> MarketingCampaignTasks { get; set; }
    
    public DbSet<AuditLog> AuditLogs { get; set; }

    public sealed override AuditDataProvider AuditDataProvider { get; set; }

    public MyDbContext(DbContextOptions options) : base(options)
    {
        // Set the custom data provider to use
        AuditDataProvider = new MyAuditDataProvider(this);
    }   
}

public class MyAuditDataProvider : AuditDataProvider
{
    private readonly MyDbContext _dbContext;

    public MyAuditDataProvider(MyDbContext dbContext)
    {
        // Assuming you want to use a DbContext to save the audit logs
        _dbContext = dbContext;
    }
    
    public override object InsertEvent(AuditEvent auditEvent)
    {
        return InsertEventAsync(auditEvent, default).ConfigureAwait(false).GetAwaiter().GetResult();
    }
    
    public override async Task<object> InsertEventAsync(AuditEvent auditEvent, CancellationToken cancellationToken = default)
    {
        // Detect the different kind of changes, and generate the logs accordingly
        var entries = auditEvent.GetEntityFrameworkEvent().Entries;

        // Find any INSERT operation on the MarketingCampaigns table where the TaskId is not NULL
        var createdEntry = entries.Find(entry =>
            entry.Table == "MarketingCampaigns"
            && entry.Action == "Insert"
            && entry.ColumnValues.ContainsKey("MarketingCampaignTaskId")
            && entry.ColumnValues["MarketingCampaignTaskId"] != null);

        // Find any UPDATE operation on the MarketingCampaigns table where the TaskId is changed
        var updatedEntry = entries.Find(entry =>
            entry.Table == "MarketingCampaigns"
            && entry.Action == "Update"
            && entry.Changes.Exists(ch => ch.ColumnName == "MarketingCampaignTaskId"));

        // If found, generate a log entry / save it to the database 
        if (createdEntry != null)
        {
            await InsertCampaignLogAsync(createdEntry, cancellationToken);
        }

        if (updatedEntry != null)
        {
            await InsertCampaignLogAsync(updatedEntry, cancellationToken);
        }

        await _dbContext.SaveChangesAsync(cancellationToken);

        return new object();
    }

    private async Task InsertCampaignLogAsync(EventEntry entry, CancellationToken cancellationToken)
    {
        var campaign = entry.Entity as MarketingCampaign;

        var text = $"{entry.Action} - Campaign {campaign.Name} - TaskId {campaign.MarketingCampaignTaskId}";

        await _dbContext.AuditLogs.AddAsync(new AuditLog { Details = text }, cancellationToken);
    }
}