How to limit scope of 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.