internal void Handle( ExceptionHandlerContext context ) {
context.Result = new TextPlainErrorResult {
Request = context.ExceptionContext.Request,
Content = "Oops! Sorry! Something went wrong." +
"Please contact [email protected] so we can try to fix it."
};
}
/// <summary>
/// Handles the exception
/// </summary>
/// <param name="context"></param>
public override void Handle(ExceptionHandlerContext context)
{
var exception = context.Exception;
if (context.Handle(exception))
{
return;
}
var correlationId = TraceCorrelation.RetrieveCorrelationInfo();
if (exception.InnerException != null)
{
var errorMessage = exception.InnerException.Message;
var stackTrace = exception.InnerException.StackTrace ?? "No stack trace available";
}
}
public override void Handle(ExceptionHandlerContext context)
{
var exception = context.Exception;
var code = GetStatusCode(exception);
if (code == HttpStatusCode.InternalServerError)
{
_loggerService.Error(exception.Message);
}
else
{
_loggerService.Warning(exception.Message);
}
context.Result = new ResponseMessageResult(context.Request.CreateResponse(code, context.Exception.Message));
}
public override void Handle(ExceptionHandlerContext context)
{
//Return a DTO representing what happened
context.Result = new ResponseMessageResult(context.Request.CreateResponse(HttpStatusCode.InternalServerError,
new ErrorInformation
{
Message = "We apologize but an unexpected error occured. Please try again later.",
ExceptionUrl = context.Request.RequestUri.ToString(),
ExceptionMessage = context.ExceptionContext.Exception.Message.ToString(),
Method = context.Request.Method.ToString(),
ErrorDate = DateTime.UtcNow
}));
//This is commented out, but could also serve the purpose if you wanted to only return some text directly, rather than JSON that the front end will bind to.
//context.Result = new ResponseMessageResult(context.Request.CreateResponse(HttpStatusCode.InternalServerError, "We apologize but an unexpected error occured. Please try again later."));
}
async Task IQueryExceptionHandler <TCommand, VoidUnit> .HandleAsync(
TCommand command,
Exception exception,
IExceptionHandlerContext <VoidUnit> context,
CancellationToken cancellationToken)
{
using var localContext = new ExceptionHandlerContext(context);
await HandleAsync(
command,
(TException)exception,
localContext,
cancellationToken
)
.ConfigureAwait(false);
}
/// <inheritdoc/>
public override void Handle(ExceptionHandlerContext context)
{
_telemetryClient.TrackException(new ExceptionTelemetry(context.Exception));
var errorResponse = new ErrorResponseModel(context.Exception);
if (_includeStackTrace)
{
errorResponse.Error.Data = context.Exception.StackTrace;
}
var formatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
var response = context.Request.CreateResponse(GetStatusCode(errorResponse), errorResponse, formatter);
context.Result = new ResponseMessageResult(response);
}
public async Task AndExceptionOccurrsInExceptionHandler()
{
_logger.Setup(l => l.Error(It.IsAny <Exception>(), It.IsAny <string>())).Throws <Exception>();
var context = new ExceptionHandlerContext(new ExceptionContext(
new Exception("any exception"),
new ExceptionContextCatchBlock("name", true, true),
new HttpRequestMessage()));
_handler.Handle(context);
var message = await context.Result.ExecuteAsync(CancellationToken.None);
message.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
message.Content.ReadAsStringAsync().Result.Should().Be($"{{\"Message\":\"{ExceptionInExceptionHandlerErrorMessage}\"}}");
}
/// <summary>Use to intercept and handle exceptions that were unexpected. Odata renders a Status code 500, this will format the message and make it a 400</summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async override Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if ((context != null) && (context.Exception != null))
{
if (context.Exception.GetType().Name.Equals("DbUpdateException"))
{
string genericErrorMessage = context.Exception.GetExceptionMessages().Replace("\n", " ").Replace("\r", " ");
HttpResponseMessage resp;
resp = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(genericErrorMessage)
};
context.Result = new ErrorMessageResult(context.Request, resp);
}
}
}
public override void Handle(ExceptionHandlerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Trace.TraceError(context.Exception.Message);
//TODO: Log error, app insight or local file storage
context.Result = new UnexpectedErrorResult
{
Request = context.Request
};
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
var ex = context.Exception as BusinessException;
var jsonObj = new
{
Error = ex == null ? HttpStatusCode.InternalServerError : ex.StatusCode,
context.Exception.Message
};
var httpResponse = context.Request.CreateResponse(jsonObj.Error, jsonObj);
context.Result = new ResponseMessageResult(httpResponse);
return(Task.FromResult(0));
}
public void HandleAsync_IfRequestIsNull_Throws()
{
// Arrange
IExceptionHandler product = CreateProductUnderTest();
ExceptionHandlerContext context = new ExceptionHandlerContext(new ExceptionContext
{
Exception = CreateException()
});
Assert.Null(context.ExceptionContext.Request); // Guard
CancellationToken cancellationToken = CancellationToken.None;
// Act & Assert
Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
"ExceptionContext.Request must not be null.");
}
private static ResponseMessageResult HandleUnhandledException(ExceptionHandlerContext context)
{
// log it
Elmah.ErrorSignal.FromCurrentContext().Raise(context.Exception);
var generalException = context.Exception as GeneralException;
if (generalException != null)
{
return(GetResponseMessageResult(context, generalException.TicketNumber));
}
else
{
return(GetResponseMessageResult(context, Guid.NewGuid().ToString()));
}
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
var errorInfo = new ErrorInformation
{
Message = "Произошла ошибка, смотрите log.txt",
ErrorDate = DateTime.UtcNow
};
Logger.ErrorException("Ошибка: ", context.Exception);
var httpResponse = context.Request.CreateResponse(HttpStatusCode.InternalServerError, errorInfo);
context.Result = new ResponseMessageResult(httpResponse);
return(Task.FromResult(0));
}
public static IHttpActionResult CreateValidationResponseFromException(this ExceptionHandlerContext actionExecutedContext,
HttpStatusCode code)
{
var typedException = actionExecutedContext.Exception as RegoValidationException;
if (typedException == null)
{
throw new RegoException("Unknown validation exception type");
}
var errorMessagError = new HttpError(typedException.Message);
errorMessagError.AddValidationErrors(typedException.ValidationErrors);
return(new ResponseMessageResult(
actionExecutedContext.Request.CreateErrorResponse(code, errorMessagError)));
}
public override Task HandleAsync(ExceptionHandlerContext context,
CancellationToken cancellationToken)
{
// Access Exception using context.Exception;
const string errorMessage = "An unexpected error occured";
var response = context.Request.CreateResponse(HttpStatusCode.InternalServerError,
new
{
Message = errorMessage
});
response.Headers.Add("X-Error", errorMessage);
context.Result = new ResponseMessageResult(response);
return(Task.FromResult(0));
}
public override void Handle(ExceptionHandlerContext context)
{
string errorMessage = "Oops! Sorry! Something went wrong." +
"Please contact [email protected] so we can try to fix it.";
if (context.Exception is CustomException)
{
errorMessage = context.Exception.Message;
}
context.Result = new TextPlainErrorResult
{
Request = context.ExceptionContext.Request,
Content = errorMessage
};
}
/// <summary>
/// Sobreescreve <see cref="ExceptionHandler.Handle"/>
/// </summary>
/// <param name="context">Instancia de <see cref="ExceptionHandlerContext"/>.</param>
public override void Handle(ExceptionHandlerContext context)
{
var correlationId = Guid.NewGuid();
var metadata = new ErrorInfoModel
{
Message = "Um erro não esperado aconteceu!",
TimeStamp = DateTime.UtcNow,
RequestUri = context.Request.RequestUri,
ErrorId = correlationId
};
var response = context.Request.CreateResponse(HttpStatusCode.InternalServerError, metadata);
context.Result = new ResponseMessageResult(response);
}
private static void Handle(ExceptionHandlerContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
Contract.Assert(exceptionContext != null);
HttpRequestMessage request = exceptionContext.Request;
context.Result = new ResponseMessageResult(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
exceptionContext.Exception));
}
/// <summary>
/// Overrides <see cref="ExceptionHandler.Handle"/> method with code that sets friendly error message to be shown in browser.
/// </summary>
/// <param name="context">Instance fo <see cref="ExceptionHandlerContext"/>.</param>
public override void Handle(ExceptionHandlerContext context)
{
var correlationId = Guid.NewGuid();
var metadata = new ErrorInfoModel
{
Message = "An unexpected error occurred! Please use the Error ID to contact support",
TimeStamp = DateTime.UtcNow,
RequestUri = context.Request.RequestUri,
ErrorId = correlationId
};
var response = context.Request.CreateResponse(HttpStatusCode.InternalServerError, metadata);
context.Result = new ResponseMessageResult(response);
}
public override void Handle(ExceptionHandlerContext context)
{
const string Message = "Your input conflicted with the current state of the system.";
if (context.Exception is DivideByZeroException)
{
context.Result = new ResponseMessageResult(context.Request.CreateErrorResponse(HttpStatusCode.Conflict, Message));
}
else
{
HttpError error = new HttpError("An interval server error occured.");
error.Add("CorrelationId", context.Request.GetCorrelationId().ToString());
var response = context.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
context.Result = new ResponseMessageResult(response);
}
}
/// <summary>When overridden in a derived class, handles the exception asynchronously.</summary>
/// <returns>A task representing the asynchronous exception handling operation.</returns>
/// <param name="context">The exception handler context.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public override Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
var statusCode = 500;
var message = "Oops! Sorry, Something went wrong.";
var response = context.Request.CreateResponse(HttpStatusCode.InternalServerError,
new
{
status = "error",
status_code = statusCode,
message
});
response.Headers.Add("X-Error", "");
context.Result = new ResponseMessageResult(response);
return(Task.FromResult(response));
}
/// <summary>
/// Handles an unhandled exception and
/// sets http result to a custom error contract
/// if request context is available
/// </summary>
/// <param name="context"></param>
public override void Handle(ExceptionHandlerContext context)
{
var config = context.RequestContext?.Configuration;
var request = context.Request;
if (config != null && request != null)
{
context.Result = errorsFactory.CreateInternalServerError(request, config,
"Something went wrong"
);
}
else
{
base.Handle(context);
}
}
/// <inheritdoc />
public override void Handle(ExceptionHandlerContext context)
{
ExceptionContext exceptionContext = context.ExceptionContext;
HttpRequestMessage request = exceptionContext.Request;
if (exceptionContext.CatchBlock == ExceptionCatchBlocks.IExceptionFilter)
{
// The exception filter stage propagates unhandled exceptions by default (when no filter handles the
// exception).
return;
}
context.Result = new ResponseMessageResult(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"An error has occuerd. Please check the logs for more details."));
}
public override void Handle(ExceptionHandlerContext context)
{
if (context.Exception is ArgumentNullException)
{
var result = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(context.Exception.Message),
ReasonPhrase = "ArgumentNullException"
};
context.Result = new ErrorMessageResult(context.Request, result);
}
else
{
// Handle other exceptions
}
}
public override void Handle(ExceptionHandlerContext context)
{
Exception exception = context.Exception;
var errorMessage = _sendDetailedError
? $"Message: {exception.Message} {Environment.NewLine} StackTrace: {exception.StackTrace}"
: exception.Message;
/*context.Result = new ErrorMessageResult(context.Request, context.Request.CreateUnknownError(errorMessage));*/
var httpResponseMessage = (exception.TargetSite.DeclaringType.Name == ControllerActivatorClassName)
// often happens because some of controller dependencies (f.e. current user) can not be resolved.
// for now just simulating 401 as it was in original nextgen implementation
? context.Request.CreateUnauthrorizedError(errorMessage)
: context.Request.CreateUnknownError(errorMessage);
context.Result = new ErrorMessageResult(context.Request, httpResponseMessage);
}
public override void Handle(ExceptionHandlerContext context)
{
List <string> errors = new List <string>();
errors.Add(context.Exception?.Message);
var d = context.Exception.GetType();
var responsePackage = new ResponsePackage(null, HttpStatusCode.BadRequest, string.Empty, string.Empty, errors);
var response = context.Request.CreateResponse(HttpStatusCode.BadRequest, new { Errors = errors, HttpStatusCode = (int)HttpStatusCode.BadRequest, Message = context.Exception.Message });
context.Result = new ResponseMessageResult(response);
}
public override void Handle(ExceptionHandlerContext context)
{
//Type exceptionType = context.Exception.GetType();
System.Exception exception = context.Exception;
//string errmsg = exception.Message;
//while (exception.InnerException != null)
//{
// errmsg += exception.InnerException.Message;
// exception = exception.InnerException;
//}
var body = ExceptionHelper.FormatExceptionMessage(exception);
HttpResponseMessage responseMessage = context.Request.CreateResponse(HttpStatusCode.OK, body);
context.Result = new ExceptionActionResult(responseMessage);
}
public override void Handle(ExceptionHandlerContext context)
{
_logger.Error(context.Exception, context.Request.RequestUri.ToString());
var result = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("Internal Server Error Occurred"),
ReasonPhrase = "Exception"
};
var request = context.Request;
var origin = request.Headers.GetValues("Origin").FirstOrDefault();
result.WriteCorsHeaders(new System.Web.Cors.CorsResult {
AllowedOrigin = origin
});
context.Result = new ErrorMessageResult(context.Request, result);
}
public override void Handle(ExceptionHandlerContext context)
{
ResponseError error = new ResponseError()
{
Id = Toolkit.Error.Id,
IsSuccess = false,
Message = context.Exception.Message,
UserFriendlyMessage = "There has been an error. We will track the error with given Id."
};
HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new JsonContent(error),
ReasonPhrase = context.Exception.GetType().Name
};
context.Result = new ExceptionResult(context.Request, responseMessage);
}
public override Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
var runtimeError = context.Exception;
var errorLog = new ErrorLog
{
DtHrErro = DateTime.Now,
ExceptionMessage = runtimeError.Message,
ExceptionSource = runtimeError.StackTrace,
ExceptionType = runtimeError.GetType().FullName,
ExceptionUrl = context.Request.RequestUri.OriginalString
};
SalvarExcecao(errorLog);
;
return(base.HandleAsync(context, cancellationToken));
}
public override void Handle(ExceptionHandlerContext context)
{
var runtimeError = context.Exception;
var errorLog = new ErrorLog
{
DtHrErro = DateTime.Now,
ExceptionMessage = runtimeError.Message,
ExceptionSource = runtimeError.StackTrace,
ExceptionType = runtimeError.GetType().FullName,
ExceptionUrl = context.Request.RequestUri.OriginalString
};
SalvarExcecao(errorLog);
base.Handle(context);
}
