for {
              _ <- ZStream.unit

              enhancedLogging <- ZStream.fromEffect(
                zio.logging.log.derive(_.annotate(RTDLogging.ValidFrom, Some(v))
                  .annotate(RTDLogging.CalculationId, Some(calcId))))
              s <- stream.updateService[zio.logging.Logger[String]](_ => enhancedLogging)
            } yield s

def label(label: => String, value: LogFormat): LogFormat =
    LogFormat.make { (builder, trace, fiberId, logLevel, message, context, spans, location) =>
      builder.openKey()
      try builder.appendText(label)
      finally builder.closeKeyOpenValue()

      try value.unsafeFormat(builder)(trace, fiberId, logLevel, message, context, spans, location)
      finally builder.closeValue()
    }

final case class LogAnnotation[A: ClassTag](name: String, neutral: A, combine: (A, A) => A, render: A => String) { self =>
  def apply[A](value: A): LogContext  => LogContext = _.annotate(self, combine(neutral, value))
}

class Live(httpClient: HttpClient.Service, logging: Logging.Service) extends GithubService.Service {
  ...
}

def getRepos: Task[List[Repo]] = for {
  ...
  _ <- logging.logger.log(LogLevel.Debug)(body)
  ...
} yield repos

def getRepos: Task[List[Repo]] = (for {
  ...
  _ <- log.debug(body)
  ...
} yield repos).provideLayer(ZLayer.succeed(logging))

def getRepos: RIO[Logging with HttpClient, List[Repo]] = for {
  ...
  _ <- log.debug(body)
  ...
} yield repos

class HomeController @Inject()(val controllerComponents: ControllerComponents) extends BaseController {

  val layer = (Clock.live ++ Console.live) >>> Logging.console((_, msg) => msg)

  def index() = Action.async { implicit request: Request[AnyContent] =>
    val io = log(LogLevel.Info)("Does this work?") *> UIO(Ok(views.html.index()))
    Runtime.default.unsafeRunToFuture(io.provideLayer(layer))
  }
}

final case class LogMedium[+E, A](log: A => IO[E, Unit]) {
  def contramap[B](f: B => A): LogMedium[E, B] =
    LogMedium[E, B](b => log(f(b)))

  def contramapM[E1 >: E, B](f: B => IO[E1, A]): LogMedium[E1, B] =
    LogMedium[E1, B](b => f(b).flatMap(log))

  def orElse[E2](that: => LogMedium[E2, A]): LogMedium[E2, A] =
    LogMedium[E2, A](a => log(a).catchAll(_ => that.log(a)))
}

trait Log[E, A] {
  def log: Log.Service[E, A]
}

object Log {
  type SafeLog[A] = Log[Nothing, A]

  def log[E, A]: ZIO[Log[E, A], Nothing, Log.Service[E, A]] =
    ZIO.access[Log[E, A]](_.log)

  /**
   * An implementation of conventional logging with timestamp and logging level
   */
  trait Service[E, A] {
    def error(s: => A): IO[E, Unit]
    def warn(s: => A): IO[E, Unit]
    def info(s: => A): IO[E, Unit]
    def debug(s: => A): IO[E, Unit]
  }
  :

object AppMain extends zio.App {

  def intLogger: UIO[Log[Int]] =
    Log.make[Int](intRendered(RawLogMedium.console))

  def intRendered(base: LogMedium[String]): LogMedium[Tagged[Int]] =
    base.contramap {
      m: Tagged[Int] =>
        val n: Int = m.message()
        "%-5s - %d:%s".format(m.level.name, n, "x" * n)
    }

  final case class AppEnv(log: Log.Service[Int]) extends Log[Int]

  override def run(args: List[String]): ZIO[zio.ZEnv, Nothing, Int] =
    for {
      logsvc <- intLogger
      log = logsvc.log

      pgm = Application.execute.provide(AppEnv(log))

      exitCode <- pgm.foldM(
        e => log.error(11) *> ZIO.succeed(1),
        _ => log.info(10) *> ZIO.succeed(0)
      )
    } yield exitCode
}

// The core application
object Application {
  val doSomething: ZIO[Log[Int], Nothing, Unit] =
    for {
      log <- Log.log[Int]
      _ <- log.info(1)
      _ <- log.info(2)
    } yield ()

