如何限制ErrorHandler的范围？

Question

I have a global error handler defined as such (simplified/proprietary info scrubbed):

export class ErrorsHandler extends CommonBase implements ErrorHandler {
  constructor(protected loggingService: LoggingService,
              private coreService: CoreService {

    super(loggingService);
  }

  handleError(error: Error) {
    if (error && error.stack && (error.stack.indexOf(Constants.PACKAGE_NAME) >= 0)) {
      this.logSystemError(error, true);
      this.coreService.showSystemError(error, this.owner);
    }
    else {
      // Rethrow all other errors.
      throw error;
    }
  }

And in my module (and only my module), it's registered as a provider as such:

export function errorHandlerFactory(loggingService: LoggingService, coreService: CoreService) {
  return new ErrorsHandler(loggingService, coreService);
}

providers: [
    { provide: ErrorHandler, useFactory: errorHandlerFactory, deps: [LoggingService, CoreService] }
]

My module is consumed by others, and together we make up one large application. My problem is that ALL script errors are caught, even though I try to filter for those that are only relevant to my module/package, because the filtering is done within handleError() . And even though I rethrow errors that are not relevant to me (in the else above), developers of other modules/packages are complaining that I'm globally catching everything and the rethrown errors they get already lose certain context/information.

So the question is, is it possible to somehow limit the scope of my error handler to catch and handle ONLY script errors originating from my module/package (while completely ignore all other script errors within the application)?

After much googling, the only alternative I can think of is putting try/catch everywhere, which is something I'd like to avoid if at all possible.

Answer 1

You can try creating a service - ErrorService to share the context and then throw the error from the global error handler . You can then catch the error from the required Component .

PFB the steps:

1. Create the error service as follows:

    @Injectable({ providedIn: 'root' }) export class ErrorService { constructor() {} private error = new BehaviorSubject(new Error()); error_message = this.error.asObservable(); changeMessage(e: Error) { this.error.next(e); } } 

2. throw the error from the handleError method in ErrorHandler . PFB the snippet:

    handleError(error: Error) { if (error && error.stack &&(error.stack.indexOf(Constants.PACKAGE_NAME) >= 0)) { this.logSystemError(error, true); this.coreService.showSystemError(error, this.owner); } else { //`errorService` is the `instance` for `ErrorService Component` //imported in the defined `ErrorHandler` this.errorService.changeMessage(error); // Rethrow all other errors. throw error; } } 

3. Use try-catch to catch the error in your Component . Use error_message from ErrorService for the same.

Answer 2

I don't know what CommonBase is doing, and therefore I am not sure if this is a feasible answer, but one thing that you could do is change your ErrorsHandler a little bit. If you change your structure and derive from the core ErrorHandler instead of implementing its interface you could end up with something like this:

import { Injectable, ErrorHandler } from '@angular/core';

@Injectable()
export class ErrorsHandler extends ErrorHandler {

  constructor() {
    super();
  }

  handleError(error: any): void {
    if(error && error.stack && error.stack.indexOf("MyModule") >= 0) {
      console.log(`Uff, that was close. Got ${error}`);
      return;
    }
    super.handleError(error);
  }
}

I figured that this gives you a much more reliability and will propagate errors correctly. Re-throwing the error doesn't work properly somehow, but I am not 100% sure about the exact reason.

I hope that helps!