feat(gl-sdk): add LogListener for foreign-binding log capture

Apps install a process-wide LogListener and receive every log message
emitted by gl-sdk and the underlying gl-client library. The bridge
sits on top of the `log` crate facade — gl-sdk's own `tracing` calls
are routed through `tracing`'s `log` feature, and gl-client's direct
`log::*!` calls flow through the same channel.

Public surface (free functions, not encumbering the Node entry
points):

  - `set_logger(level, listener)` — install once per process.
  - `set_log_level(level)` — adjust the filter at runtime.
  - `LogEntry { level, message, target, file, line }` — record
    forwarded to the listener.
  - `LogLevel { Error, Warn, Info, Debug, Trace }`.
  - `LogListener.on_log(entry)` — UniFFI callback interface.

Tests
- Python test_logging.py verifies LogLevel variants, LogEntry shape,
  LogListener callback type, and that set_log_level is callable.
- Kotlin LoggingTest.kt installs the listener in @BeforeClass
  (handling the "already installed" error gracefully) and asserts
  that register_or_recover actually drives log entries through the
  listener with non-empty targets.

Event-streaming changes (NodeEventListener trait, set_event_listener
on Node, the encumbering `event_listener` argument on register /
recover / connect / register_or_recover) are intentionally NOT in
this commit. The simple top-level functions stay 3-arg. Event
streaming can be reintroduced via the OOP / builder interface in a
separate PR.

Author: angelix

Cargo.lock

@@ -0,0 +1,73 @@
+// Instrumented tests for the SDK logging framework.
+//
+// `setLogger` installs a process-wide logger — only one install
+// succeeds per process. A `@Before` step installs a shared capturing
+// listener; subsequent tests inspect it or call `setLogLevel` without
+// re-installing.
+
+package com.blockstream.glsdk
+
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.*
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.ConcurrentLinkedQueue
+
+@RunWith(AndroidJUnit4::class)
+class LoggingTest {
+
+    companion object {
+        private val captured = ConcurrentLinkedQueue<LogEntry>()
+
+        @BeforeClass
+        @JvmStatic
+        fun installLogger() {
+            val listener = object : LogListener {
+                override fun onLog(entry: LogEntry) {
+                    captured.add(entry)
+                    Log.d("glsdk", "[${entry.level}] ${entry.target}: ${entry.message}")
+                }
+            }
+            try {
+                setLogger(LogLevel.TRACE, listener)
+            } catch (e: Exception) {
+                // Already installed by a prior test class in the same
+                // process — expected when multiple test classes run.
+            }
+        }
+    }
+
+    @Test
+    fun set_log_level_does_not_throw() {
+        setLogLevel(LogLevel.WARN)
+        setLogLevel(LogLevel.TRACE)
+    }
+
+    @Test
+    fun listener_receives_logs_during_sdk_activity() {
+        captured.clear()
+        setLogLevel(LogLevel.TRACE)
+
+        val config = Config()
+        val mnemonic = "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"
+        try {
+            registerOrRecover(mnemonic, null, config)
+        } catch (_: Exception) {
+            // May fail on network / credentials — we only care that logs flowed.
+        }
+
+        val entries = captured.toList()
+        Log.d("glsdk", "Captured ${entries.size} log entries")
+        assertTrue(
+            "Expected at least one log entry from gl-client during register_or_recover",
+            entries.isNotEmpty(),
+        )
+        // Every entry should have a non-empty target and message
+        for (entry in entries) {
+            assertFalse("empty target in $entry", entry.target.isEmpty())
+            assertNotNull(entry.message)
+        }
+    }
+}

libs/gl-sdk-android/lib/src/androidInstrumentedTest/kotlin/com/blockstream/glsdk/LoggingTest.kt

@@ -15,6 +15,7 @@ anyhow = "1"
 bip39 = "2.2.0"
 gl-client = { version = "0.4.0", path = "../gl-client" }
 hex = "0.4"
+log = "0.4"
 lightning-invoice = "0.33"
 once_cell = "1.21.3"
 serde = { version = "1", features = ["derive"] }