DLQ in Self-Hosted Kubernetes -> Azure DevOps Bug: Automatically report Unhandled API error, simulate it locally with the same message

using System.Text;
using System.Text.Json;

public sealed class GlobalExceptionToDlqMiddleware : IMiddleware
{
    private readonly IDlqPublisher _publisher;
    private readonly IConfiguration _cfg;
    private readonly ILogger<GlobalExceptionToDlqMiddleware> _logger;

    public GlobalExceptionToDlqMiddleware(IDlqPublisher publisher, IConfiguration cfg, ILogger<GlobalExceptionToDlqMiddleware> logger)
    {
        _publisher = publisher;
        _cfg = cfg;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        try
        {
            await next(context);
        }
        catch (Exception ex)
        {
            var traceId = context.TraceIdentifier;
            var request = context.Request;

            string requestBody = "";
            try
            {
                request.EnableBuffering();
                using var reader = new StreamReader(request.Body, Encoding.UTF8, leaveOpen: true);
                requestBody = await reader.ReadToEndAsync();
                request.Body.Position = 0;
            }
            catch { /* best-effort */ }

            var headers = request.Headers
                .Where(h => !IsSensitiveHeader(h.Key))
                .ToDictionary(k => k.Key, v => v.Value.ToString());

            // OPTIONAL: tenantId gibi repro için kritik alanlar (header’dan ya da body’den)
            var tenantId = request.Headers.TryGetValue("x-tenant-id", out var t) ? t.ToString() : null;

            var repro = new
            {
                kind = "unhandled_api_error",
                occurredAtUtc = DateTime.UtcNow,
                traceId,

                http = new
                {
                    method = request.Method,
                    path = request.Path.Value,
                    query = request.QueryString.Value,
                    headers,
                    body = requestBody
                },

                context = new
                {
                    tenantId,
                    // userId gibi bir şey koyacaksan hashle
                    // userHash = Hash(context.User.Identity?.Name)
                },

                exception = FlattenException(ex),

                build = new
                {
                    service = _cfg["Build:ServiceName"],
                    version = _cfg["Build:Version"],
                    gitSha = _cfg["Build:GitSha"],
                    imageTag = _cfg["Build:ImageTag"]
                },

                runtime = new
                {
                    pod = Environment.GetEnvironmentVariable("HOSTNAME"),
                    @namespace = Environment.GetEnvironmentVariable("POD_NAMESPACE"),
                    node = Environment.GetEnvironmentVariable("NODE_NAME")
                }
            };

            await _publisher.PublishAsync(repro, traceId);

            _logger.LogError(ex, "Unhandled error. traceId={TraceId}", traceId);

            context.Response.StatusCode = 500;
            await context.Response.WriteAsJsonAsync(new { success = false, code = "ERR-UNHANDLED", traceId });
        }
    }

    private static bool IsSensitiveHeader(string key)
    {
        var k = key.ToLowerInvariant();
        return k is "authorization" or "cookie" or "set-cookie" or "x-api-key";
    }

    private static object FlattenException(Exception ex)
    {
        var list = new List<object>();
        Exception? cur = ex;
        while (cur != null)
        {
            list.Add(new
            {
                type = cur.GetType().FullName,
                message = cur.Message,
                stack = cur.StackTrace
            });
            cur = cur.InnerException;
        }
        return list;
    }
}

public interface IDlqPublisher
{
    Task PublishAsync(object payload, string correlationId);
}

using System.Text;
using System.Text.Json;
using RabbitMQ.Client;

public sealed class RabbitDlqPublisher : IDlqPublisher
{
    private readonly IConnection _conn;
    private readonly string _queue;

    public RabbitDlqPublisher(IConfiguration cfg)
    {
        _queue = cfg["Dlq:RabbitMq:Queue"]!;
        var factory = new ConnectionFactory
        {
            HostName = cfg["Dlq:RabbitMq:Host"],
            UserName = cfg["Dlq:RabbitMq:User"],
            Password = cfg["Dlq:RabbitMq:Pass"]
        };
        _conn = factory.CreateConnection();
    }

    public Task PublishAsync(object payload, string correlationId)
    {
        using var ch = _conn.CreateModel();
        ch.QueueDeclare(_queue, durable: true, exclusive: false, autoDelete: false);

        var props = ch.CreateBasicProperties();
        props.Persistent = true;
        props.CorrelationId = correlationId;
        props.ContentType = "application/json";

        var bytes = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(payload));
        ch.BasicPublish(exchange: "", routingKey: _queue, basicProperties: props, body: bytes);
        return Task.CompletedTask;
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

builder.Services.AddSingleton<IDlqPublisher, RabbitDlqPublisher>();
builder.Services.AddTransient<GlobalExceptionToDlqMiddleware>();

var app = builder.Build();

app.UseMiddleware<GlobalExceptionToDlqMiddleware>();
app.MapControllers();

app.Run();

[ApiController]
[Route("api/test")]
public class TestController : ControllerBase
{
    [HttpPost("explode")]
    public IActionResult Explode([FromBody] object payload)
    {
        // "response hazırlanırken patladı" senaryosu
        throw new InvalidOperationException("Simulated unhandled exception for DLQ demo.");
    }
}