Lightweight logging framework for Kotlin. A convenient and performant logging library wrapping slf4j with Kotlin extensions

Overview

kotlin-logging kotlin-logging CI Slack channel Maven Central Apache License V.2

Lightweight logging framework for Kotlin, written in Pure Kotlin.
A convenient and performant logging library wrapping slf4j with Kotlin extensions.

Call log methods, without checking whether the respective log level is enabled

logger.debug { "Some $expensive message!" }

Behind the scenes the expensive message do not get evaluated if debug is not enabled:

// This is what happens when you write the above ^^^
if (logger.isDebugEnabled) logger.debug("Some $expensive message!")

Define the logger, without explicitly specifiying the class name

// Place definition above class declaration to make field static
private val logger = KotlinLogging.logger {}

Behind the scenes val logger will be created in the class, with the class/file name:

// This is what happens when you write the above ^^^
val logger = LoggerFactory.getLogger("package.ClassName")

Log exceptions in a Kotlin-style

// exception as first parameter with message as lambda
logger.error(exception) { "a $fancy message about the $exception" }

Getting started

import mu.KotlinLogging
private val logger = KotlinLogging.logger {} 
class FooWithLogging {
    val message = "world"
    fun bar() {
        logger.debug { "hello $message" }
    }
}

An Android example project with kotlin-logging can be found in kotlin-logging-example-android.

Download

Important note: kotlin-logging depends on slf4j-api (in the JVM artifact). In runtime, it is also required to depend on a logging implementation. More details in how-to-configure-slf4j. And an excellent detailed explanation in a-guide-to-logging-in-java.

In short, if you just want to log statements to stdout, it's possible to add the following dependency: org.slf4j:slf4j-simple:1.7.29.

Maven

<dependency>
  <groupId>io.github.microutils</groupId>
  <artifactId>kotlin-logging-jvm</artifactId>
  <version>2.1.20</version>
</dependency>

or

<dependency>
  <groupId>io.github.microutils</groupId>
  <artifactId>kotlin-logging</artifactId>
  <version>1.12.5</version>
</dependency>

See the full example in kotlin-logging-example-maven.

Gradle

implementation 'io.github.microutils:kotlin-logging-jvm:2.1.20'

or

implementation 'io.github.microutils:kotlin-logging:1.12.5'

Alternatively, download the JAR from github or bintray or maven-central.

Version 2.x vs 1.x

There are currently two supported branches: 1.x and 2.x.

The main incompatible change is in the artifact names. In version 1.x the jvm artifact is called kotlin-logging while in version 2.x it's called kotlin-logging-jvm to comply with the multiplatform schema. In addition, version 2.x supports only Kotlin >= 1.4.

Therefore, for jvm library owners it is still recommended to use 1.x, as for the rest of the use cases 2.x is recommended.

Multiplatform

An experimental common & JS & linux-x64 support is available.
More information is available on the wiki and issues #21 #45.

Overview

After seeing many questions like Idiomatic way of logging in Kotlin and Best practices for loggers, it seems like there should be a standard for logging and obtaining a logger in Kotlin. kotlin-logging provides a wrapper for slf4j-api to be used by Kotlin classes with the following advantages:

  • No need to write the logger and class name or logger name boilerplate code.
  • A straight forward way to log messages with lazy-evaluated string using lambda expression {}.
  • All previous slf4j implementation can still be used.

Who is using it

And many more... (add your name above)

FAQ

  • Why not use plain slf4j? kotlin-logging has better native Kotlin support. It adds more functionality and enables less boilerplate code.
  • Is all slf4j implementation supported (Markers, params, etc')? Yes, kotlin-logging inherits Logger and all methods are supported.
  • Is location logging possible? Yes, location awareness was added in kotlin-logging 1.4.
  • 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()? Setting log level is done per implementation. kotlin-logging and slf4j are just facades for the underlying logging lib (log4j, logback etc') more details here.
  • Can I access the actual logger? Yes, via KLogger.underlyingLogger property.

Usage

  • See wiki for more examples.

It is possible to configure IntelliJ live templates. For file level logger configure the following:

  • Text template: private val logger = mu.KotlinLogging.logger {}.
  • Applicable in Kotlin: top-level.

Support

More links

Contributors

Any contribution is appreciated. See the contributors list in: https://github.com/MicroUtils/kotlin-logging/graphs/contributors

Contributing

Pull requests are welcome!
Show your ❀ with a β˜…

Comments
  • Kotlin/Native Support

    Kotlin/Native Support

    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.

    enhancement help wanted 
    opened by joelhandwell 38
  • ability to create custom logger factories to make non-SLF4J implementations

    ability to create custom logger factories to make non-SLF4J implementations

    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

    opened by thadcodes 16
  • Add Linux X64 Support

    Add Linux X64 Support

    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.

    opened by napperley 16
  • Lazy evaluated structured arguments

    Lazy evaluated structured arguments

    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.

    opened by kschlesselmann 14
  • InvalidMutabilityException: mutation attempt of frozen mu.KotlinLoggingLevel

    InvalidMutabilityException: mutation attempt of frozen mu.KotlinLoggingLevel

    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)
    
    opened by benkuly 12
  • Feature: MDC support

    Feature: MDC support

    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()
        }
      }
    }
    
    opened by mkobit 11
  • Incorrect file name and line number

    Incorrect file name and line number

    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!

    opened by wafisher 11
  • build(deps): bump log4j from 2.18.0 to 2.19.0

    build(deps): bump log4j from 2.18.0 to 2.19.0

    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

    opened by yeikel 10
  • Bump to Kotlin 1.5

    Bump to Kotlin 1.5

    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/

    opened by snooze92 10
  • How to set project loglevel

    How to set project loglevel

    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()?

    opened by hugadams 10
  • Put LICENSE to the JAR

    Put LICENSE to the JAR

    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? image

    opened by bespaltovyj 9
  • kotlin-logging version 4.x: breaking changes

    kotlin-logging version 4.x: breaking changes

    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.

    opened by oshai 0
  • Logging with brackets (lazy) eats the eventual exceptions

    Logging with brackets (lazy) eats the eventual exceptions

    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

    opened by petrum 5
  • Not work on Android

    Not work on Android

    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{}

    opened by alessandroToninelli 15
  • [Feature Request] Structured Logging

    [Feature Request] Structured Logging

    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

    opened by qoomon 10
