As issue https://github.com/MicroUtils/kotlin-logging/issues/21 was only dedicated for Kotlin/JVM and Kotlin/JS multi platform support, this issue is for Kotlin/Native support.

Kotlin/Native target platform is seen in org.jetbrains.kotlin.konan.target.KonanTarget.kt file line 43 as of 2018 August 16th:

sealed class KonanTarget(override val name: String, val family: Family, val architecture: Architecture) : Named {
    object ANDROID_ARM32 :  KonanTarget( "android_arm32",   Family.ANDROID, Architecture.ARM32)
    object ANDROID_ARM64 :  KonanTarget( "android_arm64",   Family.ANDROID, Architecture.ARM64)
    object IOS_ARM32 :      KonanTarget( "ios_arm32",       Family.IOS,     Architecture.ARM32)
    object IOS_ARM64 :      KonanTarget( "ios_arm64",       Family.IOS,     Architecture.ARM64)
    object IOS_X64 :        KonanTarget( "ios_x64",         Family.IOS,     Architecture.X64)
    object LINUX_X64 :      KonanTarget( "linux_x64",       Family.LINUX,   Architecture.X64)
    object MINGW_X64 :      KonanTarget( "mingw_x64",       Family.MINGW,   Architecture.X64)
    object MACOS_X64 :      KonanTarget( "macos_x64",       Family.OSX,     Architecture.X64)
    object LINUX_ARM32_HFP :KonanTarget( "linux_arm32_hfp", Family.LINUX,   Architecture.ARM32)
    object LINUX_MIPS32 :   KonanTarget( "linux_mips32",    Family.LINUX,   Architecture.MIPS32)
    object LINUX_MIPSEL32 : KonanTarget( "linux_mipsel32",  Family.LINUX,   Architecture.MIPSEL32)
    object WASM32 :         KonanTarget( "wasm32",          Family.WASM,    Architecture.WASM32)

    // Tunable targets
    class ZEPHYR(val subName: String, val genericName: String = "zephyr") : KonanTarget("${genericName}_$subName", Family.ZEPHYR, Architecture.ARM32)

    override fun toString() = name
}

Above list can give idea for implementation for different platforms.

A proposal for a change that is slightly breaking but allows consumers to create their own kLogger implementations for custom logging environments. My use-case is for Android apps the SLF4J-Android implementation is deprecated and badly formats exceptions and cuts off most of the stack trace so I used this to have an implementation that in an Android app simply calls the Log.x functions.

For simplicity it also is a breaking change as it removes the SLF4J logger base interface from KLogger in JVM so I proposed a 2.0 version. Interested to hear any feedback

This PR partly addresses issue #45 by only adding support for a single Kotlin Native target (linuxX64), and is the successor to PR #103 . Implementation of this PR is based on the existing JS implementation with some minor adaptations made to make it work with the Kotlin Native linuxX64 target. Use of dependencies is minimal with only the Kotlin Native Standard library, and POSIX being used. Most Linux distributions have built-in support for POSIX (Android is one of the main exceptions).

The latest stable version of Kotlin is used due to Kotlin Native currently not having proper backwards compatibility. It remains unknown if this situation will be resolved with the Kotlin 1.4 release that is arriving soon.

Is there a way to lazy evaluate log statements that use net.logstash.logback.argument.StructuredArgument?

Currently I can only use logger.trace("msg", kv("foo", bar())) and if bar takes some time to compute I have to wrap everything with logger.isTraceEnabled. It would be nice if I could somehow fall back to some variant of logger.trace { ??? } for this case.

When using this library with the new native memory model of native I get the follwing exception:

kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen mu.KotlinLoggingLevel@fa8aa0
    at kfun:kotlin.Throwable#<init>(kotlin.String?){} (0x494001)
    at kfun:kotlin.Exception#<init>(kotlin.String?){} (0x48cc5d)
    at kfun:kotlin.RuntimeException#<init>(kotlin.String?){} (0x48ce0d)
    at kfun:kotlin.native.concurrent.InvalidMutabilityException#<init>(kotlin.String){} (0x4bd1cd)
    at ThrowInvalidMutabilityException (0x4be4c8)
    at Kotlin_AtomicReference_checkIfFrozen (0x872364)
    at kfun:kotlin.native.concurrent.AtomicReference#<init>(1:0){} (0x4bc782)
    at kfun:mu.KotlinLoggingConfiguration#<init>(){} (0x697878)
    at _ZN6kotlin2mm13InitSingletonEPNS0_10ThreadDataEPP9ObjHeaderPK8TypeInfoPFvS4_ES5_ (0x84b2b2)
    at kfun:mu.internal.KLoggerLinux#warn(kotlin.Throwable?;kotlin.Function0<kotlin.Any?>){} (0x69a286)

