Add Helper Function to Build classifierF (to pass to client and server's Middleware)

core/src/main/scala/org/http4s/metrics/MetricsOps.scala

@@ -1,6 +1,8 @@
 package org.http4s.metrics
 
-import org.http4s.{Method, Status}
+import cats.Foldable
+import cats.implicits._
+import org.http4s.{Method, Request, Status, Uri}
 
 /**
   * Describes an algebra capable of writing metrics to a metrics registry
@@ -57,6 +59,84 @@ trait MetricsOps[F[_]] {
       classifier: Option[String]): F[Unit]
 }
 
+object MetricsOps {
+
+  /**
+    * Given an exclude function, return a 'classifier' function, i.e. for application in
+    * org.http4s.server/client.middleware.Metrics#apply.
+    *
+    * Let's say you want a classifier that excludes integers since your paths consist of:
+    *   * GET    /users/{integer} = GET_users_*
+    *   * POST   /users           = POST_users
+    *   * PUT    /users/{integer} = PUT_users_*
+    *   * DELETE /users/{integer} = DELETE_users_*
+    *
+    * In such a case, we could use:
+    *
+    * classifierFMethodWithOptionallyExcludedPath(
+    *   exclude          = { str: String => scala.util.Try(str.toInt).isSuccess },
+    *   excludedValue    = "*",
+    *   intercalateValue = "_"
+    * )
+    *
+    *
+    * Chris Davenport notes the following on performance considerations of exclude's function value:
+    *
+    * > It's worth noting that this runs on every segment of a path. So note that if an intermediate Throwables with
+    * > Stack traces is known and discarded, there may be a performance penalty, such as the above example with Try(str.toInt).
+    * > I benchmarked some approaches and regex matches should generally be preferred over Throwable's
+    * > in this position.
+    *
+    * @param exclude For a given String, namely a path value, determine whether the value gets excluded.
+    * @param excludedValue Indicates the String value to be supplied for an excluded path's field.
+    * @param pathSeparator Value to use for separating the metrics fields' values
+    * @return Request[F] => Option[String]
+    */
+  def classifierFMethodWithOptionallyExcludedPath[F[_]](
+      exclude: String => Boolean,
+      excludedValue: String = "*",
+      pathSeparator: String = "_"
+  ): Request[F] => Option[String] = { request: Request[F] =>
+    val initial: String = request.method.name
+
+    val pathList: List[String] =
+      requestToPathList(request)
+
+    val minusExcluded: List[String] = pathList.map { value: String =>
+      if (exclude(value)) excludedValue else value
+    }
+
+    val result: String =
+      minusExcluded match {
+        case Nil => initial
+        case nonEmpty @ _ :: _ =>
+          initial + pathSeparator + Foldable[List]
+            .intercalate(nonEmpty, pathSeparator)
+      }
+
+    Some(result)
+  }
+
+  // The following was copied from
+  // https://github.com/http4s/http4s/blob/v0.20.17/dsl/src/main/scala/org/http4s/dsl/impl/Path.scala#L56-L64,
+  // and then modified.
+  private def requestToPathList[F[_]](request: Request[F]): List[String] = {
+    val str: String = request.pathInfo
+
+    if (str == "" || str == "/")
+      Nil
+    else {
+      val segments = str.split("/", -1)
+      // .head is safe because split always returns non-empty array
+      val segments0 = if (segments.head == "") segments.drop(1) else segments
+      val reversed: List[String] =
+        segments0.foldLeft[List[String]](Nil)((path, seg) => Uri.decode(seg) :: path)
+      reversed.reverse
+    }
+  }
+
+}
+
 /** Describes the type of abnormal termination*/
 sealed trait TerminationType
 

tests/src/test/scala/org/http4s/metrics/MetricsOpsSpec.scala

@@ -0,0 +1,79 @@
+package org.http4s.metrics
+
+import cats.effect.IO
+import cats.implicits._
+import java.util.UUID
+import org.http4s._
+import org.scalacheck.{Arbitrary, Gen}
+import MetricsOps.classifierFMethodWithOptionallyExcludedPath
+
+object MetricsOpsSpec {
+
+  private implicit val arbUUID: Arbitrary[UUID] =
+    Arbitrary(Gen.uuid)
+}
+
+class MetricsOpsSpec extends Http4sSpec {
+
+  import MetricsOpsSpec.arbUUID
+
+  "classifierFMethodWithOptionallyExcludedPath" should {
+    "properly exclude UUIDs" in prop {
+      (method: Method, uuid: UUID, excludedValue: String, separator: String) =>
+        {
+          val request: Request[IO] = Request[IO](
+            method = method,
+            uri = Uri.unsafeFromString(s"/users/$uuid/comments")
+          )
+
+          val excludeUUIDs: String => Boolean = { str: String =>
+            Either
+              .catchOnly[IllegalArgumentException](UUID.fromString(str))
+              .isRight
+          }
+
+          val classifier: Request[IO] => Option[String] =
+            classifierFMethodWithOptionallyExcludedPath(
+              exclude = excludeUUIDs,
+              excludedValue = excludedValue,
+              pathSeparator = separator
+            )
+
+          val result: Option[String] =
+            classifier(request)
+
+          val expected: Option[String] =
+            Some(
+              method.name +
+                separator +
+                "users" +
+                separator +
+                excludedValue +
+                separator +
+                "comments"
+            )
+
+          result ==== expected
+        }
+    }
+    "return '$method' if the path is '/'" in prop { method: Method =>
+      val request: Request[IO] = Request[IO](
+        method = method,
+        uri = uri"""/"""
+      )
+
+      val classifier: Request[IO] => Option[String] =
+        classifierFMethodWithOptionallyExcludedPath(
+          _ => true,
+          "*",
+          "_"
+        )
+
+      val result: Option[String] =
+        classifier(request)
+
+      result ==== Some(method.name)
+    }
+  }
+
+}