  val execute: ZIO[Log[Int], Nothing, Unit] =
    for {
      log <- Log.log[Int]
      _ <- log.info(3)
      _ <- doSomething
      _ <- log.info(4)
    } yield ()
}

import zio.{UIO, ZIO}
import zio.logging.{LogContext, Logger}

object EmptyLogger extends Logger[String] {
  override def locally[R1, E, A1](f: LogContext => LogContext)(in: ZIO[R1, E, A1]): ZIO[R1, E, A1] = in
  override def log(line: => String): UIO[Unit]                                                     = ZIO.unit
  override def logContext: UIO[LogContext]                                                         = ZIO.succeed(LogContext.empty)
}

cockpitZR <-
                ZStream
                  .fromEffect(
                    (for {
                      result <- effectWithDisabledLogging(....)
                        .updateService[zio.logging.Logger[String]](_ => EmptyLogger)
                      _ <- someOtherEffectWithNormalLogging(...)
                    } yield result)
                      .tapCause(e => zio.logging.log.error("failed to calculate ...", e))
                  )

trait ChannelHandler {
  override def channelRead(ctx: ChannelHandlerContext, msg: Any): Unit = {
    Logger.debug("Message refCount: ${msg.refCount()}") // returns a ZIO, doesn't log anything

   // .. .. 

   Logger.debug("Message refCount: ${msg.refCount()}") // returns a ZIO, doesn't log anything
  }
}

package zio

import scala.reflect.ClassTag

package object logging {
}

package logging {
  /**
   * A log level defines the level at which an element is logged.
   */
  sealed trait LogLevel { self => 
    def render: String
    def level: Int

    def > (that: LogLevel) = self.level > that.level 
    def >= (that: LogLevel) = self.level >= that.level 
    def < (that: LogLevel) = self.level < that.level 
    def <= (that: LogLevel) = self.level <= that.level 

    def max(that: LogLevel): LogLevel = if (self < that) that else self

    def min(that: LogLevel): LogLevel = if (self > that) that else self
  }
  object LogLevel {
    case object All   extends LogLevel { def level = 7; def render = "ALL" }
    case object Fatal extends LogLevel { def level = 6; def render = "FATAL" }
    case object Error extends LogLevel { def level = 5; def render = "ERROR" }
    case object Warn  extends LogLevel { def level = 4; def render = "WARN" }
    case object Info  extends LogLevel { def level = 3; def render = "INFO" }
    case object Debug extends LogLevel { def level = 2; def render = "DEBUG" }
    case object Trace extends LogLevel { def level = 1; def render = "TRACE" }
    case object Off   extends LogLevel { def level = 0; def render = "OFF" }
  }

  trait LoggerLike[-R] { self =>
    /**
     * Produces a new logger by adapting a different input type to the input 
     * type of this logger.
     */
    final def contramap[R1](f: R1 => R): LoggerLike[R1] = 
      new LoggerLike[R1] {
        def locallyAnnotate[R, E, A](f: LogContext => LogContext)(zio: ZIO[R, E, A]): ZIO[R, E, A] =
          self.locallyAnnotate(f)(zio)

        def log(line: => R1): UIO[Unit] = self.log(f(line))

        def logContext: UIO[LogContext] = self.logContext
      }

    /**
     * Derives a new logger from this one, by applying the specified decorator
     * to the logger context.
     */
    def derive(f: LogContext => LogContext): LoggerLike[R] = 
      new LoggerLike[R] { 
        def locallyAnnotate[R, E, A](f: LogContext => LogContext)(zio: ZIO[R, E, A]): ZIO[R, E, A] =
          self.locallyAnnotate(f)(zio)

        def log(line: => R): UIO[Unit] = locallyAnnotate(f)(self.log(line))

        def logContext: UIO[LogContext] = self.logContext
      }

    /**
     * Produces a logger that logs at the specified level.
     */
    def level(level: LogLevel): LoggerLike[R] = 
      derive(_.annotate(LogAnnotation.Level, level))

    /**
     * Modifies the log context in the scope of the specified effect.
     */
    def locallyAnnotate[R, E, A](f: LogContext => LogContext)(zio: ZIO[R, E, A]): ZIO[R, E, A]

    /**
     * Logs the specified element using an inherited log level.
     */
    def log(line: => R): UIO[Unit]

    /**
     * Retrieves the log context.
     */
    def logContext: UIO[LogContext]

    /**
     * Logs the specified element at the specified level. Implementations may 
     * override this for greater efficiency.
     */
    def log(level: LogLevel)(line: => R): UIO[Unit] = self.level(level).log(line)

    /**
     * Produces a named logger.
     */
    def name(name: String): LoggerLike[R] = {
      val named = name :: Nil 

      derive(_.annotate(LogAnnotation.Name, named))
    }
  }

  /**
   * A logger of strings.
   */
  trait Logger extends LoggerLike[String]
  object Logger {
    /**
     * Constructs a logger provided the specified sink.
     */
    def make(logger: (LogContext, => String) => UIO[Unit]): UIO[Logger] = 
      FiberRef.make(LogContext.empty).map { ref =>
        new Logger {
          def locallyAnnotate[R, E, A](f: LogContext => LogContext)(zio: ZIO[R, E, A]): ZIO[R, E, A] =
            ref.get.flatMap(context => ref.locally(f(context))(zio))

          def log(line: => String): UIO[Unit] = ref.get.flatMap(context => logger(context, line))

          def logContext: UIO[LogContext] = ref.get
        }
      }
  }

  /**
   * A `LogAnnotation` describes a particular type of annotation applied to log 
   * lines.
   */
  final case class LogAnnotation[A: ClassTag](name: String, neutral: A, combine: (A, A) => A, render: A => String) { self =>
    def id: (String, ClassTag[A]) = (name, classTag)

    /**
     * The class tag of the annotation type, used for disambiguation purposes only.
     */
    def classTag: ClassTag[A] = implicitly[ClassTag[A]]

    override def hashCode: Int = id.hashCode 

    override def equals(that: Any): Boolean = that match {
      case that : LogAnnotation[_] => self.id == that.id
      case _ => false
    }
  }
  object LogAnnotation {
    /**
     * The `Level` annotation keeps track of log levels.
     */
    val Level = LogAnnotation[LogLevel]("level", LogLevel.Off, (_, r) => r, _.render)

    /**
     * The `Name` annotation keeps track of logger names.
     */
    val Name = LogAnnotation[List[String]]("name", Nil, _ ++ _, _.mkString("."))
  }

  /**
   * A `LogContext` stores context associated with logging operations.
   */
  final case class LogContext private (private val map: Map[LogAnnotation[_], Any]) { self =>
    /**
     * Merges this context with the specified context.
     */
    def ++ (that: LogContext): LogContext = self merge that

    /**
     * Annotates the context with the specified annotation and value, returning
     * the new context.
     */
    def annotate[A](annotation: LogAnnotation[A], newA: A): LogContext = {
      val oldA = get(annotation)

      new LogContext(map + (annotation -> annotation.combine(oldA, newA)))
    }

    /**
     * Retrieves the specified annotation from the context.
     */
    def get[A](annotation: LogAnnotation[A]): A =
      map.get(annotation).fold(annotation.neutral)(_.asInstanceOf[A])

    /**
     * Merges this context with the specified context.
     */
    def merge(that: LogContext): LogContext = {
      val allKeys = self.map.keySet ++ that.map.keySet

      new LogContext(allKeys.foldLeft(Map.empty[LogAnnotation[_], Any]) {
        case (map, annotation) => 
          map + (annotation -> annotation.combine(self.get(annotation), that.get(annotation)))
      })
    }
  }
  object LogContext {
    /**
     * An empty context.
     */
    val empty: LogContext = new LogContext(Map())
  }
}

