leaf-framework 0.10.14__tar.gz → 0.10.16__tar.gz

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-framework
-Version: 0.10.14
+Version: 0.10.16
 Summary: Lightweight Adapter Framework (LEAF)
 License: Apache-2.0
 License-File: LICENSE
@@ -44,6 +44,18 @@ leaf
 
 LEAF automatically shows a **desktop control panel** on desktop systems, making it easy to see if the application is running and where to access it.
 
+## Updating
+
+LEAF checks PyPI for a newer release one hour after it starts, and weekly from then on -- never at startup, so a restart simply re-arms the one-hour delay. When a newer version exists, an **update badge** appears next to the version number in the web interface header; clicking it offers to install the update and restart LEAF.
+
+To check without waiting for the schedule, **click the version number** in the header. The result appears as a banner: green when this install is current, amber when a newer release exists, red when PyPI could not be reached.
+
+Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
+
+```bash
+pip install --upgrade leaf-framework
+```
+
 ## Documentation
 
 The complete documentation can be found [here](https://leaf-framework.org).

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/README.md

@@ -14,6 +14,18 @@ leaf
 
 LEAF automatically shows a **desktop control panel** on desktop systems, making it easy to see if the application is running and where to access it.
 
+## Updating
+
+LEAF checks PyPI for a newer release one hour after it starts, and weekly from then on -- never at startup, so a restart simply re-arms the one-hour delay. When a newer version exists, an **update badge** appears next to the version number in the web interface header; clicking it offers to install the update and restart LEAF.
+
+To check without waiting for the schedule, **click the version number** in the header. The result appears as a banner: green when this install is current, amber when a newer release exists, red when PyPI could not be reached.
+
+Set `LEAF_DISABLE_UPDATE_CHECK=1` to switch the check off entirely. Installs running from a source checkout are told about the new version but never overwritten -- update those with `git pull`. To update by hand:
+
+```bash
+pip install --upgrade leaf-framework
+```
+
 ## Documentation
 
 The complete documentation can be found [here](https://leaf-framework.org).

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/leaf/config/configuration.yaml

@@ -9,14 +9,17 @@ EQUIPMENT_INSTANCES:
         interval: 1
 
 OUTPUTS:
+    - plugin: mqtt
+      broker: localhost
+      port: 1883
 # MQTT output requires 'broker' and 'port' 
 # optionally 'username', 'password', 'clientid', 'protocol', 'transport', and 'tls'
 # and optionally an alternative 'fallback' output
-  - plugin: FILE
-    filename: testing.json
-    parallel: SQL
-  - plugin: SQL
-    filename: testing.db
+  # - plugin: FILE
+  #   filename: testing.json
+  #   parallel: SQL
+  # - plugin: SQL
+  #   filename: testing.db
 #   username: None #OPTIONAL expects a str
 #   password: None #OPTIONAL expects a str
 #   clientid: None #OPTIONAL expects a str

leaf_framework-0.10.16/leaf/modules/input_modules/lads_watcher.py

@@ -0,0 +1,351 @@
+import threading
+import time
+from collections.abc import Callable
+from typing import Any
+
+from leaf.register.metadata import MetadataManager
+from leaf.utility.logger.logger_utils import get_logger
+
+logger = get_logger(__name__, log_file="input_module.log")
+
+try:
+    from opcua import Client, Node, Subscription, ua  # type: ignore
+    from opcua.ua import DataChangeNotification  # type: ignore
+
+    OPCUA_AVAILABLE = True
+    # Suppress OPC UA library logging to avoid cluttering the output
+    import logging
+
+    logging.getLogger("opcua").setLevel(logging.WARNING)
+except ImportError:
+    logger.warning("OPC UA library not available. LADSWatcher will not function.")
+    OPCUA_AVAILABLE = False
+    Client = Node = Subscription = DataChangeNotification = ua = None  # Placeholders
+
+from leaf.error_handler.error_holder import ErrorHolder
+from leaf.modules.input_modules.event_watcher import EventWatcher
+
+FIRST_RECONNECT_DELAY = 1
+RECONNECT_RATE = 2
+MAX_RECONNECT_DELAY = 60
+KEEPALIVE_INTERVAL = 10
+
+# Standard LADS subtrees that hold configuration/metadata rather than live
+# measurement data (locking, historizing config, program templates, static
+# state-machine descriptors) - excluded from discovery by default.
+SKIP_BROWSE_NAMES = {
+    "Lock",
+    "HA Configuration",
+    "ProgramTemplateSet",
+    "AvailableStates",
+    "AvailableTransitions",
+}
+
+
+class LADSWatcher(EventWatcher):
+    """
+    A concrete implementation of EventWatcher for OPC UA LADS (IEC 63243)
+    lab-device servers. Unlike OPCWatcher, which requires callers to supply
+    exact NodeIds, LADSWatcher discovers monitorable variables automatically
+    by walking the standard LADS DeviceSet -> FunctionalUnitSet -> FunctionSet
+    structure.
+    """
+
+    def __init__(
+        self,
+        metadata_manager: MetadataManager,
+        host: str,
+        port: int,
+        functional_units: set[str] | None = None,
+        exclude_variables: list[str] | None = None,
+        interval: int = 1,
+        callbacks: list[Callable[..., Any]] | None = None,
+        error_holder: ErrorHolder | None = None,
+    ) -> None:
+        """
+        Initialize LADSWatcher.
+
+        Args:
+            metadata_manager (MetadataManager): Manages equipment metadata.
+            host (str): LADS OPC UA server host.
+            port (int): LADS OPC UA server port.
+            functional_units (Optional[set[str]]): Names of functional units to
+                monitor. If None, all discovered functional units are monitored.
+            exclude_variables (Optional[list[str]]): Variable browse names to
+                exclude from discovery (e.g. "RawValue").
+            callbacks (Optional[List[Callable]]): Callbacks for event updates.
+            error_holder (Optional[ErrorHolder]): Optional object to manage errors.
+        """
+        super().__init__(metadata_manager, callbacks=callbacks, error_holder=error_holder)
+
+        self._host = host
+        self._port = port
+        self._functional_units: set[str] | None = set(functional_units) if functional_units else None
+        self._exclude_variables: list[str] = exclude_variables or []
+        self._metadata_manager = metadata_manager
+        self._sub: Subscription | None = None
+        self._handler = self._dispatch_callback
+        self._handles: list[Any] = []
+        self._interval = interval
+        self.logger = get_logger(__name__, log_file="input_module.log")
+        if host is None or port is None:
+            raise ValueError("Host and port must be specified.")
+        self._client: Client | None = None
+        self._thread: threading.Thread | None = None
+        # NodeId string -> {"functional_unit": str, "browse_name": str, "node": Node}
+        self._variables: dict[str, dict[str, Any]] = {}
+
+    def datachange_notification(self, node: Node, val: int | str | float, data: DataChangeNotification) -> None:
+        nodeid = node.nodeid.to_string()
+        self.logger.debug(f"LADS datachange_notification: node={nodeid}, value={val}")
+        info = self._variables.get(nodeid, {})
+        self._dispatch_callback(
+            self._metadata_manager.experiment.measurement,
+            {
+                "functional_unit": info.get("functional_unit"),
+                "node": node.nodeid.Identifier,
+                "value": val,
+                "timestamp": data.monitored_item.Value.SourceTimestamp,
+                "data": data,
+            },
+        )
+
+    def start(self) -> None:
+        """
+        Start the LADSWatcher in a background thread with automatic reconnection.
+        """
+        if not OPCUA_AVAILABLE:
+            raise Exception("OPC UA library is not available. Cannot start LADSWatcher.")
+
+        if self._thread and self._thread.is_alive():
+            self.logger.warning("LADSWatcher already running.")
+            return
+
+        super().start()
+        self._thread = threading.Thread(target=self._connection_loop, daemon=True)
+        self._thread.start()
+        self.logger.info(f"LADSWatcher started for {self._host}:{self._port}")
+
+    def _connection_loop(self) -> None:
+        """
+        Main connection loop with automatic reconnection on failure.
+
+        Mirrors OPCWatcher's pattern: connect, discover, subscribe, keepalive,
+        and retry with exponential backoff if anything goes wrong.
+        """
+        reconnect_delay = FIRST_RECONNECT_DELAY
+
+        while self._running:
+            self.logger.info(f"Connecting to LADS OPC UA server {self._host}:{self._port}...")
+            try:
+                self._client = Client(f"opc.tcp://{self._host}:{self._port}")
+                self._client.connect()
+
+                objects = self._client.get_objects_node()
+                self._variables = self._discover_variables(objects)
+                if not self._variables:
+                    raise ValueError("No LADS functional unit variables discovered on server.")
+
+                self._subscribe_to_variables()
+
+                # Reset backoff on successful connection
+                reconnect_delay = FIRST_RECONNECT_DELAY
+                self.logger.info(
+                    f"LADS OPC UA connected and subscribed to {len(self._variables)} variables. Monitoring..."
+                )
+
+                # Keepalive loop — detect silent disconnections
+                while self._running:
+                    time.sleep(KEEPALIVE_INTERVAL)
+                    try:
+                        self._client.get_root_node().get_browse_name()
+                    except Exception as e:
+                        self.logger.warning(f"LADS OPC UA keepalive failed, reconnecting: {e}")
+                        break  # exit keepalive loop → triggers reconnect
+
+            except Exception as e:
+                self.logger.error(f"LADS OPC UA connection error: {e}")
+
+            finally:
+                self._cleanup_connection()
+
+            if not self._running:
+                break
+
+            self.logger.info(f"Reconnecting in {reconnect_delay}s...")
+            time.sleep(reconnect_delay)
+            reconnect_delay = min(reconnect_delay * RECONNECT_RATE, MAX_RECONNECT_DELAY)
+
+    def _cleanup_connection(self) -> None:
+        """Unsubscribe and disconnect cleanly."""
+        if self._sub and self._handles:
+            try:
+                for handle in self._handles:
+                    self._sub.unsubscribe(handle)
+                self._handles.clear()
+            except Exception as e:
+                self.logger.debug(f"Error unsubscribing: {e}")
+
+        if self._sub:
+            try:
+                self._sub.delete()
+            except Exception as e:
+                self.logger.debug(f"Error deleting subscription: {e}")
+            self._sub = None
+
+        if self._client:
+            try:
+                self._client.disconnect()
+            except Exception as e:
+                self.logger.debug(f"Error disconnecting: {e}")
+            self._client = None
+
+        self._variables = {}
+
+    def _browse_device_set(self, objects: Node) -> list[Node]:
+        """
+        Return device nodes under Objects/DeviceSet. A device is identified
+        structurally (an Object with a FunctionalUnitSet child) rather than by
+        name, since DeviceSet can also contain non-device components such as
+        DeviceFeatures.
+        """
+        device_set = None
+        for child in objects.get_children():
+            if child.get_browse_name().Name == "DeviceSet":
+                device_set = child
+                break
+        if device_set is None:
+            return []
+
+        devices = []
+        for child in device_set.get_children():
+            if child.get_node_class() != ua.NodeClass.Object:
+                continue
+            if any(gc.get_browse_name().Name == "FunctionalUnitSet" for gc in child.get_children()):
+                devices.append(child)
+        return devices
+
+    def _browse_functional_units(self, device_node: Node) -> dict[str, Node]:
+        """Return {functional_unit_name: node} for a device's FunctionalUnitSet."""
+        units: dict[str, Node] = {}
+        for child in device_node.get_children():
+            if child.get_browse_name().Name != "FunctionalUnitSet":
+                continue
+            for fu in child.get_children():
+                if fu.get_node_class() != ua.NodeClass.Object:
+                    continue
+                units[fu.get_browse_name().Name] = fu
+        return units
+
+    def _walk_variables(self, node: Node, visited: set[str], found: dict[str, Node]) -> None:
+        """
+        Recursively collect readable Variable nodes under a functional unit.
+
+        LADS nodesets reference the same object through multiple reference
+        types (e.g. Organizes + HasComponent), so naive recursion without a
+        visited-set revisits and duplicates nodes.
+        """
+        nodeid = node.nodeid.to_string()
+        if nodeid in visited:
+            return
+        visited.add(nodeid)
+
+        try:
+            browse_name = node.get_browse_name().Name
+        except Exception as e:
+            self.logger.debug(f"Skipping node {node.nodeid}, could not read browse name: {e}")
+            return
+
+        if browse_name in SKIP_BROWSE_NAMES:
+            return
+
+        try:
+            node_class = node.get_node_class()
+        except Exception as e:
+            self.logger.debug(f"Skipping node {node.nodeid}, could not read node class: {e}")
+            return
+
+        if node_class == ua.NodeClass.Variable:
+            if browse_name not in self._exclude_variables:
+                found[nodeid] = node
+            # Variables may have child properties (EngineeringUnits, EURange)
+            # that aren't independently useful measurements - don't recurse.
+            return
+
+        if node_class != ua.NodeClass.Object:
+            return
+
+        for child in node.get_children():
+            self._walk_variables(child, visited, found)
+
+    def _discover_variables(self, objects: Node) -> dict[str, dict[str, Any]]:
+        """
+        Walk Objects/DeviceSet -> device -> FunctionalUnitSet -> functional
+        units, collecting readable Variable nodes for each functional unit
+        (filtered by self._functional_units if provided).
+        """
+        variables: dict[str, dict[str, Any]] = {}
+        for device in self._browse_device_set(objects):
+            units = self._browse_functional_units(device)
+            for fu_name, fu_node in units.items():
+                if self._functional_units and fu_name not in self._functional_units:
+                    self.logger.info(f"Excluded functional unit: {fu_name}")
+                    continue
+                visited: set[str] = set()
+                found: dict[str, Node] = {}
+                self._walk_variables(fu_node, visited, found)
+                for nodeid, node in found.items():
+                    variables[nodeid] = {
+                        "functional_unit": fu_name,
+                        "browse_name": node.get_browse_name().Name,
+                        "node": node,
+                    }
+                    self.logger.info(f"Found variable: {fu_name}/{node.get_browse_name().Name} ({nodeid})")
+        return variables
+
+    def _subscribe_to_variables(self) -> None:
+        """
+        Subscribe to discovered LADS variables and monitor data changes.
+        """
+        if not self._client:
+            self.logger.warning("Client is not connected.")
+            return
+
+        self._sub = self._client.create_subscription(self._interval * 1000, self)  # second interval converted to ms
+
+        for nodeid, info in self._variables.items():
+            node = info["node"]
+            try:
+                handle = self._sub.subscribe_data_change(node)
+                self._handles.append(handle)
+                self.logger.info(f"Subscribed to: {info['functional_unit']}/{info['browse_name']} ({nodeid})")
+                # Send a dummy value to trigger the callback
+                self._dispatch_callback(
+                    self._metadata_manager.experiment.measurement,
+                    {
+                        "functional_unit": info["functional_unit"],
+                        "node": node.nodeid.Identifier,
+                        "value": node.get_value(),
+                        "timestamp": time.time(),
+                        "data": None,
+                    },
+                )
+
+            except Exception as e:
+                self.logger.error(f"Failed to subscribe to {nodeid}: {e}")
+                if "ServiceFault" in str(e):
+                    self.logger.info("Retrying in 5 seconds...")
+                    time.sleep(5)
+                    continue  # Try the next variable
+
+    def stop(self) -> None:
+        """
+        Stop the LADSWatcher and disconnect from the OPC UA server.
+        """
+        self.logger.info("Stopping LADSWatcher")
+        super().stop()  # sets _running = False, exits connection loop
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+
+        self._cleanup_connection()

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/leaf/modules/input_modules/modbus_watcher.py

@@ -114,7 +114,16 @@ class ModbusWatcher(ExternalEventWatcher):
                 self._emit(data)
             except Exception as e:
                 logger.error(f"ModbusWatcher poll error: {e}")
-                self._handle_exception(e)
+                try:
+                    self._handle_exception(e)
+                except Exception:
+                    # _handle_exception re-raises when no error_holder is
+                    # configured (the default) -- this loop must survive
+                    # regardless, or a single bad read (e.g. a Modbus
+                    # timeout/CRC error) silently and permanently kills all
+                    # future polling. See polling_watcher.py's _poll for the
+                    # same fix and full rationale.
+                    pass
             time.sleep(self._interval)
 
     def _read_registers(self) -> dict[str, Any]:

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/leaf/modules/input_modules/polling_watcher.py

@@ -72,16 +72,32 @@ class PollingWatcher(EventWatcher):
     def _poll(self) -> None:
         """Background loop for fetching data and dispatching events."""
         while self._running:
-            data = self._fetch_data()
-
-            if data.get("measurement") is not None:
-                self.measurement_message(data["measurement"])
-
-            if data.get("start") is not None:
-                self.start_message(data["start"])
-
-            if data.get("stop") is not None:
-                self.stop_message(data["stop"])
+            try:
+                data = self._fetch_data()
+
+                if data.get("measurement") is not None:
+                    self.measurement_message(data["measurement"])
+
+                if data.get("start") is not None:
+                    self.start_message(data["start"])
+
+                if data.get("stop") is not None:
+                    self.stop_message(data["stop"])
+            except Exception as exc:
+                logger.error(f"PollingWatcher: error during poll cycle, will retry next interval: {exc}")
+                try:
+                    self._handle_exception(exc)
+                except Exception:
+                    # _handle_exception re-raises when no error_holder is
+                    # configured (the default -- it's None throughout the
+                    # constructor chain unless an adapter explicitly wires
+                    # one up). This loop must survive regardless: without
+                    # this, a single bad cycle (e.g. a transient hardware
+                    # read glitch) silently and permanently kills this
+                    # daemon thread -- no crash, no retry, no visible
+                    # alert, just an experiment that quietly stops
+                    # reporting data.
+                    pass
 
             time.sleep(self._interval)
 

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/leaf/modules/output_modules/file.py

@@ -1,7 +1,8 @@
+import gzip
 import json
 import os
 import threading
-from typing import Any
+from typing import IO, Any, cast
 
 from leaf.error_handler.error_holder import ErrorHolder
 from leaf.error_handler.exceptions import ClientUnreachableError, SeverityLevel
@@ -30,7 +31,16 @@ class FILE(OutputModule):
         if directory:
             os.makedirs(directory, exist_ok=True)
 
-    def _handle_file_error(self, error) -> None:
+    def _open(self, mode: str) -> IO[str]:
+        """
+        Open `self.filename` in text mode, transparently using gzip
+        when the filename ends in '.gz'.
+        """
+        if self.filename.endswith(".gz"):
+            return cast(IO[str], gzip.open(self.filename, mode + "t"))
+        return open(self.filename, mode)
+
+    def _handle_file_error(self, error: Exception) -> None:
         """
         Handles file-related exceptions consistently
         with a structured error message.
@@ -56,7 +66,7 @@ class FILE(OutputModule):
 
         self._handle_exception(ClientUnreachableError(message, output_module=self, severity=severity))
 
-    def transmit(self, topic: str, data: str | dict | None = None) -> bool:
+    def transmit(self, topic: str, data: str | dict[str, Any] | None = None) -> bool:
         """
         Transmit data to the file associated with a specific topic.
         Appends a single line with the topic and data in compact JSON format.
@@ -69,7 +79,7 @@ class FILE(OutputModule):
             line = json.dumps({topic: [data]}, separators=(",", ":"))
 
             # Append to file (no reading required)
-            with self._lock, open(self.filename, "a") as f:
+            with self._lock, self._open("a") as f:
                 f.write(line + "\n")
 
             # Reset global failure counter on successful transmission
@@ -88,7 +98,7 @@ class FILE(OutputModule):
             self._handle_file_error(e)
             return self.fallback(topic, data)
 
-    def retrieve(self, topic: str) -> list:
+    def retrieve(self, topic: str) -> list[dict[str, Any]] | None:
         """
         Retrieve all data associated with a specific topic by streaming line-by-line.
         Returns a list of all data entries for the topic.
@@ -98,7 +108,7 @@ class FILE(OutputModule):
                 return []
 
             results = []
-            with self._lock, open(self.filename) as f:
+            with self._lock, self._open("r") as f:
                 for line in f:
                     line = line.strip()
                     if not line:
@@ -123,7 +133,7 @@ class FILE(OutputModule):
             self._handle_file_error(e)
             return None
 
-    def pop(self, key: str = None) -> tuple[str, Any] | None:
+    def pop(self, key: str | None = None) -> tuple[Any | None, Any | None] | None:
         """
         Retrieve and remove the first occurrence of a topic from the file.
         If a specific key is provided, removes the first line with that topic.
@@ -134,7 +144,7 @@ class FILE(OutputModule):
                                 If None, removes the first line.
 
         Returns:
-            Optional[tuple[str, Any]]: A tuple of (topic, data_list),
+            Optional[tuple[Any | None, Any | None]]: A tuple of (topic, data_list),
                                     or None if the file is empty or key not found.
         """
         try:
@@ -148,7 +158,7 @@ class FILE(OutputModule):
 
             with self._lock:
                 # Read all lines and find the first matching one
-                with open(self.filename) as f:
+                with self._open("r") as f:
                     for line in f:
                         line_content = line.strip()
                         if not line_content:
@@ -181,7 +191,7 @@ class FILE(OutputModule):
                     return None
 
                 # Rewrite file without the removed line
-                with open(self.filename, "w") as f:
+                with self._open("w") as f:
                     f.writelines(lines)
 
             return found_topic, found_data

{leaf_framework-0.10.14 → leaf_framework-0.10.16}/leaf/modules/output_modules/mqtt.py

@@ -212,7 +212,9 @@ class MQTT(OutputModule):
             logger.warning(f"Topic '{topic}' contains MQTT-illegal characters; publishing as '{sanitized}' instead.")
         return sanitized
 
-    def transmit(self, topic: str, data: str | dict | None = None, retain: bool = False) -> bool:
+    def transmit(
+        self, topic: str, data: str | dict | None = None, retain: bool = False, use_fallback: bool = True
+    ) -> bool:
         """
         Publish a message to the MQTT broker on a given topic.
 
@@ -220,6 +222,10 @@ class MQTT(OutputModule):
             topic (str): The topic to publish the message to.
             data (Optional[Union[str, dict]]): The message payload to be transmitted.
             retain (bool): Whether to retain the message on the broker.
+            use_fallback (bool): Whether a failed publish should be handed to the
+                fallback module. Set to False for messages that are only meaningful
+                live (e.g. the heartbeat), so they are dropped rather than buffered
+                and replayed later.
 
         Returns:
             bool: True if the message was successfully published, False otherwise.
@@ -228,7 +234,7 @@ class MQTT(OutputModule):
         if not self.is_enabled():
             logger.warning(f"{self.__class__.__name__} - transmit called with module disabled.")
             # Call the fallback if available
-            if self._fallback is not None:
+            if use_fallback and self._fallback is not None:
                 logger.debug("Calling fallback as module is disabled.")
                 return self.fallback(topic, data)
             return False
@@ -245,6 +251,8 @@ class MQTT(OutputModule):
         # synthetic "start" message) can otherwise lose that race every time.
         if not self.client.is_connected():
             if not self._connected_event.wait(timeout=3) or not self.client.is_connected():
+                if not use_fallback:
+                    return False
                 return self.fallback(topic, data)
         if data == "":
             data = {}
@@ -263,6 +271,8 @@ class MQTT(OutputModule):
         if error is not None:
             self.sending_success[topic] = False
             self._handle_exception(error)
+            if not use_fallback:
+                return False
             return self.fallback(topic, data)
 
         # If successfully published, check if the fallback has data on the topic
@@ -270,7 +280,7 @@ class MQTT(OutputModule):
         if not self.sending_success[topic]:
             # To prevent recursion in case the fallback also tries to publish
             self.sending_success[topic] = True
-            if self._fallback is not None:
+            if use_fallback and self._fallback is not None:
                 while True:
                     fallback_result = self._fallback.pop(topic)
                     if fallback_result is not None:
@@ -544,7 +554,10 @@ class MQTT(OutputModule):
                 }
             logger.debug(f"Publishing heartbeat to '{self._heartbeat_topic}': {payload}")
             try:
-                self.transmit(self._heartbeat_topic, payload)
+                # use_fallback=False: a heartbeat is only meaningful live, so a
+                # failed publish is dropped rather than buffered in the fallback
+                # and replayed as a stale "alive" once the broker is back.
+                self.transmit(self._heartbeat_topic, payload, use_fallback=False)
             except LEAFError as e:
                 # Must not propagate - an unhandled exception here (e.g. the broker
                 # connection not being fully up yet) would silently kill this daemon