斯卡拉期货：默认错误处理程序，为每一个新创建的，或映射异常

Question

是否有可能永远创造未来{...}用默认onFailure处处理阻止？ （例如，将堆栈跟踪写入控制台）？此处理也应该自动连接到映射期货（通过调用地图上的未来已经有一个默认的故障处理程序创建新期货）

另见我的问题在这里了解更多详情： Scala on Android with scala.concurrent.Future do not report exception on system err/out

我想有“最后手段”异常日志记录代码，如果有人不使用onFailure处或某物类似上返回的未来。

Answer 1

我有一个类似的问题，在实际结果不相关，因此没有明确处理的情况下，期货会悄无声息地失败。从ExecutionContext的文档中，我最初认为reportFailure方法需要报告Future中的任何故障。这显然是错误的 - 所以这是我想出了已经登录异常（甚至映射或以其他方式得到的）期货的办法：

• 一个LoggedFuture类委托给Future和onFailure记录类似于@异常LimbSoups回答
• 像map返回一个新Future收益率方法LoggedFuture以及
• 使用Promise为某种失败的事件被级联LoggedFutures之间共享记录异常仅即使onFailure处回调是一次APPLI编因为传播

object LoggedFuture { 
    def apply[T](future: Future[T])(implicit ec: ExecutionContext): Future[T] = { 
    if (future.isInstanceOf[LoggedFuture[T]]) { 
     // don't augment to prevent double logging 
     future.asInstanceOf[LoggedFuture[T]] 
    } 
    else { 
     val failEvent = promise[Unit] 
     failEvent.future.onFailure { 
     // do your actual logging here 
     case t => t.printStackTrace() 
     } 
     new LoggedFuture(future, failEvent, ec) 
    } 
    } 
} 

private class LoggedFuture[T](future: Future[T], failEvent: Promise[Unit], ec: ExecutionContext) extends Future[T] { 

    // fire "log event" on failure 
    future.onFailure { 
    // complete log event promise 
    // the promise is used to log the error only once, even if the 
    // future is mapped and thus further callbacks attached 
    case t => failEvent.tryComplete(Failure(t)) 
    } (ec) 

    // delegate methods 
    override def ready(atMost: Duration)(implicit permit: CanAwait): this.type = { 
    future.ready(atMost) 
    this 
    } 
    override def result(atMost: scala.concurrent.duration.Duration)(implicit permit: CanAwait): T = future.result(atMost) 
    override def isCompleted: Boolean = future.isCompleted 
    override def onComplete[U](func: scala.util.Try[T] => U)(implicit executor: ExecutionContext): Unit = future.onComplete(func) 
    override def value: Option[Try[T]] = future.value 

    // propagate LoggedFuture (and shared log event) whenever a new future is returned 
    override def map[S](f: T => S)(implicit executor: ExecutionContext): Future[S] = 
    new LoggedFuture(super.map(f), failEvent, executor) 
    override def transform[S](s: T => S, f: Throwable => Throwable)(implicit executor: ExecutionContext): Future[S] = 
    new LoggedFuture(super.transform(s, f), failEvent, executor) 
    override def flatMap[S](f: T => Future[S])(implicit executor: ExecutionContext): Future[S] = 
    new LoggedFuture(super.flatMap(f), failEvent, executor) 
    override def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] = 
    new LoggedFuture(super.recover(pf), failEvent, executor) 
    override def recoverWith[U >: T](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U] = 
    new LoggedFuture(super.recoverWith(pf), failEvent, executor) 
    override def zip[U](that: Future[U]): Future[(T, U)] = 
    new LoggedFuture(super.zip(that), failEvent, ec) 
    override def fallbackTo[U >: T](that: Future[U]): Future[U] = 
    new LoggedFuture(super.fallbackTo(that), failEvent, ec) 
    override def andThen[U](pf: PartialFunction[Try[T], U])(implicit executor: ExecutionContext): Future[T] = 
    new LoggedFuture(super.andThen(pf), failEvent, executor) 

} 

class RichFuture[T](future: Future[T]) { 
    def asLogged(implicit ec: ExecutionContext): Future[T] = LoggedFuture(future) 
} 

另外的多次，我有一个隐式转换到RichFuture（如上）中所定义，所以我可以很容易地转换现有期货与像future.asLogged呼叫。

Answer 2

就像一个延伸到我的评论：

你没有得到的地步，还有在地图失败的情况下，使每一个映射未来失败的回调，原因没有必要也不会做任何计算，只进一步传递现有失败。所以如果你将更多的计算链接到失败的计算，所有新的回调就不会被调用。

考虑这个例子：

case class TestError(msg) extends Throwable(msg) 

val f1 = Future { 10/0 } 
val f2 = f1 map { x => throw new TestError("Hello"); x + 10 } 
f1.onFailure { 
    case error => println(error.getMessage) 
} 
f2.onFailure { 
    case er: TestError => println("TestError") 
    case _ => println("Number error") 
} 

// Exiting paste mode, now interpreting. 

/by zero 
Number error 
f1: scala.concurrent.Future[Int] = scala.concurrent.impl.Promise$DefaultPromise@54659bf8 
f2: scala.concurrent.Future[Int] = scala.concurrent.impl.Promise$DefaultPromise@5ae2e211 

正如你所看到的第一个回调打印错误消息，并抛出TestError第二忽略。那是因为你的地图功能不适用。如果你看看到map评论：

/** Creates a new future by applying a function to the successful result of 
* this future. If this future is completed with an exception then the new 
* future will also contain this exception. 
*/ 

所以在安装新的故障的回调进一步不用，造成任何进一步的未来将简单的包含前一个的结果，对于每个你已经已经定义了一个回调。

Answer 3

用下面的隐含类，你可以轻松地记录你的期货失败，同时避免recover样板：

import com.typesafe.scalalogging.Logger 

    implicit class LoggingFuture[+T](val f: Future[T]) extends AnyVal { 
    def withFailureLogging(l: Logger, message: String): Future[T] = f recover { 
     case e => 
     l.error(s"$message: $e") 
     throw e 
    } 

    def withPrintStackTraceOnFailure: Future[T] = f recover { 
     case e => 
     e.printStackTrace() 
     throw e 
     } 
    } 

您可以使用它，如下图所示：

import com.typesafe.scalalogging._ 
import scala.language.postfixOps 

class MyClass extends LazyLogging { 
    def f = Future { 
    // do something that fails 
    throw new Exception("this future fails") 
    } withFailureLogging(logger, "some error message") 

    def g = Future { 
    // do something that fails 
    throw new Exception("this future fails") 
    } withPrintStackTraceOnFailure 
}