add structured logging to reliability snapshot generation

src/TransitPulse.API/Program.cs

@@ -1,32 +1,20 @@
-using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
-using TransitPulse.Application.Interfaces;
-using TransitPulse.Infrastructure.Repositories;
-using TransitPulse.Infrastructure.Services;
+using TransitPulse.Application;
+using TransitPulse.Infrastructure;
 using TransitPulse.API.Middleware;
-using Microsoft.EntityFrameworkCore;
-using TransitPulse.Infrastructure.Persistence;
-using TransitPulse.Domain.Entities;
-using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshots;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddControllers();
+// ASP.NET Core framework
+builder.Services.AddControllers(); //Registers the Web API framework.
+builder.Services.AddOpenApi(); //Registers the OpenAPI documentation services.
 
-builder.Services.AddOpenApi();
-builder.Services.AddDbContext<TransitPulseDbContext>(
-    options => options.UseNpgsql(builder.Configuration.GetConnectionString("TransitPulseDb")));
-
-builder.Services.AddScoped<IRouteEventRepository, RouteEventRepository>();
-
-builder.Services.AddScoped<IReliabilitySnapshotRepository, ReliabilitySnapshotRepository>();
-
-
-builder.Services.AddSingleton<IReliabilityCalculator, ReliabiltyCalculator>();
-builder.Services.AddScoped<GetReliabilitySnapshotsHandler>();
-builder.Services.AddScoped<GenerateReliabilitySnapshotHandler>();
-builder.Services.AddScoped<GenerateReliabilitySnapshotValidator>();
+// Application layer
+builder.Services.AddApplicationServices(); // Registers your business logic
 
+// Infrastructure layer
+builder.Services.AddInfrastructureServices(builder.Configuration); //Registers database, repositories, and infrastructure services.
 var app = builder.Build();
+
 app.UseMiddleware<ExceptionHandlingMiddleware>();
 
 if (app.Environment.IsDevelopment())

src/TransitPulse.API/TransitPulse.API.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.5" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.9" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.9">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>

src/TransitPulse.Application/DependencyInjection.cs

@@ -0,0 +1,23 @@
+using Microsoft.Extensions.DependencyInjection;
+using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
+using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshot;
+using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshots;
+
+namespace TransitPulse.Application;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplicationServices(
+        this IServiceCollection services)
+    {
+        services.AddScoped<GetReliabilitySnapshotsHandler>();
+
+        services.AddScoped<GetReliabilitySnapshotHandler>();
+
+        services.AddScoped<GenerateReliabilitySnapshotHandler>();
+
+        services.AddScoped<GenerateReliabilitySnapshotValidator>();
+
+        return services;
+    }
+}

src/TransitPulse.Application/Features/Reliability/GenerateReliabilitySnapshot/GenerateReliabilitySnapshotHandler.cs

@@ -2,6 +2,7 @@
 using TransitPulse.Application.Exceptions;
 using TransitPulse.Application.Interfaces;
 using TransitPulse.Domain.Entities;
+using Microsoft.Extensions.Logging;
 
 namespace TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
 
@@ -12,23 +13,30 @@ public class GenerateReliabilitySnapshotHandler
     private readonly IReliabilityCalculator _reliabilityCalculator;
     private readonly IReliabilitySnapshotRepository _snapshotRepository;
     private readonly GenerateReliabilitySnapshotValidator _validator;
+    private readonly ILogger<GenerateReliabilitySnapshotHandler> _logger;
 
     public GenerateReliabilitySnapshotHandler(
         IRouteEventRepository routeEventRepository,
         IReliabilityCalculator reliabilityCalculator,
         IReliabilitySnapshotRepository snapshotRepository,
-        GenerateReliabilitySnapshotValidator validator)
+        GenerateReliabilitySnapshotValidator validator,
+        ILogger<GenerateReliabilitySnapshotHandler> logger
+        )
     {
         _routeEventRepository = routeEventRepository;
         _reliabilityCalculator = reliabilityCalculator;
         _snapshotRepository = snapshotRepository;
         _validator = validator;
+        _logger = logger;
     }
 
     public async Task<GenerateReliabilitySnapshotResult> HandleAsync(
     GenerateReliabilitySnapshotCommand command,
     CancellationToken cancellationToken)
     {
+        _logger.LogInformation(
+            "Starting reliability snapshot generation for route {RouteId}.", command.RouteId);
+
         _validator.ValidateAndThrow(command);
 
         var routeEvents =
@@ -41,8 +49,14 @@ await _routeEventRepository
 
         if (!routeEvents.Any())
         {
+            _logger.LogWarning(
+                "No route events found for route {RouteId} between {PeriodStart} and {PeriodEnd}.",
+                command.RouteId,
+                command.PeriodStart,
+                command.PeriodEnd);
+
             throw new NotFoundException(
-                "No route events found for the specified period.");
+                $"No route events found for route {command.RouteId} between {command.PeriodStart:d} and {command.PeriodEnd:d}.");
         }
         //Single Responsibility Principle in IReliabilityCalculator calculate
         var metrics =
