feat(auditlog): combined telemetry dual-write transaction (#23 M3)

src/ScadaLink.Communication/Grpc/SiteStreamGrpcServer.cs

@@ -6,6 +6,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using ScadaLink.Commons.Entities.Audit;
 using ScadaLink.Commons.Messages.Audit;
+using ScadaLink.Commons.Types;
 using ScadaLink.Commons.Types.Enums;
 using GrpcStatus = Grpc.Core.Status;
 
@@ -298,9 +299,132 @@ public class SiteStreamGrpcServer : SiteStreamService.SiteStreamServiceBase
         return ack;
     }
 
+    /// <summary>
+    /// Audit Log (#23) M3 site→central combined-telemetry push RPC. Decodes a
+    /// batch of <see cref="CachedTelemetryPacket"/> entries into matched
+    /// (AuditEvent, SiteCall) pairs, Asks the central <c>AuditLogIngestActor</c>
+    /// proxy to persist them in dual-write transactions, and echoes the
+    /// AuditEvent EventIds that committed back so the site can flip its local
+    /// rows to <c>Forwarded</c>.
+    /// </summary>
+    /// <remarks>
+    /// Same wiring-incomplete fallback as <see cref="IngestAuditEvents"/>: when
+    /// the actor proxy has not been set the RPC replies with an empty ack so
+    /// sites treat the outcome as transient and retry, never a hard fault.
+    /// </remarks>
+    public override async Task<IngestAck> IngestCachedTelemetry(
+        CachedTelemetryBatch request,
+        ServerCallContext context)
+    {
+        if (request.Packets.Count == 0)
+        {
+            return new IngestAck();
+        }
+
+        var actor = _auditIngestActor;
+        if (actor is null)
+        {
+            _logger.LogWarning(
+                "IngestCachedTelemetry received {Count} packets before SetAuditIngestActor was called; returning empty ack.",
+                request.Packets.Count);
+            return new IngestAck();
+        }
+
+        var entries = new List<CachedTelemetryEntry>(request.Packets.Count);
+        foreach (var packet in request.Packets)
+        {
+            var auditEvent = MapAuditEventFromDto(packet.AuditEvent);
+            var siteCall = MapSiteCallFromDto(packet.Operational);
+            entries.Add(new CachedTelemetryEntry(auditEvent, siteCall));
+        }
+
+        var cmd = new IngestCachedTelemetryCommand(entries);
+        IngestCachedTelemetryReply reply;
+        try
+        {
+            reply = await actor.Ask<IngestCachedTelemetryReply>(
+                cmd, AuditIngestAskTimeout, context.CancellationToken);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex,
+                "AuditLogIngestActor Ask failed for combined telemetry batch of {Count} packets; returning empty ack.",
+                request.Packets.Count);
+            return new IngestAck();
+        }
+
+        var ack = new IngestAck();
+        foreach (var id in reply.AcceptedEventIds)
+        {
+            ack.AcceptedEventIds.Add(id.ToString());
+        }
+        return ack;
+    }
+
     private static string? NullIfEmpty(string? value) =>
         string.IsNullOrEmpty(value) ? null : value;
 
+    /// <summary>
+    /// Inlined audit-event DTO→entity translation, kept in sync with the
+    /// <see cref="IngestAuditEvents"/> handler above. Extracted to a private
+    /// helper so the M3 dual-write RPC can reuse it without duplicating yet
+    /// another copy. The shape still mirrors
+    /// <c>AuditEventMapper.FromDto</c> in <c>ScadaLink.AuditLog.Telemetry</c>;
+    /// the two must evolve together (the project-reference cycle that
+    /// prevents calling the AuditLog mapper directly is documented on
+    /// <see cref="IngestAuditEvents"/>).
+    /// </summary>
+    private static AuditEvent MapAuditEventFromDto(AuditEventDto dto) =>
+        new()
+        {
+            EventId = Guid.Parse(dto.EventId),
+            OccurredAtUtc = DateTime.SpecifyKind(dto.OccurredAtUtc.ToDateTime(), DateTimeKind.Utc),
+            IngestedAtUtc = null,
+            Channel = Enum.Parse<AuditChannel>(dto.Channel),
+            Kind = Enum.Parse<AuditKind>(dto.Kind),
+            CorrelationId = NullIfEmpty(dto.CorrelationId) is { } cid ? Guid.Parse(cid) : null,
+            SourceSiteId = NullIfEmpty(dto.SourceSiteId),
+            SourceInstanceId = NullIfEmpty(dto.SourceInstanceId),
+            SourceScript = NullIfEmpty(dto.SourceScript),
+            Actor = NullIfEmpty(dto.Actor),
+            Target = NullIfEmpty(dto.Target),
+            Status = Enum.Parse<AuditStatus>(dto.Status),
+            HttpStatus = dto.HttpStatus,
+            DurationMs = dto.DurationMs,
+            ErrorMessage = NullIfEmpty(dto.ErrorMessage),
+            ErrorDetail = NullIfEmpty(dto.ErrorDetail),
+            RequestSummary = NullIfEmpty(dto.RequestSummary),
+            ResponseSummary = NullIfEmpty(dto.ResponseSummary),
+            PayloadTruncated = dto.PayloadTruncated,
+            Extra = NullIfEmpty(dto.Extra),
+            ForwardState = null,
+        };
+
+    /// <summary>
+    /// Translates a <see cref="SiteCallOperationalDto"/> into the persistence
+    /// entity. <see cref="SiteCall.IngestedAtUtc"/> is stamped here as a
+    /// placeholder; the central ingest actor overwrites it inside the
+    /// dual-write transaction so the AuditLog and SiteCalls rows share one
+    /// instant.
+    /// </summary>
+    private static SiteCall MapSiteCallFromDto(SiteCallOperationalDto dto) => new()
+    {
+        TrackedOperationId = TrackedOperationId.Parse(dto.TrackedOperationId),
+        Channel = dto.Channel,
+        Target = dto.Target,
+        SourceSite = dto.SourceSite,
+        Status = dto.Status,
+        RetryCount = dto.RetryCount,
+        LastError = string.IsNullOrEmpty(dto.LastError) ? null : dto.LastError,
+        HttpStatus = dto.HttpStatus,
+        CreatedAtUtc = DateTime.SpecifyKind(dto.CreatedAtUtc.ToDateTime(), DateTimeKind.Utc),
+        UpdatedAtUtc = DateTime.SpecifyKind(dto.UpdatedAtUtc.ToDateTime(), DateTimeKind.Utc),
+        TerminalAtUtc = dto.TerminalAtUtc is null
+            ? null
+            : DateTime.SpecifyKind(dto.TerminalAtUtc.ToDateTime(), DateTimeKind.Utc),
+        IngestedAtUtc = DateTime.UtcNow, // overwritten by AuditLogIngestActor
+    };
+
     /// <summary>
     /// Tracks a single active stream so cleanup only removes its own entry.
     /// </summary>