O erro do aplicativo não é acionado quando o cliente espelha = "Ativado"

Eu tenho um código no evento global.asaxdo arquivo Application_Errorque é executado quando ocorre um erro e envia por e-mail os detalhes do erro para mim.

void Application_Error(object sender, EventArgs e)
{
    var error = Server.GetLastError();

    if (error.Message != "Not Found")
    {
        // Send email here...
    }

}

Isso funciona bem quando eu estou executando no Visual Studio; no entanto, quando publico no nosso servidor ativo, o Application_Errorevento não é acionado.

Após alguns testes, eu consigo Application_Errordisparar quando defino customErrors="Off", no entanto, configurá-lo novamente para customErrors="On"interromper o disparo do evento novamente.

Alguém pode sugerir por Application_Errorque não seria customErrorsacionado quando ativado no web.config?

ATUALIZAÇÃO
Como essa resposta fornece uma solução, não a editarei, mas encontrei uma maneira muito mais limpa de resolver esse problema. Veja minha outra resposta para obter detalhes ...

Resposta original:
Eu descobri por que o Application_Error()método não está sendo chamado ...

Global.asax.cs

public class MvcApplication : System.Web.HttpApplication
{
    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
        filters.Add(new HandleErrorAttribute()); // this line is the culprit
    }
...
}

Por padrão (quando um novo projeto é gerado), um aplicativo MVC possui alguma lógica no Global.asax.csarquivo. Essa lógica é usada para mapear rotas e registrar filtros. Por padrão, ele registra apenas um filtro: um HandleErrorAttributefiltro. Quando customErrors está ativado (ou por meio de solicitações remotas quando está definido como RemoteOnly), o HandleErrorAttribute diz ao MVC para procurar uma visualização de Erro e nunca chama o Application_Error()método. Não consegui encontrar documentação disso, mas está explicada nesta resposta em programmers.stackexchange.com .

Para obter o método ApplicationError () chamado para todas as exceções não tratadas, remova a linha que registra o filtro HandleErrorAttribute.

Agora, o problema é: Como configurar os customErrors para obter o que você deseja ...

A seção customErrors é padronizada como redirectMode="ResponseRedirect". Você também pode especificar o atributo defaultRedirect como uma rota MVC. Eu criei um ErrorController que era muito simples e alterei meu web.config para ficar assim ...

web.config

<customErrors mode="RemoteOnly" redirectMode="ResponseRedirect" defaultRedirect="~/Error">
  <error statusCode="404" redirect="~/Error/PageNotFound" />
</customErrors>

O problema com esta solução é que ele faz um redirecionamento 302 para os URLs de erro e, em seguida, essas páginas respondem com um código de status 200. Isso leva o Google a indexar as páginas de erro, o que é ruim. Também não é muito compatível com a especificação HTTP. O que eu queria fazer não era redirecionar e substituir a resposta original com minhas visualizações de erro personalizadas.

Eu tentei mudar redirectMode="ResponseRewrite". Infelizmente, esta opção não suporta rotas MVC , apenas páginas HTML estáticas ou ASPX. Tentei usar uma página HTML estática no início, mas o código de resposta ainda era 200, mas pelo menos não foi redirecionado. Então eu tive uma idéia desta resposta ...

Decidi desistir do MVC pelo tratamento de erros. Eu criei um Error.aspxe um PageNotFound.aspx. Essas páginas eram muito simples, mas tinham um pedaço de mágica ...

<script type="text/C#" runat="server">
    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        Response.StatusCode = (int) System.Net.HttpStatusCode.InternalServerError;
    }
</script>

Este bloco informa a página a ser veiculada com o código de status correto. De grosso modo, na página PageNotFound.aspx, eu usei HttpStatusCode.NotFound. Mudei meu web.config para ficar assim ...

<customErrors mode="RemoteOnly" redirectMode="ResponseRewrite" defaultRedirect="~/Error.aspx">
  <error statusCode="404" redirect="~/PageNotFound.aspx" />
</customErrors>

Tudo funcionou perfeitamente!

Resumo:

