fix linux test (#542)

it appears that the tests were not running. when adding to the build they failed and had to fix.
also seems that original implementation was too naive and do not work for cases of logger outside of class, so added implementation for it.

Author: oshai

.github/workflows/ci.yml

@@ -68,4 +68,4 @@ jobs:
           restore-keys: ${{ runner.os }}-gradle-
 
       - name: Gradle Build
-        run: ./gradlew clean build spotlessCheck --stacktrace
+        run: ./gradlew clean build spotlessCheck --stacktrace --info

build.gradle.kts

@@ -241,6 +241,9 @@ kotlin {
             getByName("${it.targetName}Main") {
                 dependsOn(linuxMain)
             }
+            getByName("${it.targetName}Test") {
+                dependsOn(nativeTest)
+            }
         }
         darwinTargets.forEach {
             getByName("${it.targetName}Main") {

src/nativeMain/kotlin/io/github/oshai/kotlinlogging/internal/KLoggerNameResolver.kt

@@ -1,6 +1,52 @@
 package io.github.oshai.kotlinlogging.internal
 
+import kotlin.experimental.ExperimentalNativeApi
+
 internal actual object KLoggerNameResolver {
 
-  internal actual fun name(func: () -> Unit): String = func::class.qualifiedName ?: ""
+  private fun removeKtSuffix(fullyQualifiedName: String): String {
+    return if (fullyQualifiedName.endsWith("Kt")) {
+      fullyQualifiedName.substring(0, fullyQualifiedName.length - 2)
+    } else {
+      fullyQualifiedName
+    }
+  }
+
+  @OptIn(ExperimentalNativeApi::class)
+  internal actual fun name(func: () -> Unit): String {
+    // Primary method: For loggers in classes, reflection returns the FQ name.
+    val nameFromReflection = func::class.qualifiedName?.substringBeforeLast(".<anonymous>")
+    if (!nameFromReflection.isNullOrBlank()) {
+      return nameFromReflection
+    }
+
+    // Fallback for top-level loggers: Parse the stack trace string array.
+    val stackTrace: Array<String> = Throwable().getStackTrace()
+
+    // START: Diagnostic code
+    //    println("--- KOTLIN-LOGGING DIAGNOSTIC: STACK TRACE ---")
+    //    stackTrace.forEach { println(it) }
+    //    println("--- END DIAGNOSTIC ---")
+    // END: Diagnostic code
+
+    // Find the first frame outside of the logging framework's internal machinery.
+    val callerFrame =
+      stackTrace.firstOrNull {
+        !it.contains("kfun:kotlin.Throwable") &&
+          !it.contains("io.github.oshai.kotlinlogging.internal") &&
+          !it.contains("io.github.oshai.kotlinlogging.KotlinLogging") &&
+          !it.contains("kfun:io.github.oshai.kotlinlogging.\$init_global#internal") &&
+          !it.contains("CallInitGlobalPossiblyLock") &&
+          !it.contains("kfun:io.github.oshai.kotlinlogging.<get-logger>#internal")
+      }
+
+    if (callerFrame != null) {
+      val regex = Regex("""kfun:([^#(<]+)""")
+      val fqName = regex.find(callerFrame)?.groupValues?.get(1)?.trim()
+      if (fqName != null) {
+        return removeKtSuffix(fqName)
+      }
+    }
+    return "UnknownLogger"
+  }
 }

src/nativeTest/kotlin/io/github/oshai/kotlinlogging/ClassLoggerNativeTest.kt

@@ -0,0 +1,17 @@
+package io.github.oshai.kotlinlogging
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ClassLoggerNativeTest {
+
+  private val logger = KotlinLogging.logger {}
+
+  @Test
+  fun loggerNameIsCorrectlyInferredFromClass() {
+    println(
+      "Asserting logger name from class: Expected 'io.github.oshai.kotlinlogging.ClassLoggerNativeTest', was '${logger.name}'"
+    )
+    assertEquals("io.github.oshai.kotlinlogging.ClassLoggerNativeTest", logger.name)
+  }
+}

src/nativeTest/kotlin/io/github/oshai/kotlinlogging/SimpleNativeTest.kt

@@ -21,61 +21,73 @@ class SimpleNativeTest {
 
   @Test
   fun simpleNativeTest() {
-    assertEquals("SimpleNativeTest", logger.name)
+    println("Asserting logger name: Expected 'SimpleNativeTest', was '${logger.name}'")
+    assertEquals(
+      "io.github.oshai.kotlinlogging.SimpleNativeTest",
+      logger.name,
+      "Expected logger name to be 'io.github.oshai.kotlinlogging.SimpleNativeTest', was '${logger.name}'",
+    )
     logger.info { "info msg" }
-    assertEquals("INFO: [SimpleNativeTest] info msg", appender.lastMessage)
-    assertEquals("info", appender.lastLevel)
-    assertEquals("info", appender.lastLoggerName)
+    println("Asserting last message: Expected 'info msg', was '${appender.lastMessage}'")
+    assertEquals(
+      "info msg",
+      appender.lastMessage,
+      "Expected last message to be 'info msg', was '${appender.lastMessage}'",
+    )
+    println("Asserting last level: Expected 'info', was '${appender.lastLevel}'")
+    assertEquals(
+      "info",
+      appender.lastLevel,
+      "Expected last level to be 'info', was '${appender.lastLevel}'",
+    )
+    println(
+      "Asserting last logger name: Expected 'io.github.oshai.kotlinlogging.SimpleNativeTest', was '${appender.lastLoggerName}'"
+    )
+    assertEquals(
+      "io.github.oshai.kotlinlogging.SimpleNativeTest",
+      appender.lastLoggerName,
+      "Expected last logger name to be 'io.github.oshai.kotlinlogging.SimpleNativeTest', was '${appender.lastLoggerName}'",
+    )
   }
 
   @Test
   fun offLevelNativeTest() {
     KotlinLoggingConfiguration.logLevel = Level.OFF
-    assertTrue(logger.isLoggingOff)
+    val isLoggingOff = logger.isLoggingOff()
+    println("Asserting logging is off: Expected true, was '$isLoggingOff'")
+    assertTrue(isLoggingOff, "Expected logging to be off, was '$isLoggingOff'")
     logger.error { "error msg" }
-    assertEquals("NA", appender.lastMessage)
-    assertEquals("NA", appender.lastLevel)
-    assertEquals("NA", appender.lastLoggerName)
+    println("Asserting last message is 'NA': Expected 'NA', was '${appender.lastMessage}'")
+    assertEquals(
+      "NA",
+      appender.lastMessage,
+      "Expected last message to be 'NA' when logging is off, was '${appender.lastMessage}'",
+    )
+    println("Asserting last level is 'NA': Expected 'NA', was '${appender.lastLevel}'")
+    assertEquals(
+      "NA",
+      appender.lastLevel,
+      "Expected last level to be 'NA' when logging is off, was '${appender.lastLevel}'",
+    )
+    println("Asserting last logger name is 'NA': Expected 'NA', was '${appender.lastLoggerName}'")
+    assertEquals(
+      "NA",
+      appender.lastLoggerName,
+      "Expected last logger name to be 'NA' when logging is off, was '${appender.lastLoggerName}'",
+    )
   }
 
   private fun createAppender(): SimpleAppender = SimpleAppender()
 
   class SimpleAppender : Appender {
-    var lastMessage: String = "NA"
+    var lastMessage: String? = "NA"
     var lastLevel: String = "NA"
     var lastLoggerName: String = "NA"
 
-    override fun trace(loggerName: String, message: String) {
-      lastMessage = message
-      lastLevel = "trace"
-      lastLoggerName = loggerName
+    override fun log(loggingEvent: KLoggingEvent) {
+      lastMessage = loggingEvent.message
+      lastLevel = loggingEvent.level.name.lowercase()
+      lastLoggerName = loggingEvent.loggerName
     }
-
-    override fun debug(loggerName: String, message: String) {
-      lastMessage = message
-      lastLevel = "debug"
-      lastLoggerName = loggerName
-    }
-
-    override fun info(loggerName: String, message: String) {
-      lastMessage = message
-      lastLevel = "info"
-      lastLoggerName = loggerName
-    }
-
-    override fun warn(loggerName: String, message: String) {
-      lastMessage = message
-      lastLevel = "warn"
-      lastLoggerName = loggerName
-    }
-
-    override fun error(loggerName: String, message: String) {
-      lastMessage = message
-      lastLevel = "error"
-      lastLoggerName = loggerName
-    }
-
-    override val includePrefix: Boolean
-      get() = true
   }
 }