Async All the Way and Thread-Pool Starvation

using System.Net.Http.Json;

public sealed record ExchangeRate(string Currency, decimal ToGbp, DateTimeOffset FetchedAt);

// Before: lock + .Result. Every request that misses the cache holds a pool thread,
// and every other request queues on the lock while still holding its own thread.
public sealed class BlockingRateProvider(HttpClient http)
{
    private readonly Lock _gate = new();
    private ExchangeRate? _cached;

    public ExchangeRate Get(string currency)
    {
        lock (_gate)
        {
            if (_cached is { } c && c.Currency == currency && c.FetchedAt > DateTimeOffset.UtcNow.AddMinutes(-5))
                return c;
            _cached = http.GetFromJsonAsync<ExchangeRate>($"/rates/{currency}").Result!;
            return _cached;
        }
    }
}

// After: async all the way. Waiters queue on the semaphore without holding a thread.
// A singleton, so the cache and the semaphore are shared by every request; it asks the
// factory for a client per call, so handler rotation still picks up DNS changes.
public sealed class RateProvider(IHttpClientFactory httpClients, TimeProvider clock)
{
    private readonly SemaphoreSlim _gate = new(1, 1);
    private ExchangeRate? _cached;

    public async Task<ExchangeRate> GetAsync(string currency, CancellationToken ct)
    {
        if (IsFresh(_cached, currency)) return _cached!;
        await _gate.WaitAsync(ct);
        try
        {
            if (IsFresh(_cached, currency)) return _cached!;
            var http = httpClients.CreateClient("rates");
            _cached = await http.GetFromJsonAsync<ExchangeRate>($"/rates/{currency}", ct)
                ?? throw new InvalidOperationException($"No rate for {currency}");
            return _cached;
        }
        finally
        {
            _gate.Release();
        }
    }

    private bool IsFresh(ExchangeRate? rate, string currency) =>
        rate is not null && rate.Currency == currency && rate.FetchedAt > clock.GetUtcNow().AddMinutes(-5);
}

public static class RateProviderRegistration
{
    public static IServiceCollection AddRateProvider(this IServiceCollection services)
    {
        services.AddHttpClient("rates", c => c.BaseAddress = new Uri("https://rates.internal.example"));
        services.AddSingleton(TimeProvider.System);
        services.AddSingleton<RateProvider>();
        return services;
    }
}

# The aspnet and chiseled images have no SDK (and chiseled has no shell), so attach an
# ephemeral debug container that shares the app's process namespace. Its image must
# contain the tools, and it must run as the app's UID (1654) to open the diagnostics socket.
kubectl debug -it orders-api-7d9f8 --target=orders-api \
  --image=registry.example.com/dotnet-diag:10.0 -- bash

# Inside the debug container: the single-file tools baked into that image
# (downloaded from https://aka.ms/dotnet-counters/linux-x64 and the matching
# dotnet-stack and dotnet-dump links)
dotnet-counters ps

# Thread-pool and request counters, refreshed every second
dotnet-counters monitor --process-id 1 --refresh-interval 1 \
  --counters "System.Runtime[dotnet.thread_pool.queue.length,dotnet.thread_pool.thread.count,dotnet.thread_pool.work_item.count],Microsoft.AspNetCore.Hosting"

# Where are the threads right now? Look for many identical frames in Task.Wait or Monitor.Enter
dotnet-stack report --process-id 1

# Dump for offline analysis, then inside 'analyze': threadpool, clrstack -all, dumpasync.
# A full dump holds every secret and customer record in memory: treat it as sensitive data.
dotnet-dump collect --process-id 1 --type Heap --output /tmp/orders-api.dmp
dotnet-dump analyze /tmp/orders-api.dmp

# On a machine with the .NET 10 SDK, dnx runs the same tools without installing them
dnx dotnet-counters ps

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <!-- Temporary: the legacy SOAP client used by /invoices is synchronous.
         Remove once InvoiceArchiveClient is replaced (ticket ORD-2141). -->
    <ThreadPoolMinThreads>64</ThreadPoolMinThreads>
  </PropertyGroup>

</Project>