Tracking Audit Logs with RabbitMQ: Publishing and Consuming Events in .NET

 dotnet new webapi -n UserActivityLogger
 cd UserActivityLogger

 dotnet add package RabbitMQ.Client --version 6.8.1

 {
  ...,
  "RabbitMQ": {
    "HostName": "localhost",
    "Port": 5672,
    "UserName": "guest",
    "Password": "guest",
    "QueueName": "user_registration_queue"
  }
}

public class User
{
    public string Username { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
}

public static class UserStore
{
    public static List<User> Users = new();
}

namespace UserActivityLogger.Settings
{
    public class RabbitMQSettings
    {
        public string HostName { get; set; } = string.Empty;
        public int Port { get; set; } = 5672;
        public string UserName { get; set; } = "guest";
        public string Password { get; set; } = "guest";
        public string QueueName { get; set; } = "user_registration_queue";
    }
}

var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<RabbitMQSettings>(builder.Configuration.GetSection("RabbitMQ"));

using RabbitMQ.Client;
using System.Text;
using Microsoft.Extensions.Configuration;
using UserActivityLogger.Settings;
using Microsoft.Extensions.Options;

namespace UserActivityLogger.Service
{
    public class RabbitMQService
    {
        private readonly IConnection _connection;
        private readonly IModel _channel;
        private readonly RabbitMQSettings _settings;

        public RabbitMQService(IOptions<RabbitMQSettings> settings)
        {
            _settings = settings.Value;
            var factory = new ConnectionFactory()
            {
                HostName = _settings.HostName,
                Port = _settings.Port,
                UserName = _settings.UserName,
                Password = _settings.Password,
                AutomaticRecoveryEnabled = true // Automatically reconnects if RabbitMQ restarts
            };
            _connection = factory.CreateConnection();
            _channel = _connection.CreateModel();

            _channel.QueueDeclare(
                _settings.QueueName,
                durable: true, // The queue will persist even if RabbitMQ restarts.
                exclusive: false, // Allows multiple consumers to listen to this queue.
                autoDelete: false // Prevents the queue from being deleted when no consumers are active.
            );
        }

        public void PublishMessage(string message)
        {
            var body = Encoding.UTF8.GetBytes(message);
            // Publish a message to the specified queue
            _channel.BasicPublish(exchange: "", routingKey: _settings.QueueName, basicProperties: null, body: body);
        }
    }
}

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System.Text;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using UserActivityLogger.Settings;

namespace UserActivityLogger.Service
{
    public class UserRegistrationConsumerService : BackgroundService
    {
        private readonly IConnection _connection;
        private readonly IModel _channel;
        private readonly RabbitMQSettings _settings;

        public UserRegistrationConsumerService(IOptions<RabbitMQSettings> settings)
        {
            _settings = settings.Value;

            var factory = new ConnectionFactory()
            {
                HostName = _settings.HostName,
                Port = _settings.Port,
                UserName = _settings.UserName,
                Password = _settings.Password,
                AutomaticRecoveryEnabled = true
            };
            _connection = factory.CreateConnection();
            _channel = _connection.CreateModel();

            // Declares a queue to ensure it exists before consuming messages
            _channel.QueueDeclare(_settings.QueueName, durable: true, exclusive: false, autoDelete: false);
        }

        protected override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var consumer = new EventingBasicConsumer(_channel);

            // Event triggered when a message is received
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine($"User registration event received: {message}");
            };

            // Starts consuming messages from the queue
            _channel.BasicConsume(queue: _settings.QueueName, autoAck: true, consumer: consumer);

            return Task.CompletedTask;
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using UserActivityLogger.Model;
using UserActivityLogger.Service;

namespace UserActivityLogger.Controller
{
    [ApiController]
    [Route("api/user")]
    public class UserController : ControllerBase
    {
        private readonly RabbitMQService _rabbitMQService;

        public UserController(RabbitMQService rabbitMQService)
        {
            _rabbitMQService = rabbitMQService;
        }

        [HttpPost("register")]
        public IActionResult RegisterUser([FromBody] User user)
        {
            UserStore.Users.Add(user);
            _rabbitMQService.PublishMessage($"User {user.Username} registered with email {user.Email}");
            return Ok("User registered successfully");
        }
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<RabbitMQService>();
builder.Services.AddHostedService<UserRegistrationConsumerService>();

var app = builder.Build();
app.UseAuthorization();
app.MapControllers();
app.Run();