Catching unhandled errors in Scala futures

Question

If a Scala future fails, and there is no continuation that "observes" that failure (or the only continuations use map/flatMap and don't run in case of failure), then errors go undetected. I would like such errors to be at least logged, so I can find bugs.

I use the term "observed error" because in .Net Tasks there is the chance to catch "unobserved task exceptions", when the Task object is collected by the GC. Similarly, with synchronous methods, uncaught exceptions that terminate the thread can be logged.

In Scala futures, to 'observe' a failure would mean that some continuation or other code reads the Exception stored in the future value before that future is disposed. I'm aware that finalization is not deterministic or reliable, and presumably that's why it's not used to catch unhandled errors, although .Net does succeed in doing this.

Is there a way to achieve this in Scala? If not, how should I organize my code to prevent unhandled error bugs?

Today I have andThen checkResult appended to various futures. But it's hard to know when to use this and when not to: if a library method returns a Future, it shouldn't checkResult and log errors itself, because the library user may handle the failure, so the responsibility falls onto the user. As I edit code I sometimes need to add checks and sometimes to remove them, and such manual management is surely wrong.

Answer 1

I have concluded there is no way to generically notice unhandled errors in Scala futures.

Answer 2

You can just use Future.recover in the function that returns the Future.

So for instance, you could just "log" the error and rethrow the original exception, in the simplest case:

def libraryFunction(): Future[Int] = {
   val f = ...
   f.recover {
      case NonFatal(t) =>
         println("Error : " + t)
         throw t
   }
}

Note the use of NonFatal to match all the exception types it is sensible to catch.
That recover block could equally return an alternative result if you wish.