How to log the HTTP Response Body in ASP.NET Core 1.0

Question

I'm creating a public REST Api using ASP.NET Core 1.0 RC2 and like to log incoming requests and outgoing responses.

I have created a middleware class which is added to the pipeline before the call to app.UseMvc();

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{            
        app.UseIOMiddleware();
        app.UseMvc();            
}

My Middleware class looks like this:

public class IOMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        LogRequest(context.Request);

        await _next.Invoke(context);            
    }

    private async void LogRequest(HttpRequest request)
    {
        using (var bodyReader = new StreamReader(request.Body))
        {
            string body = await bodyReader.ReadToEndAsync();

            request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

            System.Diagnostics.Debug.Print(body);
        }
    }
}

I can read the request body stream and rewind it using this example: Rewind request body stream, but I'm not sure how to read the response body as the stream is not readable.

In Web API 2.0 I could have used the HttpResponseMessage.Content.ReadAsByteArrayAsync() method, but how can I accomplish the same thing in ASP.Net Core 1.0 RC2?

Does this answer your question? [How to read ASP.NET Core Response.Body?](https://stackoverflow.com/questions/43403941/how-to-read-asp-net-core-response-body) — JTW, Nov 30 '20 at 15:43

score 14 · Answer 1 · answered Jun 16 '16 at 11:46

The problem is that request.Body is not readable, only writable - typically the stream will periodically flushed to the client across the wire.

You can get round this by replacing the stream and buffering the content until the rest of the pipeline has completed.

public class IOMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        await LogRequest(context.Request);

        await LogResponseAndInvokeNext(context);
    }

    private async Task LogRequest(HttpRequest request)
    {
        using (var bodyReader = new StreamReader(request.Body))
        {
            string body = await bodyReader.ReadToEndAsync();

            request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            System.Diagnostics.Debug.Print(body);
        }
    }

    private async Task LogResponseAndInvokeNext(HttpContext context)
    {
        using (var buffer = new MemoryStream())
        {
            //replace the context response with our buffer
            var stream = context.Response.Body;
            context.Response.Body = buffer;

            //invoke the rest of the pipeline
            await _next.Invoke(context);

            //reset the buffer and read out the contents
            buffer.Seek(0, SeekOrigin.Begin);
            var reader = new StreamReader(buffer);
            using (var bufferReader = new StreamReader(buffer))
            {
                string body = await bufferReader.ReadToEndAsync();

                //reset to start of stream
                buffer.Seek(0, SeekOrigin.Begin);

                //copy our content to the original stream and put it back
                await buffer.CopyToAsync(stream);
                context.Response.Body = stream;

                System.Diagnostics.Debug.Print($"Response: {body}");

            }
        }
    }
}

For reading the request body you can do the following to get a buffered stream which allows you to seek and read it multiple times; `context.Request.EnableRewind()` (HttpRequest extension method found in `Microsoft.AspNetCore.Http.Internal.BufferingHelper`). — jfiskvik, Jul 13 '16 at 14:27
I am not sure what the side effects of doing this might be. Since the buffer is being streamed over a socket, it might produce unexpected results. The body stream has it's read unimplemented for a reason. — Serguei Fedorov, Sep 05 '16 at 06:08
Wrapped this up into a single class for request and response logging, which also avoids exceptions for cached files, and disposes correctly, on [github](https://github.com/Hiblet/LogRequestAndResponseMiddleware). I would like to get it used as any bugs will get shaken out of it. — Steve Hibbert, Jun 22 '17 at 13:06
@SergueiFedorov I see one side effect of such behaviour. The data that until now could be safely streamed to the client now has to be completely held in memory. Something that could've been streamed successfully piece by piece and is too big for storage in memory now will throw OutOfMemoryException or something along these lines. — Dominik Szymański, Jun 15 '20 at 16:59

score 4 · Accepted Answer · answered Jul 08 '16 at 21:59

Unfortunately if you replace Request with MemoryStream, the same stream will be used for future calls. Here is the bug: https://github.com/aspnet/KestrelHttpServer/issues/940

The workaround is to copy Request.Body stream to local variable and set Body back to original stream in the end.

Like this:

  public async Task Invoke(HttpContext context)
    {
        //Workaround - copy original Stream
        var initalBody = context.Request.Body;

        using (var bodyReader = new StreamReader(request.Body))
        {
            string body = await bodyReader.ReadToEndAsync();
            //Do something with body
            //Replace write only request body with read/write memorystream so you can read from it later

               request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

        //handle other middlewares
        await _next.Invoke(context);

        //Workaround - return back to original Stream
        context.Request.Body = initalBody;
    }

fixed for now (1.0.1+) :) – Pavel Biryukov Nov 25 '16 at 15:18 — Pavel Biryukov, Nov 25 '16 at 15:18
Question asks for response body, not request body. – Warren Parad Dec 08 '16 at 09:30 — Warren Parad, Dec 08 '16 at 09:30

score 1 · Answer 3 · edited Jan 25 '20 at 08:38

after searching everywhere this is the class I ended up with. it's working fine for me and handles the case where there is an exception [it used to not return any response but logs it successfully!!]. This is a collective products of so many posts online.

using Microsoft.AspNetCore.Http;
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNet.Http.Internal;
using Microsoft.AspNetCore.Http.Internal;



public class LoggerMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        using (MemoryStream requestBodyStream = new MemoryStream())
        using (MemoryStream responseBodyStream = new MemoryStream())
        {
            Stream originalRequestBody = context.Request.Body;
            context.Request.EnableRewind();
            Stream originalResponseBody = context.Response.Body;

            try
            {
                await context.Request.Body.CopyToAsync(requestBodyStream);
                requestBodyStream.Seek(0, SeekOrigin.Begin);

                string requestBodyText = new StreamReader(requestBodyStream).ReadToEnd();

                requestBodyStream.Seek(0, SeekOrigin.Begin);
                context.Request.Body = requestBodyStream;

                string responseBody = "";

                context.Response.Body = responseBodyStream;

                Stopwatch watch = Stopwatch.StartNew();
                    await _next(context);
                    watch.Stop();

                responseBodyStream.Seek(0, SeekOrigin.Begin);
                responseBody = new StreamReader(responseBodyStream).ReadToEnd();
                AuditLogger.LogToAudit(context.Request.Host.Host,
                    context.Request.Path, context.Request.QueryString.ToString(), context.Connection.RemoteIpAddress.MapToIPv4().ToString(),
                        string.Join(",", context.Request.Headers.Select(he => he.Key + ":[" + he.Value + "]").ToList()),
                        requestBodyText, responseBody, DateTime.Now, watch.ElapsedMilliseconds);

                responseBodyStream.Seek(0, SeekOrigin.Begin);

                await responseBodyStream.CopyToAsync(originalResponseBody);
            }
            catch (Exception ex)
            {
                ExceptionLogger.LogToDatabse(ex);
                byte[] data = System.Text.Encoding.UTF8.GetBytes("Unhandled Error occured. Please, try again in a while.");
                originalResponseBody.Write(data, 0, data.Length);
            }
            finally
            {
                context.Request.Body = originalRequestBody;
                context.Response.Body = originalResponseBody;
            }
        }
    }
}

How to log the HTTP Response Body in ASP.NET Core 1.0

3 Answers3