Implementing Delay Throttling

using Microsoft.AspNetCore.Http;
using System.Threading;
using System.Threading.Tasks;

public class DelayThrottleMiddleware
{
    private readonly RequestDelegate _next;
    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5, 5);
    private const int MAX_CONCURRENT = 5;

    public DelayThrottleMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        await _semaphore.WaitAsync();
        
        try
        {
            await _next(context);
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

app.UseMiddleware<DelayThrottleMiddleware>();

public class DelayThrottleMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<DelayThrottleMiddleware> _logger;
    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5, 5);
    private const int MAX_CONCURRENT = 5;

    public DelayThrottleMiddleware(RequestDelegate next, ILogger<DelayThrottleMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var currentCount = MAX_CONCURRENT - _semaphore.CurrentCount;
        _logger.LogInformation("Request started. Current concurrent requests: {CurrentRequests}", currentCount);

        await _semaphore.WaitAsync();
        
        try
        {
            var processingCount = MAX_CONCURRENT - _semaphore.CurrentCount;
            _logger.LogInformation("Processing request. Concurrent requests: {ConcurrentRequests}", processingCount);
            
            await _next(context);
        }
        finally
        {
            _semaphore.Release();
            var afterCount = MAX_CONCURRENT - _semaphore.CurrentCount;
            _logger.LogInformation("Request completed. Concurrent requests: {ConcurrentRequests}", afterCount);
        }
    }
}

public class DelayThrottleMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<DelayThrottleMiddleware> _logger;
    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5, 5);
    private const int MAX_CONCURRENT = 5;
    private const int MAX_WAIT_TIME_MS = 1500;

    public DelayThrottleMiddleware(RequestDelegate next, ILogger<DelayThrottleMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var currentCount = MAX_CONCURRENT - _semaphore.CurrentCount;
        _logger.LogInformation("Request started. Current concurrent requests: {CurrentRequests}", currentCount);

        using var timeoutCts = new CancellationTokenSource(MAX_WAIT_TIME_MS);
        
        try
        {
            await _semaphore.WaitAsync(timeoutCts.Token);
        }
        catch (OperationCanceledException)
        {
            _logger.LogWarning("Request exceeded maximum wait time. Returning 503.");
            context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
            await context.Response.WriteAsync("Service Unavailable");
            return;
        }
        
        try
        {
            var processingCount = MAX_CONCURRENT - _semaphore.CurrentCount;
            _logger.LogInformation("Processing request. Concurrent requests: {ConcurrentRequests}", processingCount);
            
            await _next(context);
        }
        finally
        {
            _semaphore.Release();
            var afterCount = MAX_CONCURRENT - _semaphore.CurrentCount;
            _logger.LogInformation("Request completed. Concurrent requests: {ConcurrentRequests}", afterCount);
        }
    }
}

