Hintergrund

Ich entwickle eine API-Service-Schicht für einen Client und wurde aufgefordert, alle Fehler global abzufangen und zu protokollieren.

Während also so etwas wie ein unbekannter Endpunkt (oder eine unbekannte Aktion) einfach zu handhaben ist, verwenden Sie ELMAH oder fügen Sie Folgendes hinzu Global.asax:

protected void Application_Error()
{
     Exception unhandledException = Server.GetLastError();
     //do more stuff
}

. . Nicht behandelte Fehler, die nicht mit dem Routing zusammenhängen, werden nicht protokolliert. Beispielsweise:

public class ReportController : ApiController
{
    public int test()
    {
        var foo = Convert.ToInt32("a");//Will throw error but isn't logged!!
        return foo;
    }
}

Ich habe auch versucht, das [HandleError]Attribut global festzulegen, indem ich diesen Filter registriert habe:

filters.Add(new HandleErrorAttribute());

Das protokolliert aber auch nicht alle Fehler.

Problem / Frage

Wie fange ich Fehler ab, wie sie durch den /testobigen Aufruf generiert wurden, damit ich sie protokollieren kann? Es scheint, dass diese Antwort offensichtlich sein sollte, aber ich habe alles versucht, was mir bisher einfällt.

Im Idealfall möchte ich der Fehlerprotokollierung einige Dinge hinzufügen, z. B. die IP-Adresse des anfordernden Benutzers, Datum, Uhrzeit usw. Ich möchte auch in der Lage sein, dem Support-Personal automatisch eine E-Mail zu senden, wenn ein Fehler auftritt. All dies kann ich tun, wenn ich diese Fehler nur abfangen kann, wenn sie auftreten!

AUFGELÖST!

Dank Darin Dimitrov, dessen Antwort ich akzeptierte, habe ich das herausgefunden. WebAPI behandelt Fehler nicht wie ein normaler MVC-Controller.

Folgendes hat funktioniert:

1) Fügen Sie Ihrem Namespace einen benutzerdefinierten Filter hinzu:

public class ExceptionHandlingAttribute : ExceptionFilterAttribute
{
    public override void OnException(HttpActionExecutedContext context)
    {
        if (context.Exception is BusinessException)
        {
            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content = new StringContent(context.Exception.Message),
                ReasonPhrase = "Exception"
            });

        }

        //Log Critical errors
        Debug.WriteLine(context.Exception);

        throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
        {
            Content = new StringContent("An error occurred, please try again or contact the administrator."),
            ReasonPhrase = "Critical Exception"
        });
    }
}

2) Registrieren Sie nun den Filter global in der WebApiConfig- Klasse:

public static class WebApiConfig
{
     public static void Register(HttpConfiguration config)
     {
         config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
         config.Filters.Add(new ExceptionHandlingAttribute());
     }
}

ODER Sie können die Registrierung überspringen und einfach einen einzelnen Controller mit dem [ExceptionHandling]Attribut dekorieren .

Wenn Ihre Web-API in einer ASP.NET-Anwendung gehostet wird, wird das Application_ErrorEreignis für alle nicht behandelten Ausnahmen in Ihrem Code aufgerufen, einschließlich derjenigen in der von Ihnen gezeigten Testaktion. Sie müssen diese Ausnahme also nur innerhalb des Application_Error-Ereignisses behandeln. In dem Beispielcode, den Sie gezeigt haben, behandeln Sie nur Ausnahmen vom Typ, HttpExceptionwas beim Convert.ToInt32("a")Code offensichtlich nicht der Fall ist . Stellen Sie also sicher, dass Sie alle darin enthaltenen Ausnahmen protokollieren und behandeln:

protected void Application_Error()
{
    Exception unhandledException = Server.GetLastError();
    HttpException httpException = unhandledException as HttpException;
    if (httpException == null)
    {
        Exception innerException = unhandledException.InnerException;
        httpException = innerException as HttpException;
    }

    if (httpException != null)
    {
        int httpCode = httpException.GetHttpCode();
        switch (httpCode)
        {
            case (int)HttpStatusCode.Unauthorized:
                Response.Redirect("/Http/Error401");
                break;

            // TODO: don't forget that here you have many other status codes to test 
            // and handle in addition to 401.
        }
        else
        {
            // It was not an HttpException. This will be executed for your test action.
            // Here you should log and handle this case. Use the unhandledException instance here
        }
    }
}

Die Ausnahmebehandlung in der Web-API kann auf verschiedenen Ebenen erfolgen. Hier detailed articleerklären Sie die verschiedenen Möglichkeiten:

