MVC Error Handle with custom error Messages

Use Elmah as others have also recommended. I am, and haven't looked back!

It meets all your requirements:

• Catches all errors, e.g. 400s, 500s...
• Logs to a file, and any other data store you can think of, e.g. database, memory, Azure, more file formats(XML, CSV), RSS feed...
• Emails errors: Enable and config mail settings in Web.config - very simple. You can even send emails asynchronously!
• Add custom code - in your case add extra details to the error
• Use your own custom error pages - custom error node (for 400s, 500s) in web.config and your own error controller

Further on the custom code (2nd last point above), AFAIK you have two options:

1. Create a custom error log implementation.

This isn't that difficult. It's what I did!

Override the default error log data store. For example, taking the SQL Server data store:

In Web.config
<elmah>
   <errorLog type="Elmah.SqlErrorLog, Elmah" connectionStringName="myCn" applicationName="myAppName" />
</elmah>

Next, create a class "MySQLServerErrorLog" and derive from Elmah.ErrorLog

All that is then required is to override the Log() method.

public override string Log(Error error)
        {   

        // You have access to all the error details - joy!      
        = error.HostName,
        = error.Type,
        = error.Message,
        = error.StatusCode
        = error.User,
        = error.Source,

        // Call the base implementation
    }

In Web.config, replace the default (above) entry with your implementation:

<elmah>
   <errorLog type="myProjectName.MySQLServerErrorLog, myProjectName" />
</elmah>

2. You can programmatically log errors

Using the ErrorSignal class, you may logs errors without having to raise unhandled exceptions.

Syntax: ErrorSignal.FromCurrentContext().Raise(new NotSupportedException());

Example: A custom exception

var customException = new Exception("My error", new NotSupportedException()); 
ErrorSignal.FromCurrentContext().Raise(customException);

This gives you the option of using your custom logic to programmatically log whatever you require.

I've written functionality for my Elmah instance to logs errors to Azure Cloud Storage Table and Blob (error stack trace details).

FWIW before I used Elmah, I had written my own exception handling mechanism for MVC which used HandleErrorAttribute and Application_Error (in Global.asax). It worked but was too unwieldy IMO.

If it was me, I'd create my own exception handling Attribute which adds required behaviour to the base implementation of HandleErrorAttribute.

I've had quite good results in the past with having attributes "pointed at" various parts of the request that's of interest (am thinking the bit where you say that you want to log specific details) - so you can use these identifiers to pull the request to pieces using reflection:

CustomHandleErrorAttribute(["id", "name", "model.lastUpdatedDate"])

I've used this approach to secure controller actions (making sure that a customer is requesting things that they're allowed to request) - e.g. a parent is requesting info on their children, and not someone else's children.

Or, you could have a configuration set up whereby you'd "chain" handlers together - so lots of little handlers, all doing very specific bits, all working on the same request and request pointers (as above):

ChainedErrorHandling("emailAndLogFile", ["id", "name", "model.lastUpdatedDate"])

Where "emailAndLogFile" creates a chain of error handlers that inherit from FilterAttribute, the last of which, in the chain, is the standard MVC HandleErrorAttribute.

But by far, the simplest approach would be the former of these 2.

HTH

EDITED TO ADD: Example of inheriting custom error handling:

public class CustomErrorAttribute : HandleErrorAttribute
{
    public CustomErrorAttribute(string[] requestPropertiesToLog)
    {
        this.requestPropertiesToLog = requestPropertiesToLog;
    }

    public string[] requestPropertiesToLog { get; set; }

    public override void OnException(ExceptionContext filterContext)
    {
        var requestDetails = this.GetPropertiesFromRequest(filterContext);

        // do custom logging / handling
        LogExceptionToEmail(requestDetails, filterContext);
        LogExceptionToFile(requestDetails, filterContext);
        LogExceptionToElseWhere(requestDetails, filterContext);// you get the idea

        // even better - you could use DI (as you're in MVC at this point) to resolve the custom logging and log from there.
        //var logger = DependencyResolver.Current.GetService<IMyCustomErrorLoggingHandler>();
        // logger.HandleException(requestDetails, filterContext);

        // then let the base error handling do it's thang.
        base.OnException(filterContext);
    }

