diff --git a/app/controllers/Lobby.scala b/app/controllers/Lobby.scala
index a6f5930adc..ad0471e2d0 100644
--- a/app/controllers/Lobby.scala
+++ b/app/controllers/Lobby.scala
@@ -24,7 +24,7 @@ final class Lobby(
     Open { implicit ctx =>
       pageHit
       negotiate(
-        html = env.pageCache("home") { () =>
+        html = env.pageCache { () =>
           keyPages.homeHtml.dmap { html =>
             NoCache(Ok(html))
           }
diff --git a/app/http/ErrorHandler.scala b/app/http/ErrorHandler.scala
index 66fb2ddb4c..dcf3db11a0 100644
--- a/app/http/ErrorHandler.scala
+++ b/app/http/ErrorHandler.scala
@@ -21,7 +21,7 @@ final class ErrorHandler(
 
   override def onProdServerError(req: RequestHeader, exception: UsefulException) =
     Future {
-      val actionName = "UnknownHandler"
+      val actionName = HTTPRequest actionName req
       val client     = HTTPRequest clientName req
       lila.mon.http.error(actionName, client, req.method, 500).increment()
       lila.log("http").error(s"ERROR 500 $actionName", exception)
diff --git a/app/http/HttpFilter.scala b/app/http/HttpFilter.scala
index bec20c5590..76f86e3ee8 100644
--- a/app/http/HttpFilter.scala
+++ b/app/http/HttpFilter.scala
@@ -31,7 +31,7 @@ final class HttpFilter(env: Env)(implicit val mat: Materializer) extends Filter
     }
 
   private def monitoring(req: RequestHeader, startTime: Long, result: Result) = {
-    val actionName = "UnknownHandler"
+    val actionName = HTTPRequest actionName req
     val reqTime    = nowMillis - startTime
     val statusCode = result.header.status
     val client     = HTTPRequest clientName req
diff --git a/app/http/PageCache.scala b/app/http/PageCache.scala
index 1eef1f7c9b..5952591149 100644
--- a/app/http/PageCache.scala
+++ b/app/http/PageCache.scala
@@ -4,6 +4,7 @@ package http
 import play.api.mvc._
 import scala.concurrent.duration._
 
+import lila.common.HTTPRequest
 import lila.api.Context
 
 final class PageCache(cacheApi: lila.memo.CacheApi) {
@@ -12,14 +13,14 @@ final class PageCache(cacheApi: lila.memo.CacheApi) {
     _.expireAfterWrite(1.seconds).buildAsync()
   }
 
-  def apply(key: String)(compute: () => Fu[Result])(implicit ctx: Context): Fu[Result] =
+  def apply(compute: () => Fu[Result])(implicit ctx: Context): Fu[Result] =
     if (ctx.isAnon && langs(ctx.lang.language) && defaultPrefs(ctx.req) && !hasCookies(ctx.req))
-      cache.getFuture(cacheKey(key), _ => compute())
+      cache.getFuture(cacheKey(ctx), _ => compute())
     else
       compute()
 
-  private def cacheKey(key: String)(implicit ctx: Context) =
-    s"$key(${ctx.lang.language})"
+  private def cacheKey(ctx: Context) =
+    s"${HTTPRequest actionName ctx.req}(${ctx.lang.language})"
 
   private def defaultPrefs(req: RequestHeader) =
     lila.pref.RequestPref.fromRequest(req) == lila.pref.Pref.default
diff --git a/modules/common/src/main/HTTPRequest.scala b/modules/common/src/main/HTTPRequest.scala
index a4ff2cd15e..2d9f0c6fda 100644
--- a/modules/common/src/main/HTTPRequest.scala
+++ b/modules/common/src/main/HTTPRequest.scala
@@ -2,6 +2,7 @@ package lila.common
 
 import play.api.http.HeaderNames
 import play.api.mvc.RequestHeader
+import play.api.routing.Router
 
 object HTTPRequest {
 
@@ -96,6 +97,11 @@ object HTTPRequest {
   def acceptsNdJson(req: RequestHeader) = req.headers get HeaderNames.ACCEPT contains "application/x-ndjson"
   def acceptsJson(req: RequestHeader)   = req.headers get HeaderNames.ACCEPT contains "application/json"
 
+  def actionName(req: RequestHeader): String =
+    req.attrs.get(Router.Attrs.HandlerDef).fold("NoHandler") { handler =>
+      s"${handler.controller.drop(12)}.${handler.method}"
+    }
+
   private val ApiVersionHeaderPattern = """application/vnd\.lichess\.v(\d++)\+json""".r
 
   def apiVersion(req: RequestHeader): Option[ApiVersion] = {
diff --git a/modules/security/src/main/CSRFRequestHandler.scala b/modules/security/src/main/CSRFRequestHandler.scala
index 9a1d0dd84f..a87003f41b 100644
--- a/modules/security/src/main/CSRFRequestHandler.scala
+++ b/modules/security/src/main/CSRFRequestHandler.scala
@@ -25,7 +25,7 @@ final class CSRFRequestHandler(net: NetConfig) {
   }
 
   private def monitor(tpe: String, req: RequestHeader) =
-    lila.mon.http.csrfError(tpe, "UnknownHandler", clientName(req)).increment()
+    lila.mon.http.csrfError(tpe, actionName(req), clientName(req)).increment()
 
   private val topDomain = s"://${net.domain}"
   private val subDomain = s".${net.domain}"