Send nonfatal runtime errors to event feed

Author: brothercorvo

TASK.md

@@ -1,4 +1,5 @@
 # TASKS
+- 2026-03-06: DONE. Surface handled runtime failures in the UI Event Feed by routing non-fatal command, daemon, telemetry, sampler, embedded-LXMD, and LXMF runtime exceptions through the shared event log with regression coverage.
 - 2026-03-06: DONE. Reap stale northbound WebSocket clients and cancel stray UI reconnect timers to prevent port-8000 file descriptor exhaustion under connection churn.
 - 2026-03-05: DONE. Enforce Python-backend-only PyPI artifacts by excluding non-backend directories in Poetry packaging config and adding publish-workflow artifact validation for frontend/electron/docs/API paths.
 - 2026-03-05: DONE. Harden PyPI publish workflow with `PYPI_API_TOKEN` fallback and actionable trusted-publisher mismatch diagnostics after repository identity changes.

electron/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rch-desktop",
   "private": true,
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "Electron shell for Reticulum Community Hub.",
   "homepage": "https://github.com/FreeTAKTeam/Reticulum-Community-Hub",
   "main": "dist/main.js",

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ReticulumTelemetryHub"
-version = "2.0.9"
+version = "2.0.10"
 description = "Reticulum-Telemetry-Hub (RTH) manages a complete TCP node across a Reticulum-based network, enabling communication and data sharing between clients like Sideband or Meshchat."
 authors = ["naman108, corvo"]
 readme = "README.md"

reticulum_telemetry_hub/embedded_lxmd/embedded.py

@@ -20,6 +20,10 @@
 from reticulum_telemetry_hub.lxmf_telemetry.model.persistance.sensors.sensor_enum import (
     SID_LXMF_PROPAGATION,
 )
