scadaproj/ZB.MOM.WW.Telemetry/tests/ZB.MOM.WW.Telemetry.Serilog.Tests/RedactionTests.cs

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;
using Serilog.Core;
using Serilog.Events;
using Serilog.Sinks.InMemory;
using ZB.MOM.WW.Telemetry;
using ZB.MOM.WW.Telemetry.Serilog;

namespace ZB.MOM.WW.Telemetry.Serilog.Tests;

public sealed class RedactionTests
{
    private const string Masked = "***";

    private sealed class FakeRedactor : ILogRedactor
    {
        public void Redact(IDictionary<string, object?> properties)
        {
            if (properties.ContainsKey("apiKey"))
            {
                properties["apiKey"] = Masked;
            }
        }
    }

    private static string? ScalarOrNull(LogEvent logEvent, string propertyName) =>
        logEvent.Properties.TryGetValue(propertyName, out var value) && value is ScalarValue scalar
            ? scalar.Value?.ToString()
            : null;

    [Fact]
    public void Registered_redactor_masks_sensitive_property()
    {
        var serviceProvider = new ServiceCollection()
            .AddSingleton<ILogRedactor>(new FakeRedactor())
            .BuildServiceProvider();

        var sink = new InMemorySink();
        var options = new ZbTelemetryOptions { ServiceName = "mxgateway" };

        var loggerConfig = new LoggerConfiguration();
        ZbSerilogConfig.Apply(loggerConfig, options, serviceProvider);
        using Logger logger = loggerConfig.WriteTo.Sink(sink).CreateLogger();

        logger.Information("authenticating {apiKey}", "mxgw_secret");

        var logEvent = Assert.Single(sink.LogEvents);
        Assert.Equal(Masked, ScalarOrNull(logEvent, "apiKey"));
    }

    [Fact]
    public void No_redactor_registered_is_a_no_op()
    {
        var serviceProvider = new ServiceCollection().BuildServiceProvider();

        var sink = new InMemorySink();
        var options = new ZbTelemetryOptions { ServiceName = "mxgateway" };

        var loggerConfig = new LoggerConfiguration();
        ZbSerilogConfig.Apply(loggerConfig, options, serviceProvider);
        using Logger logger = loggerConfig.WriteTo.Sink(sink).CreateLogger();

        logger.Information("authenticating {apiKey}", "mxgw_secret");

        var logEvent = Assert.Single(sink.LogEvents);
        Assert.Equal("mxgw_secret", ScalarOrNull(logEvent, "apiKey"));
    }

    [Fact]
    public void AddZbSerilog_with_otlp_options_builds_without_error()
    {
        var builder = Host.CreateApplicationBuilder();

        builder.AddZbSerilog(o =>
        {
            o.ServiceName = "mxgateway";
            o.SiteId = "s1";
            o.NodeRole = "central";
            o.Exporter = ZbExporter.Otlp;
            o.OtlpEndpoint = "http://localhost:4317";
        });

        using var host = builder.Build();

        // Serilog.ILogger is registered by AddSerilog — not Microsoft.Extensions.Logging.ILogger.
        var logger = host.Services.GetRequiredService<ILogger>();
        logger.Information("otlp wiring smoke test");
    }

    [Fact]
    public void BuildResourceAttributes_contains_required_keys_and_optional_keys_when_set()
    {
        var options = new ZbTelemetryOptions
        {
            ServiceName = "mxgateway",
            ServiceNamespace = "ZB.MOM.WW",
            SiteId = "site-a",
            NodeRole = "central",
        };

        var attributes = ZbSerilogConfig.BuildResourceAttributes(options);

        // Required keys always present.
        Assert.True(attributes.ContainsKey("service.name"), "service.name must be present");
        Assert.True(attributes.ContainsKey("service.namespace"), "service.namespace must be present");
        Assert.True(attributes.ContainsKey("host.name"), "host.name must be present");

        // service.instance.id must be present and match ZbResource.InstanceId (parity with OTel SDK path).
        Assert.True(attributes.ContainsKey("service.instance.id"), "service.instance.id must be present");
        Assert.Equal(ZbResource.InstanceId, attributes["service.instance.id"]);

        // Optional keys present when options supply them.
        Assert.True(attributes.ContainsKey("site.id"), "site.id must be present when SiteId is set");
        Assert.True(attributes.ContainsKey("node.role"), "node.role must be present when NodeRole is set");

        Assert.Equal("mxgateway", attributes["service.name"]);
        Assert.Equal("ZB.MOM.WW", attributes["service.namespace"]);
        Assert.Equal(Environment.MachineName, attributes["host.name"]);
        Assert.Equal("site-a", attributes["site.id"]);
        Assert.Equal("central", attributes["node.role"]);
    }

