Logger

abstract def locally[R1, E, A1](f: (LogContext) ⇒ LogContext)(zio: ZIO[R1, E, A1]): ZIO[R1, E, A1]

Modifies the log context in the scope of the specified effect.

abstract def log(line: ⇒ A): UIO[Unit]

Logs the specified element using an inherited log level.

abstract def logContext: UIO[LogContext]

Retrieves the log context.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def contramap[A1](f: (A1) ⇒ A): Logger[A1]

Produces a new logger by adapting a different input type to the input type of this logger.

def debug(line: ⇒ A): UIO[Unit]

Logs the specified element at the debug level.

def debugM[R, E](line: ZIO[R, E, A]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the debug level

def derive(f: (LogContext) ⇒ LogContext): Logger[A]

Derives a new logger from this one, by applying the specified decorator to the logger context.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(line: ⇒ A, cause: Cause[Any]): ZIO[Any, Nothing, Unit]

Logs the specified element at the error level with cause.

def error(line: ⇒ A): UIO[Unit]

Logs the specified element at the error level.

def errorM[R, E](line: ZIO[R, E, A], cause: Cause[Any]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the error level

def errorM[R, E](line: ZIO[R, E, A]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the error level

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def info(line: ⇒ A): UIO[Unit]

Logs the specified element at the info level

def infoM[R, E](line: ZIO[R, E, A]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the info level

final def isInstanceOf[T0]: Boolean

final def locallyAnnotate[B, R, E, A1](annotation: LogAnnotation[B], value: B)(zio: ZIO[R, E, A1]): ZIO[R, E, A1]

Modifies the annotate in the scope of the specified effect.

def locallyM[R1, E, A1](f: (LogContext) ⇒ URIO[R1, LogContext])(zio: ZIO[R1, E, A1]): ZIO[R1, E, A1]

Modifies the log context with effect in the scope of the specified effect.

def log(level: LogLevel)(line: ⇒ A): UIO[Unit]

Logs the specified element at the specified level.

def named(name: String): Logger[A]

Produces a named logger.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def throwable(line: ⇒ A, t: Throwable): ZIO[Any, Nothing, Unit]

Logs the specified element at the error level with exception.

def toString(): String

def trace(line: ⇒ A): UIO[Unit]

Logs the specified element at the trace level.

def traceM[R, E](line: ZIO[R, E, A]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the trace level

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warn(line: ⇒ A): UIO[Unit]

Logs the specified element at the warn level.

def warnM[R, E](line: ZIO[R, E, A]): ZIO[R, E, Unit]

Evaluates the specified element based on the LogLevel set and logs at the warn level