+from reticulum_telemetry_hub.reticulum_server.event_log import EventLog
+from reticulum_telemetry_hub.reticulum_server.runtime_events import (
+    report_nonfatal_exception,
+)
 
 if TYPE_CHECKING:
     from reticulum_telemetry_hub.lxmf_telemetry.telemetry_controller import (
@@ -111,12 +115,14 @@ def __init__(
         destination: RNS.Destination,
         config_manager: Optional[HubConfigurationManager] = None,
         telemetry_controller: Optional[TelemetryController] = None,
+        event_log: EventLog | None = None,
     ) -> None:
         self.router = router
         self.destination = destination
         self.config_manager = config_manager or HubConfigurationManager()
         self.config = EmbeddedLxmdConfig.from_manager(self.config_manager)
         self.telemetry_controller = telemetry_controller
+        self.event_log = event_log
         self._propagation_observers: list[Callable[[dict[str, Any]], None]] = []
         self._propagation_snapshot: bytes | None = None
         self._propagation_lock = threading.Lock()
@@ -182,6 +188,25 @@ def add_propagation_observer(
 
         self._propagation_observers.append(observer)
 
+    def _report_propagation_exception(
+        self,
+        message: str,
+        exc: Exception,
+        *,
+        metadata: dict[str, object] | None = None,
+        log_level: int | None = None,
+    ) -> dict[str, object] | None:
+        """Record a handled embedded-LXMD failure in logs and the event feed."""
+
+        return report_nonfatal_exception(
+            self.event_log,
+            "propagation_error",
+            message,
+            exc,
+            metadata=metadata,
+            log_level=log_level if log_level is not None else getattr(RNS, "LOG_ERROR", 1),
+        )
+
     def propagation_startup_status(self) -> dict[str, Any]:
         """Return propagation startup state for control/status endpoints."""
 
@@ -269,8 +294,8 @@ def _parse_store_filename(filename: str) -> float | None:
 
         return received
 
-    @staticmethod
     def _remove_startup_files(
+        self,
         paths: list[str],
         *,
         reason: str,
@@ -283,9 +308,15 @@ def _remove_startup_files(
             except FileNotFoundError:
                 continue
             except Exception as exc:  # pragma: no cover - defensive logging
-                RNS.log(
+                self._report_propagation_exception(
                     f"Failed to remove {reason} startup message file '{path}': {exc}",
-                    RNS.LOG_WARNING,
+                    exc,
+                    metadata={
+                        "operation": "startup_prune",
+                        "reason": reason,
+                        "path": path,
+                    },
+                    log_level=RNS.LOG_WARNING,
                 )
         return removed
 
@@ -387,9 +418,10 @@ def _enable_propagation(self) -> None:
                 error=str(exc),
                 mark_finished=True,
             )
-            RNS.log(
+            self._report_propagation_exception(
                 f"Failed to enable LXMF propagation node in embedded mode: {exc}",
-                RNS.LOG_ERROR,
+                exc,
+                metadata={"operation": "enable_propagation"},
             )
             return
 
@@ -420,37 +452,45 @@ def _announce_delivery(self) -> None:
         try:
             self.router.announce(self.destination.hash)
         except Exception as exc:  # pragma: no cover - logging guard
-            RNS.log(
+            self._report_propagation_exception(
                 f"Failed to announce embedded LXMF destination: {exc}",
-                RNS.LOG_ERROR,
+                exc,
+                metadata={"operation": "announce_delivery"},
             )
 
     def _announce_propagation(self) -> None:
         try:
             self.router.announce_propagation_node()
         except Exception as exc:  # pragma: no cover - logging guard
-            RNS.log(
+            self._report_propagation_exception(
                 f"Failed to announce embedded propagation node: {exc}",
-                RNS.LOG_ERROR,
+                exc,
+                metadata={"operation": "announce_propagation"},
             )
 
     def _apply_propagation_runtime_config(self) -> None:
         if self.config.auth_required:
             try:
                 self.router.set_authentication(required=True)
             except Exception as exc:  # pragma: no cover - logging guard
-                RNS.log(
+                self._report_propagation_exception(
                     f"Failed to enable LXMF propagation authentication: {exc}",
-                    RNS.LOG_ERROR,
+                    exc,
+                    metadata={"operation": "set_authentication"},
                 )
 
         for identity_hash in self.config.control_allowed_identities:
             try:
                 self.router.allow_control(bytes.fromhex(identity_hash))
             except Exception as exc:  # pragma: no cover - logging guard
-                RNS.log(
+                self._report_propagation_exception(
                     f"Failed to add LXMF propagation control identity '{identity_hash}': {exc}",
-                    RNS.LOG_WARNING,
+                    exc,
+                    metadata={
+                        "operation": "allow_control",
+                        "identity_hash": identity_hash,
+                    },
+                    log_level=RNS.LOG_WARNING,
                 )
 
     def _baseline_propagation_payload(self) -> dict[str, Any]:
@@ -604,9 +644,10 @@ def _build_propagation_payload(self) -> dict[str, Any] | None:
         try:
             stats = self.router.compile_stats()
         except Exception as exc:  # pragma: no cover - defensive logging
-            RNS.log(
+            self._report_propagation_exception(
                 f"Failed to compile LXMF propagation stats: {exc}",
-                RNS.LOG_ERROR,
+                exc,
+                metadata={"operation": "compile_stats"},
             )
             return None
 
@@ -641,9 +682,13 @@ def _notify_propagation_observers(self, payload: dict[str, Any]) -> None:
             try:
                 observer(payload)
             except Exception as exc:  # pragma: no cover - defensive logging
-                RNS.log(
+                self._report_propagation_exception(
                     f"Propagation observer failed: {exc}",
-                    RNS.LOG_ERROR,
+                    exc,
+                    metadata={
+                        "operation": "observer",
+                        "observer": repr(observer),
+                    },
                 )
 
     def _persist_propagation_snapshot(self, payload: dict[str, Any]) -> None:
@@ -669,9 +714,13 @@ def _persist_propagation_snapshot(self, payload: dict[str, Any]) -> None:
                 _utcnow(),
             )
         except Exception as exc:  # pragma: no cover - defensive logging
-            RNS.log(
+            self._report_propagation_exception(
                 f"Failed to persist propagation telemetry: {exc}",
-                RNS.LOG_ERROR,
+                exc,
+                metadata={
+                    "operation": "persist_telemetry",
+                    "peer_hash": peer_hash,
+                },
             )
 
     def _deferred_start_jobs(self) -> None:

reticulum_telemetry_hub/lxmf_telemetry/sampler.py

@@ -10,6 +10,10 @@
 import LXMF
 import RNS
 from reticulum_telemetry_hub.reticulum_server.appearance import apply_icon_appearance
+from reticulum_telemetry_hub.reticulum_server.event_log import EventLog
+from reticulum_telemetry_hub.reticulum_server.runtime_events import (
+    report_nonfatal_exception,
+)
 from reticulum_telemetry_hub.lxmf_telemetry.model.persistance.sensors.sensor_enum import (
     SID_TIME,
 )
@@ -61,12 +65,14 @@ def __init__(
         ) = None,
         telemeter_manager: TelemeterManager | None = None,
         broadcast_updates: bool = False,
+        event_log: EventLog | None = None,
     ) -> None:
         self._controller = controller
         self._router = router
         self._source_destination = source_destination
         self._connections = connections if connections is not None else {}
         self._broadcast_updates = broadcast_updates
+        self._event_log = event_log
         self._stop_event = threading.Event()
         self._thread: threading.Thread | None = None
         self._jobs: list[_SamplerJob] = []
@@ -158,7 +164,17 @@ def _invoke_collector(
         try:
             result = collector()
         except Exception as exc:  # pragma: no cover - defensive logging
-            RNS.log(f"Telemetry collector {collector!r} failed: {exc}", RNS.LOG_ERROR)
+            report_nonfatal_exception(
+                self._event_log,
+                "telemetry_error",
+                f"Telemetry collector {collector!r} failed: {exc}",
+                exc,
+                metadata={
+                    "operation": "collect",
+                    "collector": repr(collector),
+                },
+                log_level=RNS.LOG_ERROR,
+            )
             return None
 
         if result is None:
@@ -209,9 +225,17 @@ def _process_sample(self, sample: TelemetrySample) -> None:
                     message.destination_hash = destination.identity.hash
                 self._router.handle_outbound(message)
             except Exception as exc:  # pragma: no cover - defensive logging
-                RNS.log(
+                report_nonfatal_exception(
+                    self._event_log,
+                    "telemetry_error",
                     f"Failed to deliver telemetry sample to {destination}: {exc}",
-                    RNS.LOG_ERROR,
+                    exc,
+                    metadata={
+                        "operation": "broadcast",
+                        "destination": str(destination),
+                        "peer_dest": peer_dest,
+                    },
+                    log_level=RNS.LOG_ERROR,
                 )
 
     # ------------------------------------------------------------------

reticulum_telemetry_hub/lxmf_telemetry/telemetry_controller.py

@@ -12,6 +12,9 @@
 from reticulum_telemetry_hub.reticulum_server.appearance import (
     build_telemetry_icon_appearance_value,
 )
+from reticulum_telemetry_hub.reticulum_server.runtime_events import (
+    report_nonfatal_exception,
+)
 
 import LXMF
 import RNS
@@ -762,7 +765,19 @@ def _notify_listener(
         try:
             self._telemetry_listener(telemetry, peer_hash, timestamp)
         except Exception as exc:  # pragma: no cover - defensive logging
-            RNS.log(f"Telemetry listener raised an exception: {exc}", RNS.LOG_WARNING)
+            report_nonfatal_exception(
+                self._event_log,
+                "telemetry_error",
+                f"Telemetry listener raised an exception: {exc}",
+                exc,
+                metadata={
+                    "operation": "listener",
+                    "peer_hash": (
+                        peer_hash.hex() if isinstance(peer_hash, bytes) else peer_hash
+                    ),
+                },
+                log_level=RNS.LOG_WARNING,
+            )
 
     def _record_event(
         self,