• Remova a linha: filters.Add(new HandleErrorAttribute());
• Use o Application_Error()método para registrar exceções
• Use customErrors com um ResponseRewrite, apontando para páginas ASPX
• Responsabilize as páginas ASPX por seus próprios códigos de status de resposta

Há algumas desvantagens que notei com esta solução.

• As páginas ASPX não podem compartilhar nenhuma marcação com os modelos do Razor, tive que reescrever a marcação padrão do cabeçalho e rodapé do nosso site para obter uma aparência consistente.
• As páginas * .aspx podem ser acessadas diretamente pressionando seus URLs

Existem soluções alternativas para esses problemas, mas eu não estava preocupado o suficiente com eles para fazer qualquer trabalho extra.

Eu espero que isso ajude a todos!

Resolvi isso criando um ExceptionFilter e registrando o erro lá em vez de Application_Error. Tudo o que você precisa fazer é adicionar uma chamada no RegisterGlobalFilters

log4netExceptionFilter.cs

using System
using System.Web.Mvc;

public class log4netExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        Exception ex = context.Exception;
        if (!(ex is HttpException)) //ignore "file not found"
        {
            //Log error here
        }
    }
}

Global.asax.cs

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new log4netExceptionFilter()); //must be before HandleErrorAttribute
    filters.Add(new HandleErrorAttribute());
}

Encontrei um artigo que descreve uma maneira muito mais limpa de criar páginas de erro personalizadas em um aplicativo da Web MVC3 que não impede a capacidade de registrar as exceções.

A solução é usar o <httpErrors>elemento da <system.webServer>seção.

Eu configurei meu Web.config assim ...

<httpErrors errorMode="DetailedLocalOnly" existingResponse="Replace">
  <remove statusCode="404" subStatusCode="-1" />
  <remove statusCode="500" subStatusCode="-1" />
  <error statusCode="404" path="/Error/NotFound" responseMode="ExecuteURL" />
  <error statusCode="500" path="/Error" responseMode="ExecuteURL" />
</httpErrors>

Também configurei customErrorspara ter mode="Off"(como sugerido pelo artigo).

Isso faz com que as respostas sejam substituídas pelas ações de um ErrorController. Aqui está esse controlador:

public class ErrorController : Controller
{
    public ActionResult Index()
    {
        return View();
    }

    public ActionResult NotFound()
    {
        return View();
    }
}

As visualizações são muito diretas, usei a sintaxe padrão do Razor para criar as páginas.

Isso por si só deve ser suficiente para você usar páginas de erro personalizadas com o MVC.

Eu também precisava do log de exceções, então roubei a solução do Mark usando um ExceptionFilter personalizado ...

public class ExceptionPublisherExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext exceptionContext)
    {
        var exception = exceptionContext.Exception;
        var request = exceptionContext.HttpContext.Request;
        // log stuff
    }
}

A última coisa que você precisa fazer é registrar o filtro de exceção no seu arquivo Global.asax.cs :

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

Parece uma solução muito mais limpa do que a minha resposta anterior e funciona tão bem quanto eu sei. Eu gosto especialmente porque não parecia que estava lutando contra a estrutura MVC; esta solução realmente a alavanca!

No caso do ASP.NET MVC5, use

public class ExceptionPublisherExceptionFilter : IExceptionFilter
    {
        private static Logger _logger = LogManager.GetCurrentClassLogger();
        public void OnException(ExceptionContext exceptionContext)
        {
            var exception = exceptionContext.Exception;
            var request = exceptionContext.HttpContext.Request;
            // HttpException httpException = exception as HttpException;
            // Log this exception with your logger
            _logger.Error(exception.Message);
        }
    }

Você pode encontrá-lo em FilterConfig.csde App_Startpasta.

Eu gosto da resposta de Mark com o ExceptionFilter, mas outra opção, se você tiver todos os seus controladores derivados do mesmo controlador base, é simplesmente substituir o OnException no seu controlador base. Você pode fazer seu log e enviar por e-mail lá. Isso tem a vantagem de poder usar as dependências que você já injetou no seu controlador de base com seu contêiner de IoC.