  someAction.foldM(
    { error =>
      log.error(s"Failed to do the action", error) *> InternalServerError()
    }, { response =>
      Ok(response)
    })

trait Logging {
  def logging: Logging.Service[Any]
}
object Logging {
  trait Service[-R] {
    // TODO: Define methods here
    def log(line: => String): ZIO[R, Nothing, Unit]
    def info(line: => String): ZIO[R, Nothing, Unit]
    def warning(line: => String): ZIO[R, Nothing, Unit]
    def error(line: => String): ZIO[R, Nothing, Unit]
    def errorCause(cause: Cause[Any]): ZIO[R, Nothing, Unit]
  }
}

package object logging extends Logging.Service[Logging] {
  ...
}

import zio._
import zio.logging.LogAnnotation
import zio.logging.slf4j.Slf4jLogger
import zio.stream.ZStream

import java.util.UUID
object LoggingSample {
  final val env = Slf4jLogger.makeWithAllAnnotationsAsMdc()

  final val UserId = LogAnnotation[Option[String]](
    name = "user-id",
    initialValue = None,
    combine = (_, r) => r,
    render = _.map(_.toString).getOrElse("undefined-user-id")
  )

  final val CalculationId = LogAnnotation[Option[UUID]](
    name = "calculation-id",
    initialValue = None,
    combine = (_, r) => r,
    render = _.map(_.toString).getOrElse("undefined-calculation-id")
  )

  final val CalculationNumber = LogAnnotation[Int](
    name = "calculation-number",
    initialValue = 0,
    combine = (_, r) => r,
    render = _.toString
  )

}

object SampleApp extends zio.App {

