How to get response errors from webforms WebMethod in production?

I found the answer. It wasn't a problem with the application itself, but rather an IIS configuration issue. That's why it worked in development but not in production. What was happening is that by default, IIS automatically handles HTTP errors (any 4XX or 5XX error), which caused it to overwrite the error object I was sending.

What I did was add the following to the system.webServer tag in my web.config:

XML

<httpErrors errorMode="Custom" existingResponse="PassThrough">
</httpErrors>

However, be careful when adding this to your application. This will cause any errors from now on to pass through IIS without treatment. This means exceptions could be sent to the client, potentially revealing how your application works, similar to the stack traces returned in development when an error occurs, instead of the old "Bad Request" text. To mitigate this, you should create a Module inheriting from IHttpModule that captures errors coming from the server. Evaluate the error type, and if it's an unexpected error, handle it by returning a custom response like this:

JSON

{
    "message": "An unexpected error occurred. \r\nSystem administrators have been notified. Error ID: 106025",
    "errorLogId": 106025
}

It captures the server's response after any type of status code.

C#

using System;
using System.Web;

public class WebMethodErrorModule : IHttpModule
{
    public void Init(HttpApplication context)
    {
        context.PreSendRequestHeaders += new EventHandler(OnPreSendRequestHeaders);
        context.PostMapRequestHandler += new EventHandler(OnPostMapRequestHandler);
    }

    private void OnPostMapRequestHandler(object sender, EventArgs e)
    {
        HttpApplication app = (HttpApplication)sender;
        HttpContext context = app.Context;

        // Check if it's a request to a Page Method (WebMethod)
        // This heuristic might need to be more robust depending on your URLs
        if (context.Handler is System.Web.UI.Page && !string.IsNullOrEmpty(context.Request.PathInfo))
        {
            // For WebMethods, the Content-Type is usually application/json
            string contentType = context.Request.ContentType?.Split(';')[0];
            if (string.Equals(contentType, "application/json", StringComparison.OrdinalIgnoreCase))
            {
                // This is where we hook our custom response filter
                app.Response.Filter = new WebMethodErrorLoggerStream(app.Request, app.Response, app.Response.Filter);
            }
        }
    }

    private void OnPreSendRequestHeaders(object sender, EventArgs e)
    {
        // This event can be used if you want to inspect headers or modify them
        // before the response is sent. However, for logging the body content,
        // the Response.Filter approach is generally better.
    }

    public void Dispose() { }
}

This will use the response that would be sent to the server. In my case, if it's any type of 4XX error, I don't want to do anything in the Close() method.

C#

using Ent; // Assuming these are your custom entity/business logic namespaces
using Neg; // Assuming these are your custom entity/business logic namespaces
using System;
using System.Configuration;
using System.IO;
using System.Text;
using System.Web;
using System.Web.Script.Serialization;

public sealed class WebMethodErrorLoggerStream : Stream
{
    private readonly HttpResponse _response;
    private readonly HttpRequest _request;
    private readonly Stream _baseStream;
    private readonly MemoryStream _capturedStream = new MemoryStream();

    public WebMethodErrorLoggerStream(HttpRequest request, HttpResponse response, Stream baseStream)
    {
        _request = request;
        _response = response;
        _baseStream = baseStream;
    }

    public override bool CanRead => _baseStream.CanRead;
    public override bool CanSeek => _baseStream.CanSeek;
    public override bool CanWrite => _baseStream.CanWrite;
    public override long Length => _baseStream.Length;

    public override long Position
    {
        get => _baseStream.Position;
        set => _baseStream.Position = value;
    }

    public override void Flush()
    {
        _baseStream.Flush();
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        return _baseStream.Read(buffer, offset, count);
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return _baseStream.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        _baseStream.SetLength(value);
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        // Write to our internal buffer first
        _capturedStream.Write(buffer, offset, count);
        // Also write to the original stream
        _baseStream.Write(buffer, offset, count);
    }

    public override void Close()
    {
        // This is where you process the captured content
        _capturedStream.Position = 0;
        using (StreamReader reader = new StreamReader(_capturedStream, Encoding.UTF8))
        {
            if (_response.StatusCode < 500)
            {
                base.Close();
                return;
            }

            string responseContent = reader.ReadToEnd();

            // Attempt to parse the response as a .NET exception serialized to JSON
            // The structure is typically: {"Message":"Error details","StackTrace":"..."}
            try
            {
                var serializer = new JavaScriptSerializer();
                var obj = serializer.Deserialize<dynamic>(responseContent);

                if (obj != null && obj.ContainsKey("Message") && obj.ContainsKey("StackTrace"))
                {
                    // This is likely an unhandled exception from a WebMethod
                    string errorMessage = obj["Message"];
                    string stackTrace = obj["StackTrace"];

                    int companyId = nUtil.RequestHeaderEmpresa(_request); // Assuming nUtil.RequestHeaderEmpresa gets company ID
                    int personId = nUtil.RequestHeaderIdPessoa(_request); // Assuming nUtil.RequestHeaderIdPessoa gets person ID
                    string language = nUtil.RequestHeaderIdioma(_request); // Assuming nUtil.RequestHeaderIdioma gets language


                    string user = "User not found";
                    if (personId == 0)
                    {
                        user = $"userId: {personId}";
                    }

                    // Log this error globally
                    Int32 errorLogId = LogError(user, errorMessage, stackTrace, "Unhandled error", companyId); // Assuming LogError is a global logging function

                    _response.Clear(); // Clear the existing error response
                    if (_response.StatusCode == 0)
                    {
                        _response.StatusCode = 500;
                    }

                    _response.Write(serializer.Serialize(new { message = $"An unexpected error occurred. \r\nSystem administrators have been notified. Error ID: {errorLogId}", errorLogId = errorLogId }));

                    _response.ContentType = "application/json";
                }
            }
            catch (Exception ex)
            {
                // Not a serialized .NET exception, or couldn't parse.
                // You might still log the raw content if it's an unexpected format.
                System.Diagnostics.Debug.WriteLine($"Failed to parse WebMethod error response: {responseContent}. Error: {ex.Message}");
            }
        }
        base.Close();
    }
}