Global Error Handling

1. The Zomato Standard - What Errors Should Look Like

Bad: 500 Internal Server Error + HTML with at Zomato.API.Controllers.OrdersController.Get()

Good: 500 Internal Server Error + JSON:

{
  "error": {
    "code": "INTERNAL_ERROR",
    "message": "An unexpected error occurred. Please try again.",
    "traceId": "0HMVFE0A284AM:00000001"
  }
}

Why: Frontend can display message. You can search logs using traceId. No sensitive data leaked.

2. Solution: Global Exception Middleware

Catches ANY unhandled exception from controllers, filters, services.

// Middleware/GlobalExceptionHandler.cs
public class GlobalExceptionHandler : IExceptionHandler {
  private readonly ILogger _logger;
  public GlobalExceptionHandler(ILogger logger) => _logger = logger;

  public async ValueTask TryHandleAsync(
    HttpContext httpContext,
    Exception exception,
    CancellationToken cancellationToken) {

    var traceId = Activity.Current?.Id?? httpContext.TraceIdentifier;
    _logger.LogError(exception, "Unhandled exception. TraceId: {TraceId}", traceId);

    var problemDetails = new ProblemDetails {
      Status = StatusCodes.Status500InternalServerError,
      Title = "Server Error",
      Detail = "An unexpected error occurred. Please try again.",
      Extensions = { ["traceId"] = traceId }
    };

    httpContext.Response.StatusCode = problemDetails.Status.Value;
    await httpContext.Response.WriteAsJsonAsync(problemDetails, cancellationToken);
    return true; // Mark as handled
  }
}

// Program.cs -.NET 8 way
builder.Services.AddExceptionHandler();
builder.Services.AddProblemDetails(); // Standard RFC 7807 format

var app = builder.Build();
app.UseExceptionHandler(); // Must be first! Catches all errors
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.Run();

3. Handle Known Errors Differently

Not all exceptions = 500. Custom exceptions = clean codes.

// Exceptions/NotFoundException.cs
public class NotFoundException : Exception {
  public NotFoundException(string message) : base(message) {}
}

// GlobalExceptionHandler.cs - update TryHandleAsync
public async ValueTask TryHandleAsync(...) {
  var statusCode = exception switch {
    NotFoundException => StatusCodes.Status404NotFound,
    UnauthorizedAccessException => StatusCodes.Status401Unauthorized,
    ArgumentException => StatusCodes.Status400BadRequest,
    _ => StatusCodes.Status500InternalServerError
  };

  var message = statusCode == 500
   ? "An unexpected error occurred"
    : exception.Message; // Safe to show for known errors

  var problemDetails = new ProblemDetails {
    Status = statusCode,
    Title = GetTitle(statusCode),
    Detail = message,
    Extensions = { ["traceId"] = traceId }
  };
 ...
}

Controller: throw new NotFoundException("Restaurant not found") → 404 JSON, not 500.

1. Theory: IExceptionHandler vs Middleware

Rule: Use IExceptionHandler in.NET 8. It's the official way. Middleware still works.

2. ProblemDetails - RFC 7807 Standard

Why standard matters: Frontend knows exact JSON shape. No guessing.

{
  "type": "https://tools.ietf.org/html/rfc7231#section-6.5.4",
  "title": "Not Found",
  "status": 404,
  "detail": "Restaurant 99 not found",
  "instance": "/api/v1/restaurants/99",
  "traceId": "0HMVFE0A284AM:00000001"
}

AddProblemDetails() auto-generates this. type = link to docs. instance = failing URL. Enterprise-grade.

3. Validation Errors - 400 Bad Request

[ApiController] auto-validates models. But error format is ugly. Customize it:

builder.Services.Configure(options => {
  options.InvalidModelStateResponseFactory = context => {
    var errors = context.ModelState
     .Where(e => e.Value.Errors.Count > 0)
     .ToDictionary(
        kvp => kvp.Key,
        kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()
      );

    var problemDetails = new ValidationProblemDetails(context.ModelState) {
      Status = 400,
      Title = "Validation Failed",
      Detail = "One or more validation errors occurred.",
      Instance = context.HttpContext.Request.Path
    };
    return new BadRequestObjectResult(problemDetails);
  };
});

Result: POST with missing Name → 400 JSON with field errors. React can map to form fields.

4. Logging + Correlation ID

Problem: User reports bug. You have 10GB logs. Which log is theirs?

Fix: Every request gets TraceIdentifier. Return it in error + log it.

_logger.LogError(ex, "Error processing order. TraceId: {TraceId}", httpContext.TraceIdentifier);

User sends you traceId: 0HMVFE0A284AM:00000001. You grep logs. Find exact error in 2 sec.