Issue oshai#480 - Extend the way of how to create the logger

Author: scrat98

src/commonMain/kotlin/io/github/oshai/kotlinlogging/KotlinLogging.kt

@@ -2,24 +2,40 @@ package io.github.oshai.kotlinlogging
 
 import io.github.oshai.kotlinlogging.internal.KLoggerFactory
 import io.github.oshai.kotlinlogging.internal.KLoggerNameResolver
+import kotlin.js.JsName
 
+/**
+ * Since this library is intended to be multiplatform,
+ * there are several ways to create a logger depending on your programming language.
+ *
+ * Please note, that creating a logger by reference involves reflection or, in some cases,
+ * stack trace analysis. Therefore, if performance is a priority, avoid creating loggers
+ * in frequently executed code sections.
+ *
+ * A logger created by reference will take the name of the class of the reference.
+ * If the reference is a "companion object," the name of its enclosing class will be used instead.
+ *
+ * ```kotlin
+ * val topLevelNamedLogger = KotlinLogging.logger("TopLevelNamedLogger")
+ * val topLevelLambdaLogger = KotlinLogging.logger {}
+ *
+ * class MyClass {
+ *   val classNamedLogger = KotlinLogging.logger("MyClass")
+ *   val classLambdaLogger = KotlinLogging.logger {}
+ *   val classRefLogger = KotlinLogging.logger(this)
+ *
+ *   companion object {
+ *     val companionNamedLogger = KotlinLogging.logger("MyClassCompanion")
+ *     val companionLambdaLogger = KotlinLogging.logger {}
+ *     val companionRefLogger = KotlinLogging.logger(this)
+ *   }
+ * }
+ * ```
+ */
 public object KotlinLogging {
-  /**
-   * This method allow defining the logger in a file in the following way:
-   * ```
-   * private val logger = KotlinLogging.logger {}
-   * ```
-   */
-  public fun logger(func: () -> Unit): KLogger = logger(KLoggerNameResolver.name(func))
+  @JsName("kotlinLoggerByRef")
+  public fun logger(ref: Any): KLogger = logger(KLoggerNameResolver.name(ref))
 
-  /**
-   * This method allow defining the logger in a file in the following way:
-   * ```
-   * private val logger = KotlinLogging.logger("io.github.oshai.kotlinlogging.MyLogger")
-   * ```
-   *
-   * In most cases the name represents the package notation of the file that the logger is defined
-   * in.
-   */
+  @JsName("kotlinLoggerByName")
   public fun logger(name: String): KLogger = KLoggerFactory.logger(name)
 }

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

@@ -2,5 +2,5 @@ package io.github.oshai.kotlinlogging.internal
 
 internal expect object KLoggerNameResolver {
 
-  internal fun name(func: () -> Unit): String
+  internal fun name(ref: Any): String
 }

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

@@ -2,5 +2,5 @@ package io.github.oshai.kotlinlogging.internal
 
 internal actual object KLoggerNameResolver {
 
-  internal actual fun name(func: () -> Unit): String = func::class.qualifiedName ?: ""
+  internal actual fun name(ref: Any): String = ref::class.qualifiedName ?: ""
 }

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

@@ -6,15 +6,20 @@ import java.lang.reflect.Modifier
 internal actual object KLoggerNameResolver {
 
   /** get class name for function by the package of the function */
-  internal actual fun name(func: () -> Unit): String {
-    val name = func.javaClass.name
-    val slicedName =
-      when {
-        name.contains("Kt$") -> name.substringBefore("Kt$")
-        name.contains("$") -> name.substringBefore("$")
-        else -> name
+  internal actual fun name(ref: Any): String {
+    return ref::class.java.name.toCleanClassName()
+  }
+
+  private val classNameEndings = listOf("Kt$", "$")
+
+  private fun String.toCleanClassName(): String {
+    classNameEndings.forEach { ending ->
+      val indexOfEnding = this.indexOf(ending)
+      if (indexOfEnding != -1) {
+        return this.substring(0, indexOfEnding)
       }
-    return slicedName
+    }
+    return this
   }
 
   /** get class name for java class (that usually represents kotlin class) */

src/jsMain/kotlin/io/github/oshai/kotlinlogging/KotlinLogging.kt

@@ -1,18 +1,44 @@
 package io.github.oshai.kotlinlogging.internal
 
 internal actual object KLoggerNameResolver {
+  private const val DEFAULT_LOGGER_NAME = "root-logger"
+  private const val LOGGER_FUNCTION_NAME = "kotlinLoggerByRef"
+  private const val COMPANION_GET_INSTANCE_SUFFIX = "_getInstance"
+  private val TOP_LEVEL_INIT_PROPERTIES_REGEX = Regex("_init_properties_(\\S+)_kt_")
+  private val CLASS_LEVEL_INIT_PROPERTIES_REGEX = Regex("new (\\S+)")
 
-  internal actual fun name(func: () -> Unit): String {
-    var found = false
-    val exception = Exception()
-    for (line in exception.stackTraceToString().split("\n")) {
-      if (found) {
-        return line.substringBefore(".kt").substringAfterLast(".").substringAfterLast("/")
-      }
-      if (line.contains("at KotlinLogging")) {
-        found = true
-      }
+  internal actual fun name(ref: Any): String {
+    return findLoggerCallerClassName() ?: DEFAULT_LOGGER_NAME
+  }
+
+  private fun findLoggerCallerClassName(): String? {
+    val stackTrace = Throwable().stackTraceToString().split('\n')
+    val invokeLoggerLine = stackTrace.indexOfFirst { it.contains(LOGGER_FUNCTION_NAME) }
+    if (invokeLoggerLine == -1 || invokeLoggerLine + 1 >= stackTrace.size) return null
+    val callerLine = invokeLoggerLine + 1
+    return resolveAsTopLevelProperty(stackTrace, callerLine)
+      ?: resolveAsClassLevelProperty(stackTrace, callerLine)
+  }
+
+  private fun resolveAsTopLevelProperty(stackTrace: List<String>, callerLine: Int): String? {
+    val found = TOP_LEVEL_INIT_PROPERTIES_REGEX.find(stackTrace[callerLine]) ?: return null
+    return found.groupValues[1]
+  }
+
+  private fun resolveAsClassLevelProperty(stackTrace: List<String>, callerLine: Int): String? {
+    val found = CLASS_LEVEL_INIT_PROPERTIES_REGEX.find(stackTrace[callerLine]) ?: return null
+    val className = found.groupValues[1]
+    // find enclosing class in case of Companion object:
+    // new MyCompanion() <- found class name
+    // MyCompanion_getInstance()
+    // new MyClass()     <- enclosing class
+    if (
+      callerLine + 2 >= stackTrace.size ||
+      !stackTrace[callerLine + 1].contains("$className$COMPANION_GET_INSTANCE_SUFFIX")
+    ) {
+      return className
     }
-    return ""
+    val enclosingFound = CLASS_LEVEL_INIT_PROPERTIES_REGEX.find(stackTrace[callerLine + 2]) ?: return className
+    return enclosingFound.groupValues[1]
   }
 }