Tracking Raw Sql Queries in Audit.EntityFramework.Core

Hello,

I just implemented Audit.NET and I am using the Audit.EntityFramework.Core library to track entity changes.

I noticed that any calls to SaveChangesAsync is tracked just as stated. The issue is any query executed using DbContext.Database.ExecuteSqlRawAsync() is not tracked.

Is there a way to track these kind of changes?

Thanks.

[thepirat000]

A new command interceptor was provided that logs raw SQL queries, for EF Core 3.0 and EF Core 5.0 starting on version 18.1.5

More information on the readme here

So you could attach the command interceptor with:

public class MyContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.AddInterceptors(new AuditCommandInterceptor());
    }
}

[thepirat000]

For EF Core 5, I think one option is to use a DbCommandInterceptor that intercepts the ExecuteSqlRaw calls, but I’m afraid it will also intercept any other commands issued by EF internally.

Check this: https://docs.microsoft.com/en-us/ef/core/logging-events-diagnostics/

For example:

public class AuditCommandInterceptor : DbCommandInterceptor
{
    public override int NonQueryExecuted(DbCommand command, CommandExecutedEventData eventData, int result)
    {
        var parameters = new Dictionary<string, object>();
        foreach (DbParameter p in command.Parameters)
            parameters.Add(p.ParameterName, p.Value);
        using var scope = AuditScope.Create(new AuditScopeOptions()
        {
            EventType = "NonQueryExecuted:Success",
            IsCreateAndSave = true,
            ExtraFields = new
            {
                Command = new 
                {
                    Duration = (int)eventData.Duration.TotalMilliseconds,
                    Text = command.CommandText,
                    Params = parameters,
                },
                ConnectionId = eventData.ConnectionId,
                Result = result
            }
        });
        return base.NonQueryExecuted(command, eventData, result);
    }

    public override void CommandFailed(DbCommand command, CommandErrorEventData eventData)
    {
        var parameters = new Dictionary<string, object>();
        foreach (DbParameter p in command.Parameters)
            parameters.Add(p.ParameterName, p.Value);
        using var scope = AuditScope.Create(new AuditScopeOptions()
        {
            EventType = "NonQueryExecuted:Failure",
            IsCreateAndSave = true,
            ExtraFields = new
            {
                Command = new
                {
                    Duration = (int)eventData.Duration.TotalMilliseconds,
                    Text = command.CommandText,
                    Params = parameters,
                },
                ConnectionId = eventData.ConnectionId,
                Error = eventData.Exception.ToString()
            }
        });
        base.CommandFailed(command, eventData);
    }
}

Note you should also implement the Async version of the methods: NonQueryExecutedAsync and CommandFailedAsync.

Then you can add the interceptor when creating your DbContext, for example:

using (var ctx = new MyContext(new DbContextOptionsBuilder<MyContext>()
    .UseSqlServer("...")
    .AddInterceptors(new AuditCommandInterceptor())
    .Options))
{
    var result = ctx.Database.ExecuteSqlRaw("INSERT INTO ITEMS (Name) VALUES ({0})", "test");
    //...
}