feat(logging): add platform-independent file logging [WPB-26806]

app/src/main/kotlin/com/wire/android/WireApplication.kt

@@ -28,6 +28,7 @@
 import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.work.Configuration
 import androidx.work.WorkManager
+import co.touchlab.kermit.LogWriter
 import co.touchlab.kermit.platformLogWriter
 import com.wire.android.analytics.ObserveCurrentSessionAnalyticsUseCase
 import com.wire.android.datastore.GlobalDataStore
@@ -178,7 +179,7 @@
     }
 
     private fun initializeMinimalLogging() {
-        val config = minimalLoggerConfig()
+        val config = minimalLoggerConfig(listOf(logFileWriter.value.logWriter))
         AppLogger.init(config)
         CoreLogger.init(config)
     }
@@ -346,15 +347,19 @@
         ExternalLoggerManager.initDatadogLogger(applicationContext)
 
         val isLoggingEnabled = globalDataStore.value.isLoggingEnabled().firstOrNull() == true
-        val config = fullLoggerConfig(isLoggingEnabled)
-
-        AppLogger.init(config)
-        CoreLogger.init(config)
+        val fileWriter = logFileWriter.value
 
         if (isLoggingEnabled) {
-            logFileWriter.value.start()
+            fileWriter.start()
         }
 
+        val config = fullLoggerConfig(
+            isLoggingEnabled = isLoggingEnabled,
+            additionalLogWriters = listOf(fileWriter.logWriter)
+        )
+        AppLogger.init(config)
+        CoreLogger.init(config)
+
         appLogger.i("Logger initialized after splash")
         logDeviceInformation()
         initializeAnonymousAnalytics()
