public void OnException(ExceptionContext context)
{
ErrorDetails ErrObj = new ErrorDetails();
ErrObj.StatusCode = (int)HttpStatusCode.InternalServerError;
ErrObj.Message = string.Empty;
var exceptionType = context.Exception.GetType();
if (exceptionType == typeof(UnauthorizedAccessException))
{
ErrObj.Message = "Unauthorized Access";
ErrObj.StatusCode = (int)HttpStatusCode.Unauthorized;
}
else if (exceptionType == typeof(NotImplementedException))
{
ErrObj.Message = "A server error occurred.";
ErrObj.StatusCode = (int)HttpStatusCode.NotImplemented;
}
else if (exceptionType == typeof(MyAppException))
{
ErrObj.Message = context.Exception.ToString();
ErrObj.StatusCode = (int)HttpStatusCode.InternalServerError;
}
else
{
ErrObj.Message = context.Exception.Message;
ErrObj.StatusCode = (int)HttpStatusCode.NotFound;
}
context.ExceptionHandled = true;
context.HttpContext.Response.WriteAsync(ErrObj.ToString());
}
private async Task HandleExceptionAsync(ILogger logger, HttpContext context, Exception exception)
{
logger.LogError(exception, $"{exception.Message} {exception.InnerException?.Message}");
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
// generic internal server error
var errorDetails = new ErrorDetails()
{
Status = HttpStatusCode.InternalServerError,
Message = exception.Message,
};
if (exception is NotFoundException notFoundEx)
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
errorDetails.Status = HttpStatusCode.NotFound;
errorDetails.Message = notFoundEx.Message;
}
if (exception is ValidationException validationEx)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
errorDetails.Status = HttpStatusCode.BadRequest;
errorDetails.Message = validationEx.Message;
errorDetails.Errors = validationEx.Errors;
}
await context.Response.WriteAsync(errorDetails.ToString());
}
public static void ConfigureExceptionHandler(this IApplicationBuilder app, ILoggerService logger)
{
app.UseExceptionHandler(appError =>
{
appError.Run(async context =>
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
var contextFeature = context.Features.Get <IExceptionHandlerFeature>();
if (contextFeature != null)
{
var errorDetails = new ErrorDetails();
if (contextFeature?.Error is NullReferenceException)
{
errorDetails.StatusCode = 404;
errorDetails.Message = contextFeature.Error.Message;
}
if (contextFeature?.Error is Exception)
{
errorDetails.StatusCode = 500;
errorDetails.Message = errorDetails.Message = contextFeature.Error.Message;
}
logger.LogError($"Something went wrong: {contextFeature.Error}");
await context.Response.WriteAsync(errorDetails.ToString());
}
});
});
}
private static async Task RunContextAsync(HttpContext context, ILogger logger)
{
// setup
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
var contextFeature = context.Features.Get <IExceptionHandlerFeature>();
// exit conditions
if (contextFeature == null)
{
return;
}
// handler: logging
logger.Fatal($"{Environment.NewLine}Something went wrong", contextFeature.Error);
// handler: error details
var errorDetails = new ErrorDetails()
{
StatusCode = context.Response.StatusCode,
Message = contextFeature.Error.Message,
Stack = $"{contextFeature.Error}"
};
// write
await context.Response.WriteAsync(errorDetails.ToString()).ConfigureAwait(false);
}
public static void ConfigureExceptionHandler(this IApplicationBuilder app)
{
app.UseExceptionHandler(appError =>
{
appError.Run(async context =>
{
context.Response.ContentType = "application/json";
var contextFeature = context.Features.Get <IExceptionHandlerFeature>();
if (contextFeature != null)
{
var errorDetails = new ErrorDetails();
switch (contextFeature.Error)
{
case InvalidOperationException invalidOperationException:
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
errorDetails.Message = contextFeature.Error.Message;
break;
default:
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
errorDetails.Message = "Internal Server Error";
break;
}
errorDetails.StatusCode = context.Response.StatusCode;
await context.Response.WriteAsync(errorDetails.ToString());
}
});
});
}
public string LogError()
{
ErrorDetails error = new ErrorDetails();
try
{
string connectionString = configuration.GetConnectionString("DatabaseConnStr");
using (SqlConnection con = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand("USP_MRKTPL_InsertErrorLog", con)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@StatusCode", error.StatusCode);
cmd.Parameters.AddWithValue("@ErrMessage", error.StatusCode);
cmd.Parameters.AddWithValue("@IPAddress", Dns.GetHostName());
con.Open();
SqlDataReader sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
if (sdr.Read())
{
error.StatusCode = Convert.ToInt32(sdr["StatusCode"]);
}
con.Close();
}
return(error.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
private static Task HandleExceptionAsync(HttpContext context, ErrorDetails details)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = details.StatusCode;
return(context.Response.WriteAsync(details.ToString()));
}
private Task HandleExceptionAsync(HttpContext context, HttpStatusCodeException exception)
{
ErrorDetails result = null;
context.Response.ContentType = "application/json";
if (exception is HttpStatusCodeException)
{
result = new ErrorDetails()
{
Message = exception.Message, StatusCode = (int)exception.StatusCode
};
log.LogWarning(result.ToString());
context.Response.StatusCode = (int)exception.StatusCode;
}
else
{
result = new ErrorDetails()
{
Message = "Runtime Error", StatusCode = (int)HttpStatusCode.BadRequest
};
log.LogWarning(result.ToString());
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
return(context.Response.WriteAsync(JsonConvert.SerializeObject(result)));
}
private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
{
ErrorDetails errorDetails = ex switch
{
BadRequestException => ConfigResponse(context, HttpStatusCode.BadRequest, ex.Message),
ValidationException => ConfigResponse(context, HttpStatusCode.BadRequest, ex.Message, (ex as ValidationException).Errors),
NotFoundException => ConfigResponse(context, HttpStatusCode.NotFound, ex.Message),
_ => ConfigResponse(context, HttpStatusCode.InternalServerError, "Internal Server Error.")
};
await context.Response.WriteAsync(errorDetails.ToString());
}
/// <summary>
/// Configures logging and handling exceptions.
/// </summary>
public static void ConfigureExceptionHandler(this IApplicationBuilder applicationBuilder,
IWebHostEnvironment environment)
{
var logger = LogManager.GetCurrentClassLogger();
applicationBuilder.UseExceptionHandler(options =>
{
options.Run(async context =>
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
var exception = context.Features.Get <IExceptionHandlerFeature>();
if (exception != null)
{
logger.Error(exception);
if (exception.Error is ArgumentException ||
exception.Error is InvalidOperationException)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (exception.Error is NotFoundException)
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
else if (exception.Error is UnauthorizedAccessException)
{
context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
}
else if (exception.Error is AccessDeniedException)
{
context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
}
var errorDetails = new ErrorDetails
{
StatusCode = (int)context.Response.StatusCode,
Message = exception.Error.Message
};
if (environment.IsDevelopment())
{
errorDetails.DroppedException = exception.Error;
}
await context.Response.WriteAsync(errorDetails.ToString());
}
});
});
}
//Handles error globally.
//Any unhandles error in application will come to here.
//Fomate the error using error detail class
public Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
ErrorDetails error = new ErrorDetails()
{
StatusCode = context.Response.StatusCode,
Message = exception.Message,
};
return(context.Response.WriteAsync(error.ToString()));
}
private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = "application/json";
var error = new ErrorDetails
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Message = $"{exception.Message}"
};
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync(error.ToString()).ConfigureAwait(false);
}
private void HandleError(HttpContext httpContext, Exception exception)
{
string accountNumber = ExtractAccountNumber(httpContext);
ErrorDetails errorDetails = new ErrorDetails(exception.Message)
{
AccountNumber = accountNumber
};
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
httpContext.Response.ContentType = "application/json";
_logger.LogError(errorDetails.Message);
httpContext.Response.WriteAsync(errorDetails.ToString());
}
private Task HandleExceptionAsync(HttpContext context, Exception ex)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
ErrorDetails errorDetails = new ErrorDetails();
errorDetails.StatusCode = context.Response.StatusCode;
if (_configuration.GetSection("IsDevelopmentEnvironment").Value == "1")
{
errorDetails.Message = ex.ToString();
}
else
{
errorDetails.Message = "Internal Server Error from the custom middleware.";
}
return(context.Response.WriteAsync(errorDetails.ToString()));
}
private Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = "application/json";
var errorDetails = new ErrorDetails();
switch (exception)
{
case NullReferenceException e:
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
errorDetails.StatusCode = 404;
errorDetails.Message = exception.Message;
break;
}
case FormatException ex:
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
errorDetails.StatusCode = 400;
errorDetails.Message = exception.Message;
break;
}
case Exception e:
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
errorDetails.StatusCode = 500;
errorDetails.Message = exception.Message;
break;
}
}
return(context.Response.WriteAsync(errorDetails.ToString()));
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger <Startup> logger,
IApiVersionDescriptionProvider provider)
{
//if (env.IsDevelopment()) app.UseDeveloperExceptionPage();
app.UseExceptionHandler(errorApp =>
{
errorApp.Run(async context =>
{
context.Response.StatusCode = 500;
context.Response.ContentType = "application/json";
var exceptionHandlerPathFeature =
context.Features.Get <IExceptionHandlerPathFeature>();
var error = new ErrorDetails
{
Guid = Guid.NewGuid(),
ExceptionType = exceptionHandlerPathFeature.Error.GetType().Name,
Message = exceptionHandlerPathFeature.Error.Message
};
await context.Response.WriteAsync(error.ToString());
});
});
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
app.UseSwagger();
app.UseSwaggerUI(
options =>
{
options.RoutePrefix = "";
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint(
$"/swagger/{description.GroupName}/swagger.json",
description.GroupName.ToUpperInvariant());
}
});
}
private Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
var exType = exception.GetType();
ErrorDetails err = new ErrorDetails();
switch (exception)
{
case Exception e when exType == typeof(NotFoundException):
err.StatusCode = (int)HttpStatusCode.NotFound;
err.Message = exception.Message;
_logger.LogError($"Something went wrong: {exception.StackTrace}");
break;
default:
err.StatusCode = (int)HttpStatusCode.InternalServerError;
err.Message = "Internal Server Error";
break;
}
return(context.Response.WriteAsync(err.ToString()));
}
private async Task HandleExceptionAsync(ILoggingService logger, HttpContext context, Exception exception)
{
await logger.LogError(exception, $"{exception.Message} {exception.InnerException?.Message}");
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
var errorDetails = new ErrorDetails()
{
Status = (int)HttpStatusCode.InternalServerError,
Message = "Something went wrong",
Exception = exception
};
if (exception is ExtendedException extendedException)
{
errorDetails.Status = extendedException.Status;
errorDetails.Message = extendedException.Message;
errorDetails.Exception = extendedException.Exception;
}
await context.Response.WriteAsync(errorDetails.ToString());
}
public static void ConfigureExceptionHandler(this IApplicationBuilder app, ILoggerManager logger)
{
app.UseExceptionHandler(appError =>
{
appError.Run(async context =>
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;// (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
var contextFeature = context.Features.Get <IExceptionHandlerFeature>();
if (contextFeature != null)
{
logger.LogError($"Something went wrong: {contextFeature.Error}");
var errDetail = new ErrorDetails()
{
StatusCode = context.Response.StatusCode,
Message = "Internal Server Error."
};
// await context.Response.Body.WriteAsync(errDetail.ToString());
await HttpResponseWritingExtensions.WriteAsync(context.Response, errDetail.ToString());
}
});
});
}
private async Task HandleExceptionAsync(HttpContext httpContext, Exception exception)
{
_logger.LogError($"Something went wrong: {exception}");
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
httpContext.Response.ContentType = "application/json";
ErrorDetails errorDetails = new ErrorDetails();
if (_environment.IsDevelopment())
{
errorDetails.StatusCode = (int)HttpStatusCode.InternalServerError;
errorDetails.Message = exception.Message;
errorDetails.Detail = exception.StackTrace;
errorDetails.InnerException = exception.InnerException != null ? exception.InnerException.Message : string.Empty;
}
else
{
errorDetails.StatusCode = (int)HttpStatusCode.InternalServerError;
errorDetails.Message = DefaultErrorMessage;
errorDetails.Detail = exception.Message;
}
await httpContext.Response.WriteAsync(errorDetails.ToString()).ConfigureAwait(false);
}
private async Task HandleExceptionAsync(ILogger logger, HttpContext context, Exception exception)
{
logger.LogError(exception, $"{exception.Message} {exception.InnerException?.Message}");
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Response.ContentType = "application/json";
// generic internal server error
var errorDetails = new ErrorDetails()
{
Status = HttpStatusCode.InternalServerError,
Message = exception.Message,
};
if (exception is BusinessLayer.Exceptions.ValidationException validationEx)
{
errorDetails.Status = HttpStatusCode.BadRequest;
errorDetails.Message = validationEx.Message;
errorDetails.Errors = JsonConvert.SerializeObject(validationEx._errors, Formatting.Indented);
}
else if (exception is NotFoundException)
{
errorDetails.Status = HttpStatusCode.NotFound;
errorDetails.Message = "Not found";
}
else if (exception is CreateException)
{
errorDetails.Status = HttpStatusCode.InternalServerError;
errorDetails.Message = "Could not create entity";
}
else if (exception is UpdateException)
{
errorDetails.Status = HttpStatusCode.InternalServerError;
errorDetails.Message = "Could not update entity";
}
else if (exception is DeleteException)
{
errorDetails.Status = HttpStatusCode.InternalServerError;
errorDetails.Message = "Could not delete entity";
}
else if (exception is AuthenticationException)
{
errorDetails.Status = HttpStatusCode.Unauthorized;
errorDetails.Message = "Wrong username or password";
}
else if (exception is CatchPokemonException catchEx)
{
errorDetails.Status = HttpStatusCode.BadRequest;
errorDetails.Message = catchEx.Message;
}
else
{
errorDetails.Status = HttpStatusCode.InternalServerError;
errorDetails.Message = "Internal Server Error";
}
await context.Response.WriteAsync(errorDetails.ToString());
}
public void stringifies_exception_middleware_exception()
{
ErrorDetails errorDetails = new ErrorDetails()
{
StatusCode = 500,
Message = "Internal server error"
};
Assert.Equal("{\"StatusCode\":500,\"Message\":\"Internal server error\"}", errorDetails.ToString());
}
private static async Task WriteResponse(HttpContext context, ErrorDetails details)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)details.StatusCode;
await context.Response.WriteAsync(details.ToString());
}
private static Task RespondJsonMessage(this HttpContext httpContext, ErrorDetails errorDetails)
{
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
httpContext.Response.ContentType = "application/json";
return(httpContext.Response.WriteAsync(errorDetails.ToString()));
}