@@ -64,6 +78,11 @@ await _snapshotRepository.AddAsync(
             snapshot,
             cancellationToken);
 
+        _logger.LogInformation(
+            "Reliability snapshot {SnapshotId} generated successfully for route {RouteId}.",
+            snapshot.Id,
+            command.RouteId);
+
         return new GenerateReliabilitySnapshotResult(
             snapshot.Id,
             metrics.Score,

src/TransitPulse.Application/TransitPulse.Application.csproj

@@ -12,6 +12,8 @@
 
   <ItemGroup>
     <PackageReference Include="FluentValidation" Version="12.1.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.9" />
+<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.9" />
   </ItemGroup>
 
 </Project>

src/TransitPulse.Infrastructure/DependencyInjection.cs

@@ -1,6 +1,9 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
 using TransitPulse.Application.Interfaces;
+using TransitPulse.Infrastructure.Persistence;
 using TransitPulse.Infrastructure.Repositories;
 using TransitPulse.Infrastructure.Services;
 
@@ -10,16 +13,16 @@ namespace TransitPulse.Infrastructure;
 public static class DependencyInjection
 {
     public static IServiceCollection AddInfrastructureServices(
-        this IServiceCollection services)
+        this IServiceCollection services, IConfiguration configuration)
     {
-        services.AddSingleton<IRouteEventRepository,
-            InMemoryRouteEventRepository>();
+        services.AddDbContext<TransitPulseDbContext>(options =>
+            options.UseNpgsql(configuration.GetConnectionString("TransitPulseDb")));
 
-        services.AddSingleton<IReliabilitySnapshotRepository,
-            InMemoryReliabilitySnapshotRepository>();
+        services.AddScoped<IRouteEventRepository, RouteEventRepository>();
 
-        services.AddSingleton<IReliabilityCalculator,
-            ReliabiltyCalculator>();
+        services.AddScoped<IReliabilitySnapshotRepository, ReliabilitySnapshotRepository>();
+
+        services.AddSingleton<IReliabilityCalculator, ReliabilityCalculator>();
 
         return services;
     }

src/TransitPulse.Infrastructure/Services/ReliabilityCalculator.cs

@@ -4,7 +4,7 @@
 
 namespace TransitPulse.Infrastructure.Services;
 
-public class ReliabiltyCalculator : IReliabilityCalculator
+public class ReliabilityCalculator : IReliabilityCalculator
 {
     public ReliabilityMetrics Calculate(
    IEnumerable<RouteEvent> routeEvents)

tests/TransitPulse.Application.Tests/Reliability/GenerateReliabilitySnapshotHandlerTests.cs

@@ -5,6 +5,8 @@
 using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
 using TransitPulse.Application.Interfaces;
 using TransitPulse.Domain.Entities;
+using Microsoft.Extensions.Logging;
+
 
 public class GenerateReliabilitySnapshotHandlerTests
 {
@@ -25,6 +27,9 @@ public async Task HandleAsync_WithNoRouteEvents_ShouldThrowInvalidOperationExcep
         var validator =
             new GenerateReliabilitySnapshotValidator();
 
+        var logger =
+            new Mock<ILogger<GenerateReliabilitySnapshotHandler>>();
+
         routeEventRepository
             .Setup(repository =>
                 repository.GetByRouteAndPeriodAsync(
@@ -39,7 +44,8 @@ public async Task HandleAsync_WithNoRouteEvents_ShouldThrowInvalidOperationExcep
                 routeEventRepository.Object,
                 reliabilityCalculator.Object,
                 snapshotRepository.Object,
-                validator);
+                validator,
+                logger.Object);
 
         var command =
             new GenerateReliabilitySnapshotCommand(
@@ -72,6 +78,9 @@ public async Task HandleAsync_WithValidRouteEvents_ShouldSaveSnapshotAndReturnRe
         var validator =
             new GenerateReliabilitySnapshotValidator();
 
+        var logger =
+            new Mock<ILogger<GenerateReliabilitySnapshotHandler>>();
+
         var routeEvents =
             new List<RouteEvent>
             {
@@ -116,7 +125,8 @@ public async Task HandleAsync_WithValidRouteEvents_ShouldSaveSnapshotAndReturnRe
                 routeEventRepository.Object,
                 reliabilityCalculator.Object,
                 snapshotRepository.Object,
-                validator);
+                validator,
+                logger.Object);
 
         var command =
             new GenerateReliabilitySnapshotCommand(

tests/TransitPulse.Application.Tests/Reliability/GetReliabilitySnapshot/GetReliabilitySnapshotHandlerTests.cs

@@ -0,0 +1,88 @@
+using FluentAssertions;
+using FluentValidation;
+using Moq;
+using TransitPulse.Application.Exceptions;
+using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
+using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshot;
+using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshots;
+using TransitPulse.Application.Interfaces;
+using TransitPulse.Domain.Entities;
+
+namespace TransitPulse.Application.Tests.Reliability;
+
+public class GetReliabilitySnapshotHandlerTests
+{
+
+    [Fact]
+    public async Task HandleAsync_WithSnapshotNotFound_ShouldThrowNotFoundException()
+    {
+        // Arrange
+
+        var snapshotRepository = new Mock<IReliabilitySnapshotRepository>();
+
+        snapshotRepository.Setup(repository =>
+                repository.GetByIdAsync(
+                    It.IsAny<Guid>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync((ReliabilitySnapshot?)null);
+
+        var handler = new GetReliabilitySnapshotHandler(snapshotRepository.Object);
+
+        // Act
+
+        Func<Task> action = () => handler.HandleAsync(
+                                    Guid.NewGuid(),
+                                    CancellationToken.None);
+
+        // Assert
+
+        await action.Should().ThrowAsync<NotFoundException>();
+    }
+
+    [Fact]
+    public async Task HandleAsync_WithSnapshot_ShouldReturnMappedResult()
+    {
+        // Arrange
+
+        var routeId = Guid.NewGuid();
+
+        var snapshot =
+            new ReliabilitySnapshot(
+                routeId,
+                92,
+                2.5,
+                10,
+                90,
+                new DateTime(2026, 1, 1),
+                new DateTime(2026, 1, 2),
+                new DateTime(2026, 1, 3));
+
+        var snapshotRepository =
+            new Mock<IReliabilitySnapshotRepository>();
+
+        snapshotRepository.Setup(repository =>
+                    repository.GetByIdAsync(
+                    snapshot.Id,
+                    It.IsAny<CancellationToken>())).ReturnsAsync(snapshot);
+
+        var handler = new GetReliabilitySnapshotHandler(snapshotRepository.Object);
+
+        // Act
+
+        var result = await handler.HandleAsync(snapshot.Id, CancellationToken.None);
+
+        // Assert
+
+        result.Score.Should().Be(92);
+
+        result.AverageDelay.Should().Be(2.5);
+
+        result.CancellationRate.Should().Be(10);
+
+        result.OnTimePercentage.Should().Be(90);
+
+        result.CalculatedAt.Should().Be(snapshot.CalculatedAt);
+
+        result.SnapshotId.Should().Be(snapshot.Id);
+    }
+}

tests/TransitPulse.Application.Tests/Reliability/ReliabiltyCalculatorTests.cs

@@ -10,7 +10,7 @@ public class ReliabiltyCalculatorTests
     public void Calculate_ShouldReturnExpectedMetrics()
     {
         // Arrange
-        var calculator = new ReliabiltyCalculator();
+        var calculator = new ReliabilityCalculator();
 
         var routeEvents = new List<RouteEvent>
         {
@@ -55,7 +55,7 @@ public void Calculate_ShouldReturnExpectedMetrics()
     public void Calculate_WithNoEvents_ShouldThrowInvalidOperationException()
     {
         // Arrange
-        var calculator = new ReliabiltyCalculator();
+        var calculator = new ReliabilityCalculator();
 
         // Act
         Action action =