Add logging behavior.

Author: Anthony Sneed

reference-architecture/Common/Behaviors/LoggingBehavior.cs

@@ -0,0 +1,29 @@
+using Common.Helpers;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace Common.Behaviors;
+
+public class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ILogger<LoggingBehavior<TRequest, TResponse>> _logger;
+
+    public LoggingBehavior(
+        ILogger<LoggingBehavior<TRequest, TResponse>> logger)
+    {
+        _logger = logger;
+    }
+    
+    public async Task<TResponse> Handle(
+        TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
+    {
+        _logger.LogInformation("----- Handling command {CommandName}. Request: {@Command}", 
+            request.GetGenericTypeName(), request);
+        var response = await next();
+        _logger.LogInformation("----- Handled Command {CommandName}. Response: {@Response}", 
+            request.GetGenericTypeName(), response);
+
+        return response;
+    }
+}

reference-architecture/Common/Common.csproj

@@ -8,6 +8,8 @@
 
     <ItemGroup>
         <PackageReference Include="EventDriven.EventBus.Abstractions" Version="1.2.0" />
+        <PackageReference Include="MediatR" Version="10.0.1" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
     </ItemGroup>
 
 </Project>

reference-architecture/Common/Helpers/GenericTypeExtensions.cs

@@ -0,0 +1,26 @@
+namespace Common.Helpers;
+
+public static class GenericTypeExtensions
+{
+    public static string GetGenericTypeName(this Type type)
+    {
+        string typeName;
+
+        if (type.IsGenericType)
+        {
+            var genericTypes = string.Join(",", type.GetGenericArguments().Select(t => t.Name).ToArray());
+            typeName = $"{type.Name.Remove(type.Name.IndexOf('`'))}<{genericTypes}>";
+        }
+        else
+        {
+            typeName = type.Name;
+        }
+
+        return typeName;
+    }
+    
+    public static string GetGenericTypeName(this object @object)
+    {
+        return @object.GetType().GetGenericTypeName();
+    }
+}

reference-architecture/CustomerService/Domain/CustomerAggregate/CommandHandlers/CreateCustomerHandler.cs

