Código

Basado en el problema que fui el primero en resolver en Totalplay

Recuperación de la Exception Queue de Oracle AQ

Miles de clientes atorados, sin que nadie lo supiera.

C# 81%SQL 13%MSBuild 6%15 archivos729 líneas de código 9/9 pruebas
namespace AqRecovery;

public sealed record RecoveryRunResult(int Requeued, int SentToReview, int Failed)
{
    public int Total => Requeued + SentToReview + Failed;
}

/// <summary>
/// Vacía la exception queue mensaje por mensaje. Cada mensaje se procesa en su propia
/// transacción: una falla en uno no afecta a los demás ni deja nada a medias.
/// </summary>
public sealed class RecoveryWorker
{
    private readonly IRecoveryGateway _gateway;
    private readonly RecoveryPolicy _policy;
    private readonly string _sourceQueue;
    private readonly Action<string> _log;

    public RecoveryWorker(IRecoveryGateway gateway, RecoveryPolicy policy, string sourceQueue, Action<string>? log = null)
    {
        _gateway = gateway;
        _policy = policy;
        _sourceQueue = sourceQueue;
        _log = log ?? (_ => { });
    }

    public async Task<RecoveryRunResult> RunOnceAsync(int maxMessages, CancellationToken cancellationToken = default)
    {
        int requeued = 0, review = 0, failed = 0;
        var failedThisRun = new HashSet<string>();

        for (var i = 0; i < maxMessages && !cancellationToken.IsCancellationRequested; i++)
        {
            await using var uow = await _gateway.BeginAsync(cancellationToken);
            QueueMessage? message = null;
            try
            {
                message = await uow.DequeueAsync(cancellationToken);
                if (message is null) break; // la exception queue quedó vacía

                // Un mensaje revertido vuelve al frente de la cola. Si reaparece en la misma
                // corrida, se detiene para no girar en falso; la siguiente corrida lo reintenta.
                if (failedThisRun.Contains(message.MessageId)) break;

                var key = message.CorrelationId ?? message.MessageId;
                var attempts = await _gateway.GetRecoveryAttemptsAsync(key, cancellationToken);
                var action = _policy.Decide(message, attempts);

                if (action.Kind == RecoveryActionKind.Requeue)
                {
                    await uow.RequeueAsync(message, action.Delay, cancellationToken);
                    requeued++;
                }
                else
                {
                    await uow.MoveToManualReviewAsync(message, action.Reason, cancellationToken);
                    review++;
                }

                await uow.RecordAuditAsync(new AuditEntry(
                    message.MessageId, message.CorrelationId, _sourceQueue, action.Kind, action.Reason, attempts + 1), cancellationToken);

                await uow.CommitAsync(cancellationToken);
                _log($"{action.Kind} {message.MessageId}: {action.Reason}");
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                // Sin commit, la transacción se revierte al liberar la unidad de trabajo
                // y el mensaje permanece en la exception queue para la siguiente corrida.
                // Se registra solo el identificador y el tipo de error: nunca el contenido.
                failed++;
                if (message is not null) failedThisRun.Add(message.MessageId);
                _log($"Error procesando {message?.MessageId ?? "(sin leer)"}: {ex.GetType().Name}");
                if (message is null) break; // si falla el desencolado, no tiene caso seguir
            }
        }

        return new RecoveryRunResult(requeued, review, failed);
    }
}