angular2
Version:
Angular 2 - a web framework for modern web apps
122 lines • 4.61 kB
JavaScript
import { isPresent, isBlank } from 'angular2/src/facade/lang';
import { WrappedException } from 'angular2/src/facade/exceptions';
import { isListLikeIterable } from 'angular2/src/facade/collection';
class _ArrayLogger {
constructor() {
this.res = [];
}
log(s) { this.res.push(s); }
logError(s) { this.res.push(s); }
logGroup(s) { this.res.push(s); }
logGroupEnd() { }
;
}
/**
* Provides a hook for centralized exception handling.
*
* The default implementation of `ExceptionHandler` prints error messages to the `Console`. To
* intercept error handling,
* write a custom exception handler that replaces this default as appropriate for your app.
*
* ### Example
*
* ```javascript
*
* class MyExceptionHandler implements ExceptionHandler {
* call(error, stackTrace = null, reason = null) {
* // do something with the exception
* }
* }
*
* bootstrap(MyApp, [provide(ExceptionHandler, {useClass: MyExceptionHandler})])
*
* ```
*/
export class ExceptionHandler {
constructor(_logger, _rethrowException = true) {
this._logger = _logger;
this._rethrowException = _rethrowException;
}
static exceptionToString(exception, stackTrace = null, reason = null) {
var l = new _ArrayLogger();
var e = new ExceptionHandler(l, false);
e.call(exception, stackTrace, reason);
return l.res.join("\n");
}
call(exception, stackTrace = null, reason = null) {
var originalException = this._findOriginalException(exception);
var originalStack = this._findOriginalStack(exception);
var context = this._findContext(exception);
this._logger.logGroup(`EXCEPTION: ${this._extractMessage(exception)}`);
if (isPresent(stackTrace) && isBlank(originalStack)) {
this._logger.logError("STACKTRACE:");
this._logger.logError(this._longStackTrace(stackTrace));
}
if (isPresent(reason)) {
this._logger.logError(`REASON: ${reason}`);
}
if (isPresent(originalException)) {
this._logger.logError(`ORIGINAL EXCEPTION: ${this._extractMessage(originalException)}`);
}
if (isPresent(originalStack)) {
this._logger.logError("ORIGINAL STACKTRACE:");
this._logger.logError(this._longStackTrace(originalStack));
}
if (isPresent(context)) {
this._logger.logError("ERROR CONTEXT:");
this._logger.logError(context);
}
this._logger.logGroupEnd();
// We rethrow exceptions, so operations like 'bootstrap' will result in an error
// when an exception happens. If we do not rethrow, bootstrap will always succeed.
if (this._rethrowException)
throw exception;
}
/** @internal */
_extractMessage(exception) {
return exception instanceof WrappedException ? exception.wrapperMessage : exception.toString();
}
/** @internal */
_longStackTrace(stackTrace) {
return isListLikeIterable(stackTrace) ? stackTrace.join("\n\n-----async gap-----\n") :
stackTrace.toString();
}
/** @internal */
_findContext(exception) {
try {
if (!(exception instanceof WrappedException))
return null;
return isPresent(exception.context) ? exception.context :
this._findContext(exception.originalException);
}
catch (e) {
// exception.context can throw an exception. if it happens, we ignore the context.
return null;
}
}
/** @internal */
_findOriginalException(exception) {
if (!(exception instanceof WrappedException))
return null;
var e = exception.originalException;
while (e instanceof WrappedException && isPresent(e.originalException)) {
e = e.originalException;
}
return e;
}
/** @internal */
_findOriginalStack(exception) {
if (!(exception instanceof WrappedException))
return null;
var e = exception;
var stack = exception.originalStack;
while (e instanceof WrappedException && isPresent(e.originalException)) {
e = e.originalException;
if (e instanceof WrappedException && isPresent(e.originalException)) {
stack = e.originalStack;
}
}
return stack;
}
}
//# sourceMappingURL=exception_handler.js.map