Error zone boundaries make it difficult to catch errors

[BlackHC]

I have a method runInApp(body()) that executes body in the (Angular) zone which is its own error zone.

runInApp(body()) => zone.run(body);

zone.run calls angularZone.runGuarded(body) internally.

If something throws in body, it never passes the error zone boundary. This is particularly annoying in tests because they end up timing out without telling you about the exception.

The only way I've found to route errors through the error zone boundary is not very beautiful:
(It has to support async and sync body()s.)

runInApp(body()) {
    var result;
    var error;
    var stackTrace;
    var completer = new Completer();
    zone.run(() {
      try {
        result = body();
        if (result is Future) {
          result.then((result) {
            completer.complete(result);
          }, onError: (e, st) {
            completer.completeError(e, st);
          });
          result = completer.future;
        }
      } catch (e,st) {
        error = e;
        stackTrace = st;
      }
    });
    if (error != null) {
      print(stackTrace);
      throw error;
    }
    return result;
  }

This feels rather cumbersome. Is there another way to handle this?

Also, there is no way to rethrow an exception in synchronous code that preserves the original stacktrace.

[lrhn]

I'm not sure there is much we can do: runGuarded is designed to catch all errors.
Zone.run by itself does not delegate to runGuarded, so something somewhere does this on purpose. It could be some other core-library code, I don't know which one off-hand (e.g., the bindCallback function can be asked to run guarded).

It's a design choice that errors won't pass an error-zone boundary (in either direction). It does make it cumbersome to run code in an error-zone for some other reason - if you do want to extract the errors.

Your solution (throwing the error again) only works for a single error, but error zones may catch multiple async errors. If you only care for a synchronous error or the direct async error returned by calling body, your approach is actually fine. You should accept that you are subverting the zone system - keeping errors inside error zones is the intended behavior. The question might be why the Angular zone is an error zone to being with.

It can be made shorter if you don't expect the same function to handle both sync and async (which is a good idea when possible). Then it becomes shorter than your combined function:

A method that's always asynchronous:

Future runInApp(body()) {
   Completer completer = new Completer();
   zone.run(() {
      completer.complete(new Future.sync(body));
   });
   return completer.future;
}

It can be called with both synchronous and asynchronous bodies and delivers the result as a Future.

If you want a synchronous version too, but, as you say, you do have the problem of loosing the stacktrace.

runInAppSync(body()) {
   var error;
   var result = zone.run(() {
      try { return body(); } catch (e, s) { error = e; }
   });
   if (error != null) throw e;
   return result;
}

This only works for synchronous bodies.

The only (exposed) way to rethrow with an existing stack trace is the rethrow statement, and it only works inside a catch block.

(That is actually slightly annoying - you can throw any error+stacktrace in async code by doing await new Future.error(error, stack), so maybe we should have a public function that allows you to throw a specific error and stack synchronously too).,