"The Stream Was Already Consumed": AddExtendedHttpClientLogging Breaks in Debug Builds

I run a microservices solution on .NET 10 where services talk to each other synchronously over HttpClient. I wanted structured request and response logging across all of them, so I added the extended HTTP client logging from Microsoft.Extensions.Http.Diagnostics. Everything looked fine - until I ran it locally.

The tech stack

Worth being precise here, because the combination matters - swap any one of these and you may not see it.

The exception

As soon as the caller reads the response body, in Debug:

System.InvalidOperationException:
  The stream was already consumed. It cannot be read again.

It does not come from my deserialisation code. It comes from reading HttpResponseMessage.Content a second time - the first read having been done by the diagnostics handler to log the body.

The configuration and the code that triggers it

The handler only reads the body if you ask it to. LogBody is the switch; the rest bound how much it reads and which content types it treats as text.

// Required by AddExtendedHttpClientLogging - it will not
// resolve its dependencies without the redaction services.
builder.Services.AddRedaction();

builder.Services.AddHttpClient("ReproClient")
    .AddExtendedHttpClientLogging(options =>
    {
        options.LogBody = true;                    // <- reads the body
        options.BodySizeLimit = 1024;              // max bytes read for logging
        options.BodyReadTimeout = TimeSpan.FromSeconds(5);
        options.RequestBodyContentTypes.Add("application/json");
        options.ResponseBodyContentTypes.Add("application/json");
    });

And the calling code, which is about as ordinary as it gets:

// GetAsync defaults to HttpCompletionOption.ResponseContentRead
using var response = await client.GetAsync($"{ApiUrl}/events");
response.EnsureSuccessStatusCode();

var raw = await response.Content.ReadAsStreamAsync();   // throws in Debug
var events = await JsonSerializer.DeserializeAsync<List<Event>>(
    raw, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

Debug fails, Release works

This is the detail that cost me the most time, and the one worth remembering even if you never touch this package. The exact same code, same configuration, same package version: Debug throws, Release does not.

It behaves like a heisenbug. It disappears when you publish, so you start doubting the diagnosis; it comes back the moment you run locally, so you cannot ignore it. And if you write a small reproduction and happen to run it in Release, you conclude the problem is somewhere else entirely and go hunting for exotic causes.

Narrowing it to the package version

Testing across versions put the boundary in a clear place: the failure appears from Microsoft.Extensions.Http.Diagnostics 9.1 upwards, including the 10.x releases. On 9.0 the same code, in the same Debug build, works.

So pinning the package to 9.0 is a valid fallback if you would rather not change your calling code. It just means giving up whatever else those versions brought.

The fix

What restored Debug to behaving like Release was to stop asking HttpClient to read the whole response before handing it back. GetAsync and PostAsJsonAsync use ResponseContentRead - "complete after reading the entire response including the content". Dropping to SendAsync with ResponseHeadersRead - "complete as soon as a response is available and headers are read; the content is not read yet" - leaves the stream readable for both the handler and my code.

using var request =
    new HttpRequestMessage(HttpMethod.Get, $"{ApiUrl}/events");

using var response = await client.SendAsync(
    request, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();

var raw = await response.Content.ReadAsStreamAsync();   // works
var events = await JsonSerializer.DeserializeAsync<List<Event>>(
    raw, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

Note what did not change: the logging configuration is identical in both versions. Only the way HttpClient is invoked differs.

Reproducing it

The reproduction needs nothing exotic - no OAuth handler, no retry policy, no unusual payload. Two projects are enough:

• ReproApi - an ASP.NET Core Web API exposing a single /events endpoint that returns JSON.
• ReproClient - a console app calling it through IHttpClientFactory, with the same package version and the same AddExtendedHttpClientLogging configuration.

The client has a single ApplyFix flag at the top. Leave it false to take the GetAsync path and watch it throw; set it to true to take the SendAsync path and watch the same call succeed. Then run the whole thing in Release and the failing path stops failing.

// ReproClient/Program.cs
//   false -> BUG: client.GetAsync(url)   (ResponseContentRead, the default)
//   true  -> FIX: client.SendAsync(request, ResponseHeadersRead)
const bool ApplyFix = false;

The full reproduction is on GitHub if you want to run it yourself: viorelbuligadev/StreamConsumedRepro.

If you hit this too, it is worth reporting to dotnet/extensions, which owns the package - with the version, the logging configuration, and above all the fact that it is Debug-only.

Frequently asked questions

Official resources

• LoggingOptions class - Microsoft Learn
• HttpCompletionOption enum - Microsoft Learn
• IHttpClientFactory with .NET - Microsoft Learn
• dotnet/extensions - the repository that owns this package