Split cases to with / without payload. (#335)

This allows better b.c. as in case no payload we call the old apis which are supported in older slf4j.

* add comment about reason for code duplication

src/javaMain/kotlin/io/github/oshai/kotlinlogging/slf4j/Slf4jExtensions.kt

@@ -20,17 +20,6 @@ public fun Level.toSlf4j(): org.slf4j.event.Level =
     Level.OFF -> throw IllegalArgumentException("OFF level is not supported")
   }
 
-public fun Logger.isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
-  return when (level) {
-    Level.TRACE -> this.isTraceEnabled(marker?.toSlf4j())
-    Level.DEBUG -> this.isDebugEnabled(marker?.toSlf4j())
-    Level.INFO -> this.isInfoEnabled(marker?.toSlf4j())
-    Level.WARN -> this.isWarnEnabled(marker?.toSlf4j())
-    Level.ERROR -> this.isErrorEnabled(marker?.toSlf4j())
-    Level.OFF -> false
-  }
-}
-
 @Suppress("UnusedReceiverParameter")
 public fun KotlinLogging.logger(underlyingLogger: Logger): KLogger =
   Slf4jLoggerFactory.wrapJLogger(underlyingLogger)

src/javaMain/kotlin/io/github/oshai/kotlinlogging/slf4j/internal/LocationAwareKLogger.kt

@@ -6,10 +6,10 @@ import io.github.oshai.kotlinlogging.KLoggingEventBuilder
 import io.github.oshai.kotlinlogging.Level
 import io.github.oshai.kotlinlogging.Marker
 import io.github.oshai.kotlinlogging.internal.toStringSafe
-import io.github.oshai.kotlinlogging.slf4j.isLoggingEnabledFor
 import io.github.oshai.kotlinlogging.slf4j.toSlf4j
 import org.slf4j.event.EventConstants
 import org.slf4j.helpers.MessageFormatter
+import org.slf4j.spi.CallerBoundaryAware
 import org.slf4j.spi.LocationAwareLogger
 
 /**
@@ -19,7 +19,11 @@ import org.slf4j.spi.LocationAwareLogger
 internal class LocationAwareKLogger(override val underlyingLogger: LocationAwareLogger) :
   KLogger, DelegatingKLogger<LocationAwareLogger>, Slf4jLogger() {
 
+  override val name: String
+    get() = underlyingLogger.name
+
   private val fqcn: String = LocationAwareKLogger::class.java.name
+
   private val ENTRY = io.github.oshai.kotlinlogging.KMarkerFactory.getMarker("ENTRY").toSlf4j()
   private val EXIT = io.github.oshai.kotlinlogging.KMarkerFactory.getMarker("EXIT").toSlf4j()
 
@@ -29,19 +33,50 @@ internal class LocationAwareKLogger(override val underlyingLogger: LocationAware
     io.github.oshai.kotlinlogging.KMarkerFactory.getMarker("CATCHING").toSlf4j()
   private val EXITONLY = "exit"
   private val EXITMESSAGE = "exit with ({})"
-  override val name: String
-    get() = underlyingLogger.name
 
+  override fun isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
+    return isLoggingEnabledFor(underlyingLogger, level, marker)
+  }
   override fun at(level: Level, marker: Marker?, block: KLoggingEventBuilder.() -> Unit) {
     if (isLoggingEnabledFor(level, marker)) {
       KLoggingEventBuilder().apply(block).run {
-        underlyingLogger.log(marker?.toSlf4j(), fqcn, level.toSlf4j().toInt(), message, null, cause)
+        if (payload != null) {
+          logWithPayload(this, level, marker)
+        } else {
+          logWithoutPayload(this, level, marker)
+        }
       }
     }
   }
 
-  override fun isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
-    return underlyingLogger.isLoggingEnabledFor(level, marker)
+  private fun logWithPayload(
+    kLoggingEventBuilder: KLoggingEventBuilder,
+    level: Level,
+    marker: Marker?
+  ) {
+    val builder = underlyingLogger.atLevel(level.toSlf4j())
+    marker?.toSlf4j()?.let { builder.addMarker(it) }
+    kLoggingEventBuilder.payload?.forEach { (key, value) -> builder.addKeyValue(key, value) }
+    builder.setCause(kLoggingEventBuilder.cause)
+    if (builder is CallerBoundaryAware) {
+      builder.setCallerBoundary(fqcn)
+    }
+    builder.log(kLoggingEventBuilder.message)
+  }
+
+  private fun logWithoutPayload(
+    kLoggingEventBuilder: KLoggingEventBuilder,
+    level: Level,
+    marker: Marker?
+  ) {
+    underlyingLogger.log(
+      marker?.toSlf4j(),
+      fqcn,
+      level.toSlf4j().toInt(),
+      kLoggingEventBuilder.message,
+      null,
+      kLoggingEventBuilder.cause
+    )
   }
 
   override fun <T : Throwable> catching(throwable: T) {

src/javaMain/kotlin/io/github/oshai/kotlinlogging/slf4j/internal/LocationIgnorantKLogger.kt

@@ -5,7 +5,6 @@ import io.github.oshai.kotlinlogging.KLogger
 import io.github.oshai.kotlinlogging.KLoggingEventBuilder
 import io.github.oshai.kotlinlogging.Level
 import io.github.oshai.kotlinlogging.Marker
-import io.github.oshai.kotlinlogging.slf4j.isLoggingEnabledFor
 import io.github.oshai.kotlinlogging.slf4j.toSlf4j
 import org.slf4j.Logger
 
@@ -16,22 +15,53 @@ import org.slf4j.Logger
  */
 internal class LocationIgnorantKLogger(override val underlyingLogger: Logger) :
   KLogger, DelegatingKLogger<Logger>, Slf4jLogger() {
+
   override val name: String
     get() = underlyingLogger.name
 
+  override fun isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
+    return isLoggingEnabledFor(underlyingLogger, level, marker)
+  }
+
   override fun at(level: Level, marker: Marker?, block: KLoggingEventBuilder.() -> Unit) {
     if (isLoggingEnabledFor(level, marker)) {
       KLoggingEventBuilder().apply(block).run {
-        val builder = underlyingLogger.atLevel(level.toSlf4j())
-        marker?.toSlf4j()?.let { builder.addMarker(it) }
-        payload?.forEach { (key, value) -> builder.addKeyValue(key, value) }
-        builder.setCause(cause)
-        builder.log(message)
+        if (payload != null) {
+          logWithPayload(this, level, marker)
+        } else {
+          logWithoutPayload(this, level, marker)
+        }
       }
     }
   }
 