Releases(3.0.4)
  • 3.0.4(Nov 2, 2022)

    What's Changed

    • set jvmTarget back to 8 by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/258
    • add ktfmtCheck to CI by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/259

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/3.0.3...3.0.4

    Source code(tar.gz)
    Source code(zip)
  • 3.0.3(Oct 29, 2022)

    What's Changed

    • add "Automatic-Module-Name" for #223 by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/256
    • reword slf4j usage for #229 by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/255
    • add simple native test (main) by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/219

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/3.0.1...3.0.3

    Source code(tar.gz)
    Source code(zip)
  • 3.0.1(Oct 11, 2022)

    What's Changed

    • build(deps): bump slf4j from 2.0.1 to 2.0.2 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/242
    • build(deps): bump slf4j from 2.0.2 to 2.0.3 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/243
    • build(deps): bump junit from 5.8.2 to 5.9.1 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/244
    • build(test-dep): Migrate to mockito-core by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/245
    • build(deps): bump kotlin multiplatform from 1.6.0 to 1.7.20 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/247
    • build(deps): bump dokka from 1.6.0 to 1.7.10 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/248
    • add ktfmt by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/251

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/3.0.0...3.0.1

    Source code(tar.gz)
    Source code(zip)
  • 3.0.0(Sep 18, 2022)

    What's Changed

    Major version upgrade to 3.0.0 to reflect upgrade of slf4j to 2.x.

    • Upgrade slf4j 1.x->2.x by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/234
    • fix kdoc of mu.KotlinLogging.logger by @aivantsov in https://github.com/MicroUtils/kotlin-logging/pull/230
    • remove 1.x links from readme by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/231
    • build(deps): bump log4j from 2.17.1 to 2.18.0 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/235
    • Create SECURITY.md by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/237
    • Bump gradle wrapper to 7.5.1 by @yeikel in https://github.com/MicroUtils/kotlin-logging/pull/238

    New Contributors

    • @aivantsov made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/230
    • @yeikel made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/235

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/2.1.23...3.0.0

    Source code(tar.gz)
    Source code(zip)
  • 2.1.23(May 20, 2022)

    What's Changed

    • update log4j to 2.17.1 by @imsprathap in https://github.com/MicroUtils/kotlin-logging/pull/222
    • Add support for os_log on Apple platforms by @conradev in https://github.com/MicroUtils/kotlin-logging/pull/227

    New Contributors

    • @imsprathap made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/222
    • @conradev made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/227

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/2.1.21...2.1.23

    Source code(tar.gz)
    Source code(zip)
  • 2.1.21(Dec 18, 2021)

    What's Changed

    • update log4j to 2.17.0 by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/215

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/2.1.17...2.1.21

    Source code(tar.gz)
    Source code(zip)
  • 2.1.17(Dec 16, 2021)

    What's Changed

    • Upgrade to JUnit5 by @severn-everett in https://github.com/MicroUtils/kotlin-logging/pull/204
    • Fix critical vulnerability in log4j by @stigkj in https://github.com/MicroUtils/kotlin-logging/pull/207
    • Addressing points raised in detektJvmMain task by @severn-everett in https://github.com/MicroUtils/kotlin-logging/pull/203
    • Upgraded Dokka to 1.6.0 by @severn-everett in https://github.com/MicroUtils/kotlin-logging/pull/209
    • Upgraded log4j from 2.15.0 to 2.16.0 (CVE-2021-45046) by @evmetatron in https://github.com/MicroUtils/kotlin-logging/pull/211

    New Contributors

    • @severn-everett made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/204
    • @stigkj made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/207
    • @evmetatron made their first contribution in https://github.com/MicroUtils/kotlin-logging/pull/211

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/2.1.15...2.1.17

    Source code(tar.gz)
    Source code(zip)
  • 2.1.15(Dec 6, 2021)

    What's Changed

    • upgrade kotlin 1.6.0 <- 1.5.21 by @oshai in https://github.com/MicroUtils/kotlin-logging/pull/202

    Full Changelog: https://github.com/MicroUtils/kotlin-logging/compare/2.1.14...2.1.15

    Source code(tar.gz)
    Source code(zip)