Consider adding some additional functions for managing MDC (Javadoc: https://www.slf4j.org/api/org/slf4j/MDC.html) by putting and removing keys

Additional consideration: it would be great to have it with coroutines

Docs: https://www.slf4j.org/manual.html#mdc

I don't have a concrete API proposal but here is some initial thoughts:

object MDC {
  // additional overloads for varargs and up to some N number of `Pair`
  fun <T> withContext(keyPair: Pair<String, String>, body: () -> T) {
    return org.slf4j.MDC.putCloseable(keyPair.first, keyPair.second).use {
      body()
    }
  }
}

For my logback.xml configuration of:

<pattern>... \(%F:%L\) %msg%n</pattern>

I'm consistently getting file name / line number in the KLogger file (KLogger.kt:23) for all my debug statements, which is precisely where KLogger itself calls debug().

I'm using 1.4.2 so #11 shouldn't apply. This happens when I use val logger = LoggerFactory.getLogger("class name") or private val logger = KotlinLogging.logger {}.

Thanks!

Bump log4j from 2.18.0 to 2.19.0

• Bumps log4j from 2.18.0 to 2.19.0
• Bumps slf4j from 1.7.32 to 2.0.1
• Migrates to log4j-slf4j2. See https://logging.apache.org/log4j/2.x/log4j-slf4j-impl/index.html

Release notes:

log4j : https://logging.apache.org/log4j/2.x/changes-report.html#a2.19.0 slf4j : https://www.slf4j.org/faq.html#changesInVersion200

Kotlin 1.5 is out, but kotlin-logging still being on 1.4 causes dependency conflicts in my project. With this change, I bump the Kotlin version to 1.5.

https://blog.jetbrains.com/kotlin/2021/05/kotlin-1-5-0-released/

Hi,

Thanks for putting this library together. In using kotlin, I was putoff by the long/complex answers to the simple question "how do you log in kotlin (http://stackoverflow.com/questions/34416869/idiomatic-way-of-logging-in-kotlin)".

I'm using Klogging as follows:

    companion object: KLogging()

     init {
        logger.info("NewsArticle initialized: " + this)
      }

This works nicely, but when I do logger.debug, my IntelliJ IDEA run console doesn't show any output. Do you know how I could set the console logger to debug or trace levels? Is this an IDE setting, or can it be set in the call to KLogging()?

I use gradle plugin for automatic check dependencies licenses. But your library not verified, because in your jar file license not present. Can you put license to JAR file?

As part of a revamp to the library I am considering some breaking changes, or api's that should be added / removed:

• remove slf4j from the jvm signature (ie, will not implement slf4j Logger interface) and replace is with similar KLogger interface.
• do we need to add fluent logging support?
• change artifact name for jvm version to allow split: slfj/log4j/android etc'.
• remove api of mu.KLoggable in favour of KotlinLogging.logger {} about 5k refs at: https://github.com/search?q=%22mu.KLogging%22&type=code
• do we need inline of logging methods?

I am basically considering two conflicting approaches

• keep the lib slf4j compliant.
• allow better multiplatform/android support.

Related issues: #122 #34 #228

Any feedback is appreciated.

For example the following simple code is supposed to fail:

fun main(args: Array<String>) {
    log.info{"This cannot be converted to int!".toInt()}
    log.info("I'm not supposed to see this line!")

However it does not fail:

2022-11-04 13:40:53:802 -0400 [main] INFO Main - Log message invocation failed: java.lang.NumberFormatException: For input string: "This cannot be converted to int!"
2022-11-04 13:40:53:804 -0400 [main] INFO Main - I'm not supposed to see this line!

This is unexpected: logging is not supposed to catch any user exceptions, it should not affect the intended path in any way.

Thanks, Petru

implementation 'io.github.microutils:kotlin-logging:2.0.11' implementation 'org.slf4j:slf4j-simple:1.7.36' implementation 'org.slf4j:slf4j-api:1.7.36'

With these library i can't see any log using Android

val klog = KotlinLogging.logger{}

would be nice to have a shortcut for single MDC logging. I would like to write code like this

log.info { "add Item to basket".fields("accountId" to "123456789", "itemId" to "123456789") } 

instead of

withLoggingContext("accountId" to "123456789", "itemId" to "123456789") {
    log.info { "add Item to basket" }
}

I need that feature to be able to log this key value pairs as json fields. Inspired by the slf4j structured logging feature https://stackoverflow.com/a/58710096/5376635