    private IEnumerable<KeyValuePair<string, string>> GetPropertiesFromRequest(ExceptionContext filterContext)
    {
        // in requestContext is the queryString, form, user, route data - cherry pick bits out using the this.requestPropertiesToLog and some simple mechanism you like
        var requestContext = filterContext.RequestContext;
        var qs = requestContext.HttpContext.Request.QueryString;
        var form = requestContext.HttpContext.Request.Form;
        var user = requestContext.HttpContext.User;
        var routeDataOfActionThatThrew = requestContext.RouteData;

        yield break;// just break as I'm not implementing it.
    }

    private void LogExceptionToEmail(IEnumerable<KeyValuePair<string, string>> requestDetails, ExceptionContext filterContext)
    {
        // send emails here
    }

    private void LogExceptionToFile(IEnumerable<KeyValuePair<string, string>> requestDetails, ExceptionContext filterContext)
    {
        // log to files
    }

    private void LogExceptionToElseWhere(IEnumerable<KeyValuePair<string, string>> requestDetails, ExceptionContext filterContext)
    {
        // send cash to me via paypal everytime you get an exception ;)
    }
}

And On the controller action you'd add something like:

[CustomErrorAttribute(new[] { "formProperty1", "formProperty2" })]
public ActionResult Index(){
    return View();
}

Firstly, you can define a filter attribute, and you can register it on startup in an MVC application in global.asax, so you can catch any kind of errors that occur while actions are invoking.

Note: Dependency Resolving is changeable. I'm using Castle Windsor for this story. You can resolve dependencies your own IOC container. For example, ILogger dependency. I used for this property injection while action invoking. Windsor Action Invoker

For Example Filter:

public class ExceptionHandling : FilterAttribute, IExceptionFilter
{
    public ILogger Logger { get; set; }

    public void OnException(ExceptionContext filterContext)
    {
        Logger.Log("On Exception !", LogType.Debug, filterContext.Exception);

        if (filterContext.Exception is UnauthorizedAccessException)
        {
            filterContext.Result = UnauthorizedAccessExceptionResult(filterContext);
        }
        else if (filterContext.Exception is BusinessException)
        {
            filterContext.Result = BusinessExceptionResult(filterContext);
        }
        else
        {
            // Unhandled Exception
            Logger.Log("Unhandled Exception ", LogType.Error, filterContext.Exception);
            filterContext.Result = UnhandledExceptionResult(filterContext);
        }
    } 
}

This way you can catch everything.

So:

private static ActionResult UnauthorizedAccessExceptionResult(ExceptionContext filterContext)
{
    // Send email, fire event, add error messages 
    // for example handle error messages
    // You can seperate the behaviour by: if (filterContext.HttpContext.Request.IsAjaxRequest())
    filterContext.ExceptionHandled = true;
    filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
    filterContext.Controller.TempData.Add(MessageType.Danger.ToString(), filterContext.Exception.Message);

    // So you can show messages using with TempData["Key"] on your action or views
    var lRoutes = new RouteValueDictionary(
        new
        {
            action = filterContext.RouteData.Values["action"],
            controller = filterContext.RouteData.Values["controller"]
        });
    return new RedirectToRouteResult(lRoutes);
}

In Global.asax:

protected void Application_Start()
{
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
}

FilterConfig:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new ExceptionHandling());
}

BusinessException:

public class BusinessException : Exception, ISerializable
{
    public BusinessException(string message)
        : base(message)
    {
        // Add implemenation (if required)
    }
}

So you can access the exception message OnException at ExceptionHandling class with filterContext.Exception.Message

You should use BusinessException on the action after any violated control logic this way: throw new BusinessException("Message").

Why don't you create model that contains your required Error Information and bind data to model when you need to? It will also allow you to create/return view from it

Global error catching with special information can you make with customer exceptions who contains the needed informations (id, tablesname etc.).

In HandleErrorAttribute you "only" have httpContext/ExceptionContext and othe static informations.