diff --git a/build.sbt b/build.sbt
index d18264ca..8a1e29aa 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,10 +1,10 @@
-import com.typesafe.tools.mima.core._
+import com.typesafe.tools.mima.core.*
 
 val Scala213 = "2.13.16"
 val Scala212 = "2.12.20"
 val Scala3 = "3.3.5"
 
-ThisBuild / tlBaseVersion := "2.7"
+ThisBuild / tlBaseVersion := "2.8"
 ThisBuild / crossScalaVersions := Seq(Scala213, Scala212, Scala3)
 ThisBuild / scalaVersion := Scala213
 ThisBuild / startYear := Some(2018)
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/ErrorLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/ErrorLogger.scala
index 2dbc8064..dec36b69 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/ErrorLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/ErrorLogger.scala
@@ -17,12 +17,16 @@
 package org.typelevel.log4cats
 
 import cats.*
+import org.typelevel.log4cats.extras.LogLevel
 trait ErrorLogger[F[_]] {
-  def error(t: Throwable)(message: => String): F[Unit]
-  def warn(t: Throwable)(message: => String): F[Unit]
-  def info(t: Throwable)(message: => String): F[Unit]
-  def debug(t: Throwable)(message: => String): F[Unit]
-  def trace(t: Throwable)(message: => String): F[Unit]
+  def error(t: Throwable)(message: => String): F[Unit] = log(LogLevel.Error, t, message)
+  def warn(t: Throwable)(message: => String): F[Unit] = log(LogLevel.Warn, t, message)
+  def info(t: Throwable)(message: => String): F[Unit] = log(LogLevel.Info, t, message)
+  def debug(t: Throwable)(message: => String): F[Unit] = log(LogLevel.Debug, t, message)
+  def trace(t: Throwable)(message: => String): F[Unit] = log(LogLevel.Trace, t, message)
+
+  def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit]
+
   def mapK[G[_]](fk: F ~> G): ErrorLogger[G] =
     ErrorLogger.mapK(fk)(this)
 }
