shorter monitoring calls

app/controllers/Lobby.scala

@@ -32,7 +32,7 @@ object Lobby extends LilaController {
       tours = Env.tournament.cached promotable true,
       simuls = Env.simul allCreatedFeaturable true
     ) map (html.lobby.home.apply _).tupled map { status(_) } map ensureSessionId(ctx.req)
-  }.chronometer.mon(_.http.response.home).result
+  }.mon(_.http.response.home)
 
   def seeks = Open { implicit ctx =>
     negotiate(

app/controllers/Round.scala

@@ -70,7 +70,7 @@ object Round extends LilaController with TheftPrevention {
                       prefs = ctx.isAuth option (Env.pref.forms miniPrefOf ctx.pref)))
                   }
               }
-          }.chronometer.mon(_.http.response.player.website).result,
+          }.mon(_.http.response.player.website),
           notFound
         )
       },
@@ -79,7 +79,7 @@ object Round extends LilaController with TheftPrevention {
         else {
           if (pov.game.playableByAi) env.roundMap ! Tell(pov.game.id, AiPlay)
           Env.api.roundApi.player(pov, apiVersion).map { Ok(_) }
-            .chronometer.mon(_.http.response.player.mobile).result
+            .mon(_.http.response.player.mobile)
         }
       }
     ) map NoCache
@@ -169,7 +169,7 @@ object Round extends LilaController with TheftPrevention {
                   val pgn = Env.api.pgnDump(pov.game, initialFen)
                   Ok(html.round.watcherBot(pov, initialFen, pgn, crosstable))
               }
-        }.chronometer.mon(_.http.response.watcher.website).result,
+        }.mon(_.http.response.watcher.website),
         api = apiVersion => Env.api.roundApi.watcher(pov, apiVersion, tv = none, withOpening = false) map { Ok(_) }
       ) map NoCache
     }

app/controllers/Tournament.scala

@@ -57,7 +57,7 @@ object Tournament extends LilaController {
             case (version, chat) => env.jsonView(tour, page, ctx.userId, none, version.some) map {
               html.tournament.show(tour, _, chat)
             }
-          }.map { Ok(_) }.chronometer.mon(_.http.response.tournament.show.website).result
+          }.map { Ok(_) }.mon(_.http.response.tournament.show.website)
         }
       },
       api = _ => repo byId id flatMap {
@@ -68,7 +68,7 @@ object Tournament extends LilaController {
               case (playerInfoExt, socketVersion) =>
                 env.jsonView(tour, page, ctx.userId, playerInfoExt, socketVersion)
             } map { Ok(_) }
-        }.chronometer.mon(_.http.response.tournament.show.mobile).result
+        }.mon(_.http.response.tournament.show.mobile)
       } map (_ as JSON)
     ) map NoCache
   }

app/controllers/User.scala

@@ -36,7 +36,7 @@ object User extends LilaController {
   }
 
   def show(username: String) = OpenBody { implicit ctx =>
-    filter(username, none, 1).chronometer.mon(_.http.response.player.mobile).result
+    filter(username, none, 1).mon(_.http.response.player.mobile)
   }
 
   def showMini(username: String) = Open { implicit ctx =>
@@ -82,11 +82,10 @@ object User extends LilaController {
             else userGames(u, filterOption, page) map {
               case (filterName, pag) => html.user.games(u, pag, filterName)
             }
-          }.map { status(_) }
-            .chronometer.mon(_.http.response.user.show.website).result,
+          }.map { status(_) }.mon(_.http.response.user.show.website),
           api = _ => userGames(u, filterOption, page).map {
             case (filterName, pag) => Ok(Env.api.userGameApi.filter(filterName, pag))
-          }.chronometer.mon(_.http.response.user.show.mobile).result)
+          }.mon(_.http.response.user.show.mobile))
         else negotiate(
           html = fuccess(NotFound(html.user.disabled(u))),
           api = _ => fuccess(NotFound(jsonError("No such user, or account closed"))))

modules/api/src/main/RoundApiBalancer.scala

@@ -62,9 +62,7 @@ private[api] final class RoundApiBalancer(
     withMoveTimes: Boolean = false,
     withOpening: Boolean = false)(implicit ctx: Context): Fu[JsObject] = {
     router ? Watcher(pov, apiVersion, tv, analysis, initialFenO, withMoveTimes, withOpening, ctx) mapTo manifest[JsObject]
-  }.chronometer
-    .mon(_.round.api.watcher)
-    .result
+  }.mon(_.round.api.watcher)
 
   def userAnalysisJson(pov: Pov, pref: Pref, initialFen: Option[String], orientation: chess.Color, owner: Boolean): Fu[JsObject] =
     router ? UserAnalysis(pov, pref, initialFen, orientation, owner) mapTo manifest[JsObject]

modules/insight/src/main/InsightApi.scala

@@ -34,7 +34,7 @@ final class InsightApi(
       GameRepo.userPovsByGameIds(gameIds, user) map { povs =>
         Answer(question, clusters, povs)
       }
-    }.chronometer.mon(_.insight.request).result
+    }.mon(_.insight.request)
 
   def userStatus(user: User): Fu[UserStatus] =
     GameRepo lastFinishedRatedNotFromPosition user flatMap {

modules/opening/src/main/Selector.scala

@@ -28,7 +28,7 @@ private[opening] final class Selector(
     } recoverWith {
       case e: Exception => apply(none)
     }
-  }).chronometer.mon(_.opening.selector.time).result >>- lila.mon.opening.selector.count()
+  }).mon(_.opening.selector.time) >>- lila.mon.opening.selector.count()
 
   private def tryRange(user: User, tolerance: Int, ids: BSONArray): Fu[Opening] =
     openingColl.find(BSONDocument(

modules/puzzle/src/main/Selector.scala

@@ -46,7 +46,7 @@ private[puzzle] final class Selector(
           tryRange(rating, step, step, difficultyDecay(difficulty), ids, isMate)
         }
     }
-  }.chronometer.mon(_.puzzle.selector.time).result
+  }.mon(_.puzzle.selector.time)
 
   private def toleranceStepFor(rating: Int) =
     math.abs(1500 - rating) match {

modules/search/src/main/ESClient.scala

@@ -55,8 +55,7 @@ final class ESClientHttp(
     }
   private[search] def HTTP(url: String, data: JsObject): Funit = HTTP(url, data, _ => ())
 
-  private def monitor[A](op: String)(f: Fu[A]) =
-    f.chronometer.mon(_.search.client(op)).result
+  private def monitor[A](op: String)(f: Fu[A]) = f.mon(_.search.client(op))
 }
 
 final class ESClientStub extends ESClient {