better logging support & asyncBouncer enchanced

Author: sergeych

build.gradle.kts

@@ -7,7 +7,8 @@ plugins {
 }
 
 group = "net.sergeych"
-version = "1.2.0"
+version = "1.2.2-SNAPSHOT"
+
 val serialization_version = "1.3.2"
 
 repositories {
@@ -50,14 +51,14 @@ kotlin {
         val commonMain by getting {
             dependencies {
                 api("org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version")
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1")
                 implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.2")
             }
         }
         val commonTest by getting {
             dependencies {
                 implementation(kotlin("test"))
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.0")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.1")
             }
         }
         val jvmMain by getting

src/commonMain/kotlin/net/sergeych/mp_logger/Loggable.kt

@@ -9,6 +9,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import net.sergeych.mp_logger.Log.connectConsole
 import net.sergeych.mp_logger.Log.logFlow
@@ -143,13 +144,17 @@ sealed class LogData {
     /**
      * The regular log message: no additional data
      */
+    @Serializable
+    @SerialName("msg")
     class Message(override val tag: String, override val message: String) : LogData() {
         override fun toString(): String = message
     }
 
     /**
      * Error log message: also an optional stack.
      */
+    @Serializable
+    @SerialName("err")
     class Error(
         override val tag: String,
         override val message: String,

src/commonMain/kotlin/net/sergeych/mp_tools/AsyncBouncer.kt

@@ -14,21 +14,59 @@ import kotlin.time.Duration
 /**
  * Expermiental multiplatform coroutine-based bouncer: safe way to call some suspend code
  * after a timeout. It is thread-safe (where multithreaded) and coroutine-safe.
+ *
+ * Note that creating a bouncer will not invoke its callback until the corresponding pulse call.
+ *
+ * @param initialTimeout default timeout for [pulse], could be changed at runtime assigning to [timeout].
+ * @param initialMaxTimeout maximum timeout between calls, systemm will invoke callback when it expires even if there
+ *              will be [pulse] calls in between. Could be changed with [maxTimeout]
+ * @param callback what to invoke.
  */
-class AsyncBouncer(var timeout: Duration, callback: suspend () -> Unit) {
+class AsyncBouncer(
+    initialTimeout: Duration,
+    initialMaxTimeout: Duration = initialTimeout,
+    callback: suspend () -> Unit,
+) {
 
+    private var lastCallAt: Instant? = null
     private var callAt: Instant? = null
     private val access = Mutex()
     private val pulseChannel = Channel<Int>(0, onBufferOverflow = BufferOverflow.DROP_OLDEST)
 
+    /**
+     * Default time between call to [pulse] and invocation. Assigning calls [pulse].
+     */
+    var timeout: Duration = initialTimeout
+        set(value) {
+            field = value
+            pulse()
+        }
+
+    /**
+     * Maximim time between invocations: even if [pulse] is being called more often, invocations will happen at this
+     * rate. Assigning it calls [pulse]
+     */
+    var maxTimeout: Duration = initialMaxTimeout
+        set(value) {
+            field = value
+            pulse()
+        }
+
     /**
      * Cause a block to be scheduled after [timeout] or right now from now even it is already being executing.
+     * To change effective [timeout], assign a value to it _prior to call pulse_.
      */
-    suspend fun pulse(now: Boolean = false) {
-        access.withReentrantLock {
-            checkNotClosed()
-            callAt = if (now) Now() else Now() + timeout
-            pulseChannel.send(1)
+    fun pulse(now: Boolean = false) {
+        checkNotClosed()
+        globalLaunch {
+            access.withReentrantLock {
+                callAt = if (now) Now() else Now() + timeout
+                lastCallAt?.let {
+                    val limitTime = it + maxTimeout
+                    if (callAt!! > limitTime) callAt = limitTime
+                }
+                pulseChannel.send(1)
+            }
         }
     }
 
@@ -89,8 +127,8 @@ class AsyncBouncer(var timeout: Duration, callback: suspend () -> Unit) {
                         try {
                             callback()
                             callAt = null
-                        }
-                        catch(t: Throwable) {
+                            lastCallAt = Now()
+                        } catch (t: Throwable) {
                             // we can't use logging here as logger uses us ;)
                             println("unexpected error in AsyncBouncer: $t")
                             t.printStackTrace()

src/jvmMain/kotlin/net/sergeych/mp_logger/FileLogCatcher.kt

@@ -102,7 +102,9 @@ class FileLogCatcher(name: String, level: Log.Level = Log.Level.DEBUG, rotate: B
 
         println("writing to $currentLog")
 
-        bouncer = AsyncBouncer(100.milliseconds) { withContext(Dispatchers.IO) { out.flush() } }
+        bouncer = AsyncBouncer(100.milliseconds, 100.milliseconds) { withContext(Dispatchers.IO) {
+            out.flush()
+        } }
 
         job = globalLaunch {
             Log.logFlow.collect {

src/jvmTest/kotlin/mo_logger/TestLogger.kt

@@ -56,10 +56,15 @@ class TestLogger {
 //                println("test bouncer")
 //            }
 //            b.pulse(true)
-            val c = FileLogCatcher("testlog", rotate = true)
+            val c = FileLogCatcher("testlog",rotate = true)
             val x = LogTag("TFILE")
-            x.info { "--------- we run ------------" }
-            c.flush()
+            delay(300)
+            for(i in 1..20) {
+                x.info { "--------- we run ------------" }
+                delay(50)
+            }
+            delay(4000)
+
         }
     }