issue oshai#21 : js + common will be publisher in version 1.5.5

add common and js jars (will be in https://github.com/MicroUtils/kotlin-logging/releases)
common module have expect for 2 main classes: KotlinLogging, KLogger
js implementation includes writing to console,
and a class KotlinLoggingLevel that defines the log level in LOG_LEVEL member
default level is info for js implementation

build.gradle

@@ -14,7 +14,7 @@ buildscript {
 
 allprojects {
     group 'io.github.microutils'
-    version '1.5.3'
+    version '1.5.5'
 
     repositories {
         mavenCentral()

kotlin-logging-common/build.gradle

@@ -6,4 +6,5 @@ repositories {
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlin_version"
+    testCompile "org.jetbrains.kotlin:kotlin-test-common:$kotlin_version"
 }

kotlin-logging-common/src/main/kotlin/mu/KLogger.kt

@@ -0,0 +1,57 @@
+package mu
+
+
+
+expect interface KLogger {
+
+
+  /**
+   * Lazy add a log message if isTraceEnabled is true
+   */
+  fun trace(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isDebugEnabled is true
+   */
+  fun debug(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isInfoEnabled is true
+   */
+  fun info(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isWarnEnabled is true
+   */
+  fun warn(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isErrorEnabled is true
+   */
+  fun error(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isTraceEnabled is true
+   */
+  fun trace(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isDebugEnabled is true
+   */
+  fun debug(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isInfoEnabled is true
+   */
+  fun info(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isWarnEnabled is true
+   */
+  fun warn(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isErrorEnabled is true
+   */
+  fun error(t: Throwable?, msg: () -> Any?)
+}

kotlin-logging-common/src/main/kotlin/mu/KotlinLogging.kt

@@ -0,0 +1,13 @@
+package mu
+
+
+
+expect object KotlinLogging {
+    /**
+     * This method allow defining the logger in a file in the following way:
+     * val logger = KotlinLogging.logger {}
+     */
+    fun logger(func: () -> Unit): KLogger
+
+    fun logger(name: String): KLogger
+}

kotlin-logging-js/src/main/kotlin/mu/KLogger.kt

@@ -0,0 +1,57 @@
+package mu
+
+
+
+actual interface KLogger {
+
+
+  /**
+   * Lazy add a log message if isTraceEnabled is true
+   */
+  actual fun trace(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isDebugEnabled is true
+   */
+  actual fun debug(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isInfoEnabled is true
+   */
+  actual fun info(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isWarnEnabled is true
+   */
+  actual fun warn(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message if isErrorEnabled is true
+   */
+  actual fun error(msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isTraceEnabled is true
+   */
+  actual fun trace(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isDebugEnabled is true
+   */
+  actual fun debug(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isInfoEnabled is true
+   */
+  actual fun info(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isWarnEnabled is true
+   */
+  actual fun warn(t: Throwable?, msg: () -> Any?)
+
+  /**
+   * Lazy add a log message with throwable payload if isErrorEnabled is true
+   */
+  actual fun error(t: Throwable?, msg: () -> Any?)
+}

kotlin-logging-js/src/main/kotlin/mu/KotlinLogging.kt

@@ -0,0 +1,14 @@
+package mu
+
+import mu.internal.KLoggerJS
+
+
+actual object KotlinLogging {
+    /**
+     * This method allow defining the logger in a file in the following way:
+     * val logger = KotlinLogging.logger {}
+     */
+    actual fun logger(func: () -> Unit): KLogger = KLoggerJS(func::class.js.name)
+
+    actual fun logger(name: String): KLogger = KLoggerJS(name)
+}

kotlin-logging-js/src/main/kotlin/mu/KotlinLoggingLevel.kt

@@ -0,0 +1,13 @@
+package mu
+
+var LOG_LEVEL = KotlinLoggingLevel.INFO
+
+enum class KotlinLoggingLevel {
+    TRACE,
+    DEBUG,
+    INFO,
+    WARN,
+    ERROR
+}
+
+fun KotlinLoggingLevel.isLoggingEnabled() = this.ordinal >= LOG_LEVEL.ordinal

kotlin-logging-js/src/main/kotlin/mu/internal/KLoggerJS.kt

@@ -0,0 +1,89 @@
+package mu.internal
+
+import mu.KLogger
+import mu.KotlinLoggingLevel
+import mu.isLoggingEnabled
+
+class KLoggerJS(private val loggerName: String) : KLogger {
+
+    override fun trace(msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.log("TRACE: [$loggerName] ${msg.toStringSafe()}")
+        }
+    }
+
+    override fun debug(msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.log("DEBUG: [$loggerName] ${msg.toStringSafe()}")
+        }
+    }
+
+    override fun info(msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.info("INFO: [$loggerName] ${msg.toStringSafe()}")
+        }
+    }
+
+    override fun warn(msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.warn("WARN: [$loggerName] ${msg.toStringSafe()}")
+        }
+    }
+
+    override fun error(msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.error("ERROR: [$loggerName] ${msg.toStringSafe()}")
+        }
+    }
+
+    override fun trace(t: Throwable?, msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.log("TRACE: [$loggerName] ${msg.toStringSafe()}${t.throwableToString()}")
+        }
+    }
+
+    override fun debug(t: Throwable?, msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.log("DEBUG: [$loggerName] ${msg.toStringSafe()}${t.throwableToString()}")
+        }
+    }
+
+    override fun info(t: Throwable?, msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.info("INFO: [$loggerName] ${msg.toStringSafe()}${t.throwableToString()}")
+        }
+    }
+
+    override fun warn(t: Throwable?, msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.warn("WARN: [$loggerName] ${msg.toStringSafe()}${t.throwableToString()}")
+        }
+    }
+
+    override fun error(t: Throwable?, msg: () -> Any?) {
+        if (KotlinLoggingLevel.TRACE.isLoggingEnabled()) {
+            console.error("ERROR: [$loggerName] ${msg.toStringSafe()}${t.throwableToString()}")
+        }
+    }
+
+    private fun (() -> Any?).toStringSafe(): String {
+        try {
+            return invoke().toString()
+        } catch (e: Exception) {
+            return "Log message invocation failed: $e"
+        }
+    }
+
+    private fun Throwable?.throwableToString(): String {
+        if (this == null) {
+            return ""
+        }
+        var msg = ""
+        var current = this
+        while (current != null && current.cause != current) {
+            msg += ", Caused by: '${current.message}'"
+            current = current.cause
+        }
+        return msg
+    }
+}

kotlin-logging-jvm/src/main/kotlin/mu/KLogger.kt

@@ -1,14 +1,13 @@
 package mu
 
-import mu.internal.toStringSafe
 import org.slf4j.Logger
 
 /**
  * An extension for [Logger] with Lazy message evaluation
  * example:
  * logger.info{"this is $lazy evaluated string"}
  */
-interface KLogger : Logger {
+actual interface KLogger : Logger {
 
   /**
    * The actual logger executing logging
@@ -18,70 +17,52 @@ interface KLogger : Logger {
   /**
    * Lazy add a log message if isTraceEnabled is true
    */
-  fun trace(msg: () -> Any?) {
-    if (isTraceEnabled) trace(msg.toStringSafe())
-  }
+  actual fun trace(msg: () -> Any?)
 
   /**
    * Lazy add a log message if isDebugEnabled is true
    */
-  fun debug(msg: () -> Any?) {
-    if (isDebugEnabled) debug(msg.toStringSafe())
-  }
+  actual fun debug(msg: () -> Any?)
 
   /**
    * Lazy add a log message if isInfoEnabled is true
    */
-  fun info(msg: () -> Any?) {
-    if (isInfoEnabled) info(msg.toStringSafe())
-  }
+  actual fun info(msg: () -> Any?)
 
   /**
    * Lazy add a log message if isWarnEnabled is true
    */
-  fun warn(msg: () -> Any?) {
-    if (isWarnEnabled) warn(msg.toStringSafe())
-  }
+  actual fun warn(msg: () -> Any?)
 
   /**
    * Lazy add a log message if isErrorEnabled is true
    */
-  fun error(msg: () -> Any?) {
-    if (isErrorEnabled) error(msg.toStringSafe())
-  }
+  actual fun error(msg: () -> Any?)
 
   /**
    * Lazy add a log message with throwable payload if isTraceEnabled is true
    */
-  fun trace(t: Throwable?, msg: () -> Any?) {
-    if (isTraceEnabled) trace(msg.toStringSafe(), t)
-  }
+  actual fun trace(t: Throwable?, msg: () -> Any?)
 
   /**
    * Lazy add a log message with throwable payload if isDebugEnabled is true
    */
-  fun debug(t: Throwable?, msg: () -> Any?) {
-    if (isDebugEnabled) debug(msg.toStringSafe(), t)
-  }
+  actual fun debug(t: Throwable?, msg: () -> Any?)
 
   /**
    * Lazy add a log message with throwable payload if isInfoEnabled is true
    */
-  fun info(t: Throwable?, msg: () -> Any?) {
-    if (isInfoEnabled) info(msg.toStringSafe(), t)
-  }
+  actual fun info(t: Throwable?, msg: () -> Any?)
 
   /**
    * Lazy add a log message with throwable payload if isWarnEnabled is true
    */
-  fun warn(t: Throwable?, msg: () -> Any?) {
-    if (isWarnEnabled) warn(msg.toStringSafe(), t)
-  }
+  actual fun warn(t: Throwable?, msg: () -> Any?)
 
   /**
    * Lazy add a log message with throwable payload if isErrorEnabled is true
    */
-  fun error(t: Throwable?, msg: () -> Any?) {
-    if (isErrorEnabled) error(msg.toStringSafe(), t)
-  }
+  actual fun error(t: Throwable?, msg: () -> Any?)
+
+
 }

kotlin-logging-jvm/src/main/kotlin/mu/KotlinLogging.kt

@@ -3,12 +3,12 @@ package mu
 import mu.internal.KLoggerFactory
 
 
-object KotlinLogging {
+actual object KotlinLogging {
     /**
      * This method allow defining the logger in a file in the following way:
      * val logger = KotlinLogging.logger {}
      */
-    fun logger(func: () -> Unit): KLogger = KLoggerFactory.logger(func)
+    actual fun logger(func: () -> Unit): KLogger = KLoggerFactory.logger(func)
 
-    fun logger(name: String): KLogger = KLoggerFactory.logger(name)
+    actual fun logger(name: String): KLogger = KLoggerFactory.logger(name)
 }