Cómo usar ELMAH para registrar errores manualmente

¿Es posible hacer lo siguiente usando ELMAH?

logger.Log(" something");

Estoy haciendo algo como esto:

try 
{
    // Code that might throw an exception 
}
catch(Exception ex)
{
    // I need to log error here...
}

ELMAH no registrará automáticamente esta excepción porque se manejó.

Método de escritura de registro directo, trabajando desde ELMAH 1.0:

try 
{
    some code 
}
catch(Exception ex)
{
    Elmah.ErrorLog.GetDefault(HttpContext.Current).Log(new Elmah.Error(ex));
}

ELMAH 1.2 presenta una API más flexible:

try 
{
    some code 
}
catch(Exception ex)
{
    Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
}

Hay una diferencia entre las dos soluciones:

• RaiseEl método aplica las reglas de filtrado de ELMAH a la excepción. LogEl método no lo hace.
• Raise se basa en la suscripción y puede registrar una excepción en varios registradores.

Recomiendo encapsular la llamada a Elmah en una clase de envoltura simple propia.

using Elmah;

public static class ErrorLog
{
    /// <summary>
    /// Log error to Elmah
    /// </summary>
    public static void LogError(Exception ex, string contextualMessage=null)
    {
        try
        {
            // log error to Elmah
            if (contextualMessage != null) 
            {
                // log exception with contextual information that's visible when 
                // clicking on the error in the Elmah log
                var annotatedException = new Exception(contextualMessage, ex); 
                ErrorSignal.FromCurrentContext().Raise(annotatedException, HttpContext.Current);
            }
            else 
            {
                ErrorSignal.FromCurrentContext().Raise(ex, HttpContext.Current);
            }

            // send errors to ErrorWS (my own legacy service)
            // using (ErrorWSSoapClient client = new ErrorWSSoapClient())
            // {
            //    client.LogErrors(...);
            // }
        }
        catch (Exception)
        {
            // uh oh! just keep going
        }
    }
}

Luego, simplemente llámelo cuando necesite registrar un error.

try {
   ...
} 
catch (Exception ex) 
{
    // log this and continue
    ErrorLog.LogError(ex, "Error sending email for order " + orderID);
}

Esto tiene los siguientes beneficios:

• No necesita recordar esta sintaxis ligeramente arcaica de la llamada de Elmah
• Si tiene muchas DLL, no necesita hacer referencia a Elmah Core de cada una de ellas, y simplemente poner esto en su propia DLL de 'Sistema'.
• Si alguna vez necesita hacer un manejo especial o simplemente quiere poner un punto de interrupción para depurar errores, lo tiene todo en un solo lugar.
• Si alguna vez te alejas de Elmah, puedes cambiar un lugar.
• Si tiene un registro de errores heredado que desea conservar (solo tengo un mecanismo de registro de errores simple que está vinculado a algunas IU que no tengo tiempo de eliminar de inmediato).

Nota: He agregado una propiedad 'contextualMessage' para información contextual. Puede omitir esto si lo prefiere, pero me parece muy útil. Elmah desenvuelve automáticamente las excepciones, por lo que la excepción subyacente aún se informará en el registro, pero el mensaje contextual será visible cuando haga clic en él.

Puede usar el método Elmah.ErrorSignal () para registrar un problema sin generar una excepción.

try
{
    // Some code
}
catch(Exception ex)
{
    // Log error
    Elmah.ErrorSignal.FromCurrentContext().Raise(ex);

    // Continue
}

catch(Exception ex)
{
    Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
}

Sí, es posible. ELMAH fue diseñado para interceptar excepciones no manejadas. Sin embargo, puede señalar una excepción a ELMAH a través de la clase ErrorSignal. Esas excepciones no se lanzan (no burbujean), sino que solo se envían a ELMAH (y a los suscriptores del evento Raise de la clase ErrorSignal).

Un pequeño ejemplo:

protected void ThrowExceptionAndSignalElmah()
{
    ErrorSignal.FromCurrentContext().Raise(new NotSupportedException());
}

Estaba buscando hacer lo mismo en un hilo en el que había comenzado a poner en cola el correo desde mi aplicación MVC4, por lo que no tenía el HttpContext disponible cuando se produjo una excepción. Para hacer esto, terminé con lo siguiente basado en esta pregunta y otra respuesta encontrada aquí: elmah: ¿excepciones sin HttpContext?

En el archivo de configuración especifiqué un nombre de aplicación:

<elmah>
    <security allowRemoteAccess="false" />
    <errorLog type="Elmah.SqlErrorLog, Elmah" connectionStringName="ELMAH" applicationName="myApplication"/>   
</elmah>

Luego, en el código (como la respuesta proporcionada anteriormente, pero sin el HttpContext) puede pasar nulo en lugar de un HttpContext:

ThreadPool.QueueUserWorkItem(t => {
     try {
         ...
         mySmtpClient.Send(message);
     } catch (SomeException e) {
         Elmah.ErrorLog.GetDefault(null).Log(new Elmah.Error(e));
     }
 });

A veces CurrentHttpContextpuede no estar disponible.

Definir

public class ElmahLogger : ILogger
{
    public void LogError(Exception ex, string contextualMessage = null, bool withinHttpContext = true)
    {
        try
        {
            var exc = contextualMessage == null 
                      ? ex 
                      : new ContextualElmahException(contextualMessage, ex);
            if (withinHttpContext)
                ErrorSignal.FromCurrentContext().Raise(exc);
            else
                ErrorLog.GetDefault(null).Log(new Error(exc));
        }
        catch { }
    }
}

Utilizar

public class MyClass
{
    readonly ILogger _logger;

    public MyClass(ILogger logger)
    {
        _logger = logger;
    }

    public void MethodOne()
    {
        try
        {

        }
        catch (Exception ex)
        {
            _logger.LogError(ex, withinHttpContext: false);
        }
    }
}

Estoy en ASP.NET core y uso ElmahCore .

Para registrar errores manualmente con HttpContext (en el controlador) simplemente escriba:

using ElmahCore;
...
HttpContext.RiseError(new Exception("Your Exception"));

En otra parte de su aplicación sin HttpContext :

using ElmahCore;
...
ElmahExtensions.RiseError(new Exception("Your Exception"));

Intenté escribir mensajes personalizados en los registros de elmah usando Signal.FromCurrentContext (). Raise (ex); y descubrimos que estas excepciones aparecen, por ejemplo:

try
{
    ...
}
catch (Exception ex)
{
    Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
    // this will write to the log AND throw the exception
}

Además, no veo cómo elmah admite diferentes niveles de registro: ¿es posible desactivar el registro detallado mediante una configuración web.config?

Usé esta línea y funciona perfectamente bien.

 try{
            //Code which may throw an error
    }
    catch(Exception ex){
            ErrorLog.GetDefault(HttpContext.Current).Log(new Elmah.Error(ex));
    }