Merge pull request #181 from TinkoffCreditSystems/universal-logs

Create caching and embedding universal log implementation for ease of use

Author: Odomontois

build.sbt

@@ -82,7 +82,7 @@ lazy val loggingStr = project
     ),
     macros
   )
-  .dependsOn(core, data)
+  .dependsOn(core, concurrent, data)
 
 lazy val loggingDer = project
   .in(file("logging/derivation"))

core/src/main/scala/tofu/Init.scala

@@ -0,0 +1,11 @@
+package tofu
+
+/**
+  * Initialize value of type A in type F
+  *
+  * @tparam F initialization effect type
+  * @tparam A result type
+  */
+trait Init[F[_], A] {
+  def init: F[A]
+}

derivation/src/main/scala/tofu/data/derived/Init.scala renamed to derivation/src/main/scala/tofu/data/derived/InitDerivation.scala

@@ -1,19 +1,11 @@
 package tofu.data.derived
 import cats.Monad
+import derevo.Derivation
 import magnolia.{CaseClass, Magnolia}
 import mercator.Monadic
+import tofu.Init
 
-/**
-  * Initialize value of type A in type F
-  *
-  * @tparam F initialization effect type
-  * @tparam A result type
-  */
-trait Init[F[_], A] {
-  def init: F[A]
-}
-
-class InitDerivation[F[_]: Monad] {
+class InitDerivation[F[_]: Monad] extends Derivation[Init[F, *]] {
   private[this] implicit val magnoliaMonad: Monadic[F] = new MerkatorFromCats[F]
 
   type Typeclass[A] = Init[F, A]

logging/structured/src/main/scala/tofu/logging/Logging.scala

@@ -6,8 +6,8 @@ import cats.syntax.apply._
 import cats.{Applicative, Apply, FlatMap}
 import com.github.ghik.silencer.silent
 import org.slf4j.{Logger, LoggerFactory, Marker}
-import tofu.higherKind
-import tofu.higherKind.{Embed, Function2K, RepresentableK}
+import tofu.{Init, higherKind}
+import tofu.higherKind.{Function2K, RepresentableK}
 import tofu.logging.impl.EmbedLogging
 import tofu.syntax.monoidalK._
 
@@ -74,8 +74,16 @@ object ServiceLogging {
   private[this] val representableAny: RepresentableK[ServiceLogging[*[_], Any]] =
     higherKind.derived.genRepresentableK[ServiceLogging[*[_], Any]]
 
+  implicit def initByLogs[I[_], F[_], Svc: ClassTag](implicit logs: Logs[I, F]): Init[I, ServiceLogging[F, Svc]] =
+    new Init[I, ServiceLogging[F, Svc]] {
+      def init: I[ServiceLogging[F, Svc]] = logs.service[Svc]
+    }
+
   final implicit def serviceLoggingRepresentable[Svc]: RepresentableK[ServiceLogging[*[_], Svc]] =
     representableAny.asInstanceOf[RepresentableK[ServiceLogging[*[_], Svc]]]
+
+  final implicit def byUniversal[F[_], Svc: ClassTag](implicit unilogs: Logs.Universal[F]): ServiceLogging[F, Svc] =
+    unilogs.service[Svc]
 }
 
 /** typeclass for logging using specified logger or set of loggers
@@ -122,3 +130,7 @@ private[tofu] class EmptyLogging[F[_]: Applicative] extends Logging[F] {
   private[this] val noop                                                  = Applicative[F].unit
   def write(level: Level, message: String, values: LoggedValue*): F[Unit] = noop
 }
+
+trait LoggingCompanion[U[_[_]]] {
+  type Log[F[_]] = ServiceLogging[F, U[Any]]
+}

logging/structured/src/main/scala/tofu/logging/Logs.scala

@@ -4,11 +4,17 @@ import Logging.loggerForService
 import cats.data.Tuple2K
 import cats.effect.Sync
 import cats.kernel.Monoid
+import cats.{Applicative, Apply, FlatMap, Functor, Id, Monad}
+import impl.{CachedLogs, ContextSyncLoggingImpl, SyncLogging, UniversalEmbedLogs}
 import cats.tagless.{ApplyK, FunctorK}
 import cats.tagless.syntax.functorK._
 import cats.{Applicative, Apply, FlatMap, Functor, ~>}
 import impl.{ContextSyncLoggingImpl, SyncLogging}
 import org.slf4j.LoggerFactory
+import tofu.concurrent.QVars
+import tofu.{Guarantee, higherKind}
+import tofu.higherKind.RepresentableK
+import tofu.lift.Lift
 import tofu.higherKind
 import tofu.higherKind.{Function2K, MonoidalK, Point, RepresentableK}
 import tofu.syntax.monadic._
@@ -23,9 +29,12 @@ trait Logs[+I[_], F[_]] extends LogsVOps[I, F] {
   final def biwiden[I1[a] >: I[a], F1[a] >: F[a]]: Logs[I1, F1] = this.asInstanceOf[Logs[I1, F1]]
 
   final def service[Svc: ClassTag]: I[ServiceLogging[F, Svc]] = forService[Svc].asInstanceOf[I[ServiceLogging[F, Svc]]]
+
 }
 
 object Logs extends LogsInstances0 {
+  type Universal[F[_]] = Logs[Id, F]
+
   def apply[I[_], F[_]](implicit logs: Logs[I, F]): Logs[I, F] = logs
 
   private[this] val logs1RepresentableAny: RepresentableK[Logs[*[_], Any]] =
@@ -79,6 +88,25 @@ object Logs extends LogsInstances0 {
     def apply[X: ClassTag](f: Logging[F] => I[X])(implicit logs: Logs[I, F], I: FlatMap[I]) =
       logs.forService[X].flatMap(f)
   }
+
+  final implicit class LogsOps[I[_], F[_]](private val logs: Logs[I, F]) extends AnyVal {
+    def cached(implicit IM: Monad[I], IQ: QVars[I], IG: Guarantee[I]): I[Logs[I, F]] =
+      QVars[I]
+        .of(Map.empty[String, Logging[F]])
+        .map2(
+          QVars[I].of(Map.empty[ClassTag[_], Logging[F]])
+        )(new CachedLogs[I, F](logs, _, _))
+
+    def universal(implicit il: Lift[I, F], F: FlatMap[F]): Universal[F] = new UniversalEmbedLogs(logs)
+
+    def cachedUniversal(
+        implicit IM: Monad[I],
+        IQ: QVars[I],
+        IG: Guarantee[I],
+        il: Lift[I, F],
+        F: FlatMap[F]
+    ): I[Universal[F]] = cached.map(_.universal)
+  }
 }
 
 private[logging] trait LogsInstances0 extends LogsInstances1 {

logging/structured/src/main/scala/tofu/logging/impl/CachedLogs.scala

@@ -0,0 +1,35 @@
+package tofu.logging.impl
+import cats.Monad
+import tofu.Guarantee
+import tofu.concurrent.QVar
+import tofu.logging.{LoggedValue, Logging, Logs}
+import tofu.syntax.bracket._
+import tofu.syntax.monadic._
+
+import scala.reflect.{ClassTag, classTag}
+
+class CachedLogs[I[_]: Monad: Guarantee, F[_]](
+    underlying: Logs[I, F],
+    nameCache: QVar[I, Map[String, Logging[F]]],
+    tagCache: QVar[I, Map[ClassTag[_], Logging[F]]]
+) extends Logs[I, F] {
+  private[this] case object NoneLogging extends Logging[F] {
+    def write(level: Logging.Level, message: String, values: LoggedValue*): F[Unit] =
+      throw new UnsupportedOperationException("CachedLogs.NonLogging should be never used")
+  }
+
+  private[this] def safeGet[K](mvar: QVar[I, Map[K, Logging[F]]], create: => I[Logging[F]], key: K): I[Logging[F]] =
+    mvar.read.flatMap(_.getOrElse(key, NoneLogging) match {
+      case NoneLogging =>
+        mvar.take.bracketIncomplete { map =>
+          map.getOrElse(key, NoneLogging) match {
+            case NoneLogging => create.flatTap(logging => mvar.put(map.updated(key, logging)))
+            case logging     => logging.pure[I]
+          }
+        }(mvar.put)
+      case logging => logging.pure[I]
+    })
+
+  def forService[Svc: ClassTag]: I[Logging[F]] = safeGet(tagCache, underlying.forService[Svc], classTag[Svc])
+  def byName(name: String): I[Logging[F]]      = safeGet(nameCache, underlying.byName(name), name)
+}

logging/structured/src/main/scala/tofu/logging/impl/UniversalEmbedLogs.scala

@@ -0,0 +1,14 @@
+package tofu.logging.impl
+import cats.{FlatMap, Id}
+import tofu.lift.Lift
+import tofu.logging.{Logging, Logs}
+
+import scala.reflect.ClassTag
+
+class UniversalEmbedLogs[I[_], F[_]: FlatMap](underlying: Logs[I, F])(implicit lift: Lift[I, F])
+    extends Logs.Universal[F] {
+  def forService[Svc: ClassTag]: Logging[F] =
+    Logging.loggingRepresentable.embed(lift.lift(underlying.forService[Svc]))
+  def byName(name: String): Id[Logging[F]] =
+    Logging.loggingRepresentable.embed(lift.lift(underlying.byName(name)))
+}

logging/structured/src/main/scala/tofu/logging/package.scala

@@ -0,0 +1,5 @@
+package tofu
+
+package object logging {
+  type ModuleLog[F[_], U[_[_]]] = ServiceLogging[F, U[Any]]
+}