Is it possible to use Audit.Core with Worker Service project type ?

[evertonbastiani]

Hello everyone.
I'd like to know if it's possible to use Audit.NET with Worker Service Project or Console Application/Windows Application
For example, by using data annotation as the same way we use it on Web API.
E.G

Web API
[AuditApi(EventTypeName = "My custom event")]
public async Task Post([FromBody] model)

Worker Service
[Audit (?????)
public override Task StartAsync(CancellationToken cancellationToken)

Thank you all

[thepirat000]

I believe that incorporating Audit.NET seamlessly with a Worker Service will not provide too much value, as the library might not have extensive points of integration to facilitate a standardized approach for auditing.

But you could use the AuditScope in your background service, for example:

using Audit.Core;

public class Worker : BackgroundService
{
    private AuditScope? _auditScope;

    public override Task StartAsync(CancellationToken cancellationToken)
    {
        _auditScope = AuditScope.Create(new AuditScopeOptions()
        {
            CreationPolicy = EventCreationPolicy.InsertOnEnd
        });
        
        return base.StartAsync(cancellationToken);
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _auditScope!.SetCustomField("WorkerExecutionStart", DateTimeOffset.Now);

        int i = 0;
        while (!stoppingToken.IsCancellationRequested)
        {
            _auditScope.Comment($"Worker {++i} running at: {DateTimeOffset.Now}");

            try
            {
                await DoSomeWorkAsync(stoppingToken);
            }
            catch (Exception e)
            {
                _auditScope.SetCustomField("Exception", e.Message);
                throw;
            }
        }

        _auditScope!.SetCustomField("WorkerExecutionEnd", DateTimeOffset.Now);
    }

    private async Task DoSomeWorkAsync(CancellationToken ct)
    {
        // do some work...
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        await base.StopAsync(cancellationToken);

        await _auditScope!.DisposeAsync();
    }

    public override void Dispose()
    {
        _auditScope?.Dispose();
        
        base.Dispose();
    }
}

[evertonbastiani]

It works.. thank you @thepirat000 .

[thepirat000]

Take into account that this example is using the InsertOnEnd creation policy. So, if the process is terminated or crashed, the audit event will be lost and not saved. You can change this behavior using InsertOnStartInsertOnEnd or InsertOnStartReplaceOnEnd creation policies

[Cosmas47]

@thepirat000 - This actually would be extremely valuable for integrating Audit.Net into RabbitMQ/MassTransit which is actually something I'm struggling with myself. Such systems use a BackgroundService as a means to forward messages to RabbitMQ, therefore a DataProvider would have to somehow forward messages into the BackgroundService. Would love to see this native in Audit.Net.

[Cosmas47]

Here's how I went about implementing it on my end:

public class AuditListener : BackgroundService
{
    readonly Func<DataContext> appDbContextFactory;
    readonly DataContext dataContext;
    IModel channel;

    public AuditListener(Func<DataContext> factory)
    {
        appDbContextFactory = factory;
        dataContext = appDbContextFactory();
        Initialize();
    }

    void Initialize()
    {
        var factory = new ConnectionFactory
        {
            Uri = new Uri(Environment.GetEnvironmentVariable("DBConnectionString"))
        };
        var connection = factory.CreateConnection();
        channel = connection.CreateModel();
        channel.QueueDeclare("audit-queue", durable: true, exclusive: false, autoDelete: false, arguments: null);
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumer = new EventingBasicConsumer(channel);
        consumer.Received += async (model, eventArgs) => 
        {
            var body = eventArgs.Body.ToArray();
            string message = Encoding.UTF8.GetString(body);
            if (message.Length > 0)
            {
                var data = JsonConvert.DeserializeObject<AuditEventDTO>(message);

                //Write to DB
                AuditEntry entry = new AuditEntry();
                entry.Data = data.ToJSon(message.ToString());
                //Do some more db column specific things here...

                using (var context = appDbContextFactory())
                {
                    await context.tableName.AddAsync(entry);
                    await context.SaveChangesAsync();
                }

                channel.BasicAck(eventArgs.DeliveryTag, true);
            }
        };
        channel.BasicConsume("audit-queue", false, consumer);
        return;
    }

and then in Program.cs you'd need:
builder.Services.AddHostedService<AuditListener>();

[thepirat000]

Oh but I was talking about the producer, not the consumer. How do you publish the audit events to the queue?

[Cosmas47]

It's as you suggested, just a custom DataProvider.

public class MassTransitDataProvider : AuditDataProvider
{
    public override object InsertEvent(AuditEvent auditEvent)
    {
        Task.Run(() =>
        {
            try
            {
                var factory = new ConnectionFactory
                {
                    Uri = new Uri(Environment.GetEnvironmentVariable("DBConnectionString-Audits"))
                };
                var connection = factory.CreateConnection();
                using var channel = connection.CreateModel();
                channel.QueueDeclare("audit-queue",
                    durable: true,
                    exclusive: false,
                    autoDelete: false,
                    arguments: null);

                var json = JsonConvert.SerializeObject(auditEvent);

                var body = Encoding.UTF8.GetBytes(json);

                channel.BasicPublish(exchange: "", routingKey: "audit-queue", basicProperties: null, body: body);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error occurred while sending audit event via RabbitMQ: {ex.Message}");
            }
        });
        return null;
    }
}

I'm sure there's a more proper way to do this. I'm obviously sending data in a very direct way, it just seemed clearer to me since I hadn't wrapped my head around scopes.

[thepirat000]

I think the library could provide an InMemory data provider that internally uses a BlockingCollection and exposes a mechanism to consume the events.

Something like this.

So, you could have a Background Service that consumes the collection and publishes the events, all being thread-safe.

public class AuditProviderBackgroundService : BackgroundService
{
  private readonly IBus _bus;

  public AuditProviderBackgroundService(IBus bus)
  {
    _bus = bus;
  }

  public override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
    var dataProvider = Audit.Core.Configuration.DataProviderAs<InMemoryProducerDataProvider>() ?? throw new InvalidOperationException();

    // Yield to the caller to allow startup to be asynchronous
    await Task.Yield();

    while (!stoppingToken.IsCancellationRequested)
    {
      var auditEvent = dataProvider.Take(stoppingToken);
      _bus.Publish(auditEvent);
    }
  }
}

And in your startup:

Audit.Core.Configuration.DataProvider = new InMemoryProducerDataProvider();
svc.AddHostedService<AuditProviderBackgroundService>();

[thepirat000]

Check the new providers: BlockingCollectionDataProvider and ChannelDataProvider available starting in version 25.0.1.

For example

Audit.Core.Configuration.DataProvider = new ChannelDataProvider();
svc.AddHostedService<AuditConsumerBackgroundService>();

public class AuditConsumerBackgroundService : BackgroundService
{
  private readonly IBus _bus;

  public AuditProviderBackgroundService(IBus bus)
  {
    _bus = bus;
  }

  public override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
    var dataProvider = Audit.Core.Configuration.DataProviderAs<ChannelDataProvider>() ?? throw new InvalidOperationException();

    while (!stoppingToken.IsCancellationRequested)
    {
      var auditEvent = await dataProvider.TakeAsync(stoppingToken);
      _bus.Publish(auditEvent);
    }
  }
}