feat(controlplane): AuditWriterActor with batched in-buffer-dedup insert

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/Audit/AuditWriterActor.cs

@@ -0,0 +1,113 @@
+using Akka.Actor;
+using Akka.Event;
+using Microsoft.EntityFrameworkCore;
+using ZB.MOM.WW.OtOpcUa.Commons.Messages.Audit;
+using ZB.MOM.WW.OtOpcUa.Configuration;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+
+namespace ZB.MOM.WW.OtOpcUa.ControlPlane.Audit;
+
+/// <summary>
+/// Cluster-singleton actor that batches <see cref="AuditEvent"/> messages from the cluster
+/// and bulk-inserts them into <c>ConfigAuditLog</c>. Flush triggers:
+/// - Buffer reaches <see cref="FlushBatchSize"/> events.
+/// - <see cref="FlushInterval"/> elapses with a non-empty buffer.
+/// - <c>PreRestart</c> / <c>PostStop</c> (supervisor swap or coordinated shutdown).
+///
+/// Dedup is in-buffer only — once a batch is flushed, the actor accepts a duplicate
+/// <see cref="AuditEvent.EventId"/> as a new row. True cross-restart idempotency needs an
+/// EventId column with a unique index on <c>ConfigAuditLog</c>; tracked as follow-up F3.
+/// </summary>
+public sealed class AuditWriterActor : ReceiveActor, IWithTimers
+{
+    public const int FlushBatchSize = 500;
+    public static readonly TimeSpan FlushInterval = TimeSpan.FromSeconds(5);
+
+    private readonly IDbContextFactory<OtOpcUaConfigDbContext> _dbFactory;
+    private readonly ILoggingAdapter _log = Context.GetLogger();
+    private readonly Dictionary<Guid, AuditEvent> _buffer = new();
+
+    public ITimerScheduler Timers { get; set; } = null!;
+
+    public static Props Props(IDbContextFactory<OtOpcUaConfigDbContext> dbFactory) =>
+        Akka.Actor.Props.Create(() => new AuditWriterActor(dbFactory));
+
+    public AuditWriterActor(IDbContextFactory<OtOpcUaConfigDbContext> dbFactory)
+    {
+        _dbFactory = dbFactory;
+        Receive<AuditEvent>(HandleEvent);
+        Receive<Flush>(_ => FlushBuffer());
+    }
+
+    protected override void PreStart()
+    {
+        Timers.StartPeriodicTimer("flush", Flush.Instance, FlushInterval);
+    }
+
+    private void HandleEvent(AuditEvent evt)
+    {
+        // In-buffer dedup. Last write wins on duplicate EventId within the batch — events
+        // with the same EventId are by contract identical, so this is a no-op.
+        _buffer[evt.EventId] = evt;
+        if (_buffer.Count >= FlushBatchSize) FlushBuffer();
+    }
+
+    private void FlushBuffer()
+    {
+        if (_buffer.Count == 0) return;
+
+        var snapshot = _buffer.Values.ToList();
+        _buffer.Clear();
+
+        try
+        {
+            using var db = _dbFactory.CreateDbContext();
+            foreach (var evt in snapshot)
+            {
+                db.ConfigAuditLogs.Add(new ConfigAuditLog
+                {
+                    Timestamp = evt.OccurredAtUtc,
+                    Principal = evt.Actor,
+                    EventType = $"{evt.Category}:{evt.Action}",
+                    NodeId = evt.SourceNode.Value,
+                    DetailsJson = WrapDetails(evt),
+                });
+            }
+            db.SaveChanges();
+            _log.Debug("AuditWriter flushed {Count} events", snapshot.Count);
+        }
+        catch (Exception ex)
+        {
+            _log.Error(ex, "AuditWriter flush failed; {Count} events dropped", snapshot.Count);
+        }
+    }
+
+    /// <summary>
+    /// Wraps caller-supplied details with the EventId + CorrelationId so audit consumers can
+    /// reconstruct the original message. Until ConfigAuditLog gains a first-class EventId column
+    /// (follow-up F3), this is the only place these correlation IDs are persisted.
+    /// </summary>
+    private static string WrapDetails(AuditEvent evt)
+    {
+        var details = evt.DetailsJson ?? "null";
+        return $"{{\"eventId\":\"{evt.EventId:N}\",\"correlationId\":\"{evt.CorrelationId.Value:N}\",\"details\":{details}}}";
+    }
+
+    protected override void PreRestart(Exception reason, object message)
+    {
+        FlushBuffer();
+        base.PreRestart(reason, message);
+    }
+
+    protected override void PostStop()
+    {
+        FlushBuffer();
+        base.PostStop();
+    }
+
+    public sealed class Flush
+    {
+        public static readonly Flush Instance = new();
+        private Flush() { }
+    }
+}