feat: stream ldk-node logs to android logcat

Author: ovitrif

app/src/main/java/to/bitkit/async/ServiceQueue.kt

@@ -15,7 +15,7 @@ import java.util.concurrent.ThreadFactory
 import kotlin.coroutines.CoroutineContext
 
 enum class ServiceQueue {
-    LDK, CORE, FOREX, MIGRATION;
+    LDK, CORE, FOREX, LOG, MIGRATION;
 
     private val scope by lazy { CoroutineScope(newSingleThreadDispatcher(name) + SupervisorJob()) }
 

app/src/main/java/to/bitkit/env/Env.kt

@@ -22,6 +22,8 @@ internal object Env {
     val platform = "Android ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})"
     const val version = "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})"
 
+    val ldkLogLevel = LogLevel.TRACE
+
     // TODO: remove this to load from BT API instead
     val trustedLnPeers
         get() = when (network) {
@@ -110,8 +112,8 @@ internal object Env {
 
     fun initAppStoragePath(path: String) {
         require(path.isNotBlank()) { "App storage path cannot be empty." }
-        Logger.info("App storage path: $path")
         appStoragePath = path
+        Logger.info("App storage path: $path")
     }
 
     val logDir: String
@@ -120,8 +122,6 @@ internal object Env {
             return File(appStoragePath).resolve("logs").ensureDir().path
         }
 
-    val ldkLogLevel = LogLevel.TRACE
-
     fun ldkStoragePath(walletIndex: Int) = storagePathOf(walletIndex, network.name.lowercase(), "ldk")
 
     fun bitkitCoreStoragePath(walletIndex: Int): String {

app/src/main/java/to/bitkit/ext/DateTime.kt

@@ -122,15 +122,20 @@ fun LocalDate.endOfDay(): Long {
         .toEpochMilliseconds()
 }
 
+fun utcDateFormatterOf(pattern: String) = SimpleDateFormat(pattern, Locale.US).apply {
+    timeZone = java.util.TimeZone.getTimeZone("UTC")
+}
+
 object DatePattern {
     const val DATE_TIME = "dd/MM/yyyy, HH:mm"
     const val INVOICE_EXPIRY = "MMM dd, h:mm a"
     const val ACTIVITY_DATE = "MMMM d"
     const val ACTIVITY_ROW_DATE = "MMMM d, HH:mm"
     const val ACTIVITY_ROW_DATE_YEAR = "MMMM d yyyy, HH:mm"
     const val ACTIVITY_TIME = "h:mm"
-    const val LOG_FILE = "yyyy-MM-dd_HH-mm-ss"
     const val CHANNEL_DETAILS = "MMM d, yyyy, HH:mm"
+    const val LOG_FILE = "yyyy-MM-dd_HH-mm-ss"
+    const val LOG_LINE = "yyyy-MM-dd HH:mm:ss.SSS"
 
     const val MONTH_YEAR_FORMAT = "MMMM yyyy"
     const val DATE_FORMAT = "MMM d, yyyy"
@@ -159,4 +164,3 @@ object CalendarConstants {
     // Preview
     const val PREVIEW_DAYS_AGO = 7
 }
-

app/src/main/java/to/bitkit/repositories/LogsRepo.kt

@@ -14,6 +14,7 @@ import to.bitkit.ext.fromBase64
 import to.bitkit.ext.getEnumValueOf
 import to.bitkit.ext.toBase64
 import to.bitkit.models.ChatwootMessage
+import to.bitkit.utils.LogSource
 import to.bitkit.utils.Logger
 import java.io.BufferedReader
 import java.io.ByteArrayOutputStream
@@ -205,5 +206,3 @@ data class LogFile(
 ) {
     val fileName: String get() = file.name
 }
-
-enum class LogSource { Ldk, Bitkit, Unknown }

app/src/main/java/to/bitkit/services/LightningService.kt

@@ -41,19 +41,14 @@ import to.bitkit.data.backup.VssStoreIdProvider
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.BgDispatcher
 import to.bitkit.env.Env
-import to.bitkit.ext.DatePattern
 import to.bitkit.ext.totalNextOutboundHtlcLimitSats
 import to.bitkit.ext.uByteList
 import to.bitkit.ext.uri
 import to.bitkit.models.OpenChannelResult
 import to.bitkit.utils.LdkError
+import to.bitkit.utils.LdkLogWriter
 import to.bitkit.utils.Logger
 import to.bitkit.utils.ServiceError
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.TimeZone
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.io.path.Path
@@ -88,19 +83,18 @@ class LightningService @Inject constructor(
         val dirPath = Env.ldkStoragePath(walletIndex)
 
         val trustedPeerNodeIds = trustedPeers.map { it.nodeId }
-
         val config = defaultConfig().copy(
             storageDirPath = dirPath,
             network = Env.network,
             trustedPeers0conf = trustedPeerNodeIds,
             anchorChannelsConfig = AnchorChannelsConfig(
                 trustedPeersNoReserve = trustedPeerNodeIds,
                 perChannelReserveSats = 1u,
-            )
+            ),
         )
 
         val builder = Builder.fromConfig(config).apply {
-            setFilesystemLogger(generateLogFilePath(), Env.ldkLogLevel)
+            setCustomLogger(LdkLogWriter())
 
             configureChainSource(customServerUrl)
             configureGossipSource(customRgsServerUrl)
@@ -345,15 +339,16 @@ class LightningService @Inject constructor(
         val node = this.node ?: throw ServiceError.NodeNotSetup
 
         return ServiceQueue.LDK.background {
-            try {
+            runCatching {
+                val pushToCounterpartyMsat = pushToCounterpartySats?.let { it * 1000u }
                 Logger.debug("Initiating channel open (sats: $channelAmountSats) with peer: ${peer.uri}")
 
                 val userChannelId = node.openChannel(
-                    nodeId = peer.nodeId,
-                    address = peer.address,
-                    channelAmountSats = channelAmountSats,
-                    pushToCounterpartyMsat = pushToCounterpartySats?.let { it * 1000u },
-                    channelConfig = channelConfig,
+                    peer.nodeId,
+                    peer.address,
+                    channelAmountSats,
+                    pushToCounterpartyMsat,
+                    channelConfig,
                 )
 
                 val result = OpenChannelResult(
@@ -366,11 +361,11 @@ class LightningService @Inject constructor(
 
                 Logger.info("Channel open initiated, result: $result")
 
-                Result.success(result)
-            } catch (e: NodeException) {
-                val error = LdkError(e)
+                result
+            }.onFailure { e ->
+                val error = if (e is NodeException) LdkError(e) else e
                 Logger.error("Error initiating channel open", error)
-                Result.failure(error)
+                error
             }
         }
     }
@@ -790,19 +785,9 @@ class LightningService @Inject constructor(
 }
 
 // region helpers
-
-private fun generateLogFilePath(): String {
-    val dateFormatter = SimpleDateFormat(DatePattern.LOG_FILE, Locale.US).apply {
-        timeZone = TimeZone.getTimeZone("UTC")
-    }
-    val timestamp = dateFormatter.format(Date())
-
-    val sessionLogFilePath = File(Env.logDir).resolve("ldk_$timestamp.log").path
-
-    Logger.debug("Generated LDK log file path: $sessionLogFilePath")
-    return sessionLogFilePath
-}
-
+/**
+ * TODO remove, replace all usages with [FeeRate.fromSatPerVbUnchecked]
+ * */
 private fun convertVByteToKwu(satsPerVByte: UInt): FeeRate {
     // 1 vbyte = 4 weight units, so 1 sats/vbyte = 250 sats/kwu
     val satPerKwu = satsPerVByte.toULong() * 250u