@@ -7,20 +7,16 @@ namespace CustomerService.Domain.CustomerAggregate.CommandHandlers;
 public class CreateCustomerHandler : ICommandHandler<Customer, CreateCustomer>
 {
     private readonly ICustomerRepository _repository;
-    private readonly ILogger<CreateCustomerHandler> _logger;
 
     public CreateCustomerHandler(
-        ICustomerRepository repository,
-        ILogger<CreateCustomerHandler> logger)
+        ICustomerRepository repository)
     {
         _repository = repository;
-        _logger = logger;
     }
 
     public async Task<CommandResult<Customer>> Handle(CreateCustomer command, CancellationToken cancellationToken)
     {
         // Process command
-        _logger.LogInformation("Handling command: {CommandName}", nameof(CreateCustomer));
         if (command.Entity == null) return new CommandResult<Customer>(CommandOutcome.InvalidCommand);
         var domainEvent = command.Entity.Process(command);
 

reference-architecture/CustomerService/Domain/CustomerAggregate/CommandHandlers/RemoveCustomerHandler.cs

@@ -7,19 +7,15 @@ namespace CustomerService.Domain.CustomerAggregate.CommandHandlers;
 public class RemoveCustomerHandler : ICommandHandler<RemoveCustomer>
 {
     private readonly ICustomerRepository _repository;
-    private readonly ILogger<RemoveCustomerHandler> _logger;
 
     public RemoveCustomerHandler(
-        ICustomerRepository repository,
-        ILogger<RemoveCustomerHandler> logger)
+        ICustomerRepository repository)
     {
         _repository = repository;
-        _logger = logger;
     }
 
     public async Task<CommandResult> Handle(RemoveCustomer command, CancellationToken cancellationToken)
     {
-        _logger.LogInformation("Handling command: {CommandName}", nameof(RemoveCustomer));
         var entity = await _repository.GetAsync(command.EntityId);
         if (entity != null)
         {

reference-architecture/CustomerService/Domain/CustomerAggregate/CommandHandlers/UpdateCustomerHandler.cs

@@ -31,7 +31,6 @@ public UpdateCustomerHandler(
     public async Task<CommandResult<Customer>> Handle(UpdateCustomer command, CancellationToken cancellationToken)
     {
         // Process command
-        _logger.LogInformation("Handling command: {CommandName}", nameof(UpdateCustomer));
         if (command.Entity == null) return new CommandResult<Customer>(CommandOutcome.InvalidCommand);
         var domainEvent = command.Entity.Process(command);
 
@@ -53,7 +52,7 @@ public async Task<CommandResult<Customer>> Handle(UpdateCustomer command, Cancel
             if (addressChanged)
             {
                 var shippingAddress = _mapper.Map<Integration.Models.Address>(entity.ShippingAddress);
-                _logger.LogInformation("Publishing event: {EventName}", $"v1.{nameof(CustomerAddressUpdated)}");
+                _logger.LogInformation("----- Publishing event: {EventName}", $"v1.{nameof(CustomerAddressUpdated)}");
                 await _eventBus.PublishAsync(
                     new CustomerAddressUpdated(entity.Id, shippingAddress),
                     null, "v1");

reference-architecture/CustomerService/Domain/CustomerAggregate/QueryHandlers/GetCustomerHandler.cs

@@ -7,20 +7,16 @@ namespace CustomerService.Domain.CustomerAggregate.QueryHandlers;
 public class GetCustomerHandler : IQueryHandler<GetCustomer, Customer?>
 {
     private readonly ICustomerRepository _repository;
-    private readonly ILogger<GetCustomerHandler> _logger;
 
     public GetCustomerHandler(
-        ICustomerRepository repository,
-        ILogger<GetCustomerHandler> logger)
+        ICustomerRepository repository)
     {
         _repository = repository;
-        _logger = logger;
     }
 
     public async Task<Customer?> Handle(GetCustomer query, CancellationToken cancellationToken)
     {
         // Retrieve entity
-        _logger.LogInformation("Handling command: {CommandName}", nameof(GetCustomers));
         var result = await _repository.GetAsync(query.Id);
         return result;
     }

reference-architecture/CustomerService/Domain/CustomerAggregate/QueryHandlers/GetCustomersHandler.cs

@@ -7,20 +7,16 @@ namespace CustomerService.Domain.CustomerAggregate.QueryHandlers;
 public class GetCustomersHandler : IQueryHandler<GetCustomers, IEnumerable<Customer>>
 {
     private readonly ICustomerRepository _repository;
-    private readonly ILogger<GetCustomersHandler> _logger;
 
     public GetCustomersHandler(
-        ICustomerRepository repository,
-        ILogger<GetCustomersHandler> logger)
+        ICustomerRepository repository)
     {
         _repository = repository;
-        _logger = logger;
     }
 
     public async Task<IEnumerable<Customer>> Handle(GetCustomers query, CancellationToken cancellationToken)
     {
         // Retrieve entities
-        _logger.LogInformation("Handling command: {CommandName}", nameof(GetCustomers));
         var result = await _repository.GetAsync();
         return result;
     }

reference-architecture/CustomerService/Program.cs

@@ -1,8 +1,10 @@
+using Common.Behaviors;
 using CustomerService.Configuration;
 using CustomerService.Domain.CustomerAggregate;
 using CustomerService.Repositories;
 using EventDriven.CQRS.Abstractions.DependencyInjection;
 using EventDriven.DependencyInjection.URF.Mongo;
+using MediatR;
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -17,6 +19,9 @@
 // Add command and query handlers
 builder.Services.AddHandlers(typeof(Program));
 
+// Add behaviors
+builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
+
 // Add database settings
 builder.Services.AddSingleton<ICustomerRepository, CustomerRepository>();
 builder.Services.AddMongoDbSettings<CustomerDatabaseSettings, Customer>(builder.Configuration);

reference-architecture/OrderService/Domain/OrderAggregate/CommandHandlers/CancelOrderHandler.cs

@@ -8,20 +8,16 @@ namespace OrderService.Domain.OrderAggregate.CommandHandlers;
 public class CancelOrderHandler : ICommandHandler<Order, CancelOrder>
 {
     private readonly IOrderRepository _repository;
-    private readonly ILogger<CancelOrderHandler> _logger;
 
     public CancelOrderHandler(
-        IOrderRepository repository,
-        ILogger<CancelOrderHandler> logger)
+        IOrderRepository repository)
     {
         _repository = repository;
-        _logger = logger;
     }
 
     public async Task<CommandResult<Order>> Handle(CancelOrder command, CancellationToken cancellationToken)
     {
         // Process command
-        _logger.LogInformation("Handling command: {CommandName}", nameof(CancelOrder));
         var entity = await _repository.GetAsync(command.EntityId);
         if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);
         var domainEvent = entity.Process(command);