Update otel4s

Author: iRevive

build.sbt

@@ -13,7 +13,7 @@ ThisBuild / tlSiteApiUrl := Some(url("https://www.javadoc.io/doc/org.typelevel/k
 lazy val root = tlCrossRootProject.aggregate(core)
 
 lazy val core = crossProject(JVMPlatform, JSPlatform)
-  .crossType(CrossType.Full)
+  .crossType(CrossType.Pure)
   .in(file("core"))
   .settings(commonSettings)
   .settings(
@@ -59,7 +59,7 @@ lazy val docs = project
 val catsV = "2.7.0"
 val catsEffectV = "3.3.12"
 
-val otel4sV = "0.0-d3796fb-20220613T071000Z-SNAPSHOT"
+val otel4sV = "0.0-7f89139-20220613T071957Z-SNAPSHOT"
 
 val munitV = "0.7.29"
 val munitCatsEffectV = "1.0.7"

core/src/main/scala/org/typelevel/keypool/KeyPool.scala

@@ -21,6 +21,7 @@
 
 package org.typelevel.keypool
 
+import java.util.concurrent.TimeUnit
 import cats._
 import cats.effect.kernel._
 import cats.effect.kernel.syntax.spawn._
@@ -202,7 +203,7 @@ object KeyPool {
               val (m_, toDestroy) = findStale(now, idleCount, m)
               (
                 m_,
-                toDestroy.traverse_(r => metrics.decIdle >> r._2._2).attempt.flatMap {
+                toDestroy.traverse_(r => metrics.idle.dec() >> r._2._2).attempt.flatMap {
                   case Left(t) => onReaperException(t)
                   // .handleErrorWith(t => F.delay(t.printStackTrace())) // CHEATING?
                   case Right(()) => F.unit
@@ -259,7 +260,7 @@ object KeyPool {
         }
       }
 
-    def decIdle = kp.kpMetrics.decIdle.whenA(isFromPool)
+    def decIdle = kp.kpMetrics.idle.dec().whenA(isFromPool)
 
     def go(now: FiniteDuration, pc: PoolMap[A, (B, F[Unit])]): (PoolMap[A, (B, F[Unit])], F[Unit]) =
       pc match {
@@ -271,12 +272,12 @@ object KeyPool {
               case None =>
                 val cnt_ = idleCount + 1
                 val m_ = PoolMap.open(cnt_, m + (k -> One((r, destroy), now)))
-                (m_, kp.kpMetrics.incIdle)
+                (m_, kp.kpMetrics.idle.inc())
               case Some(l) =>
                 val (l_, mx) = addToList(now, kp.kpMaxPerKey(k), (r, destroy), l)
                 val cnt_ = idleCount + mx.fold(1)(_ => 0)
                 val m_ = PoolMap.open(cnt_, m + (k -> l_))
-                (m_, mx.fold(kp.kpMetrics.incIdle)(_ => decIdle >> destroy))
+                (m_, mx.fold(kp.kpMetrics.idle.inc())(_ => decIdle >> destroy))
             }
       }
 
@@ -302,13 +303,16 @@ object KeyPool {
           }
       }
 
+    def allocateNew: F[(B, F[Unit])] =
+      kp.kpMetrics.acquireDuration
+        .recordDuration(TimeUnit.MILLISECONDS)
+        .use(_ => kp.kpRes(k).allocated)
+
     for {
       _ <- kp.kpMaxTotalSem.permit
       optR <- Resource.eval(kp.kpVar.modify(go))
       releasedState <- Resource.eval(Ref[F].of[Reusable](kp.kpDefaultReuseState))
-      resource <- Resource.make(
-        optR.fold(kp.kpMetrics.recordAcquireDuration(kp.kpRes(k)))(r => Applicative[F].pure(r))
-      ) { resource =>
+      resource <- Resource.make(optR.fold(allocateNew)(r => Applicative[F].pure(r))) { resource =>
         for {
           reusable <- releasedState.get
           out <- reusable match {
@@ -317,9 +321,9 @@ object KeyPool {
           }
         } yield out
       }
-      _ <- Resource.eval(kp.kpMetrics.acquiredTotal.add(1).whenA(optR.isEmpty))
-      _ <- Resource.make(kp.kpMetrics.incInUse)(_ => kp.kpMetrics.decInUse)
-      _ <- kp.kpMetrics.recordInUseDuration
+      _ <- Resource.eval(kp.kpMetrics.acquiredTotal.inc().whenA(optR.isEmpty))
+      _ <- Resource.make(kp.kpMetrics.inUse.inc())(_ => kp.kpMetrics.inUse.dec())
+      _ <- kp.kpMetrics.inUseDuration.recordDuration(TimeUnit.MILLISECONDS)
     } yield new Managed(resource._1, optR.isDefined, releasedState)
   }
 

core/src/main/scala/org/typelevel/keypool/internal/Metrics.scala

@@ -1,7 +1,6 @@
 package org.typelevel.keypool.internal
 
 import cats.Monad
-import cats.effect.{Resource, Temporal}
 import cats.syntax.functor._
 import cats.syntax.flatMap._
 import org.typelevel.otel4s._
@@ -29,25 +28,10 @@ private[keypool] trait Metrics[F[_]] {
 
   def acquireDuration: Histogram[F, Double]
 
-  private[keypool] final def incIdle: F[Unit] = idle.add(1L)
-  private[keypool] final def decIdle: F[Unit] = idle.add(-1L)
-  private[keypool] final def incInUse: F[Unit] = inUse.add(1L)
-  private[keypool] final def decInUse: F[Unit] = inUse.add(-1L)
-
-  private[keypool] final def recordInUseDuration(implicit F: Temporal[F]): Resource[F, Unit] =
-    Metrics.recordInUseDuration(this)
-
-  private[keypool] final def recordAcquireDuration[A](
-      resource: Resource[F, A]
-  )(implicit F: Temporal[F]): F[(A, F[Unit])] =
-    Metrics.recordAcquireDuration(this, resource)
-
 }
 
 private[keypool] object Metrics {
 
-  private val CauseKey: AttributeKey[String] = AttributeKey.string("cause")
-
   def fromMeterProvider[F[_]: Monad](meterProvider: MeterProvider[F]): F[Metrics[F]] = {
     for {
       meter <- meterProvider.get("org.typelevel.keypool")
@@ -88,33 +72,4 @@ private[keypool] object Metrics {
     }
   }
 
-  private def recordInUseDuration[F[_]](
-      metrics: Metrics[F]
-  )(implicit F: Temporal[F]): Resource[F, Unit] =
-    Resource
-      .makeCase(Temporal[F].monotonic) { case (start, ec) =>
-        for {
-          end <- Temporal[F].monotonic
-          _ <- metrics.inUseDuration.record((end - start).toMillis, causeAttributes(ec): _*)
-        } yield ()
-      }
-      .void
-
-  private def recordAcquireDuration[F[_], A](
-      metrics: Metrics[F],
-      resource: Resource[F, A]
-  )(implicit F: Temporal[F]): F[(A, F[Unit])] =
-    Temporal[F]
-      .timed(resource.allocated)
-      .flatMap { case (acquireTime, r) =>
-        metrics.acquireDuration.record(acquireTime.toMillis).as(r)
-      }
-
-  private def causeAttributes(ec: Resource.ExitCase): List[Attribute[String]] =
-    ec match {
-      case Resource.ExitCase.Succeeded => Nil
-      case Resource.ExitCase.Errored(e) => List(Attribute(CauseKey, e.getClass.getName))
-      case Resource.ExitCase.Canceled => List(Attribute(CauseKey, "canceled"))
-    }
-
 }