Add health check endpoint

- Add HealthCheck class to track application health metrics:
  - MQTT connection status
  - Last update time
  - Beacon count
  - Total nodes processed
  - Uptime
  - Version information

- Add HealthCheckServer using HttpListener:
  - Lightweight HTTP server for /health endpoint
  - Returns JSON health status (200 for healthy, 503 for degraded)
  - Configurable port (default: 8080)

- Add IsConnected() method to MQTTControl for health checks

- Update UWBManager to track health metrics on each update

- Add HealthCheckPort to ApplicationConfig (default: 8080)

- Health check endpoint available at http://localhost:8080/health

Features:
- Returns status: 'healthy' or 'degraded'
- MQTT connection status
- Time since last update
- Beacon and node counts
- Application uptime
- Version information

Useful for:
- Kubernetes/Docker health checks
- Monitoring and alerting
- Operational visibility

Author: Alex J Lennon

src/AppConfig.cs

@@ -56,6 +56,7 @@ public class ApplicationConfig
 {
     public int UpdateIntervalMs { get; set; } = 10;
     public string LogLevel { get; set; } = "Information";
+    public int HealthCheckPort { get; set; } = 8080;
 }
 
 public class AlgorithmConfig

src/HealthCheck.cs

@@ -0,0 +1,106 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+
+namespace InstDotNet;
+
+/// <summary>
+/// Health check service that tracks application health status
+/// </summary>
+public static class HealthCheck
+{
+    private static ILogger? _logger;
+    private static DateTime _lastUpdateTime = DateTime.MinValue;
+    private static int _beaconCount = 0;
+    private static int _totalNodesProcessed = 0;
+    private static DateTime _startTime = DateTime.UtcNow;
+
+    /// <summary>
+    /// Initialize the health check service
+    /// </summary>
+    public static void Initialize(ILogger? logger = null)
+    {
+        _logger = logger;
+        _startTime = DateTime.UtcNow;
+        _logger?.LogDebug("Health check service initialized");
+    }
+
+    /// <summary>
+    /// Update the last processing time
+    /// </summary>
+    public static void UpdateLastProcessTime()
+    {
+        _lastUpdateTime = DateTime.UtcNow;
+    }
+
+    /// <summary>
+    /// Update beacon count
+    /// </summary>
+    public static void UpdateBeaconCount(int count)
+    {
+        _beaconCount = count;
+    }
+
+    /// <summary>
+    /// Increment total nodes processed
+    /// </summary>
+    public static void IncrementNodesProcessed(int count = 1)
+    {
+        _totalNodesProcessed += count;
+    }
+
+    /// <summary>
+    /// Get current health status
+    /// </summary>
+    public static HealthStatus GetStatus()
+    {
+        var mqttConnected = MQTTControl.IsConnected();
+        var uptime = DateTime.UtcNow - _startTime;
+        var timeSinceLastUpdate = _lastUpdateTime == DateTime.MinValue 
+            ? TimeSpan.Zero 
+            : DateTime.UtcNow - _lastUpdateTime;
+
+        return new HealthStatus
+        {
+            Status = mqttConnected && timeSinceLastUpdate.TotalSeconds < 60 ? "healthy" : "degraded",
+            MqttConnected = mqttConnected,
+            LastUpdateTime = _lastUpdateTime == DateTime.MinValue ? null : _lastUpdateTime,
+            TimeSinceLastUpdate = timeSinceLastUpdate.TotalSeconds,
+            BeaconCount = _beaconCount,
+            TotalNodesProcessed = _totalNodesProcessed,
+            UptimeSeconds = uptime.TotalSeconds,
+            Version = VersionInfo.FullVersion
+        };
+    }
+
+    /// <summary>
+    /// Get health status as JSON string
+    /// </summary>
+    public static string GetStatusJson()
+    {
+        var status = GetStatus();
+        var options = new JsonSerializerOptions
+        {
+            WriteIndented = true,
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        };
+        return JsonSerializer.Serialize(status, options);
+    }
+}
+
+/// <summary>
+/// Health status model
+/// </summary>
+public class HealthStatus
+{
+    public string Status { get; set; } = "unknown";
+    public bool MqttConnected { get; set; }
+    public DateTime? LastUpdateTime { get; set; }
+    public double TimeSinceLastUpdate { get; set; }
+    public int BeaconCount { get; set; }
+    public int TotalNodesProcessed { get; set; }
+    public double UptimeSeconds { get; set; }
+    public string Version { get; set; } = string.Empty;
+}

src/HealthCheckServer.cs