• Benutzerdefiniertes Ausnahmefilterattribut, das als globaler Ausnahmefilter registriert werden kann

  [AttributeUsage(AttributeTargets.All)]
  public class ExceptionHandlingAttribute : ExceptionFilterAttribute
  {
      public override void OnException(HttpActionExecutedContext context)
      {
          if (context.Exception is BusinessException)
          {
              throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
              {
                  Content = new StringContent(context.Exception.Message),
                  ReasonPhrase = "Exception"
              });
          }
  
          //Log Critical errors
          Debug.WriteLine(context.Exception);
  
          throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
          {
              Content = new StringContent("An error occurred, please try again or contact the administrator."),
              ReasonPhrase = "Critical Exception"
          });
      }
  }

• Benutzerdefinierter Aktionsaufrufer

  public class MyApiControllerActionInvoker : ApiControllerActionInvoker
  {
      public override Task<HttpResponseMessage> InvokeActionAsync(HttpActionContext actionContext, System.Threading.CancellationToken cancellationToken)
      {
          var result = base.InvokeActionAsync(actionContext, cancellationToken);
  
          if (result.Exception != null && result.Exception.GetBaseException() != null)
          {
              var baseException = result.Exception.GetBaseException();
  
              if (baseException is BusinessException)
              {
                  return Task.Run<HttpResponseMessage>(() => new HttpResponseMessage(HttpStatusCode.InternalServerError)
                  {
                      Content = new StringContent(baseException.Message),
                      ReasonPhrase = "Error"
  
                  });
              }
              else
              {
                  //Log critical error
                  Debug.WriteLine(baseException);
  
                  return Task.Run<HttpResponseMessage>(() => new HttpResponseMessage(HttpStatusCode.InternalServerError)
                  {
                      Content = new StringContent(baseException.Message),
                      ReasonPhrase = "Critical Error"
                  });
              }
          }
  
          return result;
      }
  }

Als Ergänzung zu früheren Antworten.

Gestern wurde die ASP.NET Web API 2.1 offiziell veröffentlicht .
Es bietet eine weitere Möglichkeit, Ausnahmen global zu behandeln.
Die Details sind im Beispiel angegeben .

Kurz gesagt, Sie fügen globale Ausnahmeprotokollierer und / oder einen globalen Ausnahmebehandler hinzu (nur einen).
Sie fügen sie der Konfiguration hinzu:

public static void Register(HttpConfiguration config)
{
  config.MapHttpAttributeRoutes();

  // There can be multiple exception loggers.
  // (By default, no exception loggers are registered.)
  config.Services.Add(typeof(IExceptionLogger), new ElmahExceptionLogger());

  // There must be exactly one exception handler.
  // (There is a default one that may be replaced.)
  config.Services.Replace(typeof(IExceptionHandler), new GenericTextExceptionHandler());
}

Und ihre Erkenntnis:

public class ElmahExceptionLogger : ExceptionLogger
{
  public override void Log(ExceptionLoggerContext context)
  {
    ...
  }
}

public class GenericTextExceptionHandler : ExceptionHandler
{
  public override void Handle(ExceptionHandlerContext context)
  {
    context.Result = new InternalServerErrorTextPlainResult(
      "An unhandled exception occurred; check the log for more information.",
      Encoding.UTF8,
      context.Request);
  }
}

Warum neu werfen usw.? Dies funktioniert und der Servicerückgabestatus 500 usw.

public class LogExceptionFilter : ExceptionFilterAttribute
{
    private static readonly ILog log = LogManager.GetLogger(typeof (LogExceptionFilter));

    public override void OnException(HttpActionExecutedContext actionExecutedContext)
    {
        log.Error("Unhandeled Exception", actionExecutedContext.Exception);
        base.OnException(actionExecutedContext);
    }
}

Haben Sie darüber nachgedacht, so etwas wie einen Handle-Error-Action-Filter wie zu machen?

[HandleError]
public class BaseController : Controller {...}

Sie können auch eine benutzerdefinierte Version erstellen, [HandleError]mit der Sie Fehlerinformationen und alle anderen zu protokollierenden Details schreiben können

Wickeln Sie das Ganze in einen Versuch / Fang ein, protokollieren Sie die nicht behandelte Ausnahme und geben Sie sie dann weiter. Es sei denn, es gibt eine bessere integrierte Möglichkeit, dies zu tun.

Hier ist eine Referenz Ausnahmen von Catch All (behandelt oder nicht behandelt)

(edit: oh API)