unable handle exception from future failure - scala

Question

I want the following code to return a custom message when one of the method, callfuture1() or callfuture2(), throws an exception. My understanding was if either of the future fails, f would be a failed future.
However, when callfuture1 throws an exception. f.onFailure is not executed. Instead I see the call stack stopped at line of code in callFuture1() where exception occurred and a standard internalError is returned. Why does that happen?
val f = for {
x <- callfuture1()
y <- callfuture2()
} yield y
f.onFailure {
//send an internalserver error with some custom message
}
f.map {
//send data back
}
====update====
i see from the responses, that potential issue is that Exception is being thrown outside the Future and hence my code fails to catch that failed future.
So i changed the code such that Exception only occurs inside the future. I still am not able to explain the behavior i am seeing. (I wonder if it has to anything to do with Play framework.)
def controllerfunction(id: String) = Action.async{
val f = for{
x <- callfuture1(id)
y <- callfuture2(x)
} yield y
y.onFailure{case t =>
println("This gets printed");
Ok("shit happened, but i am still ok")}
y.map{resp:String => Ok(resp)}
}
def callfuture1(id: String):Future[Obj1] = {
for {
val1 <- callfuture1.1(id)
val2 <- callfuture1.2(val1)
} yield val2
}
def callfuture1.2:Future[Obj3] = Future{
thrown new Exception("TEST ME");
}
def callfuture 1.1:Future[Obj4] = {...}
def callfuture2: Future[String] = {....}
Expectation.
The method callfuture1.2 throws an exception inside the future, so my expectation is onFailure should be executed, (which does get executed), and the response returned should "Shit happened, but i am still ok"
Actuality
The play framework returns InternalServerError and i see error stack on my console. I see the printlin("This gets printed") is getting executed.
Cant understand what is happening. Any insights?
==== update 2 =====
I verified that the issue only happens when called inside controller of play framework ( i am using play 2.5). As a standalone scala program everthing works as expected. I believe play error handling catches the unhandaled exception and prints the stack trace. I think this should only be happening in development environment.

Answer 1

This can happen if callfuture1 throws "outside of a future".
Your for comprehension is desugared into this:
val f = callfuture1.flatMap{ x =>
callfuture2.map{ y =>
y
}
}
If callfuture2 throws right away (as opposed to returning a failed future), you will still end up with a failed future because callfuture2 is called inside Future.flatMap, which catches exceptions and turns them into failed futures (same for Future.map).
The situation is different for callfuture1: if it throws right away, there is no enclosing Future.map or Future.flatMap to turn it into a failed future.
In general you should try to avoid having a method that returns a Future and can also throw an error.
This means that if callfuture1 does anything that can throw, it should catch that and turn the exception in a failed future that you then return.
UPDATE: Concerning your update about how you expected "Shit happened, but i am still ok" to be returned:
As already hinted by Dima in a comment, Future.onFailure can only be used for side effects. Futures are immutable. If you want to recover from a failed exception, there is no way to modify the original (failed) future and all you can actually do is transform it into a new future.
Have a look at Future.recover. It does exactly what you need, namely it allows to transform an input future by matching the failed result (if any) and transforming it into a successful future. It is the equivalent of a catch clause, but for futures. Concretely what you really meant to do is something like this:
def controllerfunction(id: String) = Action.async{
val f = for{
x <- callfuture1(id)
y <- callfuture2(x)
} yield y
f.map{ resp: String =>
Ok(resp)
}.recover{
case t: Throwable =>
println("This gets printed");
Ok("shit happened, but i am still ok")
}
}

Answer 2

It seems that inside callfuture1() you're not wrapping all your process inside the Future constructor like
def callfuture1(): Future[?] = Future {
val x = ...
x
}
but your code seems to be
def callfuture1(): Future[?] = {
val x = ... // some error happen here
Future(x)
}
so because it's outside the future, your error is throwing directly into your program code