feat(health): wire ISiteEventLogger.FailedWriteCount into SiteHealthReport (#30, M2.16)

Add SiteHealthReport.SiteEventLogWriteFailures (trailing optional long = 0,
additive-only), ISiteHealthCollector.SetSiteEventLogWriteFailures (default
no-op so existing fakes compile), and SiteEventLogFailureCountReporter
(hosted service in HealthMonitoring, Func<long> delegate to avoid the
HealthMonitoring → StoreAndForward → SiteEventLogging cycle).

Registration helper AddSiteEventLogHealthMetricsBridge added to
HealthMonitoring.ServiceCollectionExtensions; wired in
SiteServiceRegistration after AddSiteEventLogging.

Tests: SiteEventLogWriteFailuresMetricTests (4 collector tests) +
SiteEventLogFailureCountReporterTests (2 poller tests) in
HealthMonitoring.Tests. 79/79 HealthMonitoring.Tests green,
59/59 SiteEventLogging.Tests green, 0 warnings.

tests/ZB.MOM.WW.ScadaBridge.HealthMonitoring.Tests/SiteEventLogFailureCountReporterTests.cs

@@ -0,0 +1,77 @@
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace ZB.MOM.WW.ScadaBridge.HealthMonitoring.Tests;
+
+/// <summary>
+/// M2.16 (#30) — unit tests for <see cref="SiteEventLogFailureCountReporter"/>.
+/// Verifies that the poller reads the count provided by the
+/// <see cref="Func{TResult}"/> delegate and pushes it into
+/// <see cref="ISiteHealthCollector.SetSiteEventLogWriteFailures"/>.
+/// </summary>
+public class SiteEventLogFailureCountReporterTests
+{
+    [Fact]
+    public async Task StartAsync_ImmediatelyProbes_FailedWriteCount()
+    {
+        // Arrange
+        var count = 99L;
+        var collector = new SiteHealthCollector();
+        using var reporter = new SiteEventLogFailureCountReporter(
+            failedWriteCountProvider: () => count,
+            collector: collector,
+            logger: NullLogger<SiteEventLogFailureCountReporter>.Instance,
+            refreshInterval: TimeSpan.FromHours(1)); // long interval — only immediate tick matters
+
+        // Act
+        await reporter.StartAsync(CancellationToken.None);
+
+        // Give the background Task a moment to execute its synchronous immediate probe.
+        var deadline = DateTime.UtcNow.AddSeconds(5);
+        while (collector.CollectReport("probe").SiteEventLogWriteFailures == 0L
+               && DateTime.UtcNow < deadline)
+        {
+            await Task.Delay(10);
+        }
+
+        // Assert — the immediate probe before the first Delay must have fired.
+        var report = collector.CollectReport("site-1");
+        Assert.Equal(99L, report.SiteEventLogWriteFailures);
+
+        await reporter.StopAsync(CancellationToken.None);
+    }
+
+    [Fact]
+    public async Task StartAsync_PushesLatestCount_OnEachTick()
+    {
+        // Arrange — start with count 5; advance to 12 after the first tick.
+        var count = 5L;
+        var collector = new SiteHealthCollector();
+        using var reporter = new SiteEventLogFailureCountReporter(
+            failedWriteCountProvider: () => count,
+            collector: collector,
+            logger: NullLogger<SiteEventLogFailureCountReporter>.Instance,
+            refreshInterval: TimeSpan.FromMilliseconds(50));
+
+        await reporter.StartAsync(CancellationToken.None);
+
+        // Wait for immediate probe.
+        var deadline = DateTime.UtcNow.AddSeconds(5);
+        while (collector.CollectReport("probe").SiteEventLogWriteFailures != 5L
+               && DateTime.UtcNow < deadline)
+            await Task.Delay(10);
+
+        Assert.Equal(5L, collector.CollectReport("site-1").SiteEventLogWriteFailures);
+
+        // Advance the counter and wait for the next tick to push the new value.
+        count = 12L;
+
+        deadline = DateTime.UtcNow.AddSeconds(5);
+        while (collector.CollectReport("probe").SiteEventLogWriteFailures != 12L
+               && DateTime.UtcNow < deadline)
+            await Task.Delay(10);
+
+        Assert.Equal(12L, collector.CollectReport("site-1").SiteEventLogWriteFailures);
+
+        await reporter.StopAsync(CancellationToken.None);
+    }
+}

tests/ZB.MOM.WW.ScadaBridge.HealthMonitoring.Tests/SiteEventLogWriteFailuresMetricTests.cs

@@ -0,0 +1,62 @@
+namespace ZB.MOM.WW.ScadaBridge.HealthMonitoring.Tests;
+
+/// <summary>
+/// M2.16 (#30) regression coverage. <see cref="ISiteEventLogger.FailedWriteCount"/>
+/// is a cumulative (point-in-time) counter. A periodic
+/// <c>SiteEventLogFailureCountReporter</c> hosted service polls the count and
+/// pushes it into the collector via
+/// <see cref="ISiteHealthCollector.SetSiteEventLogWriteFailures"/> so the next
+/// <see cref="ISiteHealthCollector.CollectReport"/> includes it in the report
+/// payload as <c>SiteEventLogWriteFailures</c>. Unlike the per-interval
+/// SiteAuditWriteFailures counter, this value is NOT reset on collect — it
+/// carries forward whatever the most recent poller push delivered.
+/// </summary>
+public class SiteEventLogWriteFailuresMetricTests
+{
+    private readonly SiteHealthCollector _collector = new();
+
+    [Fact]
+    public void Set_Then_CollectReport_IncludesCount()
+    {
+        _collector.SetSiteEventLogWriteFailures(17L);
+
+        var report = _collector.CollectReport("site-1");
+
+        Assert.Equal(17L, report.SiteEventLogWriteFailures);
+    }
+
+    [Fact]
+    public void Report_Payload_Includes_SiteEventLogWriteFailures_AsZeroByDefault()
+    {
+        var report = _collector.CollectReport("site-1");
+
+        Assert.Equal(0L, report.SiteEventLogWriteFailures);
+    }
+
+    [Fact]
+    public void CollectReport_DoesNotReset_SiteEventLogWriteFailures()
+    {
+        // This is a point-in-time cumulative count — successive CollectReport
+        // calls before the next poller tick MUST carry forward the same value
+        // rather than resetting to zero (which would falsely indicate no failures
+        // between the two reports).
+        _collector.SetSiteEventLogWriteFailures(42L);
+
+        var first = _collector.CollectReport("site-1");
+        var second = _collector.CollectReport("site-1");
+
+        Assert.Equal(42L, first.SiteEventLogWriteFailures);
+        Assert.Equal(42L, second.SiteEventLogWriteFailures);
+    }
+
+    [Fact]
+    public void Set_Overwrites_Previous_Value()
+    {
+        _collector.SetSiteEventLogWriteFailures(5L);
+        _collector.SetSiteEventLogWriteFailures(9L);
+
+        var report = _collector.CollectReport("site-1");
+
+        Assert.Equal(9L, report.SiteEventLogWriteFailures);
+    }
+}