Add synchronization to buffer access and add log size limit

Author: zsmb13

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/AppInit.kt

@@ -60,7 +60,7 @@ private fun initKoin(
 ): Koin {
     return startKoin {
         val appModule = module {
-            single { BufferedDelegatingLogger() }
+            single { BufferedDelegatingLogger(get()) }
             single<Logger> { get<BufferedDelegatingLogger>() }
 
             single<ApplicationStorage> { MultiplatformSettingsStorage(get(), get()) }

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/utils/BufferedDelegatingLogger.kt

@@ -0,0 +1,56 @@
+package org.jetbrains.kotlinconf.utils
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * A logger that's constructed during startup and later attached to a real logger.
+ * Until attached, it buffers log entries in memory. When [attach] is called,
+ * it forwards the buffered entries to the attached logger in order, and from
+ * that point on it delegates all calls directly.
+ */
+class BufferedDelegatingLogger(
+    private val scope: CoroutineScope,
+) : Logger {
+    private var delegate: Logger? = null
+
+    private data class Entry(val tag: String, val lazyMessage: () -> String)
+
+    private val mutex = Mutex()
+
+    private val buffer = mutableListOf<Entry>()
+
+    override fun log(tag: String, lazyMessage: () -> String) {
+        val current = delegate
+        if (current != null) {
+            current.log(tag, lazyMessage)
+            return
+        }
+
+        scope.launch {
+            mutex.withLock {
+                buffer += Entry(tag, lazyMessage)
+                while (buffer.size > MAX_LOG_MESSAGES_IN_MEMORY) {
+                    buffer.removeAt(0)
+                }
+            }
+        }
+    }
+
+    fun attach(realLogger: Logger) {
+        require(delegate == null) { "Logger delegate was already set, this should only happen once" }
+
+        delegate = realLogger
+
+        scope.launch {
+            mutex.withLock {
+                buffer.forEach { entry ->
+                    realLogger.log(entry.tag, entry.lazyMessage)
+                }
+                buffer.clear()
+            }
+        }
+    }
+}

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/utils/DebugLogger.kt

@@ -10,6 +10,9 @@ class DebugLogger(private val platformLogger: Logger) : Logger {
 
     override fun log(tag: String, lazyMessage: () -> String) {
         logs += "${Clock.System.now()} [${tag}] ${lazyMessage()}"
+        while (logs.size > MAX_LOG_MESSAGES_IN_MEMORY) {
+            logs.removeAt(0)
+        }
         platformLogger.log(tag, lazyMessage)
     }
 

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/utils/Logger.kt

@@ -21,36 +21,4 @@ class NoopProdLogger : Logger {
     }
 }
 
-/**
- * A logger that's constructed during startup and later attached to a real logger.
- * Until attached, it buffers log entries in memory. When [attach] is called,
- * it forwards the buffered entries to the attached logger in order, and from
- * that point on it delegates all calls directly.
- */
-class BufferedDelegatingLogger : Logger {
-    private var delegate: Logger? = null
-
-    private data class Entry(val tag: String, val message: String)
-
-    private val buffer = mutableListOf<Entry>()
-
-    override fun log(tag: String, lazyMessage: () -> String) {
-        val current = delegate
-        if (current != null) {
-            current.log(tag, lazyMessage)
-            return
-        }
-
-        buffer += Entry(tag, lazyMessage())
-    }
-
-    fun attach(realLogger: Logger) {
-        require(delegate == null) { "Logger delegate was already set, this should only happen once" }
-
-        buffer.forEach { entry ->
-            realLogger.log(entry.tag) { entry.message }
-        }
-        buffer.clear()
-        delegate = realLogger
-    }
-}
+internal const val MAX_LOG_MESSAGES_IN_MEMORY = 200