app

commit 7ed73453f0c26c6af53b63f55488b11a951ae4ce
parent e7410e8595db1db35d97133a9f3795d5408c8cd4
Author: triesap <triesap@radroots.dev>
Date:   Mon, 19 Jan 2026 23:54:48 +0000

app: instrument keystore notifications and tangle

- log keystore public key lookups and ensure flows

- log notification permission checks and requests

- log tangle stub init attempts

- keep service behavior unchanged

Diffstat:
M
app/src/keystore.rs
 | 
29
+++++++++++++++++++++++++----
M
app/src/notifications.rs
 | 
24
+++++++++++++++++++++---
M
app/src/tangle.rs
 | 
3
+++

3 files changed, 49 insertions(+), 7 deletions(-)
diff --git a/app/src/keystore.rs b/app/src/keystore.rs
@@ -2,6 +2,8 @@
 
 use radroots_app_core::keystore::{RadrootsClientKeystoreError, RadrootsClientKeystoreNostr};
 
+use crate::app_log_debug_emit;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AppKeystoreError {
     Keystore(RadrootsClientKeystoreError),
@@ -34,14 +36,26 @@ impl From<RadrootsClientKeystoreError> for AppKeystoreError {
 pub async fn app_keystore_nostr_keys<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
 ) -> AppKeystoreResult<Vec<String>> {
-    keystore.keys().await.map_err(AppKeystoreError::from)
+    let result = keystore.keys().await.map_err(AppKeystoreError::from);
+    let context = match &result {
+        Ok(keys) => Some(format!("count={}", keys.len())),
+        Err(err) => Some(err.to_string()),
+    };
+    let _ = app_log_debug_emit("log.app.keystore.keys", "fetch", context);
+    result
 }
 
 pub async fn app_keystore_nostr_public_key<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
 ) -> AppKeystoreResult<Option<String>> {
+    let _ = app_log_debug_emit("log.app.keystore.public_key", "start", None);
     match keystore.keys().await {
-        Ok(mut keys) => Ok(keys.pop()),
+        Ok(mut keys) => {
+            let key = keys.pop();
+            let context = key.as_ref().map(|value| format!("key={value}"));
+            let _ = app_log_debug_emit("log.app.keystore.public_key", "resolved", context);
+            Ok(key)
+        }
         Err(RadrootsClientKeystoreError::NostrNoResults) => Ok(None),
         Err(err) => Err(AppKeystoreError::from(err)),
     }
@@ -51,8 +65,15 @@ pub async fn app_keystore_nostr_ensure_key<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
 ) -> AppKeystoreResult<String> {
     match app_keystore_nostr_public_key(keystore).await? {
-        Some(key) => Ok(key),
-        None => keystore.generate().await.map_err(AppKeystoreError::from),
+        Some(key) => {
+            let _ = app_log_debug_emit("log.app.keystore.ensure", "existing", None);
+            Ok(key)
+        }
+        None => {
+            let generated = keystore.generate().await.map_err(AppKeystoreError::from)?;
+            let _ = app_log_debug_emit("log.app.keystore.ensure", "generated", None);
+            Ok(generated)
+        }
     }
 }
 
diff --git a/app/src/notifications.rs b/app/src/notifications.rs
@@ -8,6 +8,8 @@ use radroots_app_core::notifications::{
     RadrootsClientWebNotifications,
 };
 
+use crate::app_log_debug_emit;
+
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
 
@@ -80,6 +82,7 @@ impl AppNotifications {
     pub async fn permission(
         &self,
     ) -> AppNotificationsResult<RadrootsClientNotificationsPermission> {
+        let _ = app_log_debug_emit("log.app.notifications.permission", "start", None);
         #[cfg(not(target_arch = "wasm32"))]
         {
             return Ok(RadrootsClientNotificationsPermission::Unavailable);
@@ -91,17 +94,32 @@ impl AppNotifications {
             if !Self::notification_available(&window) {
                 return Ok(RadrootsClientNotificationsPermission::Unavailable);
             }
-            Ok(Self::permission_from_web(web_sys::Notification::permission()))
+            let permission = Self::permission_from_web(web_sys::Notification::permission());
+            let _ = app_log_debug_emit(
+                "log.app.notifications.permission",
+                "resolved",
+                Some(permission.as_str().to_string()),
+            );
+            Ok(permission)
         }
     }
 
     pub async fn request_permission(
         &self,
     ) -> AppNotificationsResult<RadrootsClientNotificationsPermission> {
-        self.client
+        let _ = app_log_debug_emit("log.app.notifications.request", "start", None);
+        let result = self.client
             .notify_init()
             .await
-            .map_err(AppNotificationsError::from)
+            .map_err(AppNotificationsError::from);
+        if let Ok(permission) = &result {
+            let _ = app_log_debug_emit(
+                "log.app.notifications.request",
+                "resolved",
+                Some(permission.as_str().to_string()),
+            );
+        }
+        result
     }
 }
 
diff --git a/app/src/tangle.rs b/app/src/tangle.rs
@@ -1,5 +1,7 @@
 #![forbid(unsafe_code)]
 
+use crate::app_log_debug_emit;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AppTangleError {
     NotImplemented,
@@ -37,6 +39,7 @@ impl AppTangleClientStub {
 
 impl AppTangleClient for AppTangleClientStub {
     fn init(&self) -> AppTangleResult<()> {
+        let _ = app_log_debug_emit("log.app.tangle.init", "stub", None);
         Err(AppTangleError::NotImplemented)
     }
 }