hotfix of js assert accordance

1.2.4

.github/workflows/kdocs.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Build
         run: ./gradlew dokkaHtml
       - name: Publish KDocs

.github/workflows/publish.yml

@@ -7,10 +7,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
-      - name: Fix android 32.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+          java-version: 17
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
@@ -19,6 +16,11 @@ jobs:
           mv gradle.properties.tmp gradle.properties
       - name: Build
         run: ./gradlew build
+      - name: Publish to Gitea
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGiteaRepository
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
       - name: Publish
         continue-on-error: true
         run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository

.gitignore

@@ -12,6 +12,5 @@ out/
 secret.gradle
 local.*
 local/
-kotlin-js-store/
 
 publishing.sh

CHANGELOG.md

@@ -1,7 +1,92 @@
 # Changelog
 
+## 1.3.0
+
+**THIS UPDATE CONTAINS CHANGES OF LOG LEVELS ACCORDANCES. LOOK AT THE LEVELS ACCORDANCE IN THE [DOCUMENTATION](https://docs.inmo.dev/kslog/logging.html#logging)
+FOR MORE INFO**
+
+* Add `trace` logging level
+* Change overall table of log level accordance
+* Now you may change default platform logger
+
+## 1.2.4
+
+**This update contains migration onto gradle 8+ (for both wrapper and android plugin). Use it with caution**
+
+## 1.2.3
+
+* `Kotlin`: `1.9.20`
+
+## 1.2.2
+
+**wasm32 target has been removed**
+**mingwX86 target has been removed**
+
+* `Kotlin`: `1.9.20-RC`
+
+## 1.2.1
+
+* `Kotlin`: `1.9.10`
+* Latest supported android sdk now is `34`
+
+## 1.2.0
+
+* `Kotlin`: `1.9.0`
+
+## 1.1.2
+
+* `Kotlin`: `1.8.22`
+
+## 1.1.1
+
+* Rollback `KSLog` with `String` arg factory to use `DefaultKSLog`
+
+## 1.1.0
+
+* `Kotlin`: `1.8.20`
+* Standard factory `KSLog` with `String` arg now use `TagLogger`
+
+## 1.0.0
+
+* `Kotlin`: `1.8.0`
+
+## 0.5.4
+
+* `Kotlin`: `1.7.22`
+
+## 0.5.3
+
+* `Kotlin`: `1.7.20`
+
+## 0.5.2
+
+* Add support of next platform:
+  * Linux ARM x64
+  * Linux ARM x32 HFP
+  * Linux x64
+  * WASM x32
+  * MinGW x64
+  * MinGW x86
+
+## 0.5.1
+
+* New property `defaultMessageFormatterWithErrorPrint` for messages format with errors
+
+## 0.5.0
+
+* `Kotlin`: `1.7.10`
+
+## 0.4.2
+
+* Add `setDefaultKSLog` and `addDefaultKSLog`
+* Add `plus` operation for two `KSLog` instances to call them both on each log performing
+* Add `KSLog` factory for simple creation of `CallbackKSLog`
+* Add `MessageFormatter` factory
+
 ## 0.4.1
 
+* Fixes in resolution ambiguity for functions with messages
+
 ## 0.4.0
 
 **THIS UPDATE CONTAINS BREAKING CHANGES**

README.md

@@ -1,18 +1,33 @@
-# How to use
+# KSLog
+
+It is simple and easy-to-use tool for logging on the most popular platforms in Kotlin Multiplatform:
 
 ![JVM](https://img.shields.io/badge/JVM-red?style=for-the-badge&logo=openjdk&logoColor=white)
 ![Android](https://img.shields.io/badge/Android-green?style=for-the-badge&logo=android&logoColor=white)
 ![Js](https://img.shields.io/badge/JavaScript-323330?style=for-the-badge&logo=javascript&logoColor=F7DF1E)
+![ARM x64](https://img.shields.io/badge/ARMx64-0091BD?style=for-the-badge&logo=arm&logoColor=F7DF1E)
+![ARM x32](https://img.shields.io/badge/ARMx32-0091BD?style=for-the-badge&logo=arm&logoColor=F7DF1E)
+![Linux x64](https://img.shields.io/badge/Linuxx64-FCC624?style=for-the-badge&logo=linux&logoColor=F7DF1E)
 
 [![KDocs](https://img.shields.io/badge/KDocs-323330?style=for-the-badge&logo=Kotlin&logoColor=7F52FF)](https://insanusmokrassar.github.io/KSLog/)
-[![Tutorials](https://img.shields.io/badge/Tutorials-0288D1?style=for-the-badge&logo=bookstack&logoColor=white)](https://bookstack.inmo.dev/books/kslog)
+[![Tutorials](https://img.shields.io/badge/Tutorials-0288D1?style=for-the-badge&logo=mkdocs&logoColor=white)](https://docs.inmo.dev/kslog/index.html)
 
-It is simple logging tool which is using built-in tools for logging:
+By default, KSLog is using built-in tools for logging on each supported platform:
 
 * `java.util.logging.Logger` for `JVM`
 * `android.util.Log` for `Android`
 * `Console` for `JS`
 
+But you always may create your logger and customize as you wish:
+
+```kotlin
+KSLog.default = KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+    // do your logging
+}
+```
+
+**This library also supports native targets in experimental mode. By default all native targets will use simple printing in the console**
+
 ## How to use
 
 ### Fast-travel
@@ -39,9 +54,11 @@ KSLog.l(LogLevel.INFO, "Some optional tag", IllegalArgumentException("So, that i
 
 There are several important "terms" in context of this library:
 
-* Default logger (available via `KSLog.default`)
+* Default logger (available via `KSLog.default` or simply `KSLog`)
 * Local logger (can be created via `KSLog` functions and passed anywhere as `KSLog`)
 * Logging shortcuts like `KSLog.i`/`KSLog.info`
+* Built-in extension `Any.logger` which allow you to create logger binded to the default with the tag based on the class of receiver
+    * __Be careful with the receivers: if you will use some extension like `apply`, the receiver will be different with your class inside of that `apply`__
 
 Every logging extension (like `KSLog.i`) have its analog with lazy inited message text and the same one with suffix `S` (like `KSLog.iS`) for the suspendable message calculation.
 

build.gradle

@@ -19,6 +19,7 @@ buildscript {
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.kotlin.dokka)
+    alias(libs.plugins.versions)
 }
 
 apply plugin: "com.android.library"
@@ -44,9 +45,23 @@ kotlin {
         browser()
         nodejs()
     }
-    android {
+    androidTarget {
         publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
     }
+    linuxArm64()
+    linuxArm32Hfp()
+    linuxX64()
+    wasm {
+        browser()
+        nodejs()
+        d8()
+    }
+    mingwX64()
 
     sourceSets {
         commonMain {
@@ -54,6 +69,13 @@ kotlin {
                 implementation libs.kotlin
             }
         }
+        commonTest {
+            dependencies {
+                implementation libs.kotlin.test.common
+                implementation libs.kotlin.test.annotations.common
+                implementation libs.kotlin.test.junit
+            }
+        }
     }
 }
 

defaultAndroidSettings.gradle

@@ -26,8 +26,9 @@ android {
         }
     }
 
-    compileSdkVersion libs.versions.android.compileSdk.get().toInteger()
-    buildToolsVersion libs.versions.android.buildTools.get()
+    compileSdk libs.versions.android.compileSdk.get().toInteger()
+    buildToolsVersion = libs.versions.android.buildTools.get()
+    namespace "${group}.${project.name}"
 
     defaultConfig {
         minSdkVersion libs.versions.android.minSdk.get().toInteger()
@@ -51,12 +52,8 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_1_8.toString()
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
 
     sourceSets {

gradle.properties

@@ -5,9 +5,10 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 android.useAndroidX=true
 android.enableJetifier=true
+org.gradle.jvmargs=-Xmx512m
 
 # Project data
 
 group=dev.inmo
-version=0.4.1
-android_code_version=11
+version=1.3.0
+android_code_version=27

gradle/libs.versions.toml

@@ -1,16 +1,20 @@
 [versions]
 
-kotlin = "1.6.21"
-kotlin-gradle-plugin = "7.0.4"
+kotlin = "1.9.20"
+kotlin-gradle-plugin = "8.1.4"
 
-dexcount = "3.1.0"
+versions = "0.50.0"
+
+dokka = "1.9.10"
+
+dexcount = "4.0.0"
 junit_version = "4.12"
-test_ext_junit_version = "1.1.2"
-espresso_core = "3.3.0"
+test_ext_junit_version = "1.1.5"
+espresso_core = "3.5.1"
 
 android-minSdk = "21"
-android-compileSdk = "32"
-android-buildTools = "32.0.0"
+android-compileSdk = "34"
+android-buildTools = "34.0.0"
 
 github-release = "2.4.1"
 
@@ -29,10 +33,12 @@ android-test-espresso-core = { module = "androidx.test.espresso:espresso-core",
 android-tools-build = { module = "com.android.tools.build:gradle", version.ref = "kotlin-gradle-plugin" }
 android-dexcount = { module = "com.getkeepsafe.dexcount:dexcount-gradle-plugin", version.ref = "dexcount" }
 kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
-kotlin-dokka-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "kotlin" }
+kotlin-dokka-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
 github-release = { module = "com.github.breadmoirai:github-release", version.ref = "github-release" }
 
 [plugins]
 
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
-kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "kotlin" }
+kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

publish.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 
 publishing {
@@ -49,20 +49,40 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/KSLog")
+            
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
+            
+                }
+            }
+            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+            
+                    credentials(HttpHeaderCredentials) {
+                        name = "Authorization"
+                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                    }
+            
+                    authentication {
+                        header(HttpHeaderAuthentication)
+                    }
+            
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+            
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
+            
                 }
             }
         }
@@ -83,4 +103,10 @@ if (project.hasProperty("signing.gnupg.keyName")) {
             dependsOn(it)
         }
     }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
 }

publish.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"MIT","title":"MIT License","url":"https://opensource.org/licenses/MIT"}],"mavenConfig":{"name":"${project.name}","description":"Simple logging library for kotlin","url":"https://github.com/InsanusMokrassar/KSLog","vcsUrl":"https://github.com/InsanusMokrassar/KSLog.git","developers":[{"id":"Akkihi","name":"Akkihi","eMail":"akkihiguy@gmail.com"},{"id":"InsanusMokrassar","name":"InsanusMokrassar","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/KSLog"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}
+{"licenses":[{"id":"MIT","title":"MIT License","url":"https://opensource.org/licenses/MIT"}],"mavenConfig":{"name":"${project.name}","description":"Simple logging library for kotlin","url":"https://github.com/InsanusMokrassar/KSLog","vcsUrl":"https://github.com/InsanusMokrassar/KSLog.git","developers":[{"id":"Akkihi","name":"Akkihi","eMail":"akkihiguy@gmail.com"},{"id":"InsanusMokrassar","name":"InsanusMokrassar","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/KSLog"},{"name":"Gitea","url":"https://git.inmo.dev/api/packages/InsanusMokrassar/maven","credsType":{"type":"dev.inmo.kmppscriptbuilder.core.models.MavenPublishingRepository.CredentialsType.HttpHeaderCredentials","headerName":"Authorization","headerValueProperty":"GITEA_TOKEN"}},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

settings.gradle

@@ -1,3 +1 @@
 rootProject.name = 'kslog'
-
-enableFeaturePreview("VERSION_CATALOGS")

src/androidMain/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -2,10 +2,10 @@ package dev.inmo.kslog.common
 
 import android.util.Log
 
-
-internal actual val defaultLogging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
     val messageString = m.toString()
     when(l) {
+        LogLevel.TRACE -> Log.d(t, messageString, e)
         LogLevel.DEBUG -> Log.d(t, messageString, e)
         LogLevel.VERBOSE -> Log.v(t, messageString, e)
         LogLevel.INFO -> Log.i(t, messageString, e)

src/commonMain/kotlin/AutoLoggers.kt

@@ -1,8 +1,20 @@
 package dev.inmo.kslog.common
 
+/**
+ * Creating base tag using class simple name of receiver
+ *
+ * @throws IllegalStateException If there is no opportunity to take simple name of receiver class
+ */
 val Any.logTag
     get() = this::class.simpleName ?: error("Unable to retrieve log tag")
+
+/**
+ * Creating [TagLogger] with [logTag] as base tag
+ */
 val Any.logger: KSLog
     get() = TagLogger(logTag)
 
+/**
+ * Creating [TagLogger] using [logger] extension property with [tagBase] as `this`
+ */
 fun taggedLogger(tagBase: Any): KSLog = tagBase.logger

src/commonMain/kotlin/CallbackKSLog.kt

@@ -1,9 +1,22 @@
 package dev.inmo.kslog.common
 
+import kotlin.jvm.JvmInline
+
 typealias SimpleKSLogCallback = (level: LogLevel, tag: String?, message: Any, throwable: Throwable?) -> Unit
 
-class CallbackKSLog(
+/**
+ * Creates simple [KSLog] which will pass all incoming [performLog] calls to [performLogCallback]
+ */
+@JvmInline
+value class CallbackKSLog(
     private val performLogCallback: SimpleKSLogCallback
 ) : KSLog {
     override fun performLog(level: LogLevel, tag: String?, message: Any, throwable: Throwable?) = performLogCallback(level, tag, message, throwable)
 }
+
+/**
+ * Creating [CallbackKSLog] using [performLogCallback] as an argument for constructor
+ */
+fun KSLog(
+    performLogCallback: SimpleKSLogCallback
+) = CallbackKSLog(performLogCallback)

src/commonMain/kotlin/DefaultKSLog.kt

@@ -2,23 +2,32 @@ package dev.inmo.kslog.common
 
 import dev.inmo.kslog.common.filter.filtered
 
+/**
+ * Logger based on [KSLoggerDefaultPlatformLoggerLambda] or [logging] parameter
+ *
+ * @param defaultTag will be used in case when `tag` parameter in [performLog] omitted
+ * @param messageFormatter special formatter which creating [String] inside of [performLog] for each call. Defaults to
+ * [defaultMessageFormatter]
+ * @param logging target lambda which will be called with a result of [messageFormatter] logs formatting as a message
+ * and tag as tag if not `null` and [defaultTag] otherwise
+ */
 class DefaultKSLog(
     private val defaultTag: String,
     private val messageFormatter: MessageFormatter = defaultMessageFormatter,
-    private val logging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = defaultLogging
+    private val logging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = KSLoggerDefaultPlatformLoggerLambda
 ) : KSLog {
     override fun performLog(level: LogLevel, tag: String?, message: Any, throwable: Throwable?) {
-        val tag = tag ?: defaultTag
+        val resultTag = tag ?: defaultTag
 
-        val text = messageFormatter(level, tag, message, throwable)
-        logging(level, tag, text, throwable)
+        val text = messageFormatter(level, resultTag, message, throwable)
+        logging(level, resultTag, text, throwable)
     }
 
     override fun performLog(level: LogLevel, tag: String?, throwable: Throwable?, messageBuilder: () -> Any) {
-        val tag = tag ?: defaultTag
+        val resultTag = tag ?: defaultTag
 
-        val text = messageFormatter(level, tag, messageBuilder(), throwable)
-        logging(level, tag, text, throwable)
+        val text = messageFormatter(level, resultTag, messageBuilder(), throwable)
+        logging(level, resultTag, text, throwable)
     }
 
     override suspend fun performLogS(
@@ -27,10 +36,10 @@ class DefaultKSLog(
         throwable: Throwable?,
         messageBuilder: suspend () -> Any
     ) {
-        val tag = tag ?: defaultTag
+        val resultTag = tag ?: defaultTag
 
-        val text = messageFormatter(level, tag, messageBuilder(), throwable)
-        logging(level, tag, text, throwable)
+        val text = messageFormatter(level, resultTag, messageBuilder(), throwable)
+        logging(level, resultTag, text, throwable)
     }
 }
 
@@ -39,7 +48,7 @@ fun DefaultKSLog(
     defaultTag: String,
     filter: MessageFilter = { _, _, _ -> true },
     messageFormatter: MessageFormatter = defaultMessageFormatter,
-    logging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = defaultLogging
+    logging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = KSLoggerDefaultPlatformLoggerLambda
 ) = DefaultKSLog(
     defaultTag, messageFormatter, logging
 ).filtered(filter)

src/commonMain/kotlin/Extensions.kt

@@ -15,6 +15,19 @@ inline fun KSLog.log(level: LogLevel, tag: String, message: Any, e: Throwable?)
 inline fun KSLog.log(level: LogLevel, tag: String, message: Any) = performLog(level, tag, message, null)
 
 
+inline fun KSLog.trace(e: Throwable? = null, noinline messageBuilder: () -> Any) = log(LogLevel.TRACE, null, e, messageBuilder)
+inline fun KSLog.trace(tag: String?, e: Throwable? = null, noinline messageBuilder: () -> Any) = log(LogLevel.TRACE, tag, e, messageBuilder)
+inline fun KSLog.trace(tag: String, noinline messageBuilder: () -> Any) = trace(tag, null, messageBuilder)
+suspend inline fun KSLog.traceS(e: Throwable? = null, noinline messageBuilder: suspend () -> Any) = logS(LogLevel.TRACE, null, e, messageBuilder)
+suspend inline fun KSLog.traceS(tag: String?, e: Throwable? = null, noinline messageBuilder: suspend () -> Any) = logS(LogLevel.TRACE, tag, e, messageBuilder)
+suspend inline fun KSLog.traceS(tag: String, noinline messageBuilder: suspend () -> Any) = traceS(tag, null, messageBuilder)
+inline fun KSLog.trace(message: Any, e: Throwable?) = log(LogLevel.TRACE, message, e)
+inline fun KSLog.trace(message: String, e: Throwable) = trace(message as Any, e)
+inline fun KSLog.trace(message: Any) = trace(message, null)
+inline fun KSLog.trace(tag: String, message: Any, e: Throwable?) = log(LogLevel.TRACE, tag, message, e)
+inline fun KSLog.trace(tag: String, message: Any) = trace(tag, message, null)
+
+
 inline fun KSLog.debug(e: Throwable? = null, noinline messageBuilder: () -> Any) = log(LogLevel.DEBUG, null, e, messageBuilder)
 inline fun KSLog.debug(tag: String?, e: Throwable? = null, noinline messageBuilder: () -> Any) = log(LogLevel.DEBUG, tag, e, messageBuilder)
 inline fun KSLog.debug(tag: String, noinline messageBuilder: () -> Any) = debug(tag, null, messageBuilder)
@@ -108,6 +121,19 @@ inline fun KSLog.l(level: LogLevel, tag: String, message: Any, e: Throwable?) =
 inline fun KSLog.l(level: LogLevel, tag: String, message: Any) = log(level, tag, message, null)
 
 
+inline fun KSLog.t(e: Throwable? = null, noinline messageBuilder: () -> Any) = trace(e, messageBuilder)
+inline fun KSLog.t(tag: String?, e: Throwable? = null, noinline messageBuilder: () -> Any) = trace(tag, e, messageBuilder)
+inline fun KSLog.t(tag: String, noinline messageBuilder: () -> Any) = t(tag, null, messageBuilder)
+suspend inline fun KSLog.tS(e: Throwable? = null, noinline messageBuilder: suspend () -> Any) = traceS(e, messageBuilder)
+suspend inline fun KSLog.tS(tag: String?, e: Throwable? = null, noinline messageBuilder: suspend () -> Any) = traceS(tag, e, messageBuilder)
+suspend inline fun KSLog.tS(tag: String, noinline messageBuilder: suspend () -> Any) = tS(tag, null, messageBuilder)
+inline fun KSLog.t(message: Any, e: Throwable?) = trace(message, e)
+inline fun KSLog.t(message: String, e: Throwable) = t(message as Any, e)
+inline fun KSLog.t(message: Any) = t(message, null)
+inline fun KSLog.t(tag: String, message: Any, e: Throwable?) = trace(tag, message, e)
+inline fun KSLog.t(tag: String, message: Any) = t(tag, message, null)
+
+
 inline fun KSLog.d(e: Throwable? = null, noinline messageBuilder: () -> Any) = debug(e, messageBuilder)
 inline fun KSLog.d(tag: String?, e: Throwable? = null, noinline messageBuilder: () -> Any) = debug(tag, e, messageBuilder)
 inline fun KSLog.d(tag: String, noinline messageBuilder: () -> Any) = d(tag, null, messageBuilder)

src/commonMain/kotlin/KSLog.kt

@@ -1,9 +1,11 @@
 package dev.inmo.kslog.common
 
 import dev.inmo.kslog.common.filter.filtered
+import dev.inmo.kslog.common.utils.plus
 
 
 enum class LogLevel {
+    TRACE,
     DEBUG,
     VERBOSE,
     INFO,
@@ -12,15 +14,38 @@ enum class LogLevel {
     ASSERT,
 }
 
+/**
+ * Base interface for any logger
+ *
+ * @see default
+ *
+ */
 interface KSLog {
+    /**
+     * The only one function required to realization in any inheritor. All other [performLog] functions
+     * will call this one by default
+     */
     fun performLog(level: LogLevel, tag: String?, message: Any, throwable: Throwable?)
+
+    /**
+     * Calls default [performLog] with `tag` == `null`
+     */
     fun performLog(level: LogLevel, message: Any, throwable: Throwable?) = performLog(level, null, message, throwable)
+    /**
+     * Calls default [performLog] with `message` built using [messageBuilder]. This method supposed to be overriden in
+     * case when logger supports lazy-loaded messages (like [dev.inmo.kslog.common.filter.FilterKSLog])
+     */
     fun performLog(
         level: LogLevel,
         tag: String?,
         throwable: Throwable?,
         messageBuilder: () -> Any
     ) = performLog(level, tag, messageBuilder(), throwable)
+
+    /**
+     * Suspendable variant of [performLog] with [messageBuilder]. Uses default [performLog] with `message` built using
+     * [messageBuilder] by default
+     */
     suspend fun performLogS(
         level: LogLevel,
         tag: String?,
@@ -31,6 +56,10 @@ interface KSLog {
 
     companion object : KSLog {
         private var defaultLogger: KSLog? = null
+
+        /**
+         * Default logger used in case you are trying to use [KSLog] as a receiver for extensions like [info]
+         */
         var default: KSLog
             get() {
                 return defaultLogger ?: KSLog("app").also {
@@ -60,11 +89,23 @@ interface KSLog {
 
 operator fun KSLog.invoke(performLogCallback: (level: LogLevel, tag: String?, message: Any, throwable: Throwable?) -> Unit) = CallbackKSLog(performLogCallback)
 
-internal expect val defaultLogging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit
+internal val printlnLogging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
+    println(defaultMessageFormatter(l, t, m, e))
+}
 
+/**
+ * Simple builder for [DefaultKSLog] logger based on [defaultTag]
+ */
 fun KSLog(
     defaultTag: String,
-    messageFormatter: MessageFormatter = defaultMessageFormatter
+): KSLog = DefaultKSLog(defaultTag)
+
+/**
+ * Simple builder for [DefaultKSLog] logger based on [defaultTag] and [messageFormatter]
+ */
+fun KSLog(
+    defaultTag: String,
+    messageFormatter: MessageFormatter
 ): KSLog = DefaultKSLog(
     defaultTag,
     messageFormatter
@@ -75,23 +116,30 @@ fun KSLog(
     defaultTag: String,
     filter: MessageFilter,
     messageFormatter: MessageFormatter = defaultMessageFormatter
-): KSLog = DefaultKSLog(
+): KSLog = KSLog (
     defaultTag,
-    filter,
     messageFormatter
-)
+).filtered(filter)
 
+/**
+ * Building logger using [KSLog] builder based on [defaultTag] and [messageFormatter]. This logger will also filter
+ * incoming levels: only levels passed in [levels] param will be logged
+ */
 fun KSLog(
     defaultTag: String,
     levels: Iterable<LogLevel>,
     messageFormatter: MessageFormatter = defaultMessageFormatter
 ): KSLog {
-    val levels = levels.toSet()
+    val levelsSet = levels.toSet()
     return KSLog (defaultTag, messageFormatter).filtered { l, _, _ ->
-        l in levels
+        l in levelsSet
     }
 }
 
+/**
+ * Building logger using [KSLog] builder based on [defaultTag] and [messageFormatter]. This logger will also filter
+ * incoming levels: only levels passed in [firstLevel], [secondLevel] and [otherLevels] param will be logged
+ */
 fun KSLog(
     defaultTag: String,
     firstLevel: LogLevel,
@@ -100,6 +148,10 @@ fun KSLog(
     messageFormatter: MessageFormatter = defaultMessageFormatter,
 ): KSLog = KSLog(defaultTag, setOf(firstLevel, secondLevel, *otherLevels), messageFormatter)
 
+/**
+ * Building logger using [KSLog] builder based on [defaultTag] and [messageFormatter]. This logger will also filter
+ * incoming levels: only levels above [minLoggingLevel] will be logged
+ */
 fun KSLog(
     defaultTag: String,
     minLoggingLevel: LogLevel,
@@ -110,3 +162,14 @@ fun KSLog(
 ).filtered { l, _, _ ->
     minLoggingLevel.ordinal <= l.ordinal
 }
+
+/**
+ * Setting [KSLog.default] logger to [newDefault]
+ */
+fun setDefaultKSLog(newDefault: KSLog) { KSLog.default = newDefault }
+/**
+ * Setting [KSLog.default] logger to new [CallbackKSLog] using [plus] operation
+ */
+fun addDefaultKSLog(newDefault: KSLog) {
+    KSLog.default += newDefault
+}

src/commonMain/kotlin/KSLogTypealiases.kt

@@ -1,6 +1,7 @@
 package dev.inmo.kslog.common
 
-typealias MessageFormatter = (l: LogLevel, t: String, m: Any, Throwable?) -> String
+typealias MessageFormatter = (l: LogLevel, t: String?, m: Any, Throwable?) -> String
+inline fun MessageFormatter(noinline formatter: MessageFormatter) = formatter
 typealias MessageFilter = (l: LogLevel, t: String?, Throwable?) -> Boolean
-val defaultMessageFormatter: MessageFormatter = { l, t, m, _ -> "[$l] $t - $m" }
-
+val defaultMessageFormatter: MessageFormatter = { l, t, m, _ -> "[$l] ${t ?.let { "$it " } ?: ""}- $m" }
+val defaultMessageFormatterWithErrorPrint: MessageFormatter = { l, t, m, e -> "[$l] ${t ?.let { "$it " } ?: ""}- $m${e ?.let { ": ${it.stackTraceToString()}" } ?: ""}" }

src/commonMain/kotlin/KSLoggerDefaultPlatformLoggerLambdaExpect.kt

@@ -0,0 +1,7 @@
+package dev.inmo.kslog.common
+
+/**
+ * Default logger for current platform. You may change it, but you should remember that it is global logger
+ * used in [KSLog.default] by default
+ */
+expect var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit

src/commonMain/kotlin/TagLogger.kt

@@ -2,6 +2,9 @@ package dev.inmo.kslog.common
 
 import kotlin.jvm.JvmInline
 
+/**
+ * Logger which will use [tag] as default one in cases when [performLog] have `null` tag
+ */
 @JvmInline
 value class TagLogger(val tag: String) : KSLog {
     override fun performLog(level: LogLevel, tag: String?, message: Any, throwable: Throwable?) {

src/commonMain/kotlin/filter/FilterKSLog.kt

@@ -2,6 +2,10 @@ package dev.inmo.kslog.common.filter
 
 import dev.inmo.kslog.common.*
 
+/**
+ * In its [performLog]/[performLogS] methods do logging only in cases when [messageFilter] returns true for incoming
+ * parameters
+ */
 class FilterKSLog(
     private val fallbackLogger: KSLog,
     private val messageFilter: MessageFilter

src/commonMain/kotlin/filter/FilteredExtension.kt

@@ -3,6 +3,9 @@ package dev.inmo.kslog.common.filter
 import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.MessageFilter
 
+/**
+ * Creates [FilterKSLog] with applying of [filter] to it
+ */
 fun KSLog.filtered(
     filter: MessageFilter
 ) = FilterKSLog(this, filter)

src/commonMain/kotlin/typed/TypedKSLog.kt

@@ -3,6 +3,11 @@ package dev.inmo.kslog.common.typed
 import dev.inmo.kslog.common.*
 import kotlin.reflect.KClass
 
+/**
+ * Uses [typedLoggers] [Map] to determine, where incoming __message__s should be sent. If there is no [KClass] key for
+ * incoming message in [typedLoggers], logger will use logger by `null` key if exists. If there is no default logger
+ * (by `null` key), logging will be skipped
+ */
 class TypedKSLog(
     private val typedLoggers: Map<KClass<*>?, KSLog>
 ) : KSLog {

src/commonMain/kotlin/typed/TypedKSLogBuilder.kt

@@ -3,6 +3,9 @@ package dev.inmo.kslog.common.typed
 import dev.inmo.kslog.common.*
 import kotlin.reflect.KClass
 
+/**
+ * Special builder for [TypedKSLog]
+ */
 class TypedKSLogBuilder(
     private val preset: Map<KClass<*>?, KSLog> = emptyMap()
 ) {
@@ -22,6 +25,9 @@ class TypedKSLogBuilder(
     fun build() = TypedKSLog(loggers.toMap())
 }
 
+/**
+ * DSL for [TypedKSLogBuilder]
+ */
 inline fun buildTypedLogger(
     preset: Map<KClass<*>?, KSLog> = emptyMap(),
     block: TypedKSLogBuilder.() -> Unit

src/commonMain/kotlin/utils/Combination.kt

@@ -0,0 +1,19 @@
+package dev.inmo.kslog.common.utils
+
+import dev.inmo.kslog.common.CallbackKSLog
+import dev.inmo.kslog.common.KSLog
+
+/**
+ * Will send [KSLog.performLog] of both [this] and [other] [KSLog] instances. In case when [this] will throw exception
+ * result logger will rethrow it. After it, if [other] will throw exception - will also rethrow it
+ */
+infix operator fun KSLog.plus(other: KSLog) = CallbackKSLog { l, t, m, e ->
+    val resultOfFirst = runCatching {
+        this@plus.performLog(l, t, m, e)
+    }
+    val resultOfSecond = runCatching {
+        other.performLog(l, t, m, e)
+    }
+    resultOfFirst.onFailure { throw it }
+    resultOfSecond.onFailure { throw it }
+}

src/jsMain/kotlin/ActualLogger.kt

@@ -1,15 +0,0 @@
-package dev.inmo.kslog.common
-
-internal actual val defaultLogging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
-    val args = e ?.let {
-        arrayOf(m, e)
-    } ?: arrayOf(m)
-    when (l) {
-        LogLevel.DEBUG -> console.log(*args)
-        LogLevel.VERBOSE,
-        LogLevel.INFO -> console.info(*args)
-        LogLevel.WARNING -> console.warn(*args)
-        LogLevel.ERROR,
-        LogLevel.ASSERT -> console.error(*args)
-    }
-}

src/jsMain/kotlin/ExtendedConsole.kt

@@ -0,0 +1,24 @@
+package dev.inmo.kslog.common
+
+import kotlin.js.Console
+
+external interface ExtendedConsole : Console {
+    fun trace()
+    fun debug(vararg o: Any?)
+    fun assert(assertion: Boolean, vararg o: Any?)
+}
+
+/**
+ * [https://developer.mozilla.org/en-US/docs/Web/API/console/debug_static](https://developer.mozilla.org/en-US/docs/Web/API/console/debug_static)
+ */
+fun Console.debug(vararg args: Any?) = unsafeCast<ExtendedConsole>().debug(*args)
+
+/**
+ * [https://developer.mozilla.org/en-US/docs/Web/APtraceI/console/assert_static](https://developer.mozilla.org/en-US/docs/Web/API/console/assert_static)
+ */
+fun Console.assert(assertion: Boolean, vararg args: Any?) = unsafeCast<ExtendedConsole>().assert(assertion, *args)
+
+/**
+ * [https://developer.mozilla.org/en-US/docs/Web/API/console/trace_static](https://developer.mozilla.org/en-US/docs/Web/API/console/trace_static)
+ */
+fun Console.trace() = unsafeCast<ExtendedConsole>().trace()

src/jsMain/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,19 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, _, m, e ->
+    val args = e ?.let {
+        arrayOf(m, e)
+    } ?: arrayOf(m)
+    when (l) {
+        LogLevel.TRACE -> {
+            console.trace()
+            console.debug(*args)
+        }
+        LogLevel.DEBUG -> console.debug(*args)
+        LogLevel.VERBOSE,
+        LogLevel.INFO -> console.info(*args)
+        LogLevel.WARNING -> console.warn(*args)
+        LogLevel.ERROR -> console.error(*args)
+        LogLevel.ASSERT -> console.error(*args)
+    }
+}

src/jvmMain/kotlin/ActualLogger.kt

@@ -4,14 +4,15 @@ import dev.inmo.kslog.common.filter.filtered
 import java.util.logging.Level
 import java.util.logging.Logger
 
-private val defaultKSLogLogger by lazy {
+internal val defaultKSLogLogger by lazy {
     Logger.getLogger("KSLog")
 }
-private fun Logger.doLog(
+internal fun Logger.doLog(
     l: LogLevel, t: String, m: String, e: Throwable?
 ) = log(
     when(l) {
-        LogLevel.DEBUG -> Level.FINEST
+        LogLevel.TRACE -> Level.FINEST
+        LogLevel.DEBUG -> Level.FINER
         LogLevel.VERBOSE -> Level.FINE
         LogLevel.INFO -> Level.INFO
         LogLevel.WARNING -> Level.WARNING
@@ -21,9 +22,6 @@ private fun Logger.doLog(
     m,
     e
 )
-internal actual val defaultLogging: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
-    defaultKSLogLogger.doLog(l, t, m.toString(), e)
-}
 
 @Deprecated("Filtering should be replaced with FilterKSLog")
 fun KSLog(
@@ -52,8 +50,8 @@ fun KSLog(
     levels: Iterable<LogLevel>,
     messageFormatter: MessageFormatter = defaultMessageFormatter
 ): KSLog {
-    val levels = levels.toSet()
-    return KSLog (defaultTag, logger, messageFormatter).filtered { l, _, _ -> l in levels }
+    val levelsSet = levels.toSet()
+    return KSLog (defaultTag, logger, messageFormatter).filtered { l, _, _ -> l in levelsSet }
 }
 
 fun KSLog(

src/jvmMain/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,5 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit = { l, t, m, e ->
+    defaultKSLogLogger.doLog(l, t, m.toString(), e)
+}

src/linuxArm32HfpMain/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,4 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit =
+    printlnLogging

src/linuxArm64Main/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,4 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit =
+    printlnLogging

src/linuxX64Main/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,4 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit =
+    printlnLogging

src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.kslog"/>

src/mingwX64Main/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,4 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit =
+    printlnLogging

src/wasmJsMain/kotlin/KSLoggerDefaultPlatformLoggerLambda.kt

@@ -0,0 +1,4 @@
+package dev.inmo.kslog.common
+
+actual var KSLoggerDefaultPlatformLoggerLambda: (level: LogLevel, tag: String, message: Any, throwable: Throwable?) -> Unit =
+    printlnLogging