public async Task InvokeAsync(HttpContext context)
{
    var currentCount = MAX_CONCURRENT - _semaphore.CurrentCount;
    _logger.LogInformation("Request started. Current concurrent requests: {CurrentRequests}", currentCount);

    var startTime = DateTime.UtcNow;
    
    using var timeoutCts = new CancellationTokenSource(MAX_WAIT_TIME_MS);
    
    try
    {
        await _semaphore.WaitAsync(timeoutCts.Token);
    }
    catch (OperationCanceledException)
    {
        _logger.LogWarning("Request exceeded maximum wait time. Returning 503.");
        context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
        await context.Response.WriteAsync("Service Unavailable");
        return;
    }
    
    var waitTime = (DateTime.UtcNow - startTime).TotalMilliseconds;
    
    try
    {
        var processingCount = MAX_CONCURRENT - _semaphore.CurrentCount;
        _logger.LogInformation("Processing request. Concurrent requests: {ConcurrentRequests}, Wait time: {WaitTime}ms", 
            processingCount, waitTime);
        
        context.Response.Headers["X-Throttle-Wait-Time"] = waitTime.ToString("F0");
        
        await _next(context);
    }
    finally
    {
        _semaphore.Release();
        var afterCount = MAX_CONCURRENT - _semaphore.CurrentCount;
        _logger.LogInformation("Request completed. Concurrent requests: {ConcurrentRequests}", afterCount);
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    private const string BASE_URL = "http://localhost:5000";
    private const string ENDPOINT = "/api/snippets/test-throttling";
    private const int TOTAL_REQUESTS = 15;

    static async Task Main(string[] args)
    {
        Console.WriteLine($"Testing throttling with {TOTAL_REQUESTS} concurrent requests...");
        Console.WriteLine($"Target: {BASE_URL}{ENDPOINT}\n");

        using var httpClient = new HttpClient();
        var results = new List<RequestResult>();

        var tasks = Enumerable.Range(1, TOTAL_REQUESTS).Select(async i =>
        {
            var stopwatch = Stopwatch.StartNew();
            try
            {
                var response = await httpClient.GetAsync($"{BASE_URL}{ENDPOINT}");
                stopwatch.Stop();
                
                var waitTime = response.Headers.Contains("X-Throttle-Wait-Time")
                    ? response.Headers.GetValues("X-Throttle-Wait-Time").First()
                    : "N/A";

                Console.WriteLine($"Request {i,2}: Status {(int)response.StatusCode}, " +
                                $"Duration: {stopwatch.ElapsedMilliseconds,4}ms, " +
                                $"Wait: {waitTime,4}ms");

                return new RequestResult
                {
                    Id = i,
                    StatusCode = (int)response.StatusCode,
                    Duration = stopwatch.ElapsedMilliseconds,
                    WaitTime = waitTime
                };
            }
            catch (Exception ex)
            {
                stopwatch.Stop();
                Console.WriteLine($"Request {i,2}: Failed - {ex.Message}");

                return new RequestResult
                {
                    Id = i,
                    StatusCode = 0,
                    Duration = stopwatch.ElapsedMilliseconds,
                    Error = true
                };
            }
        });

        results = (await Task.WhenAll(tasks)).ToList();

        Console.WriteLine("\n--- Summary ---");
        
        var statusGroups = results.GroupBy(r => r.StatusCode).OrderBy(g => g.Key);
        foreach (var group in statusGroups)
        {
            var statusText = group.Key == 0 ? "Error" : 
                            group.Key == 200 ? "200 OK" : 
                            group.Key == 503 ? "503 Service Unavailable" : 
                            group.Key.ToString();
            Console.WriteLine($"{statusText}: {group.Count()} requests");
        }

        var successfulRequests = results.Where(r => r.StatusCode == 200).ToList();
        if (successfulRequests.Any())
        {
            var durations = successfulRequests.Select(r => r.Duration).ToList();
            Console.WriteLine($"\nSuccessful requests timing:");
            Console.WriteLine($"  Fastest: {durations.Min()}ms");
            Console.WriteLine($"  Slowest: {durations.Max()}ms");
            Console.WriteLine($"  Average: {durations.Average():F0}ms");
        }
    }

    private class RequestResult
    {
        public int Id { get; set; }
        public int StatusCode { get; set; }
        public long Duration { get; set; }
        public string WaitTime { get; set; }
        public bool Error { get; set; }
    }
}

Testing throttling with 15 concurrent requests...
Target: http://localhost:5000/api/snippets/test-throttling

Request  1: Status 200, Duration:  523ms, Wait:    0ms
Request  2: Status 200, Duration:  531ms, Wait:    0ms
Request  3: Status 200, Duration:  529ms, Wait:    0ms
Request  4: Status 200, Duration:  527ms, Wait:    0ms
Request  5: Status 200, Duration:  535ms, Wait:    0ms
Request  6: Status 200, Duration: 1045ms, Wait:  512ms
Request  7: Status 200, Duration: 1053ms, Wait:  520ms
Request  8: Status 200, Duration: 1051ms, Wait:  518ms
Request  9: Status 200, Duration: 1049ms, Wait:  516ms
Request 10: Status 200, Duration: 1057ms, Wait:  524ms
Request 11: Status 503, Duration: 1502ms, Wait:  N/A
Request 12: Status 503, Duration: 1504ms, Wait:  N/A
Request 13: Status 503, Duration: 1503ms, Wait:  N/A
Request 14: Status 503, Duration: 1505ms, Wait:  N/A
Request 15: Status 503, Duration: 1501ms, Wait:  N/A

--- Summary ---
200 OK: 10 requests
503 Service Unavailable: 5 requests

Successful requests timing:
  Fastest: 523ms
  Slowest: 1057ms
  Average: 850ms