Owner
null
StaticLog - super lightweight static logging for Kotlin, Java and Android

StaticLog StaticLog is a super lightweight logging library implemented in pure Kotlin (https://kotlinlang.org). It is designed to be used in Kotlin, J

Julian Pfeifer 28 Oct 3, 2022
Various experimental proposals and extensions to Javalin 4.x used in Reposilite 3.x

Javalin RFCs Various experimental extensions to Javalin 4.x used in Reposilite 3.x. Provides basic support for Kotlin coroutines and async routes with

Reposilite Playground 5 Feb 22, 2022
Automatic CoroutineDispatcher injection and extensions for kotlinx.coroutines

Dispatch Utilities for kotlinx.coroutines which make them type-safe, easier to test, and more expressive. Use the predefined types and factories or de

Rick Busarow 132 Dec 9, 2022
Easy Android logging with Kotlin and Timber

Kotlin logging extensions for Timber Jake Wharton's Timber library is great. It's a Java library with an API that works well for Java, but that isn't

AJ Alt 198 Nov 15, 2022
Minimalistic and multiplatform logging for Kotlin

klog This project is not abandonned. It's just nothing to add. KLogging provides unified logging API, which you can use from Kotlin code targeted for

Lev Shagalov 11 Oct 3, 2022
A collection of hand-crafted extensions for your Kotlin projects.

Splitties Splitties is a collection of small Kotlin multiplatform libraries (with Android as first target). These libraries are intended to reduce the

Louis CAD 2.2k Dec 25, 2022
Common Android/Kotlin extensions

Common Android/Kotlin extensions Gradle implementation "com.github.javokhirsavriev:common-extensions:1.0.1" License Copyright 2022 Javokhir Savriev L

Javokhir 0 Feb 15, 2022
Android View Lifecycle Extensions

Android View Lifecycle Extensions Extensions for Android View class that let you access a view lifecycle without having to create a custom view (exten

Thomas Gorisse 22 Dec 6, 2022
Actions are things that run, with parameters. Serves as a common dependency for a variety of Cepi extensions.

Actions Actions that take in customizable paramaters, an optional target, and do things. Installation Download the jar from Releases OR compile it you

Cepi 1 Jan 9, 2022
Simple, fast, efficient logging facade for Android apps

Β΅log Simple, fast, and efficient logging facade for Android apps. Inspired by Timber and Logcat. Features Lazy message evaluation Pluggable backends (

Danny Lin 9 Oct 21, 2022
🚟 Lightweight, and simple scheduling library made for Kotlin (JVM)

Haru ?? Lightweight, and simple scheduling library made for Kotlin (JVM) Why did you build this? I built this library as a personal usage library to h

Noel 13 Dec 16, 2022
A lightweight and simple Kotlin library for deep link handling on Android πŸ”—.

A lightweight and simple Kotlin library for deep link handling on Android ??.

Jeziel Lago 101 Aug 14, 2022
Lightweight compiler plugin intended for Kotlin/JVM library development and symbol visibility control.

Restrikt A Kotlin/JVM compiler plugin to restrict symbols access, from external project sources. This plugin offers two ways to hide symbols: An autom

Lorris Creantor 18 Nov 24, 2022
Lightweight data loading and caching library for android

ColdStorage A lightweight data loading and caching library for android Quicklinks Feature requests: Got a new requirement? Request it here and it will

Cryptic Minds 41 Oct 17, 2022
A lightweight, simple, smart and powerful Android routing library.

RxRouter Read this in other languages: δΈ­ζ–‡, English A lightweight, simple, smart and powerful Android routing library. Getting started Setting up the d

Season 323 Nov 10, 2022
Clickstream - A Modern, Fast, and Lightweight Android Library Ingestion Platform.

Clickstream is an event agnostic, real-time data ingestion platform. Clickstream allows apps to maintain a long-running connection to send data in real-time.

Gojek 60 Dec 24, 2022
A lightweight cache library written in Kotlin

[NEW] Released to Maven Central: 'com.github.yundom:kache:1.x.x' Kache A runtime in-memory cache. Installation Put this in your build.gradle implemen

Dennis 22 Nov 19, 2022
Easy lightweight SharedPreferences library for Android in Kotlin using delegated properties

Easy lightweight SharedPreferences library for Android in Kotlin using delegated properties Idea Delegated properties in Kotlin allow you to execute a

null 25 Dec 27, 2022
Koi, a lightweight kotlin library for Android Development.

Koi - A lightweight Kotlin library for Android Koi include many useful extensions and functions, they can help reducing the boilerplate code in Androi

Hello World 514 Nov 29, 2022