feat: Implement Issue #27 - 15-minute rollup background job

- Create IRollupService and RollupService with rollup algorithms
- Add RollupBackgroundService that runs every 5 minutes
- Process raw checks into 15-minute and daily rollups
- Calculate UpPct, AvgRttMs, DownEvents per bucket
- Use watermark tracking via SettingsService
- Handle SQLite DateTimeOffset limitations with in-memory filtering
- Add TestRollupController for manual testing
- Successfully tested: generates rollup records from monitoring data

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: hemanandr

.claude/settings.local.json

@@ -8,6 +8,8 @@
       "Bash(taskkill:*)",
       "Bash(dotnet clean:*)",
       "Bash(dotnet run:*)",
+      "Bash(powershell:*)",
+      "Bash(dotnet build:*)",
       "Bash(powershell:*)"
     ],
     "deny": [],

ThingConnect.Pulse.Server/Controllers/TestRollupController.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Mvc;
+using ThingConnect.Pulse.Server.Services.Rollup;
+
+namespace ThingConnect.Pulse.Server.Controllers;
+
+/// <summary>
+/// Test controller for rollup functionality (development only)
+/// </summary>
+[ApiController]
+[Route("api/test/rollup")]
+public sealed class TestRollupController : ControllerBase
+{
+    private readonly IRollupService _rollupService;
+    private readonly ILogger<TestRollupController> _logger;
+
+    public TestRollupController(IRollupService rollupService, ILogger<TestRollupController> logger)
+    {
+        _rollupService = rollupService;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Manually trigger 15-minute rollup processing
+    /// </summary>
+    [HttpPost("process-15m")]
+    public async Task<IActionResult> ProcessRollup15mAsync()
+    {
+        try
+        {
+            _logger.LogInformation("Manual 15m rollup processing requested");
+            await _rollupService.ProcessRollup15mAsync();
+            return Ok(new { message = "15-minute rollup processing completed successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error processing 15m rollups");
+            return StatusCode(500, new { message = "Error processing rollups", error = ex.Message });
+        }
+    }
+
+    /// <summary>
+    /// Manually trigger daily rollup processing
+    /// </summary>
+    [HttpPost("process-daily")]
+    public async Task<IActionResult> ProcessRollupDailyAsync()
+    {
+        try
+        {
+            _logger.LogInformation("Manual daily rollup processing requested");
+            await _rollupService.ProcessRollupDailyAsync();
+            return Ok(new { message = "Daily rollup processing completed successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error processing daily rollups");
+            return StatusCode(500, new { message = "Error processing rollups", error = ex.Message });
+        }
+    }
+}

ThingConnect.Pulse.Server/Program.cs

@@ -4,6 +4,7 @@
 using ThingConnect.Pulse.Server.Infrastructure;
 using ThingConnect.Pulse.Server.Services;
 using ThingConnect.Pulse.Server.Services.Monitoring;
+using ThingConnect.Pulse.Server.Services.Rollup;
 
 namespace ThingConnect.Pulse.Server;
 
@@ -36,6 +37,10 @@ public static void Main(string[] args)
         builder.Services.AddScoped<IHistoryService, HistoryService>();
         builder.Services.AddHostedService<MonitoringBackgroundService>();
 
+        // Add rollup services
+        builder.Services.AddScoped<IRollupService, RollupService>();
+        builder.Services.AddHostedService<RollupBackgroundService>();
+
         builder.Services.AddControllers(options =>
         {
             options.InputFormatters.Insert(0, new PlainTextInputFormatter());

ThingConnect.Pulse.Server/Services/Rollup/IRollupService.cs

@@ -0,0 +1,17 @@
+namespace ThingConnect.Pulse.Server.Services.Rollup;
+
+/// <summary>
+/// Service for computing data rollups from raw check results
+/// </summary>
+public interface IRollupService
+{
+    /// <summary>
+    /// Process 15-minute rollups from raw check results since last watermark
+    /// </summary>
+    Task ProcessRollup15mAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Process daily rollups from raw check results since last watermark
+    /// </summary>
+    Task ProcessRollupDailyAsync(CancellationToken cancellationToken = default);
+}

ThingConnect.Pulse.Server/Services/Rollup/RollupBackgroundService.cs

@@ -0,0 +1,82 @@
+namespace ThingConnect.Pulse.Server.Services.Rollup;
+
+/// <summary>
+/// Background service that processes rollups every 5 minutes
+/// </summary>
+public sealed class RollupBackgroundService : BackgroundService
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ILogger<RollupBackgroundService> _logger;
+    private readonly TimeSpan _rollupInterval = TimeSpan.FromMinutes(5);
+
+    public RollupBackgroundService(IServiceProvider serviceProvider, ILogger<RollupBackgroundService> logger)
+    {
+        _serviceProvider = serviceProvider;
+        _logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        _logger.LogInformation("RollupBackgroundService starting. Rollup interval: {Interval}", _rollupInterval);
+
+        // Wait a bit before starting to let the application fully initialize
+        await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                await ProcessRollupsAsync(stoppingToken);
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected when cancellation is requested
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error in rollup background service");
+            }
+
+            // Wait for next rollup cycle
+            try
+            {
+                await Task.Delay(_rollupInterval, stoppingToken);
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected when cancellation is requested
+                break;
+            }
+        }
+
+        _logger.LogInformation("RollupBackgroundService stopping");
+    }
+
+    private async Task ProcessRollupsAsync(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceProvider.CreateScope();
+        IRollupService rollupService = scope.ServiceProvider.GetRequiredService<IRollupService>();
+
+        try
+        {
+            // Process 15-minute rollups
+            await rollupService.ProcessRollup15mAsync(cancellationToken);
+
+            // Process daily rollups (less frequent, but check each cycle)
+            await rollupService.ProcessRollupDailyAsync(cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to process rollups");
+            throw;
+        }
+    }
+
+    public override async Task StopAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("RollupBackgroundService stop requested");
+        await base.StopAsync(cancellationToken);
+        _logger.LogInformation("RollupBackgroundService stopped");
+    }
+}