@@ -450,25 +455,42 @@
 
     override fun onLowMemory() {
         super.onLowMemory()
-        appLogger.w("onLowMemory called - Stopping logging, buckling the seatbelt and hoping for the best!")
+        appLogger.w("onLowMemory called - Flushing pending logs")
         globalAppScope.launch {
-            logFileWriter.value.stop()
+            flushLogsAfterLowMemory(logFileWriter.value) { error ->
+                Log.e(TAG, "Failed to flush logs after onLowMemory", error)
+            }
         }
     }
 
     internal companion object {
-        fun minimalLoggerConfig() = KaliumLogger.Config(
+        @Suppress("TooGenericExceptionCaught")
+        suspend fun flushLogsAfterLowMemory(
+            logFileWriter: LogFileWriter,
+            reportFailure: (Exception) -> Unit
+        ) {
+            try {
+                logFileWriter.forceFlush()
+            } catch (e: Exception) {
+                reportFailure(e)
+            }
+        }
+
+        fun minimalLoggerConfig(additionalLogWriters: List<LogWriter> = emptyList()) = KaliumLogger.Config(
             KaliumLogLevel.WARN,
-            listOf(platformLogWriter())
+            listOf(platformLogWriter()) + additionalLogWriters
         )
 
-        fun fullLoggerConfig(isLoggingEnabled: Boolean) = if (isLoggingEnabled) {
+        fun fullLoggerConfig(
+            isLoggingEnabled: Boolean,
+            additionalLogWriters: List<LogWriter> = emptyList()
+        ) = if (isLoggingEnabled) {
             KaliumLogger.Config(
                 KaliumLogLevel.VERBOSE,
-                listOf(DataDogLogger, platformLogWriter())
+                listOf(DataDogLogger, platformLogWriter()) + additionalLogWriters
             )
         } else {
-            minimalLoggerConfig()
+            minimalLoggerConfig(additionalLogWriters)
         }
 
         enum class MemoryLevel(val level: Int) {

app/src/main/kotlin/com/wire/android/di/LogWriterModule.kt

@@ -19,11 +19,12 @@
 package com.wire.android.di
 
 import android.content.Context
+import com.wire.android.BuildConfig
 import com.wire.android.util.logging.LogFileWriter
-import com.wire.android.util.logging.LogFileWriterImpl
+import com.wire.android.util.logging.LogFileWriterFactory
+import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.BindingContainer
 import dev.zacsweers.metro.Provides
-import dev.zacsweers.metro.AppScope
 import dev.zacsweers.metro.SingleIn
 
 @BindingContainer
@@ -33,6 +34,9 @@ class LogWriterModule {
     @Provides
     fun provideKaliumFileWriter(@ApplicationContext context: Context): LogFileWriter {
         val logsDirectory = LogFileWriter.logsDirectory(context)
-        return LogFileWriterImpl(logsDirectory)
+        return LogFileWriterFactory.create(
+            logsDirectory = logsDirectory,
+            usePlatformIndependentFileLogger = BuildConfig.USE_PLATFORM_INDEPENDENT_FILE_LOGGER
+        )
     }
 }

app/src/main/kotlin/com/wire/android/ui/debug/LogManagementViewModel.kt

@@ -62,7 +62,9 @@
     }
 
     fun deleteLogs() {
-        logFileWriter.deleteAllLogFiles()
+        viewModelScope.launch {
+            logFileWriter.deleteAllLogFiles()
+        }
     }
 
     fun flushLogs(): Deferred<Unit> {

app/src/main/kotlin/com/wire/android/ui/debug/UserDebugViewModel.kt

@@ -81,7 +81,9 @@
     }
 
     fun deleteLogs() {
-        logFileWriter.deleteAllLogFiles()
+        viewModelScope.launch {
+            logFileWriter.deleteAllLogFiles()
+        }
     }
 
     fun flushLogs(): Deferred<Unit> {

app/src/main/kotlin/com/wire/android/util/logging/LogFileWriter.kt

@@ -19,6 +19,7 @@
 package com.wire.android.util.logging
 
 import android.content.Context
+import co.touchlab.kermit.LogWriter
 import java.io.File
 
 /**
@@ -32,6 +33,11 @@ interface LogFileWriter {
      */
     val activeLoggingFile: File
 
+    /**
+     * Kermit sink that writes log entries into [activeLoggingFile] while this writer is started.
+     */
+    val logWriter: LogWriter
+
     /**
      * Starts the log collection system
      */
@@ -51,7 +57,7 @@ interface LogFileWriter {
      * Deletes all log files including active and compressed files
      *
      */
-    fun deleteAllLogFiles()
+    suspend fun deleteAllLogFiles()
 
     companion object {
         fun logsDirectory(context: Context) = File(context.cacheDir, "logs")

app/src/main/kotlin/com/wire/android/util/logging/LogFileWriterFactory.kt

@@ -0,0 +1,30 @@
+/*
+ * Wire
+ * Copyright (C) 2026 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+package com.wire.android.util.logging
+
+import java.io.File
+
+object LogFileWriterFactory {
+    fun create(logsDirectory: File, usePlatformIndependentFileLogger: Boolean): LogFileWriter =
+        if (usePlatformIndependentFileLogger) {
+            PlatformIndependentLogFileWriter(logsDirectory)
+        } else {
+            LogFileWriterImpl(logsDirectory)
+        }
+}

app/src/main/kotlin/com/wire/android/util/logging/LogFileWriterImpl.kt

@@ -19,6 +19,8 @@
 package com.wire.android.util.logging
 
 import android.util.Log
+import co.touchlab.kermit.LogWriter
+import co.touchlab.kermit.Severity
 import com.wire.android.appLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -73,6 +75,11 @@
     // Process management
     private var logcatProcess: Process? = null
 
+    override val logWriter: LogWriter = object : LogWriter() {
+        @Suppress("UnusedParameter")
+        override fun log(severity: Severity, message: String, tag: String, throwable: Throwable?) = Unit
+    }
+
     /**
      * Initializes logging, waiting until the logger is actually initialized before returning.
      * ```kotlin
@@ -324,11 +331,13 @@
         }
     }
 
-    override fun deleteAllLogFiles() {
-        clearActiveLoggingFileContent()
-        logsDirectory.listFiles()?.filter {
-            it.extension.lowercase(Locale.ROOT) == LOG_COMPRESSED_FILE_EXTENSION
-        }?.forEach { it.delete() }
+    override suspend fun deleteAllLogFiles() {
+        withContext(Dispatchers.IO) {
+            clearActiveLoggingFileContent()
+            logsDirectory.listFiles()?.filter {
+                it.extension.lowercase(Locale.ROOT) == LOG_COMPRESSED_FILE_EXTENSION
+            }?.forEach { it.delete() }
+        }
     }
 
     private fun getCompressedFilesList() = (logsDirectory.listFiles() ?: emptyArray()).filter {

app/src/main/kotlin/com/wire/android/util/logging/LogLineTimestampFormatter.kt

@@ -0,0 +1,63 @@
+/*
+ * Wire
+ * Copyright (C) 2026 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+package com.wire.android.util.logging
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+internal class LogLineTimestampFormatter(
+    private val currentTimeMillis: () -> Long = System::currentTimeMillis
+) {
+    private val dateFormat = SimpleDateFormat(TIMESTAMP_PATTERN, Locale.US)
+    private val date = Date(0L)
+    private var cachedEpochSecond = Long.MIN_VALUE
+    private var cachedPrefix = ""
+
+    fun now(): String = format(currentTimeMillis())
+
+    fun format(timestampMillis: Long): String {
+        val epochSecond = timestampMillis / MILLIS_IN_SECOND
+        if (epochSecond != cachedEpochSecond) {
+            date.time = epochSecond * MILLIS_IN_SECOND
+            cachedPrefix = dateFormat.format(date)
+            cachedEpochSecond = epochSecond
+        }
+
+        val millis = (timestampMillis - epochSecond * MILLIS_IN_SECOND).toInt()
+        return buildString(capacity = cachedPrefix.length + MILLIS_SUFFIX_LENGTH) {
+            append(cachedPrefix)
+            append('.')
+            appendPaddedMillis(millis)
+        }
+    }
+
+    private fun StringBuilder.appendPaddedMillis(millis: Int) {
+        if (millis < HUNDRED_MILLIS) append('0')
+        if (millis < TEN_MILLIS) append('0')
+        append(millis)
+    }
+
+    private companion object {
+        const val TIMESTAMP_PATTERN = "yyyy-MM-dd HH:mm:ss"
+        const val MILLIS_IN_SECOND = 1000L
+        const val MILLIS_SUFFIX_LENGTH = 4
+        const val HUNDRED_MILLIS = 100
+        const val TEN_MILLIS = 10
+    }
+}