@@ -32,16 +36,9 @@ object ErrorLogger {
 
   private def mapK[G[_], F[_]](f: G ~> F)(logger: ErrorLogger[G]): ErrorLogger[F] =
     new ErrorLogger[F] {
-      def error(t: Throwable)(message: => String): F[Unit] =
-        f(logger.error(t)(message))
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        f(logger.warn(t)(message))
-      def info(t: Throwable)(message: => String): F[Unit] =
-        f(logger.info(t)(message))
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        f(logger.debug(t)(message))
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        f(logger.trace(t)(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = f(
+        logger.log(ll, t, msg)
+      )
     }
 
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/Logger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/Logger.scala
index 78a84258..6b391c61 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/Logger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/Logger.scala
@@ -18,6 +18,7 @@ package org.typelevel.log4cats
 
 import cats.*
 import cats.data.{EitherT, Kleisli, OptionT}
+import org.typelevel.log4cats.extras.LogLevel
 
 trait Logger[F[_]] extends MessageLogger[F] with ErrorLogger[F] {
   def withModifiedString(f: String => String): Logger[F] = Logger.withModifiedString[F](this, f)
@@ -25,7 +26,7 @@ trait Logger[F[_]] extends MessageLogger[F] with ErrorLogger[F] {
 }
 
 object Logger {
-  def apply[F[_]](implicit ev: Logger[F]) = ev
+  def apply[F[_]](implicit ev: Logger[F]): Logger[F] = ev
 
   implicit def optionTLogger[F[_]: Logger: Functor]: Logger[OptionT[F, *]] =
     Logger[F].mapK(OptionT.liftK[F])
@@ -38,40 +39,16 @@ object Logger {
 
   private def withModifiedString[F[_]](l: Logger[F], f: String => String): Logger[F] =
     new Logger[F] {
-      def error(message: => String): F[Unit] = l.error(f(message))
-      def error(t: Throwable)(message: => String): F[Unit] = l.error(t)(f(message))
-      def warn(message: => String): F[Unit] = l.warn(f(message))
-      def warn(t: Throwable)(message: => String): F[Unit] = l.warn(t)(f(message))
-      def info(message: => String): F[Unit] = l.info(f(message))
-      def info(t: Throwable)(message: => String): F[Unit] = l.info(t)(f(message))
-      def debug(message: => String): F[Unit] = l.debug(f(message))
-      def debug(t: Throwable)(message: => String): F[Unit] = l.debug(t)(f(message))
-      def trace(message: => String): F[Unit] = l.trace(f(message))
-      def trace(t: Throwable)(message: => String): F[Unit] = l.trace(t)(f(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = l.log(ll, t, f(msg))
+      override def log(ll: LogLevel, msg: => String): F[Unit] = l.log(ll, f(msg))
     }
 
   private def mapK[G[_], F[_]](f: G ~> F)(logger: Logger[G]): Logger[F] =
     new Logger[F] {
-      def error(t: Throwable)(message: => String): F[Unit] =
-        f(logger.error(t)(message))
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        f(logger.warn(t)(message))
-      def info(t: Throwable)(message: => String): F[Unit] =
-        f(logger.info(t)(message))
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        f(logger.debug(t)(message))
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        f(logger.trace(t)(message))
-      def error(message: => String): F[Unit] =
-        f(logger.error(message))
-      def warn(message: => String): F[Unit] =
-        f(logger.warn(message))
-      def info(message: => String): F[Unit] =
-        f(logger.info(message))
-      def debug(message: => String): F[Unit] =
-        f(logger.debug(message))
-      def trace(message: => String): F[Unit] =
-        f(logger.trace(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = f(
+        logger.log(ll, t, msg)
+      )
+      override def log(ll: LogLevel, msg: => String): F[Unit] = f(logger.log(ll, msg))
     }
 
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/MessageLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/MessageLogger.scala
index 5c267d85..54121037 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/MessageLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/MessageLogger.scala
@@ -17,13 +17,17 @@
 package org.typelevel.log4cats
 
 import cats.*
+import org.typelevel.log4cats.extras.LogLevel
 
 trait MessageLogger[F[_]] {
-  def error(message: => String): F[Unit]
-  def warn(message: => String): F[Unit]
-  def info(message: => String): F[Unit]
-  def debug(message: => String): F[Unit]
-  def trace(message: => String): F[Unit]
+  def error(message: => String): F[Unit] = log(LogLevel.Error, message)
+  def warn(message: => String): F[Unit] = log(LogLevel.Warn, message)
+  def info(message: => String): F[Unit] = log(LogLevel.Info, message)
+  def debug(message: => String): F[Unit] = log(LogLevel.Debug, message)
+  def trace(message: => String): F[Unit] = log(LogLevel.Trace, message)
+
+  def log(ll: LogLevel, msg: => String): F[Unit]
+
   def mapK[G[_]](fk: F ~> G): MessageLogger[G] =
     MessageLogger.mapK(fk)(this)
 }
@@ -33,15 +37,6 @@ object MessageLogger {
 
   private def mapK[G[_], F[_]](f: G ~> F)(logger: MessageLogger[G]): MessageLogger[F] =
     new MessageLogger[F] {
-      def error(message: => String): F[Unit] =
-        f(logger.error(message))
-      def warn(message: => String): F[Unit] =
-        f(logger.warn(message))
-      def info(message: => String): F[Unit] =
-        f(logger.info(message))
-      def debug(message: => String): F[Unit] =
-        f(logger.debug(message))
-      def trace(message: => String): F[Unit] =
-        f(logger.trace(message))
+      override def log(ll: LogLevel, msg: => String): F[Unit] = f(logger.log(ll, msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/PagingSelfAwareStructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/PagingSelfAwareStructuredLogger.scala
index 432514d2..16020ba6 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/PagingSelfAwareStructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/PagingSelfAwareStructuredLogger.scala
@@ -19,6 +19,7 @@ package org.typelevel.log4cats
 import cats.*
 import cats.effect.std.UUIDGen
 import cats.syntax.all.*
+import org.typelevel.log4cats.extras.LogLevel
 
 import java.io.{PrintWriter, StringWriter}
 import java.util.UUID
@@ -87,15 +88,14 @@ object PagingSelfAwareStructuredLogger {
     private val pageSize = pageSizeK * 1024
 
     private def pagedLogging(
-        logOpWithCtx: Map[String, String] => (=> String) => F[Unit],
+        logLevel: LogLevel,
         ctx: Map[String, String],
         logSplitId: String,
         msg: String
     ): F[Unit] = {
       val numOfPagesRaw = (msg.length - 1) / pageSize + 1
       val numOfPages = Math.min(numOfPagesRaw, maxPageNeeded)
-      if (numOfPages <= 1)
-        logOpWithCtx(addPageCtx(msg, 1, 1, ctx))(msg)
+      if (numOfPages <= 1) sl.log(logLevel, addPageCtx(msg, 1, 1, ctx), msg)
       else {
         val logSplitIdPart1 = logSplitId.split('-').head
         val pageHeaderTail = s"$numOfPages $logSplitIdPart1"
@@ -112,24 +112,21 @@ object PagingSelfAwareStructuredLogger {
                             |
                             |Page $pi/$pageFooterTail""".stripMargin
 
-            logOpWithCtx(addPageCtx(page, pi, numOfPages, ctx))(page)
+            sl.log(logLevel, addPageCtx(page, pi, numOfPages, ctx), page)
           }
       }
     }
 
-    private def addMsgCtx(
-        msg: String,
-        ctx: Map[String, String]
-    ): F[(String, Map[String, String])] =
+    private def addMsgCtx(msg: String, ctx: Map[String, String]): F[(String, Map[String, String])] =
       randomUUID.map { uuid =>
         val logSplitId = uuid.show
-        val msgLength = msg.length
+        val msgLength = s"${msg.length}"
         (
           logSplitId,
           ctx
             .updated(logSplitIdN, logSplitId)
             .updated("page_size", s"$pageSizeK Kib")
-            .updated("whole_message_size_bytes", s"$msgLength")
+            .updated("whole_message_size_bytes", msgLength)
             // The following is deprecated
             .updated("log_size", s"$msgLength Byte")
         )
@@ -146,38 +143,24 @@ object PagingSelfAwareStructuredLogger {
         .updated("page_num", s"$pageNum")
         .updated("log_size_bytes", s"${page.length}")
 
-    private def doLogging(
-        loggingLevelChk: => F[Boolean],
-        logOpWithCtx: Map[String, String] => (=> String) => F[Unit],
-        msg: => String,
-        ctx: Map[String, String] = Map()
-    ): F[Unit] = {
-      loggingLevelChk.ifM(
-        {
-          // At this point we know we're going to log and/or interact
-          // with msg, so we materialize the message here so we don't
-          // materialize it multiple times
-          val materializedMsg = msg
-          addMsgCtx(materializedMsg, ctx).flatMap { case (logSplitId, newCtx) =>
-            pagedLogging(logOpWithCtx, newCtx, logSplitId, materializedMsg)
-          }
-        },
-        Applicative[F].unit
-      )
-    }
+    private def doLogging(logLevel: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+      sl.isEnabled(logLevel)
+        .ifM(
+          {
+            val cachedMsg = msg
+            addMsgCtx(cachedMsg, ctx).flatMap { case (logSplitId, newCtx) =>
+              pagedLogging(logLevel, newCtx, logSplitId, cachedMsg)
+            }
+          },
+          Applicative[F].unit
+        )
 
     private def doLoggingThrowable(
-        loggingLevelChk: => F[Boolean],
-        logOpWithCtx: Map[String, String] => (=> String) => F[Unit],
+        logLevel: LogLevel,
+        ctx: Map[String, String],
         t: Throwable,
-        msg: => String,
-        ctx: Map[String, String] = Map()
-    ): F[Unit] = {
-      loggingLevelChk.ifM(
-        doLogging(loggingLevelChk, logOpWithCtx, s"$msg\n${getStackTrace(t)}", ctx),
-        Applicative[F].unit
-      )
-    }
+        msg: => String
+    ): F[Unit] = doLogging(logLevel, ctx, s"$msg\n${getStackTrace(t)}")
 
     def getStackTrace(t: Throwable): String = {
       val sw = new StringWriter()
@@ -186,82 +169,23 @@ object PagingSelfAwareStructuredLogger {
       sw.getBuffer.toString
     }
 
-    override def isTraceEnabled: F[Boolean] = sl.isTraceEnabled
-
-    override def isDebugEnabled: F[Boolean] = sl.isDebugEnabled
-
-    override def isInfoEnabled: F[Boolean] = sl.isInfoEnabled
-
-    override def isWarnEnabled: F[Boolean] = sl.isWarnEnabled
-
-    override def isErrorEnabled: F[Boolean] = sl.isErrorEnabled
-
-    // Log message
-
-    override def trace(msg: => String): F[Unit] =
-      doLogging(isTraceEnabled, sl.trace, msg)
-
-    override def debug(msg: => String): F[Unit] =
-      doLogging(isDebugEnabled, sl.debug, msg)
-
-    override def info(msg: => String): F[Unit] =
-      doLogging(isInfoEnabled, sl.info, msg)
+    override def isEnabled(ll: LogLevel): F[Boolean] = sl.isEnabled(ll)
 
-    override def warn(msg: => String): F[Unit] =
-      doLogging(isWarnEnabled, sl.warn, msg)
+    override def log(ll: LogLevel, msg: => String): F[Unit] =
+      doLogging(ll, Map.empty, msg)
 
-    override def error(msg: => String): F[Unit] =
-      doLogging(isErrorEnabled, sl.error, msg)
+    override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+      doLoggingThrowable(ll, Map.empty, t, msg)
 
-    // Log message and throwable
+    override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+      doLogging(ll, ctx, msg)
 
-    override def trace(t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isTraceEnabled, sl.trace, t, msg)
-
-    override def debug(t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isDebugEnabled, sl.debug, t, msg)
-
-    override def info(t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isInfoEnabled, sl.info, t, msg)
-
-    override def warn(t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isWarnEnabled, sl.warn, t, msg)
-
-    override def error(t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isErrorEnabled, sl.error, t, msg)
-
-    // Log message, passing context
-
-    override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-      doLogging(isTraceEnabled, sl.trace, msg, ctx)
-
-    override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-      doLogging(isDebugEnabled, sl.debug, msg, ctx)
-
-    override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-      doLogging(isInfoEnabled, sl.info, msg, ctx)
-
-    override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-      doLogging(isWarnEnabled, sl.warn, msg, ctx)
-
-    override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-      doLogging(isErrorEnabled, sl.error, msg, ctx)
-
-    // Log message and throwable, passing context
-
-    override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isTraceEnabled, sl.trace, t, msg, ctx)
-
-    override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isDebugEnabled, sl.debug, t, msg, ctx)
-
-    override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isInfoEnabled, sl.info, t, msg, ctx)
-
-    override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isWarnEnabled, sl.warn, t, msg, ctx)
-
-    override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      doLoggingThrowable(isErrorEnabled, sl.error, t, msg, ctx)
+    override def log(
+        ll: LogLevel,
+        ctx: Map[String, String],
+        t: Throwable,
+        msg: => String
+    ): F[Unit] =
+      doLoggingThrowable(ll, ctx, t, msg)
   }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareLogger.scala
index e609e1eb..13733e88 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareLogger.scala
@@ -17,13 +17,17 @@
 package org.typelevel.log4cats
 
 import cats.*
+import org.typelevel.log4cats.extras.LogLevel
 
 trait SelfAwareLogger[F[_]] extends Logger[F] {
-  def isTraceEnabled: F[Boolean]
-  def isDebugEnabled: F[Boolean]
-  def isInfoEnabled: F[Boolean]
-  def isWarnEnabled: F[Boolean]
-  def isErrorEnabled: F[Boolean]
+  def isTraceEnabled: F[Boolean] = isEnabled(LogLevel.Trace)
+  def isDebugEnabled: F[Boolean] = isEnabled(LogLevel.Debug)
+  def isInfoEnabled: F[Boolean] = isEnabled(LogLevel.Info)
+  def isWarnEnabled: F[Boolean] = isEnabled(LogLevel.Warn)
+  def isErrorEnabled: F[Boolean] = isEnabled(LogLevel.Error)
+
+  def isEnabled(ll: LogLevel): F[Boolean]
+
   override def mapK[G[_]](fk: F ~> G): SelfAwareLogger[G] = SelfAwareLogger.mapK(fk)(this)
 
   override def withModifiedString(f: String => String): SelfAwareLogger[F] =
@@ -34,37 +38,11 @@ object SelfAwareLogger {
 
   private def mapK[G[_], F[_]](f: G ~> F)(logger: SelfAwareLogger[G]): SelfAwareLogger[F] =
     new SelfAwareLogger[F] {
-      def isTraceEnabled: F[Boolean] =
-        f(logger.isTraceEnabled)
-      def isDebugEnabled: F[Boolean] =
-        f(logger.isDebugEnabled)
-      def isInfoEnabled: F[Boolean] =
-        f(logger.isInfoEnabled)
-      def isWarnEnabled: F[Boolean] =
-        f(logger.isWarnEnabled)
-      def isErrorEnabled: F[Boolean] =
-        f(logger.isErrorEnabled)
-
-      def error(t: Throwable)(message: => String): F[Unit] =
-        f(logger.error(t)(message))
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        f(logger.warn(t)(message))
-      def info(t: Throwable)(message: => String): F[Unit] =
-        f(logger.info(t)(message))
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        f(logger.debug(t)(message))
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        f(logger.trace(t)(message))
-      def error(message: => String): F[Unit] =
-        f(logger.error(message))
-      def warn(message: => String): F[Unit] =
-        f(logger.warn(message))
-      def info(message: => String): F[Unit] =
-        f(logger.info(message))
-      def debug(message: => String): F[Unit] =
-        f(logger.debug(message))
-      def trace(message: => String): F[Unit] =
-        f(logger.trace(message))
+      override def isEnabled(ll: LogLevel): F[Boolean] = f(logger.isEnabled(ll))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = f(
+        logger.log(ll, t, msg)
+      )
+      override def log(ll: LogLevel, msg: => String): F[Unit] = f(logger.log(ll, msg))
     }
 
   private def withModifiedString[F[_]](
@@ -72,21 +50,10 @@ object SelfAwareLogger {
       f: String => String
   ): SelfAwareLogger[F] =
     new SelfAwareLogger[F] {
-      override def isTraceEnabled: F[Boolean] = l.isTraceEnabled
-      override def isDebugEnabled: F[Boolean] = l.isDebugEnabled
-      override def isInfoEnabled: F[Boolean] = l.isInfoEnabled
-      override def isWarnEnabled: F[Boolean] = l.isWarnEnabled
-      override def isErrorEnabled: F[Boolean] = l.isErrorEnabled
+      override def isEnabled(ll: LogLevel): F[Boolean] = l.isEnabled(ll)
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = l.log(ll, t, f(msg))
 
-      override def error(message: => String): F[Unit] = l.error(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = l.error(t)(f(message))
-      override def warn(message: => String): F[Unit] = l.warn(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = l.warn(t)(f(message))
-      override def info(message: => String): F[Unit] = l.info(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = l.info(t)(f(message))
-      override def debug(message: => String): F[Unit] = l.debug(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = l.debug(t)(f(message))
-      override def trace(message: => String): F[Unit] = l.trace(f(message))
-      override def trace(t: Throwable)(message: => String): F[Unit] = l.trace(t)(f(message))
+      override def log(ll: LogLevel, msg: => String): F[Unit] = l.log(ll, f(msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareStructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareStructuredLogger.scala
index 40907bcf..d92021d4 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareStructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/SelfAwareStructuredLogger.scala
@@ -18,6 +18,7 @@ package org.typelevel.log4cats
 
 import cats.*
 import cats.Show.Shown
+import org.typelevel.log4cats.extras.LogLevel
 
 trait SelfAwareStructuredLogger[F[_]] extends SelfAwareLogger[F] with StructuredLogger[F] {
   override def mapK[G[_]](fk: F ~> G): SelfAwareStructuredLogger[G] =
@@ -49,49 +50,25 @@ object SelfAwareStructuredLogger {
       modify: Map[String, String] => Map[String, String]
   ) extends SelfAwareStructuredLogger[F] {
     private lazy val defaultCtx: Map[String, String] = modify(Map.empty)
-    def error(message: => String): F[Unit] = sl.error(defaultCtx)(message)
-    def warn(message: => String): F[Unit] = sl.warn(defaultCtx)(message)
-    def info(message: => String): F[Unit] = sl.info(defaultCtx)(message)
-    def debug(message: => String): F[Unit] = sl.debug(defaultCtx)(message)
-    def trace(message: => String): F[Unit] = sl.trace(defaultCtx)(message)
-    def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.trace(modify(ctx))(msg)
-    def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.debug(modify(ctx))(msg)
-    def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.info(modify(ctx))(msg)
-    def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.warn(modify(ctx))(msg)
-    def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.error(modify(ctx))(msg)
-
-    def isTraceEnabled: F[Boolean] = sl.isTraceEnabled
-    def isDebugEnabled: F[Boolean] = sl.isDebugEnabled
-    def isInfoEnabled: F[Boolean] = sl.isInfoEnabled
-    def isWarnEnabled: F[Boolean] = sl.isWarnEnabled
-    def isErrorEnabled: F[Boolean] = sl.isErrorEnabled
-
-    def error(t: Throwable)(message: => String): F[Unit] =
-      sl.error(defaultCtx, t)(message)
-    def warn(t: Throwable)(message: => String): F[Unit] =
-      sl.warn(defaultCtx, t)(message)
-    def info(t: Throwable)(message: => String): F[Unit] =
-      sl.info(defaultCtx, t)(message)
-    def debug(t: Throwable)(message: => String): F[Unit] =
-      sl.debug(defaultCtx, t)(message)
-    def trace(t: Throwable)(message: => String): F[Unit] =
-      sl.trace(defaultCtx, t)(message)
-
-    def error(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.error(modify(ctx), t)(message)
-    def warn(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.warn(modify(ctx), t)(message)
-    def info(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.info(modify(ctx), t)(message)
-    def debug(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.debug(modify(ctx), t)(message)
-    def trace(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.trace(modify(ctx), t)(message)
+
+    override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+      sl.log(ll, modify(ctx), msg)
+
+    override def log(
+        ll: LogLevel,
+        ctx: Map[String, String],
+        t: Throwable,
+        msg: => String
+    ): F[Unit] =
+      sl.log(ll, modify(ctx), t, msg)
+
+    override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+      sl.log(ll, defaultCtx, t, msg)
+
+    override def log(ll: LogLevel, msg: => String): F[Unit] =
+      sl.log(ll, defaultCtx, msg)
+
+    override def isEnabled(ll: LogLevel): F[Boolean] = sl.isEnabled(ll)
   }
 
   private def withModifiedString[F[_]](
@@ -99,95 +76,47 @@ object SelfAwareStructuredLogger {
       f: String => String
   ): SelfAwareStructuredLogger[F] =
     new SelfAwareStructuredLogger[F] {
-      def isTraceEnabled: F[Boolean] = l.isTraceEnabled
-      def isDebugEnabled: F[Boolean] = l.isDebugEnabled
-      def isInfoEnabled: F[Boolean] = l.isInfoEnabled
-      def isWarnEnabled: F[Boolean] = l.isWarnEnabled
-      def isErrorEnabled: F[Boolean] = l.isErrorEnabled
-
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] = l.trace(ctx)(f(msg))
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.trace(ctx, t)(f(msg))
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] = l.debug(ctx)(f(msg))
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.debug(ctx, t)(f(msg))
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] = l.info(ctx)(f(msg))
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.info(ctx, t)(f(msg))
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] = l.warn(ctx)(f(msg))
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.warn(ctx, t)(f(msg))
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] = l.error(ctx)(f(msg))
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.error(ctx, t)(f(msg))
-      override def error(message: => String): F[Unit] = l.error(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = l.error(t)(f(message))
-      override def warn(message: => String): F[Unit] = l.warn(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = l.warn(t)(f(message))
-      override def info(message: => String): F[Unit] = l.info(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = l.info(t)(f(message))
-      override def debug(message: => String): F[Unit] = l.debug(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = l.debug(t)(f(message))
-      override def trace(message: => String): F[Unit] = l.trace(f(message))
-      override def trace(t: Throwable)(message: => String): F[Unit] = l.trace(t)(f(message))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        l.log(ll, ctx, f(msg))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        l.log(ll, ctx, t, f(msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        l.log(ll, t, f(msg))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        l.log(ll, f(msg))
+
+      override def isEnabled(ll: LogLevel): F[Boolean] = l.isEnabled(ll)
     }
 
   private def mapK[G[_], F[_]](
       f: G ~> F
   )(logger: SelfAwareStructuredLogger[G]): SelfAwareStructuredLogger[F] =
     new SelfAwareStructuredLogger[F] {
-      def isTraceEnabled: F[Boolean] =
-        f(logger.isTraceEnabled)
-      def isDebugEnabled: F[Boolean] =
-        f(logger.isDebugEnabled)
-      def isInfoEnabled: F[Boolean] =
-        f(logger.isInfoEnabled)
-      def isWarnEnabled: F[Boolean] =
-        f(logger.isWarnEnabled)
-      def isErrorEnabled: F[Boolean] =
-        f(logger.isErrorEnabled)
-
-      def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.trace(ctx)(msg))
-      def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.debug(ctx)(msg))
-      def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.info(ctx)(msg))
-      def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.warn(ctx)(msg))
-      def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.error(ctx)(msg))
-
-      def error(t: Throwable)(message: => String): F[Unit] =
-        f(logger.error(t)(message))
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        f(logger.warn(t)(message))
-      def info(t: Throwable)(message: => String): F[Unit] =
-        f(logger.info(t)(message))
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        f(logger.debug(t)(message))
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        f(logger.trace(t)(message))
-      def error(message: => String): F[Unit] =
-        f(logger.error(message))
-      def warn(message: => String): F[Unit] =
-        f(logger.warn(message))
-      def info(message: => String): F[Unit] =
-        f(logger.info(message))
-      def debug(message: => String): F[Unit] =
-        f(logger.debug(message))
-      def trace(message: => String): F[Unit] =
-        f(logger.trace(message))
-
-      def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.trace(ctx, t)(msg))
-      def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.debug(ctx, t)(msg))
-      def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.info(ctx, t)(msg))
-      def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.warn(ctx, t)(msg))
-      def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.error(ctx, t)(msg))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        f(logger.log(ll, ctx, msg))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        f(logger.log(ll, ctx, t, msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        f(logger.log(ll, t, msg))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        f(logger.log(ll, msg))
+
+      override def isEnabled(ll: LogLevel): F[Boolean] = f(logger.isEnabled(ll))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/StructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/StructuredLogger.scala
index ee50e011..c1526be2 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/StructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/StructuredLogger.scala
@@ -18,18 +18,28 @@ package org.typelevel.log4cats
 
 import cats.*
 import cats.Show.Shown
+import org.typelevel.log4cats.extras.LogLevel
 
 trait StructuredLogger[F[_]] extends Logger[F] {
-  def trace(ctx: Map[String, String])(msg: => String): F[Unit]
-  def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit]
-  def debug(ctx: Map[String, String])(msg: => String): F[Unit]
-  def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit]
-  def info(ctx: Map[String, String])(msg: => String): F[Unit]
-  def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit]
-  def warn(ctx: Map[String, String])(msg: => String): F[Unit]
-  def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit]
-  def error(ctx: Map[String, String])(msg: => String): F[Unit]
-  def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit]
+  def trace(ctx: Map[String, String])(msg: => String): F[Unit] = log(LogLevel.Trace, ctx, msg)
+  def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
+    log(LogLevel.Trace, ctx, t, msg)
+  def debug(ctx: Map[String, String])(msg: => String): F[Unit] = log(LogLevel.Debug, ctx, msg)
+  def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
+    log(LogLevel.Debug, ctx, t, msg)
+  def info(ctx: Map[String, String])(msg: => String): F[Unit] = log(LogLevel.Info, ctx, msg)
+  def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
+    log(LogLevel.Info, ctx, t, msg)
+  def warn(ctx: Map[String, String])(msg: => String): F[Unit] = log(LogLevel.Warn, ctx, msg)
+  def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
+    log(LogLevel.Warn, ctx, t, msg)
+  def error(ctx: Map[String, String])(msg: => String): F[Unit] = log(LogLevel.Error, ctx, msg)
+  def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
+    log(LogLevel.Error, ctx, t, msg)
+
+  def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit]
+  def log(ll: LogLevel, ctx: Map[String, String], t: Throwable, msg: => String): F[Unit]
+
   override def mapK[G[_]](fk: F ~> G): StructuredLogger[G] =
     StructuredLogger.mapK(fk)(this)
 
@@ -62,43 +72,23 @@ object StructuredLogger {
       modify: Map[String, String] => Map[String, String]
   ) extends StructuredLogger[F] {
     private lazy val defaultCtx: Map[String, String] = modify(Map.empty)
-    def error(message: => String): F[Unit] = sl.error(defaultCtx)(message)
-    def warn(message: => String): F[Unit] = sl.warn(defaultCtx)(message)
-    def info(message: => String): F[Unit] = sl.info(defaultCtx)(message)
-    def debug(message: => String): F[Unit] = sl.debug(defaultCtx)(message)
-    def trace(message: => String): F[Unit] = sl.trace(defaultCtx)(message)
-    def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.trace(modify(ctx))(msg)
-    def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.debug(modify(ctx))(msg)
-    def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.info(modify(ctx))(msg)
-    def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.warn(modify(ctx))(msg)
-    def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-      sl.error(modify(ctx))(msg)
-
-    def error(t: Throwable)(message: => String): F[Unit] =
-      sl.error(defaultCtx, t)(message)
-    def warn(t: Throwable)(message: => String): F[Unit] =
-      sl.warn(defaultCtx, t)(message)
-    def info(t: Throwable)(message: => String): F[Unit] =
-      sl.info(defaultCtx, t)(message)
-    def debug(t: Throwable)(message: => String): F[Unit] =
-      sl.debug(defaultCtx, t)(message)
-    def trace(t: Throwable)(message: => String): F[Unit] =
-      sl.trace(defaultCtx, t)(message)
-
-    def error(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.error(modify(ctx), t)(message)
-    def warn(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.warn(modify(ctx), t)(message)
-    def info(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.info(modify(ctx), t)(message)
-    def debug(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.debug(modify(ctx), t)(message)
-    def trace(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-      sl.trace(modify(ctx), t)(message)
+
+    override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+      sl.log(ll, modify(ctx), msg)
+
+    override def log(
+        ll: LogLevel,
+        ctx: Map[String, String],
+        t: Throwable,
+        msg: => String
+    ): F[Unit] =
+      sl.log(ll, modify(ctx), t, msg)
+
+    override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+      sl.log(ll, defaultCtx, t, msg)
+
+    override def log(ll: LogLevel, msg: => String): F[Unit] =
+      sl.log(ll, defaultCtx, msg)
   }
 
   private def withModifiedString[F[_]](
@@ -106,76 +96,41 @@ object StructuredLogger {
       f: String => String
   ): StructuredLogger[F] =
     new StructuredLogger[F] {
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] = l.trace(ctx)(f(msg))
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.trace(ctx, t)(f(msg))
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] = l.debug(ctx)(f(msg))
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.debug(ctx, t)(f(msg))
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] = l.info(ctx)(f(msg))
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.info(ctx, t)(f(msg))
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] = l.warn(ctx)(f(msg))
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.warn(ctx, t)(f(msg))
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] = l.error(ctx)(f(msg))
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        l.error(ctx, t)(f(msg))
-      override def error(message: => String): F[Unit] = l.error(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = l.error(t)(f(message))
-      override def warn(message: => String): F[Unit] = l.warn(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = l.warn(t)(f(message))
-      override def info(message: => String): F[Unit] = l.info(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = l.info(t)(f(message))
-      override def debug(message: => String): F[Unit] = l.debug(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = l.debug(t)(f(message))
-      override def trace(message: => String): F[Unit] = l.trace(f(message))
-      override def trace(t: Throwable)(message: => String): F[Unit] = l.trace(t)(f(message))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        l.log(ll, ctx, f(msg))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        l.log(ll, ctx, t, f(msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        l.log(ll, t, f(msg))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        l.log(ll, f(msg))
     }
 
   private def mapK[G[_], F[_]](f: G ~> F)(logger: StructuredLogger[G]): StructuredLogger[F] =
     new StructuredLogger[F] {
-      def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.trace(ctx)(msg))
-      def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.debug(ctx)(msg))
-      def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.info(ctx)(msg))
-      def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.warn(ctx)(msg))
-      def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        f(logger.error(ctx)(msg))
-
-      def error(t: Throwable)(message: => String): F[Unit] =
-        f(logger.error(t)(message))
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        f(logger.warn(t)(message))
-      def info(t: Throwable)(message: => String): F[Unit] =
-        f(logger.info(t)(message))
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        f(logger.debug(t)(message))
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        f(logger.trace(t)(message))
-      def error(message: => String): F[Unit] =
-        f(logger.error(message))
-      def warn(message: => String): F[Unit] =
-        f(logger.warn(message))
-      def info(message: => String): F[Unit] =
-        f(logger.info(message))
-      def debug(message: => String): F[Unit] =
-        f(logger.debug(message))
-      def trace(message: => String): F[Unit] =
-        f(logger.trace(message))
-
-      def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.trace(ctx, t)(msg))
-      def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.debug(ctx, t)(msg))
-      def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.info(ctx, t)(msg))
-      def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.warn(ctx, t)(msg))
-      def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        f(logger.error(ctx, t)(msg))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        f(logger.log(ll, ctx, msg))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        f(logger.log(ll, ctx, t, msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        f(logger.log(ll, t, msg))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        f(logger.log(ll, msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredLogger.scala
index d8ac9c60..b6f260a4 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredLogger.scala
@@ -66,31 +66,15 @@ object DeferredLogger {
         new DeferredLogger[F] {
           private def save(lm: DeferredLogMessage): F[Unit] = ref.update(_.append(lm))
 
-          override def trace(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(Map.empty, t.some, () => msg))
-          override def debug(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(Map.empty, t.some, () => msg))
-          override def info(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(Map.empty, t.some, () => msg))
-          override def warn(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(Map.empty, t.some, () => msg))
-          override def error(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(Map.empty, t.some, () => msg))
-
-          override def trace(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(Map.empty, none, () => msg))
-          override def debug(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(Map.empty, none, () => msg))
-          override def info(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(Map.empty, none, () => msg))
-          override def warn(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(Map.empty, none, () => msg))
-          override def error(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(Map.empty, none, () => msg))
-
           override def inspect: F[Chain[DeferredLogMessage]] = ref.get
 
           override def log: F[Unit] = ref.getAndSet(Chain.empty).flatMap(_.traverse_(_.log(logger)))
+
+          override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+            save(DeferredLogMessage(ll, Map.empty, t.some, () => msg))
+
+          override def log(ll: LogLevel, msg: => String): F[Unit] =
+            save(DeferredLogMessage(ll, Map.empty, none, () => msg))
         }
       }
 
@@ -100,23 +84,14 @@ object DeferredLogger {
   ): DeferredLogger[G] =
     new DeferredLogger[G] {
       override def inspect: G[Chain[DeferredLogMessage]] = fk(logger.inspect)
-      override def log: G[Unit] = fk(logger.log)
 
-      override def trace(t: Throwable)(message: => String): G[Unit] = fk(logger.trace(t)(message))
-      override def debug(t: Throwable)(message: => String): G[Unit] = fk(logger.debug(t)(message))
-      override def info(t: Throwable)(message: => String): G[Unit] = fk(logger.info(t)(message))
-      override def warn(t: Throwable)(message: => String): G[Unit] = fk(logger.warn(t)(message))
-      override def error(t: Throwable)(message: => String): G[Unit] = fk(logger.error(t)(message))
+      override def log: G[Unit] = fk(logger.log)
 
-      override def trace(message: => String): G[Unit] = fk(logger.trace(message))
-      override def debug(message: => String): G[Unit] = fk(logger.debug(message))
-      override def info(message: => String): G[Unit] = fk(logger.info(message))
-      override def warn(message: => String): G[Unit] = fk(logger.warn(message))
-      override def error(message: => String): G[Unit] = fk(logger.error(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): G[Unit] = fk(
+        logger.log(ll, t, msg)
+      )
 
-      override def withModifiedString(f: String => String): DeferredLogger[G] =
-        DeferredLogger.withModifiedString(this, f)
-      override def mapK[H[_]](fk: G ~> H): DeferredLogger[H] = DeferredLogger.mapK(this, fk)
+      override def log(ll: LogLevel, msg: => String): G[Unit] = fk(logger.log(ll, msg))
     }
 
   def withModifiedString[F[_]](
@@ -125,18 +100,12 @@ object DeferredLogger {
   ): DeferredLogger[F] =
     new DeferredLogger[F] {
       override def inspect: F[Chain[DeferredLogMessage]] = logger.inspect
+
       override def log: F[Unit] = logger.log
 
-      override def trace(t: Throwable)(message: => String): F[Unit] = logger.trace(t)(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = logger.debug(t)(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = logger.info(t)(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = logger.warn(t)(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = logger.error(t)(f(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        logger.log(ll, t, f(msg))
 
-      override def trace(message: => String): F[Unit] = logger.trace(f(message))
-      override def debug(message: => String): F[Unit] = logger.debug(f(message))
-      override def info(message: => String): F[Unit] = logger.info(f(message))
-      override def warn(message: => String): F[Unit] = logger.warn(f(message))
-      override def error(message: => String): F[Unit] = logger.error(f(message))
+      override def log(ll: LogLevel, msg: => String): F[Unit] = logger.log(ll, f(msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredSelfAwareStructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredSelfAwareStructuredLogger.scala
index 778305db..c9a0f4d1 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredSelfAwareStructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredSelfAwareStructuredLogger.scala
@@ -58,77 +58,11 @@ object DeferredSelfAwareStructuredLogger {
       stash: Ref[F, Chain[(DeferredLogMessage, SelfAwareStructuredLogger[F])]]
   ): DeferredSelfAwareStructuredLogger[F] =
     new DeferredSelfAwareStructuredLogger[F] {
+      override def isEnabled(ll: LogLevel): F[Boolean] = logger.isEnabled(ll)
+
       private def save(lm: DeferredLogMessage): F[Unit] =
         stash.update(_.append(lm -> logger))
 
-      override def isTraceEnabled: F[Boolean] = logger.isTraceEnabled
-      override def isDebugEnabled: F[Boolean] = logger.isDebugEnabled
-      override def isInfoEnabled: F[Boolean] = logger.isInfoEnabled
-      override def isWarnEnabled: F[Boolean] = logger.isWarnEnabled
-      override def isErrorEnabled: F[Boolean] = logger.isErrorEnabled
-
-      private def saveTrace(
-          c: Map[String, String],
-          t: Option[Throwable],
-          m: () => String
-      ): F[Unit] =
-        isTraceEnabled.flatMap(save(DeferredLogMessage.trace(c, t, m)).whenA(_))
-      private def saveDebug(
-          c: Map[String, String],
-          t: Option[Throwable],
-          m: () => String
-      ): F[Unit] =
-        isDebugEnabled.flatMap(save(DeferredLogMessage.debug(c, t, m)).whenA(_))
-      private def saveInfo(c: Map[String, String], t: Option[Throwable], m: () => String): F[Unit] =
-        isInfoEnabled.flatMap(save(DeferredLogMessage.info(c, t, m)).whenA(_))
-      private def saveWarn(c: Map[String, String], t: Option[Throwable], m: () => String): F[Unit] =
-        isWarnEnabled.flatMap(save(DeferredLogMessage.warn(c, t, m)).whenA(_))
-      private def saveError(
-          c: Map[String, String],
-          t: Option[Throwable],
-          m: () => String
-      ): F[Unit] =
-        isErrorEnabled.flatMap(save(DeferredLogMessage.error(c, t, m)).whenA(_))
-
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        saveTrace(ctx, none, () => msg)
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        saveDebug(ctx, none, () => msg)
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        saveInfo(ctx, none, () => msg)
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        saveWarn(ctx, none, () => msg)
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        saveError(ctx, none, () => msg)
-
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        saveTrace(ctx, t.some, () => msg)
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        saveDebug(ctx, t.some, () => msg)
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        saveInfo(ctx, t.some, () => msg)
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        saveWarn(ctx, t.some, () => msg)
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        saveError(ctx, t.some, () => msg)
-
-      override def trace(t: Throwable)(msg: => String): F[Unit] =
-        saveTrace(Map.empty, t.some, () => msg)
-      override def debug(t: Throwable)(msg: => String): F[Unit] =
-        saveDebug(Map.empty, t.some, () => msg)
-      override def info(t: Throwable)(msg: => String): F[Unit] =
-        saveInfo(Map.empty, t.some, () => msg)
-      override def warn(t: Throwable)(msg: => String): F[Unit] =
-        saveWarn(Map.empty, t.some, () => msg)
-      override def error(t: Throwable)(msg: => String): F[Unit] =
-        saveError(Map.empty, t.some, () => msg)
-
-      override def trace(msg: => String): F[Unit] = saveTrace(Map.empty, none, () => msg)
-      override def debug(msg: => String): F[Unit] = saveDebug(Map.empty, none, () => msg)
-      override def info(msg: => String): F[Unit] = saveInfo(Map.empty, none, () => msg)
-      override def warn(msg: => String): F[Unit] = saveWarn(Map.empty, none, () => msg)
-      override def error(msg: => String): F[Unit] = saveError(Map.empty, none, () => msg)
-
       override def inspect: F[Chain[DeferredLogMessage]] = stash.get.map(_._1F)
 
       override def log: F[Unit] = stash
@@ -136,6 +70,23 @@ object DeferredSelfAwareStructuredLogger {
         .flatMap(_.traverse_ { case (msg, logger) =>
           msg.logStructured(logger)
         })
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        isEnabled(ll).flatMap(save(DeferredLogMessage(ll, ctx, t.some, () => msg)).whenA(_))
+
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        isEnabled(ll).flatMap(save(DeferredLogMessage(ll, ctx, none, () => msg)).whenA(_))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        isEnabled(ll).flatMap(save(DeferredLogMessage(ll, Map.empty, t.some, () => msg)).whenA(_))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        isEnabled(ll).flatMap(save(DeferredLogMessage(ll, Map.empty, none, () => msg)).whenA(_))
     }
 
   private[extras] def makeCache[F[_]](implicit
@@ -156,113 +107,58 @@ object DeferredSelfAwareStructuredLogger {
       fk: F ~> G
   ): DeferredSelfAwareStructuredLogger[G] =
     new DeferredSelfAwareStructuredLogger[G] {
-      override def inspect: G[Chain[DeferredLogMessage]] = fk(
-        logger.inspect
-      )
+      override def isEnabled(ll: LogLevel): G[Boolean] = fk(logger.isEnabled(ll))
+
+      override def inspect: G[Chain[DeferredLogMessage]] = fk(logger.inspect)
+
       override def log: G[Unit] = fk(logger.log)
-      override def isTraceEnabled: G[Boolean] = fk(logger.isTraceEnabled)
-      override def isDebugEnabled: G[Boolean] = fk(logger.isDebugEnabled)
-      override def isInfoEnabled: G[Boolean] = fk(logger.isInfoEnabled)
-      override def isWarnEnabled: G[Boolean] = fk(logger.isWarnEnabled)
-      override def isErrorEnabled: G[Boolean] = fk(logger.isErrorEnabled)
-
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] = fk(
-        logger.trace(ctx, t)(msg)
-      )
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] = fk(
-        logger.debug(ctx, t)(msg)
-      )
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] = fk(
-        logger.info(ctx, t)(msg)
-      )
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] = fk(
-        logger.warn(ctx, t)(msg)
-      )
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] = fk(
-        logger.error(ctx, t)(msg)
-      )
 
-      override def trace(ctx: Map[String, String])(msg: => String): G[Unit] = fk(
-        logger.trace(ctx)(msg)
-      )
-      override def debug(ctx: Map[String, String])(msg: => String): G[Unit] = fk(
-        logger.debug(ctx)(msg)
-      )
-      override def info(ctx: Map[String, String])(msg: => String): G[Unit] = fk(
-        logger.info(ctx)(msg)
-      )
-      override def warn(ctx: Map[String, String])(msg: => String): G[Unit] = fk(
-        logger.warn(ctx)(msg)
-      )
-      override def error(ctx: Map[String, String])(msg: => String): G[Unit] = fk(
-        logger.error(ctx)(msg)
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): G[Unit] =
+        fk(logger.log(ll, ctx, t, msg))
+
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): G[Unit] =
+        fk(logger.log(ll, ctx, msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): G[Unit] = fk(
+        logger.log(ll, t, msg)
       )
 
-      override def trace(t: Throwable)(message: => String): G[Unit] = fk(logger.trace(t)(message))
-      override def debug(t: Throwable)(message: => String): G[Unit] = fk(logger.debug(t)(message))
-      override def info(t: Throwable)(message: => String): G[Unit] = fk(logger.info(t)(message))
-      override def warn(t: Throwable)(message: => String): G[Unit] = fk(logger.warn(t)(message))
-      override def error(t: Throwable)(message: => String): G[Unit] = fk(logger.error(t)(message))
-
-      override def trace(message: => String): G[Unit] = fk(logger.trace(message))
-      override def debug(message: => String): G[Unit] = fk(logger.debug(message))
-      override def info(message: => String): G[Unit] = fk(logger.info(message))
-      override def warn(message: => String): G[Unit] = fk(logger.warn(message))
-      override def error(message: => String): G[Unit] = fk(logger.error(message))
+      override def log(ll: LogLevel, msg: => String): G[Unit] = fk(logger.log(ll, msg))
     }
 
   def withContext[F[_]](
       logger: DeferredSelfAwareStructuredLogger[F]
   )(baseCtx: Map[String, String]): DeferredSelfAwareStructuredLogger[F] =
     new DeferredSelfAwareStructuredLogger[F] {
-      private def addCtx(ctx: Map[String, String]): Map[String, String] = baseCtx ++ ctx
+      override def isEnabled(ll: LogLevel): F[Boolean] = logger.isEnabled(ll)
 
       override def inspect: F[Chain[DeferredLogMessage]] = logger.inspect
+
       override def log: F[Unit] = logger.log
-      override def isTraceEnabled: F[Boolean] = logger.isTraceEnabled
-      override def isDebugEnabled: F[Boolean] = logger.isDebugEnabled
-      override def isInfoEnabled: F[Boolean] = logger.isInfoEnabled
-      override def isWarnEnabled: F[Boolean] = logger.isWarnEnabled
-      override def isErrorEnabled: F[Boolean] = logger.isErrorEnabled
-
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.trace(addCtx(ctx), t)(msg)
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.debug(addCtx(ctx), t)(msg)
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.info(addCtx(ctx), t)(msg)
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.warn(addCtx(ctx), t)(msg)
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.error(addCtx(ctx), t)(msg)
-
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.trace(addCtx(ctx))(msg)
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.debug(addCtx(ctx))(msg)
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.info(addCtx(ctx))(msg)
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.warn(addCtx(ctx))(msg)
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.error(addCtx(ctx))(msg)
-
-      override def trace(t: Throwable)(message: => String): F[Unit] =
-        logger.trace(baseCtx, t)(message)
-      override def debug(t: Throwable)(message: => String): F[Unit] =
-        logger.debug(baseCtx, t)(message)
-      override def info(t: Throwable)(message: => String): F[Unit] =
-        logger.info(baseCtx, t)(message)
-      override def warn(t: Throwable)(message: => String): F[Unit] =
-        logger.warn(baseCtx, t)(message)
-      override def error(t: Throwable)(message: => String): F[Unit] =
-        logger.error(baseCtx, t)(message)
-
-      override def trace(message: => String): F[Unit] = logger.trace(baseCtx)(message)
-      override def debug(message: => String): F[Unit] = logger.debug(baseCtx)(message)
-      override def info(message: => String): F[Unit] = logger.info(baseCtx)(message)
-      override def warn(message: => String): F[Unit] = logger.warn(baseCtx)(message)
-      override def error(message: => String): F[Unit] = logger.error(baseCtx)(message)
+
+      private def addCtx(ctx: Map[String, String]): Map[String, String] = baseCtx ++ ctx
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        logger.log(ll, addCtx(ctx), t, msg)
+
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        logger.log(ll, addCtx(ctx), msg)
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        logger.log(ll, t, msg)
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        logger.log(ll, msg)
     }
 
   def withModifiedString[F[_]](
@@ -270,46 +166,25 @@ object DeferredSelfAwareStructuredLogger {
       f: String => String
   ): DeferredSelfAwareStructuredLogger[F] =
     new DeferredSelfAwareStructuredLogger[F] {
+      override def isEnabled(ll: LogLevel): F[Boolean] = logger.isEnabled(ll)
+
       override def inspect: F[Chain[DeferredLogMessage]] = logger.inspect
+
       override def log: F[Unit] = logger.log
-      override def isTraceEnabled: F[Boolean] = logger.isTraceEnabled
-      override def isDebugEnabled: F[Boolean] = logger.isDebugEnabled
-      override def isInfoEnabled: F[Boolean] = logger.isInfoEnabled
-      override def isWarnEnabled: F[Boolean] = logger.isWarnEnabled
-      override def isErrorEnabled: F[Boolean] = logger.isErrorEnabled
-
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.trace(ctx, t)(f(msg))
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.debug(ctx, t)(f(msg))
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.info(ctx, t)(f(msg))
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.warn(ctx, t)(f(msg))
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.error(ctx, t)(f(msg))
-
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.trace(ctx)(f(msg))
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.debug(ctx)(f(msg))
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.info(ctx)(f(msg))
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.warn(ctx)(f(msg))
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.error(ctx)(f(msg))
-
-      override def trace(t: Throwable)(message: => String): F[Unit] = logger.trace(t)(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = logger.debug(t)(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = logger.info(t)(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = logger.warn(t)(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = logger.error(t)(f(message))
-
-      override def trace(message: => String): F[Unit] = logger.trace(f(message))
-      override def debug(message: => String): F[Unit] = logger.debug(f(message))
-      override def info(message: => String): F[Unit] = logger.info(f(message))
-      override def warn(message: => String): F[Unit] = logger.warn(f(message))
-      override def error(message: => String): F[Unit] = logger.error(f(message))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] = logger.log(ll, ctx, t, f(msg))
+
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        logger.log(ll, ctx, f(msg))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        logger.log(ll, t, f(msg))
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] = logger.log(ll, f(msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredStructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredStructuredLogger.scala
index 1c0855bc..3d472a2e 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredStructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/extras/DeferredStructuredLogger.scala
@@ -79,54 +79,27 @@ object DeferredStructuredLogger {
         new DeferredStructuredLogger[F] {
           private def save(lm: DeferredLogMessage): F[Unit] = ref.update(_.append(lm))
 
-          override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(ctx, none, () => msg))
-          override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(ctx, none, () => msg))
-          override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(ctx, none, () => msg))
-          override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(ctx, none, () => msg))
-          override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(ctx, none, () => msg))
+          override def inspect: F[Chain[DeferredLogMessage]] = ref.get
 
-          override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(ctx, t.some, () => msg))
-          override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(ctx, t.some, () => msg))
-          override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(ctx, t.some, () => msg))
-          override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(ctx, t.some, () => msg))
-          override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(ctx, t.some, () => msg))
+          override def log: F[Unit] =
+            ref.getAndSet(Chain.empty).flatMap(_.traverse_(_.logStructured(logger)))
 
-          override def trace(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(Map.empty, t.some, () => msg))
-          override def debug(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(Map.empty, t.some, () => msg))
-          override def info(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(Map.empty, t.some, () => msg))
-          override def warn(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(Map.empty, t.some, () => msg))
-          override def error(t: Throwable)(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(Map.empty, t.some, () => msg))
+          override def log(
+              ll: LogLevel,
+              ctx: Map[String, String],
+              t: Throwable,
+              msg: => String
+          ): F[Unit] =
+            save(DeferredLogMessage(ll, ctx, t.some, () => msg))
 
-          override def trace(msg: => String): F[Unit] =
-            save(DeferredLogMessage.trace(Map.empty, none, () => msg))
-          override def debug(msg: => String): F[Unit] =
-            save(DeferredLogMessage.debug(Map.empty, none, () => msg))
-          override def info(msg: => String): F[Unit] =
-            save(DeferredLogMessage.info(Map.empty, none, () => msg))
-          override def warn(msg: => String): F[Unit] =
-            save(DeferredLogMessage.warn(Map.empty, none, () => msg))
-          override def error(msg: => String): F[Unit] =
-            save(DeferredLogMessage.error(Map.empty, none, () => msg))
+          override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+            save(DeferredLogMessage(ll, ctx, none, () => msg))
 
-          override def inspect: F[Chain[DeferredLogMessage]] = ref.get
+          override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+            save(DeferredLogMessage(ll, Map.empty, t.some, () => msg))
 
-          override def log: F[Unit] =
-            ref.getAndSet(Chain.empty).flatMap(_.traverse_(_.logStructured(logger)))
+          override def log(ll: LogLevel, msg: => String): F[Unit] =
+            save(DeferredLogMessage(ll, Map.empty, none, () => msg))
         }
       }
 
@@ -138,39 +111,22 @@ object DeferredStructuredLogger {
       override def inspect: G[Chain[DeferredLogMessage]] = fk(logger.inspect)
       override def log: G[Unit] = fk(logger.log)
 
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] =
-        fk(logger.trace(ctx, t)(msg))
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] =
-        fk(logger.debug(ctx, t)(msg))
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] =
-        fk(logger.info(ctx, t)(msg))
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] =
-        fk(logger.warn(ctx, t)(msg))
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): G[Unit] =
-        fk(logger.error(ctx, t)(msg))
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): G[Unit] =
+        fk(logger.log(ll, ctx, t, msg))
 
-      override def trace(ctx: Map[String, String])(msg: => String): G[Unit] =
-        fk(logger.trace(ctx)(msg))
-      override def debug(ctx: Map[String, String])(msg: => String): G[Unit] =
-        fk(logger.debug(ctx)(msg))
-      override def info(ctx: Map[String, String])(msg: => String): G[Unit] =
-        fk(logger.info(ctx)(msg))
-      override def warn(ctx: Map[String, String])(msg: => String): G[Unit] =
-        fk(logger.warn(ctx)(msg))
-      override def error(ctx: Map[String, String])(msg: => String): G[Unit] =
-        fk(logger.error(ctx)(msg))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): G[Unit] =
+        fk(logger.log(ll, ctx, msg))
 
-      override def trace(t: Throwable)(message: => String): G[Unit] = fk(logger.trace(t)(message))
-      override def debug(t: Throwable)(message: => String): G[Unit] = fk(logger.debug(t)(message))
-      override def info(t: Throwable)(message: => String): G[Unit] = fk(logger.info(t)(message))
-      override def warn(t: Throwable)(message: => String): G[Unit] = fk(logger.warn(t)(message))
-      override def error(t: Throwable)(message: => String): G[Unit] = fk(logger.error(t)(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): G[Unit] = fk(
+        logger.log(ll, t, msg)
+      )
 
-      override def trace(message: => String): G[Unit] = fk(logger.trace(message))
-      override def debug(message: => String): G[Unit] = fk(logger.debug(message))
-      override def info(message: => String): G[Unit] = fk(logger.info(message))
-      override def warn(message: => String): G[Unit] = fk(logger.warn(message))
-      override def error(message: => String): G[Unit] = fk(logger.error(message))
+      override def log(ll: LogLevel, msg: => String): G[Unit] = fk(logger.log(ll, msg))
     }
 
   def withContext[F[_]](
@@ -181,46 +137,25 @@ object DeferredStructuredLogger {
       private def addCtx(ctx: Map[String, String]): Map[String, String] = baseCtx ++ ctx
 
       override def inspect: F[Chain[DeferredLogMessage]] = logger.inspect
+
       override def log: F[Unit] = logger.log
 
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.trace(addCtx(ctx), t)(msg)
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.debug(addCtx(ctx), t)(msg)
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.info(addCtx(ctx), t)(msg)
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.warn(addCtx(ctx), t)(msg)
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.error(addCtx(ctx), t)(msg)
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] =
+        logger.log(ll, addCtx(ctx), t, msg)
 
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.trace(addCtx(ctx))(msg)
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.debug(addCtx(ctx))(msg)
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.info(addCtx(ctx))(msg)
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.warn(addCtx(ctx))(msg)
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.error(addCtx(ctx))(msg)
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        logger.log(ll, addCtx(ctx), msg)
 
-      override def trace(t: Throwable)(message: => String): F[Unit] =
-        logger.trace(baseCtx, t)(message)
-      override def debug(t: Throwable)(message: => String): F[Unit] =
-        logger.debug(baseCtx, t)(message)
-      override def info(t: Throwable)(message: => String): F[Unit] =
-        logger.info(baseCtx, t)(message)
-      override def warn(t: Throwable)(message: => String): F[Unit] =
-        logger.warn(baseCtx, t)(message)
-      override def error(t: Throwable)(message: => String): F[Unit] =
-        logger.error(baseCtx, t)(message)
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        logger.log(ll, baseCtx, t, msg)
 
-      override def trace(message: => String): F[Unit] = logger.trace(baseCtx)(message)
-      override def debug(message: => String): F[Unit] = logger.debug(baseCtx)(message)
-      override def info(message: => String): F[Unit] = logger.info(baseCtx)(message)
-      override def warn(message: => String): F[Unit] = logger.warn(baseCtx)(message)
-      override def error(message: => String): F[Unit] = logger.error(baseCtx)(message)
+      override def log(ll: LogLevel, msg: => String): F[Unit] =
+        logger.log(ll, baseCtx, msg)
     }
 
   def withModifiedString[F[_]](
@@ -229,40 +164,22 @@ object DeferredStructuredLogger {
   ): DeferredStructuredLogger[F] =
     new DeferredStructuredLogger[F] {
       override def inspect: F[Chain[DeferredLogMessage]] = logger.inspect
+
       override def log: F[Unit] = logger.log
 
-      override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.trace(ctx, t)(f(msg))
-      override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.debug(ctx, t)(f(msg))
-      override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.info(ctx, t)(f(msg))
-      override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.warn(ctx, t)(f(msg))
-      override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-        logger.error(ctx, t)(f(msg))
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] = logger.log(ll, ctx, t, f(msg))
 
-      override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.trace(ctx)(f(msg))
-      override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.debug(ctx)(f(msg))
-      override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.info(ctx)(f(msg))
-      override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.warn(ctx)(f(msg))
-      override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-        logger.error(ctx)(f(msg))
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        logger.log(ll, ctx, f(msg))
 
-      override def trace(t: Throwable)(message: => String): F[Unit] = logger.trace(t)(f(message))
-      override def debug(t: Throwable)(message: => String): F[Unit] = logger.debug(t)(f(message))
-      override def info(t: Throwable)(message: => String): F[Unit] = logger.info(t)(f(message))
-      override def warn(t: Throwable)(message: => String): F[Unit] = logger.warn(t)(f(message))
-      override def error(t: Throwable)(message: => String): F[Unit] = logger.error(t)(f(message))
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        logger.log(ll, t, f(msg))
 
-      override def trace(message: => String): F[Unit] = logger.trace(f(message))
-      override def debug(message: => String): F[Unit] = logger.debug(f(message))
-      override def info(message: => String): F[Unit] = logger.info(f(message))
-      override def warn(message: => String): F[Unit] = logger.warn(f(message))
-      override def error(message: => String): F[Unit] = logger.error(f(message))
+      override def log(ll: LogLevel, msg: => String): F[Unit] = logger.log(ll, f(msg))
     }
 }
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTLogger.scala
index 70ecd01a..a9e034c8 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTLogger.scala
@@ -18,6 +18,7 @@ package org.typelevel.log4cats.extras
 
 import cats.*
 import cats.data.*
+import cats.kernel.Monoid
 import cats.syntax.all.*
 import org.typelevel.log4cats.*
 
@@ -40,52 +41,38 @@ object WriterTLogger {
       errorEnabled: Boolean = true
   ): SelfAwareLogger[WriterT[F, G[LogMessage], *]] =
     new SelfAwareLogger[WriterT[F, G[LogMessage], *]] {
-      override def isTraceEnabled: WriterT[F, G[LogMessage], Boolean] = isEnabled(traceEnabled)
-      override def isDebugEnabled: WriterT[F, G[LogMessage], Boolean] = isEnabled(debugEnabled)
-      override def isInfoEnabled: WriterT[F, G[LogMessage], Boolean] = isEnabled(infoEnabled)
-      override def isWarnEnabled: WriterT[F, G[LogMessage], Boolean] = isEnabled(warnEnabled)
-      override def isErrorEnabled: WriterT[F, G[LogMessage], Boolean] = isEnabled(errorEnabled)
+      type LoggerF[A] = WriterT[F, G[LogMessage], A]
 
-      override def trace(t: Throwable)(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(traceEnabled, LogLevel.Trace, t.some, message)
-      override def trace(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(traceEnabled, LogLevel.Trace, None, message)
-
-      override def debug(t: Throwable)(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(debugEnabled, LogLevel.Debug, t.some, message)
-      override def debug(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(debugEnabled, LogLevel.Debug, None, message)
-
-      override def info(t: Throwable)(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(infoEnabled, LogLevel.Info, t.some, message)
-      override def info(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(infoEnabled, LogLevel.Info, None, message)
+      private implicit val monoidGLogMessage: Monoid[G[LogMessage]] =
+        Alternative[G].algebra[LogMessage]
 
-      override def warn(t: Throwable)(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(warnEnabled, LogLevel.Warn, t.some, message)
-      override def warn(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(warnEnabled, LogLevel.Warn, None, message)
+      private def shouldLog(ll: LogLevel): Boolean = ll match {
+        case LogLevel.Error => errorEnabled
+        case LogLevel.Warn => warnEnabled
+        case LogLevel.Info => infoEnabled
+        case LogLevel.Debug => debugEnabled
+        case LogLevel.Trace => traceEnabled
+      }
 
-      override def error(t: Throwable)(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(errorEnabled, LogLevel.Error, t.some, message)
-      override def error(message: => String): WriterT[F, G[LogMessage], Unit] =
-        build(errorEnabled, LogLevel.Error, None, message)
+      private def build(level: LogLevel, t: Option[Throwable], message: => String): LoggerF[Unit] =
+        Applicative[LoggerF].whenA(shouldLog(level)) {
+          WriterT.tell[F, G[LogMessage]](Applicative[G].pure {
+            LogMessage(level, t, message)
+          })
+        }
 
-      private def isEnabled(enabled: Boolean): WriterT[F, G[LogMessage], Boolean] =
-        WriterT.liftF[F, G[LogMessage], Boolean](Applicative[F].pure(enabled))
+      override def isEnabled(ll: LogLevel): WriterT[F, G[LogMessage], Boolean] =
+        WriterT.liftF[F, G[LogMessage], Boolean](Applicative[F].pure(shouldLog(ll)))
 
-      private def build(
-          enabled: Boolean,
-          level: LogLevel,
-          t: Option[Throwable],
-          message: => String
+      override def log(
+          ll: LogLevel,
+          t: Throwable,
+          msg: => String
       ): WriterT[F, G[LogMessage], Unit] =
-        if (enabled)
-          WriterT.tell[F, G[LogMessage]](Applicative[G].pure(LogMessage(level, t, message)))
-        else WriterT.value[F, G[LogMessage], Unit](())
+        build(ll, t.some, msg)
 
-      private implicit val monoidGLogMessage: Monoid[G[LogMessage]] =
-        Alternative[G].algebra[LogMessage]
+      override def log(ll: LogLevel, msg: => String): WriterT[F, G[LogMessage], Unit] =
+        build(ll, none, msg)
     }
 
   def run[F[_]: Monad, G[_]: Foldable](l: Logger[F]): WriterT[F, G[LogMessage], *] ~> F =
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTStructuredLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTStructuredLogger.scala
index b8b218de..c5876121 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTStructuredLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/extras/WriterTStructuredLogger.scala
@@ -43,100 +43,56 @@ object WriterTStructuredLogger {
     new SelfAwareStructuredLogger[WriterT[F, G[StructuredLogMessage], *]] {
       type LoggerF[A] = WriterT[F, G[StructuredLogMessage], A]
 
-      override def isTraceEnabled: LoggerF[Boolean] = isEnabled(traceEnabled)
-
-      override def isDebugEnabled: LoggerF[Boolean] = isEnabled(debugEnabled)
-
-      override def isInfoEnabled: LoggerF[Boolean] = isEnabled(infoEnabled)
-
-      override def isWarnEnabled: LoggerF[Boolean] = isEnabled(warnEnabled)
-
-      override def isErrorEnabled: LoggerF[Boolean] = isEnabled(errorEnabled)
-
-      override def trace(t: Throwable)(message: => String): LoggerF[Unit] =
-        build(Map.empty, traceEnabled, LogLevel.Trace, t.some, message)
-
-      override def trace(message: => String): LoggerF[Unit] =
-        build(Map.empty, traceEnabled, LogLevel.Trace, None, message)
-
-      override def debug(t: Throwable)(message: => String): LoggerF[Unit] =
-        build(Map.empty, debugEnabled, LogLevel.Debug, t.some, message)
-
-      override def debug(message: => String): LoggerF[Unit] =
-        build(Map.empty, debugEnabled, LogLevel.Debug, None, message)
-
-      override def info(t: Throwable)(message: => String): LoggerF[Unit] =
-        build(Map.empty, infoEnabled, LogLevel.Info, t.some, message)
-
-      override def info(message: => String): LoggerF[Unit] =
-        build(Map.empty, infoEnabled, LogLevel.Info, None, message)
-
-      override def warn(t: Throwable)(message: => String): LoggerF[Unit] =
-        build(Map.empty, warnEnabled, LogLevel.Warn, t.some, message)
-
-      override def warn(message: => String): LoggerF[Unit] =
-        build(Map.empty, warnEnabled, LogLevel.Warn, None, message)
-
-      override def error(t: Throwable)(message: => String): LoggerF[Unit] =
-        build(Map.empty, errorEnabled, LogLevel.Error, t.some, message)
-
-      override def error(message: => String): LoggerF[Unit] =
-        build(Map.empty, errorEnabled, LogLevel.Error, None, message)
+      private implicit val monoidGLogMessage: Monoid[G[StructuredLogMessage]] =
+        Alternative[G].algebra[StructuredLogMessage]
 
-      private def isEnabled(enabled: Boolean): LoggerF[Boolean] =
-        WriterT.liftF[F, G[StructuredLogMessage], Boolean](Applicative[F].pure(enabled))
+      private def shouldLog(ll: LogLevel): Boolean = ll match {
+        case LogLevel.Error => errorEnabled
+        case LogLevel.Warn => warnEnabled
+        case LogLevel.Info => infoEnabled
+        case LogLevel.Debug => debugEnabled
+        case LogLevel.Trace => traceEnabled
+      }
 
       private def build(
-          ctx: Map[String, String],
-          enabled: Boolean,
           level: LogLevel,
+          ctx: Map[String, String],
           t: Option[Throwable],
           message: => String
       ): LoggerF[Unit] =
-        if (enabled)
+        Applicative[LoggerF].whenA(shouldLog(level)) {
           WriterT.tell[F, G[StructuredLogMessage]](Applicative[G].pure {
             StructuredLogMessage(level, ctx, t, message)
           })
-        else WriterT.value[F, G[StructuredLogMessage], Unit](())
-
-      private implicit val monoidGLogMessage: Monoid[G[StructuredLogMessage]] =
-        Alternative[G].algebra[StructuredLogMessage]
-
-      override def trace(ctx: Map[String, String])(message: => String): LoggerF[Unit] =
-        build(ctx, traceEnabled, LogLevel.Trace, None, message)
-
-      override def trace(ctx: Map[String, String], t: Throwable)(
-          message: => String
-      ): LoggerF[Unit] =
-        build(ctx, traceEnabled, LogLevel.Trace, t.some, message)
-
-      override def debug(ctx: Map[String, String])(message: => String): LoggerF[Unit] =
-        build(ctx, debugEnabled, LogLevel.Debug, None, message)
-
-      override def debug(ctx: Map[String, String], t: Throwable)(
-          message: => String
-      ): LoggerF[Unit] =
-        build(ctx, debugEnabled, LogLevel.Debug, t.some, message)
-
-      override def info(ctx: Map[String, String])(message: => String): LoggerF[Unit] =
-        build(ctx, infoEnabled, LogLevel.Info, None, message)
+        }
 
-      override def info(ctx: Map[String, String], t: Throwable)(message: => String): LoggerF[Unit] =
-        build(ctx, infoEnabled, LogLevel.Info, t.some, message)
+      override def isEnabled(ll: LogLevel): WriterT[F, G[StructuredLogMessage], Boolean] =
+        WriterT.liftF[F, G[StructuredLogMessage], Boolean](Applicative[F].pure(shouldLog(ll)))
 
-      override def warn(ctx: Map[String, String])(message: => String): LoggerF[Unit] =
-        build(ctx, warnEnabled, LogLevel.Warn, None, message)
+      override def log(ll: LogLevel, msg: => String): WriterT[F, G[StructuredLogMessage], Unit] =
+        build(ll, Map.empty, none, msg)
 
-      override def warn(ctx: Map[String, String], t: Throwable)(message: => String): LoggerF[Unit] =
-        build(ctx, warnEnabled, LogLevel.Warn, t.some, message)
+      override def log(
+          ll: LogLevel,
+          t: Throwable,
+          msg: => String
+      ): WriterT[F, G[StructuredLogMessage], Unit] =
+        build(ll, Map.empty, t.some, msg)
 
-      override def error(ctx: Map[String, String])(message: => String): LoggerF[Unit] =
-        build(ctx, errorEnabled, LogLevel.Error, None, message)
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          msg: => String
+      ): WriterT[F, G[StructuredLogMessage], Unit] =
+        build(ll, ctx, none, msg)
 
-      override def error(ctx: Map[String, String], t: Throwable)(
-          message: => String
-      ): LoggerF[Unit] =
-        build(ctx, errorEnabled, LogLevel.Error, t.some, message)
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): WriterT[F, G[StructuredLogMessage], Unit] =
+        build(ll, ctx, t.some, msg)
     }
 
   def run[F[_]: Monad, G[_]: Foldable](
diff --git a/core/shared/src/main/scala/org/typelevel/log4cats/noop/NoOpLogger.scala b/core/shared/src/main/scala/org/typelevel/log4cats/noop/NoOpLogger.scala
index 95762949..3e101f70 100644
--- a/core/shared/src/main/scala/org/typelevel/log4cats/noop/NoOpLogger.scala
+++ b/core/shared/src/main/scala/org/typelevel/log4cats/noop/NoOpLogger.scala
@@ -18,6 +18,7 @@ package org.typelevel.log4cats.noop
 
 import cats.Applicative
 import org.typelevel.log4cats.SelfAwareStructuredLogger
+import org.typelevel.log4cats.extras.LogLevel
 
 object NoOpLogger {
   def apply[F[_]: Applicative]: SelfAwareStructuredLogger[F] = impl[F]
@@ -25,86 +26,50 @@ object NoOpLogger {
   def strictEvalArgs[F[_]: Applicative]: SelfAwareStructuredLogger[F] =
     impl_[F](evaluateArgs = true)
 
-  def impl[F[_]: Applicative] = impl_[F](evaluateArgs = false)
+  def impl[F[_]: Applicative]: SelfAwareStructuredLogger[F] = impl_[F](evaluateArgs = false)
 
   private[noop] def impl_[F[_]: Applicative](evaluateArgs: Boolean): SelfAwareStructuredLogger[F] =
     if (evaluateArgs) strictImpl else lazyImpl
 
-  private def lazyImpl[F[_]: Applicative] = new SelfAwareStructuredLogger[F] {
+  private def lazyImpl[F[_]: Applicative]: SelfAwareStructuredLogger[F] =
+    new SelfAwareStructuredLogger[F] {
 
-    val no: F[Boolean] = Applicative[F].pure(false)
-    val unit: F[Unit] = Applicative[F].pure(())
+      val no: F[Boolean] = Applicative[F].pure(false)
+      val unit: F[Unit] = Applicative[F].pure(())
 
-    @inline override def isTraceEnabled: F[Boolean] = no
-    @inline override def isDebugEnabled: F[Boolean] = no
-    @inline override def isInfoEnabled: F[Boolean] = no
-    @inline override def isWarnEnabled: F[Boolean] = no
-    @inline override def isErrorEnabled: F[Boolean] = no
-    @inline override def trace(t: Throwable)(msg: => String): F[Unit] = unit
-    @inline override def trace(msg: => String): F[Unit] = unit
-    @inline override def trace(ctx: Map[String, String])(msg: => String): F[Unit] = unit
-    @inline override def debug(t: Throwable)(msg: => String): F[Unit] = unit
-    @inline override def debug(msg: => String): F[Unit] = unit
-    @inline override def debug(ctx: Map[String, String])(msg: => String): F[Unit] = unit
-    @inline override def info(t: Throwable)(msg: => String): F[Unit] = unit
-    @inline override def info(msg: => String): F[Unit] = unit
-    @inline override def info(ctx: Map[String, String])(msg: => String): F[Unit] = unit
-    @inline override def warn(t: Throwable)(msg: => String): F[Unit] = unit
-    @inline override def warn(msg: => String): F[Unit] = unit
-    @inline override def warn(ctx: Map[String, String])(msg: => String): F[Unit] = unit
-    @inline override def error(t: Throwable)(msg: => String): F[Unit] = unit
-    @inline override def error(msg: => String): F[Unit] = unit
-    @inline override def error(ctx: Map[String, String])(msg: => String): F[Unit] = unit
-    @inline override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      unit
-    @inline override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      unit
-    @inline override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      unit
-    @inline override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      unit
-    @inline override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      unit
-  }
+      @inline override def isEnabled(ll: LogLevel): F[Boolean] = no
+      @inline override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        unit
+      @inline override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] = unit
+      @inline override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = unit
+      @inline override def log(ll: LogLevel, msg: => String): F[Unit] = unit
+    }
 
-  private def strictImpl[F[_]: Applicative] = new SelfAwareStructuredLogger[F] {
+  private def strictImpl[F[_]: Applicative]: SelfAwareStructuredLogger[F] =
+    new SelfAwareStructuredLogger[F] {
 
-    val yes: F[Boolean] = Applicative[F].pure(true)
-    def void(arg: => Any): F[Unit] = Applicative[F].pure {
-      val _ = arg
-      ()
-    }
+      val yes: F[Boolean] = Applicative[F].pure(true)
+      def void(arg: => String): F[Unit] = Applicative[F].pure {
+        val _ = arg
+        ()
+      }
 
-    @inline override def isTraceEnabled: F[Boolean] = yes
-    @inline override def isDebugEnabled: F[Boolean] = yes
-    @inline override def isInfoEnabled: F[Boolean] = yes
-    @inline override def isWarnEnabled: F[Boolean] = yes
-    @inline override def isErrorEnabled: F[Boolean] = yes
-    @inline override def trace(t: Throwable)(msg: => String): F[Unit] = void(t)
-    @inline override def trace(msg: => String): F[Unit] = void(msg)
-    @inline override def trace(ctx: Map[String, String])(msg: => String): F[Unit] = void(msg)
-    @inline override def debug(t: Throwable)(msg: => String): F[Unit] = void(msg)
-    @inline override def debug(msg: => String): F[Unit] = void(msg)
-    @inline override def debug(ctx: Map[String, String])(msg: => String): F[Unit] = void(msg)
-    @inline override def info(t: Throwable)(msg: => String): F[Unit] = void(msg)
-    @inline override def info(msg: => String): F[Unit] = void(msg)
-    @inline override def info(ctx: Map[String, String])(msg: => String): F[Unit] = void(msg)
-    @inline override def warn(t: Throwable)(msg: => String): F[Unit] = void(msg)
-    @inline override def warn(msg: => String): F[Unit] = void(msg)
-    @inline override def warn(ctx: Map[String, String])(msg: => String): F[Unit] = void(msg)
-    @inline override def error(t: Throwable)(msg: => String): F[Unit] = void(msg)
-    @inline override def error(msg: => String): F[Unit] = void(msg)
-    @inline override def error(ctx: Map[String, String])(msg: => String): F[Unit] = void(msg)
-    @inline override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      void(msg)
-    @inline override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      void(msg)
-    @inline override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      void(msg)
-    @inline override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      void(msg)
-    @inline override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-      void(msg)
-  }
+      @inline override def isEnabled(ll: LogLevel): F[Boolean] = yes
+      @inline override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        void(msg)
+      @inline override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] = void(msg)
+      @inline override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = void(msg)
+      @inline override def log(ll: LogLevel, msg: => String): F[Unit] = void(msg)
+    }
 
 }
diff --git a/js-console/src/main/scala/org/typelevel/log4cats/console/ConsoleLogger.scala b/js-console/src/main/scala/org/typelevel/log4cats/console/ConsoleLogger.scala
index 6f79e754..3fe6906f 100644
--- a/js-console/src/main/scala/org/typelevel/log4cats/console/ConsoleLogger.scala
+++ b/js-console/src/main/scala/org/typelevel/log4cats/console/ConsoleLogger.scala
@@ -25,25 +25,41 @@ import org.typelevel.log4cats.extras.LogLevel.*
 class ConsoleLogger[F[_]: Sync](logLevel: Option[LogLevel] = Option(Trace))
     extends SelfAwareStructuredLogger[F] {
   private val ConsoleF: ConsoleF[F] = implicitly
+
+  override def isEnabled(ll: LogLevel): F[Boolean] = logLevel.exists(_ <= ll).pure[F]
+
+  override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+    ll match {
+      case LogLevel.Error => error(t)(msg)
+      case LogLevel.Warn => warn(t)(msg)
+      case LogLevel.Info => info(t)(msg)
+      case LogLevel.Debug => debug(t)(msg)
+      case LogLevel.Trace => trace(t)(msg)
+    }
+
+  override def log(ll: LogLevel, msg: => String): F[Unit] =
+    ll match {
+      case LogLevel.Error => error(msg)
+      case LogLevel.Warn => warn(msg)
+      case LogLevel.Info => info(msg)
+      case LogLevel.Debug => debug(msg)
+      case LogLevel.Trace => trace(msg)
+    }
+
   override def trace(t: Throwable)(message: => String): F[Unit] = ConsoleF.debug(message, t)
   override def trace(message: => String): F[Unit] = ConsoleF.debug(message)
-  override def isTraceEnabled: F[Boolean] = logLevel.exists(_ <= Trace).pure[F]
 
   override def debug(t: Throwable)(message: => String): F[Unit] = ConsoleF.debug(message, t)
   override def debug(message: => String): F[Unit] = ConsoleF.debug(message)
-  override def isDebugEnabled: F[Boolean] = logLevel.exists(_ <= Debug).pure[F]
 
   override def info(t: Throwable)(message: => String): F[Unit] = ConsoleF.info(message, t)
   override def info(message: => String): F[Unit] = ConsoleF.info(message)
-  override def isInfoEnabled: F[Boolean] = logLevel.exists(_ <= Info).pure[F]
 
   override def warn(t: Throwable)(message: => String): F[Unit] = ConsoleF.warn(message, t)
   override def warn(message: => String): F[Unit] = ConsoleF.warn(message)
-  override def isWarnEnabled: F[Boolean] = logLevel.exists(_ <= Warn).pure[F]
 
   override def error(t: Throwable)(message: => String): F[Unit] = ConsoleF.error(message, t)
   override def error(message: => String): F[Unit] = ConsoleF.error(message)
-  override def isErrorEnabled: F[Boolean] = logLevel.exists(_ <= Error).pure[F]
 
   /*
    * ConsoleLogger should probably not extend from StructuredLogger, because there's not
@@ -66,4 +82,7 @@ class ConsoleLogger[F[_]: Sync](logLevel: Option[LogLevel] = Option(Trace))
   override def error(ctx: Map[String, String])(msg: => String): F[Unit] = error(msg)
   override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
     error(t)(msg)
+  override def log(ll: LogLevel, ctx: Map[String, String], t: Throwable, msg: => String): F[Unit] =
+    log(ll, t, msg)
+  override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] = log(ll, msg)
 }
diff --git a/slf4j/src/main/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternal.scala b/slf4j/src/main/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternal.scala
index 4f652a08..dbb5b589 100644
--- a/slf4j/src/main/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternal.scala
+++ b/slf4j/src/main/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternal.scala
@@ -21,6 +21,7 @@ import cats.syntax.all.*
 import cats.effect.*
 import org.slf4j.Logger as JLogger
 import org.slf4j.MDC
+import org.typelevel.log4cats.extras.LogLevel
 
 import scala.annotation.nowarn
 
@@ -137,5 +138,51 @@ private[slf4j] object Slf4jLoggerInternal {
       contextLog(isErrorEnabled, ctx, () => logger.error(msg))
     override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
       contextLog(isErrorEnabled, ctx, () => logger.error(msg, t))
+
+    override def isEnabled(ll: LogLevel): F[Boolean] = ll match {
+      case LogLevel.Error => isErrorEnabled
+      case LogLevel.Warn => isWarnEnabled
+      case LogLevel.Info => isInfoEnabled
+      case LogLevel.Debug => isDebugEnabled
+      case LogLevel.Trace => isTraceEnabled
+    }
+
+    override def log(
+        ll: LogLevel,
+        ctx: Map[String, String],
+        t: Throwable,
+        msg: => String
+    ): F[Unit] =
+      ll match {
+        case LogLevel.Error => error(ctx, t)(msg)
+        case LogLevel.Warn => warn(ctx, t)(msg)
+        case LogLevel.Info => info(ctx, t)(msg)
+        case LogLevel.Debug => debug(ctx, t)(msg)
+        case LogLevel.Trace => trace(ctx, t)(msg)
+      }
+
+    override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] = ll match {
+      case LogLevel.Error => error(ctx)(msg)
+      case LogLevel.Warn => warn(ctx)(msg)
+      case LogLevel.Info => info(ctx)(msg)
+      case LogLevel.Debug => debug(ctx)(msg)
+      case LogLevel.Trace => trace(ctx)(msg)
+    }
+
+    override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = ll match {
+      case LogLevel.Error => error(t)(msg)
+      case LogLevel.Warn => warn(t)(msg)
+      case LogLevel.Info => info(t)(msg)
+      case LogLevel.Debug => debug(t)(msg)
+      case LogLevel.Trace => trace(t)(msg)
+    }
+
+    override def log(ll: LogLevel, msg: => String): F[Unit] = ll match {
+      case LogLevel.Error => error(msg)
+      case LogLevel.Warn => warn(msg)
+      case LogLevel.Info => info(msg)
+      case LogLevel.Debug => debug(msg)
+      case LogLevel.Trace => trace(msg)
+    }
   }
 }
diff --git a/slf4j/src/test/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternalSuite.scala b/slf4j/src/test/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternalSuite.scala
index a5afc569..b68fcde4 100644
--- a/slf4j/src/test/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternalSuite.scala
+++ b/slf4j/src/test/scala/org/typelevel/log4cats/slf4j/internal/Slf4jLoggerInternalSuite.scala
@@ -22,7 +22,8 @@ import cats.effect.unsafe.IORuntime
 import cats.effect.{IO, Resource, SyncIO}
 import cats.syntax.all.*
 
-import java.util.concurrent.{Executors, ThreadFactory}
+import java.util.concurrent.Executors
+import java.util.concurrent.ThreadFactory
 import org.slf4j.MDC
 import munit.{CatsEffectSuite, Location}
 import org.typelevel.log4cats.extras.DeferredLogMessage
@@ -38,15 +39,16 @@ import scala.concurrent.ExecutionContextExecutorService
 import scala.util.control.NoStackTrace
 
 class Slf4jLoggerInternalSuite extends CatsEffectSuite {
-
   private val computeEC = ExecutionContext.fromExecutorService(
     Executors.newSingleThreadExecutor(),
     t => fail("Uncaught exception on compute thread", t)
   )
+
   private val blockingEC = ExecutionContext.fromExecutorService(
     Executors.newSingleThreadExecutor(),
     t => fail("Uncaught exception on blocking thread", t)
   )
+
   override implicit def munitIORuntime: IORuntime =
     IORuntime
       .builder()
@@ -74,7 +76,7 @@ class Slf4jLoggerInternalSuite extends CatsEffectSuite {
     }
   }
 
-  private def testLoggerFixture(
+  def testLoggerFixture(
       traceEnabled: Boolean = true,
       debugEnabled: Boolean = true,
       infoEnabled: Boolean = true,
@@ -117,6 +119,20 @@ class Slf4jLoggerInternalSuite extends CatsEffectSuite {
       override val finisher: function.Function[ListBuffer[A], List[A]] = _.result()
     }
 
+  private def toDeferredLogs(jl: java.util.List[TestLogMessage]): List[DeferredLogMessage] =
+    jl.stream()
+      .map[DeferredLogMessage] { tl =>
+        val context =
+          tl.context
+            .entrySet()
+            .stream()
+            .map[(String, String)](e => e.getKey -> e.getValue)
+            .collect(toScalaList)
+            .toMap
+        DeferredLogMessage(tl.logLevel, context, tl.throwableOpt, () => tl.message.get())
+      }
+      .collect(toScalaList[DeferredLogMessage])
+
   private val prepareMDC: IO[Unit] = IO.delay {
     MDC.clear()
     MDC.put("foo", "yellow")
@@ -150,20 +166,6 @@ class Slf4jLoggerInternalSuite extends CatsEffectSuite {
       validateMDC
   }
 
-  private def toDeferredLogs(jl: java.util.List[TestLogMessage]): List[DeferredLogMessage] =
-    jl.stream()
-      .map[DeferredLogMessage] { tl =>
-        val context =
-          tl.context
-            .entrySet()
-            .stream()
-            .map[(String, String)](e => e.getKey -> e.getValue)
-            .collect(toScalaList)
-            .toMap
-        DeferredLogMessage(tl.logLevel, context, tl.throwableOpt, () => tl.message.get())
-      }
-      .collect(toScalaList[DeferredLogMessage])
-
   testLoggerFixture().test("Slf4jLoggerInternal correctly sets the MDC") { testLogger =>
     prepareMDC >>
       Slf4jLogger.getLoggerFromSlf4j[IO](testLogger).info(Map("foo" -> "bar"))("A log went here") >>
diff --git a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/StructuredTestingLogger.scala b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/StructuredTestingLogger.scala
index 640a67f5..27d890d4 100644
--- a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/StructuredTestingLogger.scala
+++ b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/StructuredTestingLogger.scala
@@ -20,6 +20,7 @@ import cats.data.Chain
 import org.typelevel.log4cats.SelfAwareStructuredLogger
 import cats.effect.{Ref, Sync}
 import cats.syntax.all.*
+import org.typelevel.log4cats.extras.LogLevel
 
 import java.util.concurrent.atomic.AtomicReference
 import scala.annotation.tailrec
@@ -139,57 +140,43 @@ object StructuredTestingLogger {
     new StructuredTestingLogger[F] {
       def logged: F[Vector[LogMessage]] = read()
 
-      def isTraceEnabled: F[Boolean] = Sync[F].pure(traceEnabled)
-      def isDebugEnabled: F[Boolean] = Sync[F].pure(debugEnabled)
-      def isInfoEnabled: F[Boolean] = Sync[F].pure(infoEnabled)
-      def isWarnEnabled: F[Boolean] = Sync[F].pure(warnEnabled)
-      def isErrorEnabled: F[Boolean] = Sync[F].pure(errorEnabled)
-
-      private val noop = Sync[F].unit
-
-      def error(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, None)) else noop
-      def error(t: Throwable)(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, t.some)) else noop
-      def error(ctx: Map[String, String])(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, None, ctx)) else noop
-      def error(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, t.some, ctx)) else noop
-
-      def warn(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, None)) else noop
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, t.some)) else noop
-      def warn(ctx: Map[String, String])(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, None, ctx)) else noop
-      def warn(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, t.some, ctx)) else noop
-
-      def info(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, None)) else noop
-      def info(t: Throwable)(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, t.some)) else noop
-      def info(ctx: Map[String, String])(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, None, ctx)) else noop
-      def info(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, t.some, ctx)) else noop
-
-      def debug(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, None)) else noop
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, t.some)) else noop
-      def debug(ctx: Map[String, String])(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, None, ctx)) else noop
-      def debug(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, t.some, ctx)) else noop
-
-      def trace(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, None)) else noop
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, t.some)) else noop
-      def trace(ctx: Map[String, String])(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, None, ctx)) else noop
-      def trace(ctx: Map[String, String], t: Throwable)(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, t.some, ctx)) else noop
+      private def shouldLog(ll: LogLevel): Boolean = ll match {
+        case LogLevel.Error => errorEnabled
+        case LogLevel.Warn => warnEnabled
+        case LogLevel.Info => infoEnabled
+        case LogLevel.Debug => debugEnabled
+        case LogLevel.Trace => traceEnabled
+      }
+
+      private def save(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Option[Throwable],
+          msg: => String
+      ): F[Unit] =
+        Sync[F].whenA(shouldLog(ll))(appendLogMessage(ll match {
+          case LogLevel.Error => ERROR(msg, t, ctx)
+          case LogLevel.Warn => WARN(msg, t, ctx)
+          case LogLevel.Info => INFO(msg, t, ctx)
+          case LogLevel.Debug => DEBUG(msg, t, ctx)
+          case LogLevel.Trace => TRACE(msg, t, ctx)
+        }))
+
+      override def isEnabled(ll: LogLevel): F[Boolean] = Sync[F].pure(shouldLog(ll))
+
+      override def log(
+          ll: LogLevel,
+          ctx: Map[String, String],
+          t: Throwable,
+          msg: => String
+      ): F[Unit] = save(ll, ctx, t.some, msg)
+
+      override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+        save(ll, ctx, none, msg)
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+        save(ll, Map.empty, t.some, msg)
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] = save(ll, Map.empty, none, msg)
     }
 }
diff --git a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLogger.scala b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLogger.scala
index 80bc2700..971a87ea 100644
--- a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLogger.scala
+++ b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLogger.scala
@@ -20,6 +20,7 @@ import cats.data.Chain
 import org.typelevel.log4cats.SelfAwareLogger
 import cats.effect.{Ref, Sync}
 import cats.syntax.all.*
+import org.typelevel.log4cats.extras.LogLevel
 
 import java.util.concurrent.atomic.AtomicReference
 import scala.annotation.tailrec
@@ -118,38 +119,28 @@ object TestingLogger {
     new TestingLogger[F] {
       def logged: F[Vector[LogMessage]] = read()
 
-      def isTraceEnabled: F[Boolean] = Sync[F].pure(traceEnabled)
-      def isDebugEnabled: F[Boolean] = Sync[F].pure(debugEnabled)
-      def isInfoEnabled: F[Boolean] = Sync[F].pure(infoEnabled)
-      def isWarnEnabled: F[Boolean] = Sync[F].pure(warnEnabled)
-      def isErrorEnabled: F[Boolean] = Sync[F].pure(errorEnabled)
-
-      private val noop = Sync[F].unit
-
-      def error(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, None)) else noop
-      def error(t: Throwable)(message: => String): F[Unit] =
-        if (errorEnabled) appendLogMessage(ERROR(message, t.some)) else noop
-
-      def warn(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, None)) else noop
-      def warn(t: Throwable)(message: => String): F[Unit] =
-        if (warnEnabled) appendLogMessage(WARN(message, t.some)) else noop
-
-      def info(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, None)) else noop
-      def info(t: Throwable)(message: => String): F[Unit] =
-        if (infoEnabled) appendLogMessage(INFO(message, t.some)) else noop
-
-      def debug(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, None)) else noop
-      def debug(t: Throwable)(message: => String): F[Unit] =
-        if (debugEnabled) appendLogMessage(DEBUG(message, t.some)) else noop
-
-      def trace(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, None)) else noop
-      def trace(t: Throwable)(message: => String): F[Unit] =
-        if (traceEnabled) appendLogMessage(TRACE(message, t.some)) else noop
+      private def shouldLog(ll: LogLevel): Boolean = ll match {
+        case LogLevel.Error => errorEnabled
+        case LogLevel.Warn => warnEnabled
+        case LogLevel.Info => infoEnabled
+        case LogLevel.Debug => debugEnabled
+        case LogLevel.Trace => traceEnabled
+      }
+
+      private def save(ll: LogLevel, t: Option[Throwable], msg: => String): F[Unit] =
+        Sync[F].whenA(shouldLog(ll))(appendLogMessage(ll match {
+          case LogLevel.Error => ERROR(msg, t)
+          case LogLevel.Warn => WARN(msg, t)
+          case LogLevel.Info => INFO(msg, t)
+          case LogLevel.Debug => DEBUG(msg, t)
+          case LogLevel.Trace => TRACE(msg, t)
+        }))
+
+      override def isEnabled(ll: LogLevel): F[Boolean] = Sync[F].pure(shouldLog(ll))
+
+      override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] = save(ll, t.some, msg)
+
+      override def log(ll: LogLevel, msg: => String): F[Unit] = save(ll, none, msg)
     }
 
 }
diff --git a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLoggerFactory.scala b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLoggerFactory.scala
index c05c95e9..8e373658 100644
--- a/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLoggerFactory.scala
+++ b/testing/shared/src/main/scala/org/typelevel/log4cats/testing/TestingLoggerFactory.scala
@@ -173,57 +173,46 @@ object TestingLoggerFactory {
         Sync[F].delay(getLoggerFromName(name))
       override def getLoggerFromName(name: String): SelfAwareStructuredLogger[F] =
         new SelfAwareStructuredLogger[F] {
-          override val isTraceEnabled: F[Boolean] = traceEnabled.pure[F]
-          override val isDebugEnabled: F[Boolean] = debugEnabled.pure[F]
-          override val isInfoEnabled: F[Boolean] = infoEnabled.pure[F]
-          override val isWarnEnabled: F[Boolean] = warnEnabled.pure[F]
-          override val isErrorEnabled: F[Boolean] = errorEnabled.pure[F]
-
-          private val noop = Sync[F].unit
-
-          override def trace(ctx: Map[String, String])(msg: => String): F[Unit] =
-            if (traceEnabled) save(Trace(name, msg, none, ctx)) else noop
-          override def debug(ctx: Map[String, String])(msg: => String): F[Unit] =
-            if (debugEnabled) save(Debug(name, msg, none, ctx)) else noop
-          override def info(ctx: Map[String, String])(msg: => String): F[Unit] =
-            if (infoEnabled) save(Info(name, msg, none, ctx)) else noop
-          override def warn(ctx: Map[String, String])(msg: => String): F[Unit] =
-            if (warnEnabled) save(Warn(name, msg, none, ctx)) else noop
-          override def error(ctx: Map[String, String])(msg: => String): F[Unit] =
-            if (errorEnabled) save(Error(name, msg, none, ctx)) else noop
-
-          override def trace(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            if (traceEnabled) save(Trace(name, msg, t.some, ctx)) else noop
-          override def debug(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            if (debugEnabled) save(Debug(name, msg, t.some, ctx)) else noop
-          override def info(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            if (infoEnabled) save(Info(name, msg, t.some, ctx)) else noop
-          override def warn(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            if (warnEnabled) save(Warn(name, msg, t.some, ctx)) else noop
-          override def error(ctx: Map[String, String], t: Throwable)(msg: => String): F[Unit] =
-            if (errorEnabled) save(Error(name, msg, t.some, ctx)) else noop
-
-          override def trace(t: Throwable)(msg: => String): F[Unit] =
-            if (traceEnabled) save(Trace(name, msg, t.some, Map.empty)) else noop
-          override def debug(t: Throwable)(msg: => String): F[Unit] =
-            if (debugEnabled) save(Debug(name, msg, t.some, Map.empty)) else noop
-          override def info(t: Throwable)(msg: => String): F[Unit] =
-            if (infoEnabled) save(Info(name, msg, t.some, Map.empty)) else noop
-          override def warn(t: Throwable)(msg: => String): F[Unit] =
-            if (warnEnabled) save(Warn(name, msg, t.some, Map.empty)) else noop
-          override def error(t: Throwable)(msg: => String): F[Unit] =
-            if (errorEnabled) save(Error(name, msg, t.some, Map.empty)) else noop
-
-          override def trace(msg: => String): F[Unit] =
-            if (traceEnabled) save(Trace(name, msg, none, Map.empty)) else noop
-          override def debug(msg: => String): F[Unit] =
-            if (debugEnabled) save(Debug(name, msg, none, Map.empty)) else noop
-          override def info(msg: => String): F[Unit] =
-            if (infoEnabled) save(Info(name, msg, none, Map.empty)) else noop
-          override def warn(msg: => String): F[Unit] =
-            if (warnEnabled) save(Warn(name, msg, none, Map.empty)) else noop
-          override def error(msg: => String): F[Unit] =
-            if (errorEnabled) save(Error(name, msg, none, Map.empty)) else noop
+
+          private def shouldLog(ll: LogLevel): Boolean = ll match {
+            case LogLevel.Error => errorEnabled
+            case LogLevel.Warn => warnEnabled
+            case LogLevel.Info => infoEnabled
+            case LogLevel.Debug => debugEnabled
+            case LogLevel.Trace => traceEnabled
+          }
+
+          private def write(
+              ll: LogLevel,
+              ctx: Map[String, String],
+              t: Option[Throwable],
+              msg: => String
+          ): F[Unit] =
+            Sync[F].whenA(shouldLog(ll))(save(ll match {
+              case LogLevel.Error => Error(name, msg, t, ctx)
+              case LogLevel.Warn => Warn(name, msg, t, ctx)
+              case LogLevel.Info => Info(name, msg, t, ctx)
+              case LogLevel.Debug => Debug(name, msg, t, ctx)
+              case LogLevel.Trace => Trace(name, msg, t, ctx)
+            }))
+
+          override def isEnabled(ll: LogLevel): F[Boolean] = Sync[F].pure(shouldLog(ll))
+
+          override def log(
+              ll: LogLevel,
+              ctx: Map[String, String],
+              t: Throwable,
+              msg: => String
+          ): F[Unit] =
+            write(ll, ctx, t.some, msg)
+
+          override def log(ll: LogLevel, ctx: Map[String, String], msg: => String): F[Unit] =
+            write(ll, ctx, none, msg)
+
+          override def log(ll: LogLevel, t: Throwable, msg: => String): F[Unit] =
+            write(ll, Map.empty, t.some, msg)
+
+          override def log(ll: LogLevel, msg: => String): F[Unit] = write(ll, Map.empty, none, msg)
         }
 
     }