  override def run(args: List[String]): URIO[zio.ZEnv, ExitCode] = {

    val initialStream = ZStream.fromIterable(Seq(1, 2, 3, 4, 5))

    val s = for {
      calcNumber <- initialStream

      subStream = (for {
        _ <- ZStream.fromEffect(zio.logging.log.debug(s"would log first line for calculation# ${calcNumber}"))
        _ <- ZStream.fromEffect(zio.logging.log.debug(s"would log second line for calculation# ${calcNumber}"))
      } yield ())

      updatedLoggingDep <- ZStream.fromEffect(
        zio.logging.log.derive(_.annotate(LoggingSample.CalculationId, Some(UUID.randomUUID()))
          .annotate(LoggingSample.CalculationNumber, calcNumber)))

      x <- subStream.updateService[zio.logging.Logger[String]](_ => updatedLoggingDep)

    } yield calcNumber

    val e = for {
      _ <- ZIO.unit
      _ <- s.runDrain
    } yield ()

    e.provideSomeLayer(LoggingSample.env).exitCode
  }
}

Caused by: java.lang.ClassNotFoundException: zio.ZIO$AccessMPartiallyApplied$
        at zio.logging.Logging$.<clinit>(Logging.scala:43)
        at zio.logging.slf4j.Slf4jLogger$.make(Slf4jLogger.scala:40)
        at io.km8.Server$.run$$anonfun$1(Server.scala:16)
        at zio.ZIO.provideLayer$$anonfun$1(ZIO.scala:1389)
        at zio.ZIO$.suspendSucceed$$anonfun$1(ZIO.scala:4936)
        at zio.internal.FiberContext.runUntil(FiberContext.scala:496)
        at zio.internal.FiberContext.run(FiberContext.scala:314)
        at zio.internal.ZScheduler$$anon$2.run(ZScheduler.scala:149)

log.locallyManaged(LogAnnotations.Name("x" :: Nil)) {
  ZManaged.make(log.info("x"))(_ => log.info("y")).use { _ => log.info("z") }
}

  val logLayerLive: ULayer[Logging] =
    Slf4jLogger.make((context, message) => "[correlation-id = %s] %s".format(context(correlationId), message))

  val logLayerLive: ULayer[Logging] =
    Slf4jLogger.make((context, message) => "[correlation-id = %s] %s".format(context(correlationId), message)) >>> initializeSlf4jBridge

[IJ]app-embedded[ERROR] java.lang.StackOverflowError
app-embedded[ERROR] 	at zio.internal.PlatformSpecific$$anon$2.fatal(PlatformSpecific.scala:88)
app-embedded[ERROR] 	at zio.internal.Platform$Proxy.fatal(Platform.scala:110)
app-embedded[ERROR] 	at zio.internal.FiberContext.evaluateNow(FiberContext.scala:653)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunWith(Runtime.scala:214)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync(Runtime.scala:83)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync$(Runtime.scala:80)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRunSync(Runtime.scala:280)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun(Runtime.scala:58)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun$(Runtime.scala:57)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRun(Runtime.scala:280)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLoggerFactory.run(ZioLoggerFactory.scala:19)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.run(ZioLogger.scala:11)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.info(ZioLogger.scala:73)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2(Slf4jLogger.scala:32)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2$adapted(Slf4jLogger.scala:26)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4438)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4436)
app-embedded[ERROR] 	at zio.internal.FiberContext.evaluateNow(FiberContext.scala:351)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunWith(Runtime.scala:214)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync(Runtime.scala:83)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync$(Runtime.scala:80)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRunSync(Runtime.scala:280)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun(Runtime.scala:58)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun$(Runtime.scala:57)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRun(Runtime.scala:280)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLoggerFactory.run(ZioLoggerFactory.scala:19)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.run(ZioLogger.scala:11)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.info(ZioLogger.scala:73)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2(Slf4jLogger.scala:32)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2$adapted(Slf4jLogger.scala:26)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4438)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4436)
app-embedded[ERROR] 	at zio.internal.FiberContext.evaluateNow(FiberContext.scala:351)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunWith(Runtime.scala:214)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync(Runtime.scala:83)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync$(Runtime.scala:80)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRunSync(Runtime.scala:280)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun(Runtime.scala:58)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun$(Runtime.scala:57)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRun(Runtime.scala:280)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLoggerFactory.run(ZioLoggerFactory.scala:19)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.run(ZioLogger.scala:11)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.info(ZioLogger.scala:73)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2(Slf4jLogger.scala:32)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2$adapted(Slf4jLogger.scala:26)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4438)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4436)
app-embedded[ERROR] 	at zio.internal.FiberContext.evaluateNow(FiberContext.scala:351)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunWith(Runtime.scala:214)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync(Runtime.scala:83)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync$(Runtime.scala:80)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRunSync(Runtime.scala:280)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun(Runtime.scala:58)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun$(Runtime.scala:57)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRun(Runtime.scala:280)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLoggerFactory.run(ZioLoggerFactory.scala:19)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.run(ZioLogger.scala:11)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.info(ZioLogger.scala:73)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2(Slf4jLogger.scala:32)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2$adapted(Slf4jLogger.scala:26)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4438)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4436)
app-embedded[ERROR] 	at zio.internal.FiberContext.evaluateNow(FiberContext.scala:351)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunWith(Runtime.scala:214)
app-embedded **** WARNING ***
app-embedded Catastrophic JVM error encountered. Application not safely interrupted. Resources may be leaked. Check the logs for more details and consider overriding `Platform.reportFatal` to capture context.
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync(Runtime.scala:83)
app-embedded[ERROR] 	at zio.Runtime.unsafeRunSync$(Runtime.scala:80)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRunSync(Runtime.scala:280)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun(Runtime.scala:58)
app-embedded[ERROR] 	at zio.Runtime.unsafeRun$(Runtime.scala:57)
app-embedded[ERROR] 	at zio.Runtime$$anon$3.unsafeRun(Runtime.scala:280)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLoggerFactory.run(ZioLoggerFactory.scala:19)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.run(ZioLogger.scala:11)
app-embedded[ERROR] 	at org.slf4j.impl.ZioLogger.info(ZioLogger.scala:73)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2(Slf4jLogger.scala:32)
app-embedded[ERROR] 	at zio.logging.slf4j.Slf4jLogger$.$anonfun$make$2$adapted(Slf4jLogger.scala:26)
app-embedded[ERROR] 	at zio.ZIO$MapFn.apply(ZIO.scala:4438)
...

