Is it possible to enqueue the Audit to be processed later?

[Ewerton]

To offload from the main app the serialization and the saving process, I want to enqueue the audit serialization and saving processing to execute it later by another server. Is it possible?

Before I knew Audit.NET I wanted to do something like this:

• Override the SaveChanges() from EntityFramework and enqueue the ChangeTracker data to a queue.
• Another application in another server will process the queue to serialize and save the audit data to Postgres Database

Is something similar to it possible with Audit.NET?

[thepirat000]

Certainly, you have the option to do that, but it depends on the location where you intend to maintain the queue.
Using an in-memory queue may not be suitable, since you're consuming messages from a distinct server.

how do you anticipate the other server retrieving the generated audit?

If you opt for Redis or Confluent Kafka, you may use the Audit.NET.Kafka or Audit.NET.Redis extensions.

Alternatively, you have the flexibility to create a custom data provider to store the audit events.

[Ewerton]

I was thinking about and reconsidering if my initial approach is good enough to offload the auditing and saving processing from the main thread, now I'm considering two options:

1. Process and save the auditing data in the same server but in another thread.
   It will "release" the main thread to continue its jobs and it will offload the auditing processing and saving as desired.
2. Process and save the auditing data in other server
   It will "release" the main thread to continue its job but the main thread will need to "send" the auditing data to some queue keeping this "sending" process in the main thread. Don't know if it is a problem, as you mentioned Audit.NET.Redis I suppose I can use Redis as a queue and it will be (probably) fast.

Am I right with my assumptions? Any advice on which path should I follow?

[thepirat000]

I can't advise since there are many things to consider depending on your use cases.

But I can give you some examples.

A simple fire-and-forget mechanism can be achieved by creating a custom data provider that inherits from the real data provider and overrides the Insert methods to execute the insert in a different thread:

public class FireAndForgetPostgreSqlDataProvider : PostgreSqlDataProvider
{
    public FireAndForgetPostgreSqlDataProvider(Action<IPostgreSqlProviderConfigurator> c) : base(c) { }

    public override object InsertEvent(AuditEvent auditEvent)
    {
        Task.Run(() =>
        {
            try
            {
                base.InsertEvent(auditEvent);
            }
            catch
            {
                // fire-and-forget
            }
        });

        return new object();
    }


    public override Task<object> InsertEventAsync(AuditEvent auditEvent, CancellationToken cancellationToken = default)
    {
        Task.Run(() =>
        {
            try
            {
                base.InsertEventAsync(auditEvent, cancellationToken);
            }
            catch
            {
                // fire-and-forget
            }
        }, cancellationToken);

        return Task.FromResult(new object());
    }
}

// And to configure:
Audit.Core.Configuration.Setup()
    .Use(new FireAndForgetPostgreSqlDataProvider(config => config
        .ConnectionString("...")
        .TableName("audit")));

Or, if you wish to use Redis, you could use a Redis List as a Queue, for example:

// Configure Redis List as audit output
Audit.Core.Configuration.Setup()
    .UseRedis(config => config
        .ConnectionString("localhost:6379")
        .AsList(list => list.Key("AuditList")));

// generate the logs...

// In a different process, you could use StackExchange.Redis to consume the List:
var connectionMultiplexer = ConnectionMultiplexer.Connect("localhost:6379");

while (true)
{
    var auditEventJson = connectionMultiplexer.GetDatabase().ListRightPop("AuditList");

    if (auditEventJson.HasValue)
    {
        // store the audit event...
        var auditEvent = JsonSerializer.Deserialize<AuditEvent>(auditEventJson);
        Store(auditEvent);
    }
}

[Ewerton]

That's an elegant and effective solution to my requirement.
Thank you so much!