Você ainda pode usar sua IoC com um IExceptionFilter, mas é um pouco mais complicado configurar suas ligações.

Até onde eu sei, você está passando o controle para a página especificada no parâmetro url e sua notificação de evento fica aqui, em vez de Application_Error

<customErrors defaultRedirect="myErrorPage.aspx"
              mode="On">
</customErrors>

Muitas informações podem ser encontradas aqui: http://support.microsoft.com/kb/306355

Para contornar isso, acabei deixando os espelhos do cliente desativados e manipulando todos os erros do evento Application_Error em global.asax. É um pouco complicado com o MVC, como eu não queria retornar um redirecionamento 301, queria retornar códigos de erro adequados. Mais detalhes podem ser vistos no meu blog em http://www.wduffy.co.uk/blog/using-application_error-in-asp-net-mvcs-global-asax-to-handle-errors/, mas o código final é listado abaixo...

void Application_Error(object sender, EventArgs e)
{
    var error = Server.GetLastError();
    var code = (error is HttpException) ? (error as HttpException).GetHttpCode() : 500;

    if (code != 404)
    {
            // Generate email with error details and send to administrator
    }

    Response.Clear();
    Server.ClearError();

    string path = Request.Path;
    Context.RewritePath(string.Format("~/Errors/Http{0}", code), false);
    IHttpHandler httpHandler = new MvcHttpHandler();
    httpHandler.ProcessRequest(Context);
    Context.RewritePath(path, false);
}

E aqui está o controlador

public class ErrorsController : Controller
{

    [HttpGet]
    public ActionResult Http404(string source)
    {
            Response.StatusCode = 404;
            return View();
    }

    [HttpGet]
    public ActionResult Http500(string source)
    {
            Response.StatusCode = 500;
            return View();
    }

}

Esta entrada do blog me ajudou a:

http://asp-net.vexedlogic.com/2011/04/23/asp-net-maximum-request-length-exceeded/

Se você estiver usando o IIS 7.0 ou superior, poderá alterar o arquivo Web.config para lidar com solicitações muito grandes. Existem algumas ressalvas, mas aqui está um exemplo:

<system.webServer>
  <security>
    <requestFiltering>
      <requestLimits maxAllowedContentLength="1048576" />
    </requestFiltering>
  </security>
  <httpErrors errorMode="Custom" existingResponse="Replace">
    <remove statusCode="404" subStatusCode="13" />
    <error statusCode="404" subStatusCode="13" prefixLanguageFilePath="" path="/UploadTooLarge.htm" responseMode="Redirect" />
  </httpErrors>
</system.webServer>

Há detalhes adicionais sobre esses elementos do arquivo de configuração aqui:

http://www.iis.net/ConfigReference/system.webServer/security/requestFiltering/requestLimits

O código de status 404.13 é definido como "Comprimento do conteúdo muito grande". Uma coisa importante a observar é que o maxAllowedContentLengthé especificado em bytes. Isso é diferente da maxRequestLengthconfiguração encontrada na <system.web>seção especificada em kilobytes.

<system.web>
  <httpRuntime maxRequestLength="10240" />
</system.web>

Observe também que o pathatributo deve ser um caminho absoluto quando responseModeestiver Redirect, portanto, acrescente o nome do diretório virtual, se relevante. As respostas informativas de Jesse Webb mostram como fazer isso responseMode="ExecuteURL", e eu acho que essa abordagem também funcionaria bem.

Essa abordagem não funcionará se você estiver desenvolvendo usando o Visual Studio Development Server (Cassini, o servidor da Web integrado ao Visual Studio). Suponho que funcionaria no IIS Express, mas não testei isso.

Eu estava tendo o mesmo problema em que Application_Error() não estava sendo atingido. Eu tentei de tudo, até que finalmente passei pelo que estava acontecendo. Eu tinha um código personalizado em um evento ELMAH que estava adicionando JSON ao email que ele envia e houve um erro nulo lá!

A correção do erro interno permitiu que o código continuasse no Application_Error()evento conforme o esperado.