website·Indexed 32 days ago
https://logger-f.kevinly.devA tool for logging tagless final with an effect library, providing easy ways to log Either and EitherT. It supports Cats, Cats Effect, Monix, and Scalaz Effect, with integration for SLF4J. Available in versions v1 and v2.14.0.
Log is an algebra used to log various effectful types such as F[A], F[Option[A]], F[Either[A, B]], OptionT[F, A], and EitherT[F, A, B]. It provides an abstraction for logging operations that can be interpreted differently depending on the requirements. To function, it requires Fx from the Effectie library and Monad from the Cats library.F[_]. It simplifies logging by allowing developers to attach logging logic directly to the effect chain rather than manually inserting flatMap or delay blocks for every log statement.// Traditional approach
for {
a <- foo(n)
_ <- Sync[F].delay(logger.debug(s"a is $a"))
b <- bar(a)
} yield b
// With LoggerF
for {
a <- foo(n).log(a => debug(s"a is $a"))
b <- bar(a).log(b => debug(s"b is $b"))
} yield bF[_]. It is designed to solve logging inconveniences that arise when using OptionT or EitherT within an effect stack, where standard flatMap logging may not capture the desired state (e.g., logging the None case in an OptionT chain).Log typeclass provides a mechanism to log values wrapped in functional containers. It supports F[A], F[Option[A]], F[Either[A, B]], OptionT[F, A], and EitherT[F, A, B]. To use Log, the environment must provide Fx from the Effectie library and Monad from the Cats library.Either and EitherT types.Log typeclass provides a mechanism to log values wrapped in effect types such as F[A], F[Option[A]], F[Either[A, B]], OptionT[F, A], and EitherT[F, A, B]. To use this typeclass, the environment must provide Fx from Effectie and Monad from Cats.Log typeclass provides a mechanism to log values within effect types. It is compatible with F[A], F[Option[A]], F[A \/ B], OptionT[F, A], and EitherT[F, A, B]. To use this typeclass, the environment must provide Fx from Effectie and Monad from Scalaz.Log within a service (Greeting) and execute it within a TaskApp. It requires a CanLog instance (e.g., Slf4JLogger) to be available in the implicit scope.import cats._
import cats.syntax.all._
import cats.effect.ExitCode
import effectie.monix.{ConsoleEffect, Fx}
import effectie.monix.Effectful._
import loggerf.logger._
import loggerf.monix._
import loggerf.syntax._
import monix.eval.Task
import monix.eval.TaskApp
trait Named[A] {
def name(a: A): String
}
final case class GivenName(givenName: String) extends AnyVal
final case class Surname(surname: String) extends AnyVal
final case class Person(givenName: GivenName, surname: Surname)
object Person {
implicit val namedPerson: Named[Person] =
person => s"${person.givenName.givenName} ${person.surname.surname}"
}
trait Greeting[F[_]] {
def greet[A: Named](a: A): F[String]
}
object Greeting {
def apply[F[_]: Greeting]: Greeting[F] = implicitly[Greeting[F]]
implicit def hello[F[_]: Fx: Monad: Log]: Greeting[F] =
new Greeting[F] {
def greet[A: Named](a: A): F[String] =
for {
// Log the result of the effect
name <- log(effectOf(Named[A].name(a)))(x => info(s"The name is $x"))
greeting <- pureOf(s"Hello $name")
} yield greeting
}
}
object TaskMainApp extends TaskApp {
// Configure the logger implementation
implicit val canLog: CanLog = Slf4JLogger.slf4JCanLog("MyApp")
def run(args: List[String]): Task[ExitCode] =
for {
greetingMessage <- Greeting[Task].greet(
Person(GivenName("Kevin"), Surname("Lee"))
)
_ <- ConsoleEffect[Task].putStrLn(greetingMessage)
} yield ExitCode.Success
}logger-f-cats-effect dependency along with the desired logging backend dependency in your build.sbt.// For SLF4J
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-cats-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-slf4j" % "1.20.0"
)
// For Log4j
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-cats-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-log4j" % "1.20.0"
)
// For Log4s
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-cats-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-log4s" % "1.20.0"
)
// For sbt Logging Util (sbt plugin development)
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-cats-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-sbt-logging" % "1.20.0"
)OptionT is empty (using warn) or contains a value (using info), and how to use ignore to skip logging for specific cases.import cats._
import cats.data._
import cats.syntax.all._
import cats.effect._
import effectie.core._
import effectie.syntax.all._
import loggerf.core._
import loggerf.syntax.all._
import loggerf.logger._
def hello[F[_]: Monad: Fx: Log](maybeName: Option[String]): F[Unit] =
(for {
name <- OptionT(pureOf(maybeName))
.log(
warn("No name given"),
name => info(s"Name: $name")
)
message <- OptionT.liftF(greeting[F](name))
.log(ignore, msg => info(s"Message: $msg"))
} yield message)
.foreachF(msg => effectOf(println(msg)))
implicit val canLog: CanLog = Slf4JLogger.slf4JCanLog("MyApp- OptionT[F, A]")build.sbt file."io.kevinlee" %% "logger-f-cats" % "2.14.0"logger-f-scalaz-effect dependency and the chosen logging backend in build.sbt.// For SLF4J
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-scalaz-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-slf4j" % "1.20.0"
)
// For Log4j
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-scalaz-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-log4j" % "1.20.0"
)
// For Log4s
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-scalaz-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-log4s" % "1.20.0"
)
// For sbt Logging Util
libraryDependencies ++= Seq(
"io.kevinlee" %% "logger-f-scalaz-effect" % "1.20.0",
"io.kevinlee" %% "logger-f-sbt-logging" % "1.20.0"
)