    [Fact]
    public void BuildResourceAttributes_omits_optional_keys_when_not_set()
    {
        var options = new ZbTelemetryOptions
        {
            ServiceName = "mxgateway",
            SiteId = null,
            NodeRole = null,
        };

        var attributes = ZbSerilogConfig.BuildResourceAttributes(options);

        Assert.False(attributes.ContainsKey("site.id"), "site.id must be absent when SiteId is null");
        Assert.False(attributes.ContainsKey("node.role"), "node.role must be absent when NodeRole is null");
        // service.instance.id is always present regardless of optional fields.
        Assert.True(attributes.ContainsKey("service.instance.id"), "service.instance.id must always be present");
        Assert.Equal(ZbResource.InstanceId, attributes["service.instance.id"]);
    }

    /// <summary>
    /// Fix 1 — Symmetric OTLP trigger: the Serilog path must only activate the OTel log sink
    /// when <c>Exporter == ZbExporter.Otlp</c>, NOT merely when <c>OtlpEndpoint</c> is set.
    /// This matches the core OTel metrics/traces path that ignores a bare endpoint without
    /// <c>Exporter=Otlp</c>.
    /// </summary>
    [Fact]
    public void ApplyOpenTelemetryExport_does_not_activate_when_only_endpoint_is_set()
    {
        // Arrange: set OtlpEndpoint but leave Exporter at the default (not Otlp).
        var options = new ZbTelemetryOptions
        {
            ServiceName = "mxgateway",
            OtlpEndpoint = "http://localhost:4317",
            // Exporter is intentionally left at default (ZbExporter.None / Prometheus only)
        };

        // Act: Apply the shared Serilog config — if the bug is present this will attempt to
        // connect to localhost:4317 and the OpenTelemetry sink will be registered.
        // We verify by inspecting the LoggerConfiguration directly: after Apply, if WriteTo
        // contained an OTel sink the LoggerConfiguration's internal list would be non-empty.
        // The simplest observable proxy: building the logger must not throw, and we assert
        // the exporter is not Otlp.
        Assert.NotEqual(ZbExporter.Otlp, options.Exporter);

        // Building the logger with only OtlpEndpoint set (no Exporter=Otlp) must not throw
        // and must not attempt any OTLP connection — the sink should simply be absent.
        var exception = Record.Exception(() =>
        {
            var loggerConfig = new LoggerConfiguration();
            ZbSerilogConfig.Apply(loggerConfig, options);
            using var logger = loggerConfig.CreateLogger();
            logger.Information("no otlp sink expected");
        });

        Assert.Null(exception);
    }

    [Fact]
    public void ApplyOpenTelemetryExport_activates_when_Exporter_is_Otlp()
    {
        // Arrange: Exporter explicitly set to Otlp (no endpoint — exporter registered but won't connect).
        var options = new ZbTelemetryOptions
        {
            ServiceName = "mxgateway",
            Exporter = ZbExporter.Otlp,
            // OtlpEndpoint intentionally left null — we test the trigger, not the connection.
        };

        // Act + Assert: must not throw (the sink is registered but won't connect in tests).
        var exception = Record.Exception(() =>
        {
            var loggerConfig = new LoggerConfiguration();
            ZbSerilogConfig.Apply(loggerConfig, options);
            using var logger = loggerConfig.CreateLogger();
            logger.Information("otlp sink registered");
        });

        Assert.Null(exception);
    }
}