-  override fun isLoggingEnabledFor(level: Level, marker: Marker?): Boolean {
-    return underlyingLogger.isLoggingEnabledFor(level, marker)
+  private fun logWithPayload(
+    kLoggingEventBuilder: KLoggingEventBuilder,
+    level: Level,
+    marker: Marker?
+  ) {
+    val builder = underlyingLogger.atLevel(level.toSlf4j())
+    marker?.toSlf4j()?.let { builder.addMarker(it) }
+    kLoggingEventBuilder.payload?.forEach { (key, value) -> builder.addKeyValue(key, value) }
+    builder.setCause(kLoggingEventBuilder.cause)
+    builder.log(kLoggingEventBuilder.message)
+  }
+
+  private fun logWithoutPayload(
+    kLoggingEventBuilder: KLoggingEventBuilder,
+    level: Level,
+    marker: Marker?
+  ) {
+    val slf4jMarker = marker?.toSlf4j()
+    val message = kLoggingEventBuilder.message
+    val cause = kLoggingEventBuilder.cause
+    when (level) {
+      Level.TRACE -> underlyingLogger.trace(slf4jMarker, message, cause)
+      Level.DEBUG -> underlyingLogger.debug(slf4jMarker, message, cause)
+      Level.INFO -> underlyingLogger.info(slf4jMarker, message, cause)
+      Level.WARN -> underlyingLogger.warn(slf4jMarker, message, cause)
+      Level.ERROR -> underlyingLogger.error(slf4jMarker, message, cause)
+      Level.OFF -> Unit
+    }
   }
 }

src/javaMain/kotlin/io/github/oshai/kotlinlogging/slf4j/internal/Slf4jLogger.kt

@@ -1,5 +1,29 @@
 package io.github.oshai.kotlinlogging.slf4j.internal
 
 import io.github.oshai.kotlinlogging.KLogger
+import io.github.oshai.kotlinlogging.Level
+import io.github.oshai.kotlinlogging.Marker
+import io.github.oshai.kotlinlogging.slf4j.toSlf4j
+import org.slf4j.Logger
 
-public abstract class Slf4jLogger : KLogger {}
+public abstract class Slf4jLogger : KLogger {
+
+  // we don't move more methods to here because if it will appear on stacktrace
+  // it will break fqcn for class name in location aware loggers
+  // (tests are also failing when doing this)
+
+  protected fun isLoggingEnabledFor(
+    underlyingLogger: Logger,
+    level: Level,
+    marker: Marker?
+  ): Boolean {
+    return when (level) {
+      Level.TRACE -> underlyingLogger.isTraceEnabled(marker?.toSlf4j())
+      Level.DEBUG -> underlyingLogger.isDebugEnabled(marker?.toSlf4j())
+      Level.INFO -> underlyingLogger.isInfoEnabled(marker?.toSlf4j())
+      Level.WARN -> underlyingLogger.isWarnEnabled(marker?.toSlf4j())
+      Level.ERROR -> underlyingLogger.isErrorEnabled(marker?.toSlf4j())
+      Level.OFF -> false
+    }
+  }
+}