private async Task HandleException(HttpContext context, Exception ex, int httpStatusCode) { PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } try { context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = httpStatusCode; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); if (_options.ExceptionHandler != null) { await _options.ExceptionHandler(context); } return; } finally { context.Request.Path = originalPath; } }
public async Task Invoke(HttpContext context) { try { await _next(context); } catch (Exception ex) { //Log.Error($"There was an unexpected error: {ex.ToString()}"); //Log.CloseAndFlush(); PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); await _options.ExceptionHandler(context); return; } }
public async Task Invoke(HttpContext context) { try { await _next(context); } catch (Exception ex) { WebHelper.LogWebError(_product, _layer, ex, context); PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); await _options.ExceptionHandler(context); return; } }
public async Task InvokeAsync(HttpContext context) { try { await _next(context); } catch (Exception ex) { _logger.LogError(new EventId(1, "UnhandledException"), ex, "An unhandled exception while request"); // We can't do anything if the response has already started, just abort. if (context.Response.HasStarted) { _logger.LogError(new EventId(2, "ResponseStartedErrorHandler"), ex, "ResponseStartedErrorHandler"); throw; } PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } try { context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); await _options.ExceptionHandler(context); if (_diagnosticSource.IsEnabled("Microsoft.AspNetCore.Diagnostics.HandledException")) { _diagnosticSource.Write("Microsoft.AspNetCore.Diagnostics.HandledException", new { httpContext = context, exception = ex }); } // TODO: Optional re-throw? We'll re-throw the original exception by default if the error handler throws. return; } catch (Exception ex2) { // Suppress secondary exceptions, re-throw the original. _logger.LogError(new EventId(3, "ErrorHandlerException"), ex, "ErrorHandlerException"); } finally { context.Request.Path = originalPath; } throw; // Re-throw the original if we couldn't handle it } }
public async Task Invoke(HttpContext context) { try { await _next(context); } catch (Exception ex) { bool isWebApi = context.Request.Path.StartsWithSegments("/api") || context.Request.Path.StartsWithSegments("/internalapi") || context.Request.Path.StartsWithSegments("/publicapi"); if (isWebApi) { context.Response.StatusCode = 500; context.Response.ContentType = "application/json"; EnvyWebHelper.LogWebError("Core", "Api", ex, context); var errorId = Activity.Current?.Id ?? context.TraceIdentifier; var jsonResponse = JsonConvert.SerializeObject(new EnvyErrorResponse { ErrorId = errorId, Message = "Some kind of error happened in the API" }); await context.Response.WriteAsync(jsonResponse, Encoding.UTF8); } else { EnvyWebHelper.LogWebError(_product, _layer, ex, context); PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); await _options.ExceptionHandler(context); return; } } }
public async Task Invoke(HttpContext context, ITmsLogger tmsLogger) { try { _tmsLogger = tmsLogger; await _next(context); } catch (Exception ex) { var infoToLog = new LogDetails() { Message = ex.Message, Product = "TMS", Location = context.Request.Path, Hostname = Environment.MachineName, User = Environment.UserName, Exception = ex }; _tmsLogger.LogError(infoToLog); PathString originalPath = context.Request.Path; context.Request.Path = "/Home/Error"; context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; await _options.ExceptionHandler(context); return; } }
public async Task Invoke(HttpContext context) { try { await _Next(context); if (context.Response.StatusCode >= 400) { string path = null; if (context.Response.StatusCode == 404) { path = "received for: " + context.Request.Path; _Logger.LogError(0, $"HTTP status code: {context.Response.StatusCode} {path}"); } if (!context.Response.HasStarted) { await WriteResponseAsync(context.Response, $"HTTP status code: {context.Response.StatusCode} {path}").ConfigureAwait(true); } return; } } catch (Exception ex) { _Logger.LogError(0, ex, "An unhandled exception has occurred: " + ex.Message); // We can't do anything if the response has already started, just abort. if (context.Response.HasStarted) { _Logger.LogWarning("The response has already started, the error handler will not be executed."); throw; } PathString originalPath = context.Request.Path; if (_Options.ExceptionHandlingPath.HasValue) { context.Request.Path = _Options.ExceptionHandlingPath; } try { context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_ClearCacheHeadersDelegate, context.Response); await _Options.ExceptionHandler(context); if (_DiagnosticSource.IsEnabled("Microsoft.AspNetCore.Diagnostics.HandledException")) { _DiagnosticSource.Write("Microsoft.AspNetCore.Diagnostics.HandledException", new { httpContext = context, exception = ex }); } // TODO: Optional re-throw? We'll re-throw the original exception by default if the error handler throws. return; } catch (Exception ex2) { // Suppress secondary exceptions, re-throw the original. _Logger.LogError(0, ex2, "An exception was thrown attempting to execute the error handler."); } finally { context.Request.Path = originalPath; } throw; // Re-throw the original if we couldn't handle it } }
public async Task Invoke(HttpContext context) { try { // _sw = Stopwatch.StartNew(); await _next(context); // _sw.Stop(); //LogForContext(context).Information(MessageTemplate, context.Request.Method, context.Request.Path, context.Response?.StatusCode, _sw.ElapsedMilliseconds); } catch (Exception ex) { //_sw.Stop(); var ai = new TelemetryClient(); ai.TrackException(ex); // LogException(context, _sw.ElapsedMilliseconds, ex); bool isWebApi = context.Request.Path.StartsWithSegments("/api") || context.Request.Path.StartsWithSegments("/api-core") || context.Request.Path.StartsWithSegments("/internalapi") || context.Request.Path.StartsWithSegments("/publicapi"); if (isWebApi) { context.Response.StatusCode = 500; context.Response.ContentType = "application/json"; var errorId = context.TraceIdentifier; var jsonResponse = JsonConvert.SerializeObject(new EnvyErrorResponse { ErrorId = errorId, Message = _hostingEnvironment.IsDevelopment() ? ex.ToString() : "Some kind of error happened in the API" }); await context.Response.WriteAsync(jsonResponse, Encoding.UTF8); } else { PathString originalPath = context.Request.Path; if (_options.ExceptionHandlingPath.HasValue) { context.Request.Path = _options.ExceptionHandlingPath; } context.Response.Clear(); var exceptionHandlerFeature = new ExceptionHandlerFeature() { Error = ex, Path = originalPath.Value, }; context.Features.Set <IExceptionHandlerFeature>(exceptionHandlerFeature); context.Features.Set <IExceptionHandlerPathFeature>(exceptionHandlerFeature); context.Response.StatusCode = 500; context.Response.OnStarting(_clearCacheHeadersDelegate, context.Response); await _options.ExceptionHandler(context); return; } } }