val output = new OutputStreamWriter(new FileOutputStream(destination.toFile), charset)

val output = new OutputStreamWriter(new FileOutputStream(destination.toFile, true), charset)

def error(line: => String, cause: Cause[Any])

def warn(line: => String, cause: Cause[Any]) 

implicit class ZIOLogOps[R <: Logging with ZUUID, E, A](val z: ZIO[R, E, A]) extends AnyVal {
    def withCorrelationId: ZIO[R, E, A] =
      for {
        uuid  <- ZUUID.uuid
        result <- log.locally(_.annotate(LogAnnotation.CorrelationId, Some(uuid)))(z)
      } yield result

    def withLoggerName(name: String): ZIO[R, E, A] =
      log.locally(_.annotate(LogAnnotation.Name, name :: Nil))(z)

    def logInfo(f: A => String): ZIO[R, E, A] =
      z.tap(a => log.info(f(a)))

    def logError(f: E => String): ZIO[R, E, A] =
      z.tapError(e => log.error(f(e)))

    def logFold(fe: E => String, fa: A => String): ZIO[R, E, A] =
      z.logError(fe).logInfo(fa)
  }

val pipe = for {
  user <- UserRepository.findById(userId).logError(e => s"Error finding user: $e")
  credit <- BalanceRepository.getBalanceByUserId(userId).logInfo(b => s"Balance of $b found")
} yield ()

pipe
  .withLoggerName("UserBalanceService")
  .withCorrelationId

val pipe = for {
  user <- UserRepository.findById(userId).tapError(e => log.error(s"Error finding user: $e"))
  credit <- BalanceRepository.getBalanceByUserId(userId).tap(b => log.info(s"Balance of $b found"))
} yield ()

for {
  correlationId <- ZUUID.uuid
  _ <- log.locally(_.annotate(LogAnnotation.Name, "UserBalanceService" :: Nil)
.annotate(LogAnnotation.CorrelationId, Some(uuid)))(pipe)  
} yield ()

def withLoggingContext[A](eff: => A): ZIO[Logging, Throwable, A] =
  log.context.flatMap { ctx =>
    ZIO.effect {
      import scala.jdk.CollectionConverters._
      val previous =
        Option(MDC.getCopyOfContextMap().asScala)
          .getOrElse(Map.empty[String, String])

      try {
        ctx.renderContext.foreach((MDC.put _).tupled)
        eff
      } finally MDC.setContextMap(previous.asJava)
    }
  }

def throwable(line: => A, t: Throwable)