Jak używać ELMAH do ręcznego rejestrowania błędów

Czy można wykonać następujące czynności przy użyciu ELMAH?

logger.Log(" something");

Robię coś takiego:

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

Ten wyjątek nie zostanie automatycznie zarejestrowany przez ELMAH, ponieważ został obsłużony.

Metoda bezpośredniego zapisu dziennika, działająca od ELMAH 1.0:

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

ELMAH 1.2 wprowadza bardziej elastyczny interfejs API:

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

Istnieje różnica między tymi dwoma rozwiązaniami:

• RaiseMetoda stosuje reguły filtrowania ELMAH do wyjątku. Logmetoda nie.
• Raise jest oparty na subskrypcji i może zalogować jeden wyjątek do kilku rejestratorów.

Poleciłbym zawinięcie połączenia do Elmah w swoją własną prostą klasę opakowania.

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
        }
    }
}

Następnie wystarczy zadzwonić, gdy trzeba zarejestrować błąd.

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

Ma to następujące zalety:

• Nie musisz pamiętać tej nieco archaicznej składni wywołania Elmah
• Jeśli masz wiele bibliotek DLL, nie musisz odwoływać się do Elmah Core z każdego z nich - po prostu umieść to we własnej bibliotece DLL systemu.
• Jeśli kiedykolwiek potrzebujesz specjalnej obsługi lub po prostu chcesz ustawić punkt przerwania w celu debugowania błędów, masz wszystko w jednym miejscu.
• Jeśli kiedykolwiek odejdziesz od Elmah, możesz po prostu zmienić jedno miejsce.
• Jeśli masz starsze rejestrowanie błędów, które chcesz zachować (akurat mam prosty mechanizm rejestrowania błędów związany z niektórymi interfejsami użytkownika, których natychmiast nie mam czasu).

Uwaga: Dodałem właściwość „contextualMessage” dla informacji kontekstowych. Możesz to pominąć, jeśli wolisz, ale uważam to za bardzo przydatne. Elmah automatycznie rozpakowuje wyjątki, więc bazowy wyjątek będzie nadal zgłaszany w dzienniku, ale komunikat kontekstowy będzie widoczny po kliknięciu.

Za pomocą metody Elmah.ErrorSignal () można zarejestrować problem bez zgłaszania wyjątku.

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

    // Continue
}

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

Tak to mozliwe. ELMAH został zaprojektowany do przechwytywania nieobsługiwanych wyjątków. Możesz jednak zasygnalizować wyjątek ELMAH za pośrednictwem klasy ErrorSignal. Te wyjątki nie są zgłaszane (nie wygasają), ale są wysyłane tylko do ELMAH (i do subskrybentów zdarzenia Raise klasy ErrorSignal).

Mały przykład:

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

Chciałem zrobić to samo w wątku, w którym zacząłem umieszczać w kolejce pocztę z poziomu aplikacji MVC4, ponieważ nie miałem dostępnego HttpContext po zgłoszeniu wyjątku. Aby to zrobić, skończyłem z następującymi na podstawie tego pytania i kolejnej odpowiedzi tutaj: elmah: wyjątki bez HttpContext?

W pliku konfiguracyjnym podałem nazwę aplikacji:

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

Następnie w kodzie (jak odpowiedź podana powyżej, ale bez HttpContext) możesz podać null zamiast HttpContext:

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

Czasami CurrentHttpContext może nie być dostępna.

Definiować

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 { }
    }
}

Posługiwać się

public class MyClass
{
    readonly ILogger _logger;

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

    public void MethodOne()
    {
        try
        {

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

Jestem na rdzeniu ASP.NET i używam ElmahCore .

Aby ręcznie rejestrować błędy za pomocą HttpContext (w kontrolerze), po prostu napisz:

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

W innej części aplikacji bez HttpContext :

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

Próbowałem zapisywać niestandardowe komunikaty w dziennikach elmah za pomocą Signal.FromCurrentContext (). Raise (ex); i stwierdził, że te wyjątki są propagowane, np .:

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

Poza tym nie widzę, jak elmah obsługuje różne poziomy rejestrowania - czy można wyłączyć pełne rejestrowanie za pomocą ustawienia web.config?

Użyłem tej linii i działa idealnie dobrze.

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