@@ -0,0 +1,134 @@
+#nullable enable
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace InstDotNet;
+
+/// <summary>
+/// HTTP server for health check endpoint
+/// </summary>
+public static class HealthCheckServer
+{
+    private static HttpListener? _listener;
+    private static Task? _serverTask;
+    private static CancellationTokenSource? _cts;
+    private static ILogger? _logger;
+    private static int _port = 8080;
+
+    /// <summary>
+    /// Start the health check HTTP server
+    /// </summary>
+    public static void Start(int port = 8080, ILogger? logger = null)
+    {
+        _port = port;
+        _logger = logger;
+        _cts = new CancellationTokenSource();
+
+        _listener = new HttpListener();
+        _listener.Prefixes.Add($"http://+:{port}/");
+        
+        try
+        {
+            _listener.Start();
+            _logger?.LogInformation("Health check server started on port {Port}", port);
+            
+            _serverTask = Task.Run(async () => await ListenAsync(_cts.Token), _cts.Token);
+        }
+        catch (Exception ex)
+        {
+            _logger?.LogError(ex, "Failed to start health check server on port {Port}", port);
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Stop the health check server
+    /// </summary>
+    public static void Stop()
+    {
+        _cts?.Cancel();
+        _listener?.Stop();
+        _listener?.Close();
+        _logger?.LogInformation("Health check server stopped");
+    }
+
+    private static async Task ListenAsync(CancellationToken cancellationToken)
+    {
+        while (!cancellationToken.IsCancellationRequested && _listener != null && _listener.IsListening)
+        {
+            try
+            {
+                var context = await _listener.GetContextAsync().ConfigureAwait(false);
+                _ = Task.Run(() => HandleRequest(context), cancellationToken);
+            }
+            catch (ObjectDisposedException)
+            {
+                // Listener was closed, exit gracefully
+                break;
+            }
+            catch (HttpListenerException ex)
+            {
+                _logger?.LogWarning(ex, "Health check server error");
+                if (!_listener.IsListening)
+                    break;
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogError(ex, "Unexpected error in health check server");
+            }
+        }
+    }
+
+    private static void HandleRequest(HttpListenerContext context)
+    {
+        try
+        {
+            var request = context.Request;
+            var response = context.Response;
+
+            // Only handle GET requests to /health
+            if (request.HttpMethod == "GET" && request.Url?.AbsolutePath == "/health")
+            {
+                var status = HealthCheck.GetStatus();
+                var json = HealthCheck.GetStatusJson();
+                
+                // Set status code based on health
+                response.StatusCode = status.Status == "healthy" ? 200 : 503;
+                response.ContentType = "application/json";
+                response.ContentEncoding = Encoding.UTF8;
+
+                var buffer = Encoding.UTF8.GetBytes(json);
+                response.ContentLength64 = buffer.Length;
+                response.OutputStream.Write(buffer, 0, buffer.Length);
+                response.OutputStream.Close();
+
+                _logger?.LogDebug("Health check request: {Status}", status.Status);
+            }
+            else
+            {
+                // 404 for other paths
+                response.StatusCode = 404;
+                response.Close();
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger?.LogError(ex, "Error handling health check request");
+            try
+            {
+                context.Response.StatusCode = 500;
+                context.Response.Close();
+            }
+            catch
+            {
+                // Ignore errors when closing response
+            }
+        }
+    }
+}
+

src/MQTTControl.cs

@@ -198,6 +198,14 @@ public static async Task Initialise(CancellationTokenSource cts, AppConfig? conf
         await ConnectWithRetryAsync(options, _cts.Token).ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Check if MQTT client is connected
+    /// </summary>
+    public static bool IsConnected()
+    {
+        return client != null && client.IsConnected;
+    }
+
     public static async Task DisconnectAsync()
     {
         if (client == null)

src/Program.cs

@@ -46,6 +46,21 @@ static async Task Main()
 
         try
         {
+            // Initialize health check
+            HealthCheck.Initialize(logger);
+            
+            // Start health check server
+            int healthCheckPort = _config.Application.HealthCheckPort;
+            try
+            {
+                HealthCheckServer.Start(healthCheckPort, logger);
+                logger.LogInformation("Health check endpoint available at http://localhost:{Port}/health", healthCheckPort);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to start health check server on port {Port}, continuing without health endpoint", healthCheckPort);
+            }
+
             await MQTTControl.Initialise(cts, _config);
             UWBManager.Initialise(_config);
 
@@ -80,6 +95,7 @@ static async Task Main()
             try { await Task.Delay(Timeout.Infinite, cts.Token); } catch { }
 
             logger.LogInformation("Shutting down...");
+            HealthCheckServer.Stop();
             MQTTControl.StopReconnect();
             await MQTTControl.DisconnectAsync();
             AppLogger.Dispose();

src/UWBManager.cs

@@ -1,6 +1,7 @@
 #nullable enable
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -106,6 +107,12 @@ private static void UpdateUwbs()
         bool refine = _config?.Algorithm.RefinementEnabled ?? true;
         UWB2GPSConverter.ConvertUWBToPositions(network, refine, _config?.Algorithm);
 
+        // Update health check metrics
+        HealthCheck.UpdateLastProcessTime();
+        var beaconCount = network.uwbs.Count(u => u.positionKnown);
+        HealthCheck.UpdateBeaconCount(beaconCount);
+        HealthCheck.IncrementNodesProcessed(network.uwbs.Length);
+
         if (sendUwbsList == null)
         {
             sendUwbsList = new List<UWB2GPSConverter.UWB>();

src/appsettings.json

@@ -20,7 +20,8 @@
   },
   "Application": {
     "UpdateIntervalMs": 10,
-    "LogLevel": "Information"
+    "LogLevel": "Information",
+    "HealthCheckPort": 8080
   },
   "Algorithm": {
     "MaxIterations": 10,