marilib-pkg 0.6.0__py3-none-any.whl → 0.7.0rc1__py3-none-any.whl

marilib/mari_protocol.py

@@ -1,5 +1,6 @@
 import dataclasses
 from dataclasses import dataclass
+from enum import IntEnum
 
 from marilib.protocol import Packet, PacketFieldMetadata, PacketType
 
@@ -8,6 +9,195 @@ MARI_BROADCAST_ADDRESS = 0xFFFFFFFFFFFFFFFF
 MARI_NET_ID_DEFAULT = 0x0001
 
 
+class DefaultPayloadType(IntEnum):
+    APPLICATION_DATA = 1
+    METRICS_REQUEST = 128
+    METRICS_RESPONSE = 129
+    METRICS_LOAD = 130
+    METRICS_PROBE = 140
+
+    def as_bytes(self) -> bytes:
+        return bytes([self.value])
+
+
+@dataclass
+class DefaultPayload(Packet):
+    metadata: list[PacketFieldMetadata] = dataclasses.field(
+        default_factory=lambda: [
+            PacketFieldMetadata(name="type", length=1),
+        ]
+    )
+    type_: DefaultPayloadType = DefaultPayloadType.APPLICATION_DATA
+
+
+@dataclass
+class MetricsProbePayload(Packet):
+    metadata: list[PacketFieldMetadata] = dataclasses.field(
+        default_factory=lambda: [
+            PacketFieldMetadata(name="type", length=1),
+            PacketFieldMetadata(name="cloud_tx_ts_us", length=8),
+            PacketFieldMetadata(name="cloud_rx_ts_us", length=8),
+            PacketFieldMetadata(name="cloud_tx_count", length=4),
+            PacketFieldMetadata(name="cloud_rx_count", length=4),
+            PacketFieldMetadata(name="edge_tx_ts_us", length=8),
+            PacketFieldMetadata(name="edge_rx_ts_us", length=8),
+            PacketFieldMetadata(name="edge_tx_count", length=4),
+            PacketFieldMetadata(name="edge_rx_count", length=4),
+            PacketFieldMetadata(name="gw_tx_count", length=4),
+            PacketFieldMetadata(name="gw_rx_count", length=4),
+            PacketFieldMetadata(name="gw_rx_asn", length=8),
+            PacketFieldMetadata(name="gw_tx_enqueued_asn", length=8),
+            PacketFieldMetadata(name="gw_tx_dequeued_asn", length=8),
+            PacketFieldMetadata(name="node_rx_count", length=4),
+            PacketFieldMetadata(name="node_tx_count", length=4),
+            PacketFieldMetadata(name="node_rx_asn", length=8),
+            PacketFieldMetadata(name="node_tx_enqueued_asn", length=8),
+            PacketFieldMetadata(name="node_tx_dequeued_asn", length=8),
+            PacketFieldMetadata(name="rssi_at_node", length=1),
+            PacketFieldMetadata(name="rssi_at_gw", length=1),
+        ]
+    )
+    type_: DefaultPayloadType = DefaultPayloadType.METRICS_PROBE
+    cloud_tx_ts_us: int = 0
+    cloud_rx_ts_us: int = 0
+    cloud_tx_count: int = 0
+    cloud_rx_count: int = 0
+    edge_tx_ts_us: int = 0
+    edge_rx_ts_us: int = 0
+    edge_tx_count: int = 0
+    edge_rx_count: int = 0
+    gw_tx_count: int = 0
+    gw_rx_count: int = 0
+    gw_rx_asn: int = 0
+    gw_tx_enqueued_asn: int = 0
+    gw_tx_dequeued_asn: int = 0
+    node_rx_count: int = 0
+    node_tx_count: int = 0
+    node_rx_asn: int = 0
+    node_tx_enqueued_asn: int = 0
+    node_tx_dequeued_asn: int = 0
+    rssi_at_node: int = 0
+    rssi_at_gw: int = 0
+
+    @property
+    def packet_length(self) -> int:
+        return sum(field.length for field in self.metadata)
+
+    @property
+    def asn(self) -> int:
+        """ASN at reception back from the network"""
+        return self.gw_rx_asn
+
+    def latency_roundtrip_node_edge_ms(self) -> float:
+        return (self.edge_rx_ts_us - self.edge_tx_ts_us) / 1000.0
+
+    def latency_roundtrip_node_cloud_ms(self) -> float:
+        return (self.cloud_rx_ts_us - self.cloud_tx_ts_us) / 1000.0
+
+    def pdr_uplink_radio(self, probe_stats_start_epoch=None) -> float:
+        if probe_stats_start_epoch is None:
+            # if no epoch is provided, use the current values
+            gw_rx_count = self.gw_rx_count
+            node_tx_count = self.node_tx_count
+        else:
+            # if epoch is provided, subtract the epoch values from the current values
+            if probe_stats_start_epoch.asn == 0:
+                return 0
+            gw_rx_count = self.gw_rx_count - probe_stats_start_epoch.gw_rx_count
+            node_tx_count = self.node_tx_count - probe_stats_start_epoch.node_tx_count
+        if node_tx_count <= 0:
+            return 0
+        return gw_rx_count / node_tx_count
+
+    def pdr_downlink_radio(self, probe_stats_start_epoch=None) -> float:
+        if probe_stats_start_epoch is None:
+            # if no epoch is provided, use the current values
+            gw_tx_count = self.gw_tx_count
+            node_rx_count = self.node_rx_count
+        else:
+            # if epoch is provided, subtract the epoch values from the current values
+            if probe_stats_start_epoch.asn == 0:
+                return 0
+            gw_tx_count = self.gw_tx_count - probe_stats_start_epoch.gw_tx_count
+            node_rx_count = self.node_rx_count - probe_stats_start_epoch.node_rx_count
+        if gw_tx_count <= 0:
+            return 0
+        return node_rx_count / gw_tx_count
+
+    def pdr_uplink_uart(self, probe_stats_start_epoch=None) -> float:
+        if probe_stats_start_epoch is None:
+            # if no epoch is provided, just wait a bit
+            return -1
+        else:
+            # if epoch is provided, subtract the epoch values from the current values
+            if probe_stats_start_epoch.asn == 0:
+                return 0
+            # if a packet was received at the gatweway, it should also be received at the edge (otherwise, it's a loss)
+            gw_rx_count = self.gw_rx_count - probe_stats_start_epoch.gw_rx_count
+            edge_rx_count = self.edge_rx_count - probe_stats_start_epoch.edge_rx_count
+        if gw_rx_count <= 0:
+            return 0
+        return edge_rx_count / gw_rx_count
+
+    def pdr_downlink_uart(self, probe_stats_start_epoch=None) -> float:
+        if probe_stats_start_epoch is None:
+            # if no epoch is provided, just wait a bit
+            return -1
+        else:
+            # if epoch is provided, subtract the epoch values from the current values
+            if probe_stats_start_epoch.asn == 0:
+                return 0
+            # if a packet was sent at the edge, it should also be sent at the gateway (otherwise, it's a loss)
+            gw_tx_count = self.gw_tx_count - probe_stats_start_epoch.gw_tx_count
+            edge_tx_count = self.edge_tx_count - probe_stats_start_epoch.edge_tx_count
+        if edge_tx_count <= 0:
+            return 0
+        return gw_tx_count / edge_tx_count
+
+    def rssi_at_node_dbm(self) -> int:
+        if self.rssi_at_node > 127:
+            return self.rssi_at_node - 255
+        return self.rssi_at_node
+
+    def rssi_at_gw_dbm(self) -> int:
+        if self.rssi_at_gw > 127:
+            return self.rssi_at_gw - 255
+        return self.rssi_at_gw
+
+    def __repr__(self):
+        rep = dataclasses.asdict(self)
+        rep.pop("metadata", None)
+        return f"{rep}"
+
+
+@dataclass
+class MetricsRequestPayload(Packet):
+    metadata: list[PacketFieldMetadata] = dataclasses.field(
+        default_factory=lambda: [
+            PacketFieldMetadata(name="type", length=1),
+            PacketFieldMetadata(name="timestamp_us", length=8),
+        ]
+    )
+    type_: DefaultPayloadType = DefaultPayloadType.METRICS_REQUEST
+    timestamp_us: int = 0
+
+
+@dataclass
+class MetricsResponsePayload(Packet):
+    metadata: list[PacketFieldMetadata] = dataclasses.field(
+        default_factory=lambda: [
+            PacketFieldMetadata(name="type", length=1),
+            PacketFieldMetadata(name="timestamp_us", length=8),
+            PacketFieldMetadata(name="rx_count", length=4),
+            PacketFieldMetadata(name="tx_count", length=4),
+        ]
+    )
+    type_: DefaultPayloadType = DefaultPayloadType.METRICS_RESPONSE
+    timestamp_us: int = 0
+    rx_count: int = 0
+    tx_count: int = 0
+
+
 @dataclass
 class HeaderStats(Packet):
     """Dataclass that holds MAC header stats."""
@@ -71,6 +261,20 @@ class Frame:
         stats_bytes = self.stats.to_bytes(byteorder)
         return header_bytes + stats_bytes + self.payload
 
+    @property
+    def is_test_packet(self) -> bool:
+        """Returns True if either the payload is a metrics response, request, or load test packet."""
+        return (
+            self.payload.startswith(DefaultPayloadType.METRICS_RESPONSE.as_bytes())
+            or self.payload.startswith(DefaultPayloadType.METRICS_REQUEST.as_bytes())
+            or self.payload.startswith(DefaultPayloadType.METRICS_LOAD.as_bytes())
+            or self.payload.startswith(DefaultPayloadType.METRICS_PROBE.as_bytes())
+        )
+
+    @property
+    def is_load_test_packet(self) -> bool:
+        return self.payload.startswith(DefaultPayloadType.METRICS_LOAD.as_bytes())
+
     def __repr__(self):
         header_no_metadata = dataclasses.replace(self.header, metadata=[])
         return f"Frame(header={header_no_metadata}, payload={self.payload})"

marilib/marilib_cloud.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Callable
 
-from marilib.latency import LatencyTester
+from marilib.metrics import MetricsTester
 from marilib.mari_protocol import Frame, Header
 from marilib.model import (
     EdgeEvent,
@@ -34,7 +34,7 @@ class MarilibCloud(MarilibBase):
     logger: Any | None = None
     gateways: dict[int, MariGateway] = field(default_factory=dict)
     lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
-    latency_tester: LatencyTester | None = None
+    metrics_tester: MetricsTester | None = None
 
     started_ts: datetime = field(default_factory=datetime.now)
     last_received_mqtt_data_ts: datetime = field(default_factory=datetime.now)
@@ -52,6 +52,9 @@ class MarilibCloud(MarilibBase):
         self.mqtt_interface.init()
         if self.logger:
             self.logger.log_setup_parameters(self.setup_params)
+        self.metrics_tester = MetricsTester(
+            self
+        )  # just instantiate, do not start it at the cloud, for now
 
     # ============================ MarilibBase methods =========================
 
@@ -168,12 +171,21 @@ class MarilibCloud(MarilibBase):
                 gateway_address = frame.header.destination
                 node_address = frame.header.source
                 gateway = self.gateways.get(gateway_address)
+                if not gateway:
+                    return False, EdgeEvent.UNKNOWN, None
                 node = gateway.get_node(node_address)
                 if not gateway or not node:
                     return False, EdgeEvent.UNKNOWN, None
 
                 gateway.update_node_liveness(node_address)
-                gateway.register_received_frame(frame, is_test_packet=False)
+                gateway.register_received_frame(frame)
+
+                # handle metrics probe packets
+                if frame.is_test_packet:
+                    payload = self.metrics_tester.handle_response_cloud(frame, gateway, node)
+                    if payload:
+                        frame.payload = payload.to_bytes()
+
                 return True, EdgeEvent.NODE_DATA, frame
 
         except Exception as e:

marilib/marilib_edge.py

@@ -4,8 +4,14 @@ from datetime import datetime
 from typing import Any, Callable
 from rich import print
 
-from marilib.latency import LATENCY_PACKET_MAGIC, LatencyTester
-from marilib.mari_protocol import MARI_BROADCAST_ADDRESS, Frame, Header
+from marilib.metrics import MetricsTester
+from marilib.mari_protocol import (
+    MARI_BROADCAST_ADDRESS,
+    Frame,
+    Header,
+    DefaultPayload,
+    DefaultPayloadType,
+)
 from marilib.model import (
     EdgeEvent,
     GatewayInfo,
@@ -19,8 +25,6 @@ from marilib.communication_adapter import MQTTAdapter, MQTTAdapterDummy, SerialA
 from marilib.marilib import MarilibBase
 from marilib.tui_edge import MarilibTUIEdge
 
-LOAD_PACKET_PAYLOAD = b"L"
-
 
 @dataclass
 class MarilibEdge(MarilibBase):
@@ -39,10 +43,11 @@ class MarilibEdge(MarilibBase):
     logger: Any | None = None
     gateway: MariGateway = field(default_factory=MariGateway)
     lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
-    latency_tester: LatencyTester | None = None
+    metrics_tester: MetricsTester | None = None
 
     started_ts: datetime = field(default_factory=datetime.now)
     last_received_serial_data_ts: datetime = field(default_factory=datetime.now)
+    last_received_mqtt_data_ts: datetime = field(default_factory=datetime.now)
     main_file: str | None = None
 
     def __post_init__(self):
@@ -53,9 +58,9 @@ class MarilibEdge(MarilibBase):
         if self.mqtt_interface is None:
             self.mqtt_interface = MQTTAdapterDummy()
         self.serial_interface.init(self.on_serial_data_received)
-        # NOTE: MQTT interface will only be initialized when the network_id is known
         if self.logger:
             self.logger.log_setup_parameters(self.setup_params)
+        self.metrics_tester = MetricsTester(self)  # it may or not be started later
 
     # ============================ MarilibBase methods =========================
 
@@ -82,19 +87,18 @@ class MarilibEdge(MarilibBase):
         assert self.serial_interface is not None
 
         mari_frame = Frame(Header(destination=dst), payload=payload)
-        is_test = self._is_test_packet(payload)
 
         with self.lock:
-            # Only register statistics for normal data packets, not for test packets.
-            self.gateway.register_sent_frame(mari_frame, is_test)
+            self.gateway.register_sent_frame(mari_frame)
             if dst == MARI_BROADCAST_ADDRESS:
                 for n in self.gateway.nodes:
-                    n.register_sent_frame(mari_frame, is_test)
+                    n.register_sent_frame(mari_frame)
             elif n := self.gateway.get_node(dst):
-                n.register_sent_frame(mari_frame, is_test)
+                n.register_sent_frame(mari_frame)
 
-        # FIXME: instead of prefixing with a magic 0x01 byte, we should use EdgeEvent.NODE_DATA
-        self.serial_interface.send_data(b"\x01" + mari_frame.to_bytes())
+        self.serial_interface.send_data(
+            EdgeEvent.to_bytes(EdgeEvent.NODE_DATA) + mari_frame.to_bytes()
+        )
 
     def render_tui(self):
         if self.tui:
@@ -110,6 +114,10 @@ class MarilibEdge(MarilibBase):
     def uses_mqtt(self) -> bool:
         return not isinstance(self.mqtt_interface, MQTTAdapterDummy)
 
+    @property
+    def mqtt_connected(self) -> bool:
+        return self.uses_mqtt and self.mqtt_interface.is_ready()
+
     @property
     def serial_connected(self) -> bool:
         return self.serial_interface is not None
@@ -131,6 +139,9 @@ class MarilibEdge(MarilibBase):
         """Just forwards the data to the serial interface."""
         if len(data) < 1:
             return
+
+        self.last_received_mqtt_data_ts = datetime.now()
+
         try:
             event_type = EdgeEvent(data[0])
             frame = Frame().from_bytes(data[1:])
@@ -138,23 +149,17 @@ class MarilibEdge(MarilibBase):
             print(f"[red]Error parsing frame: {exc}[/]")
             return
         if event_type != EdgeEvent.NODE_DATA:
-            # ignore non-data events
             return
         if frame.header.destination != MARI_BROADCAST_ADDRESS and not self.gateway.get_node(
             frame.header.destination
         ):
-            # ignore frames for unknown nodes
             return
         self.send_frame(frame.header.destination, frame.payload)
 
     def handle_serial_data(self, data: bytes) -> tuple[bool, EdgeEvent, Any]:
         """
-        Handles the serial data received from the radio gateway:
-        - parses the event
-        - updates node or gateway information
-        - returns the event type and data
+        Handles the serial data received from the radio gateway.
         """
-
         if len(data) < 1:
             return False, EdgeEvent.UNKNOWN, None
 
@@ -196,53 +201,58 @@ class MarilibEdge(MarilibBase):
                 frame = Frame().from_bytes(data[1:])
                 with self.lock:
                     self.gateway.update_node_liveness(frame.header.source)
-                    self.gateway.register_received_frame(frame, is_test_packet=False)
+                    self.gateway.register_received_frame(frame)
+
+                    # handle metrics probe packets
+                    if frame.is_test_packet:
+                        payload = self.metrics_tester.handle_response_edge(frame)
+                        if payload:
+                            frame.payload = payload.to_bytes()
+
                 return True, event_type, frame
             except (ValueError, ProtocolPayloadParserException):
                 return False, EdgeEvent.UNKNOWN, None
-        return True, event_type, None
+
+        return False, event_type, None
 
     def on_serial_data_received(self, data: bytes):
         res, event_type, event_data = self.handle_serial_data(data)
-        if res:
-            if self.logger and event_type in [EdgeEvent.NODE_JOINED, EdgeEvent.NODE_LEFT]:
-                self.logger.log_event(
-                    self.gateway.info.address, event_data.address, event_type.name
-                )
-            if event_type == EdgeEvent.GATEWAY_INFO:
-                # when the first GATEWAY_INFO is received, this will cause the MQTT interface to be initialized
-                self.mqtt_interface.update(event_data.network_id_str, self.on_mqtt_data_received)
-                if self.logger:
-                    self.setup_params["schedule_name"] = self.gateway.info.schedule_name
-                    self.logger.log_setup_parameters(self.setup_params)
+        if not res:
+            return
+
+        if self.logger and event_type in [EdgeEvent.NODE_JOINED, EdgeEvent.NODE_LEFT]:
+            self.logger.log_event(self.gateway.info.address, event_data.address, event_type.name)
+        if event_type == EdgeEvent.GATEWAY_INFO:
+            self.mqtt_interface.update(event_data.network_id_str, self.on_mqtt_data_received)
+            if self.logger:
+                self.setup_params["schedule_name"] = self.gateway.info.schedule_name
+                self.logger.log_setup_parameters(self.setup_params)
+
+        if event_type == EdgeEvent.NODE_DATA and not event_data.is_test_packet:
+            # only notify the application if it's not a test packet
             self.cb_application(event_type, event_data)
-            self.send_data_to_cloud(event_type, event_data)
+
+        self.send_data_to_cloud(event_type, event_data)
 
     def send_data_to_cloud(
         self, event_type: EdgeEvent, event_data: NodeInfoEdge | GatewayInfo | Frame
     ):
         if event_type in [EdgeEvent.NODE_JOINED, EdgeEvent.NODE_LEFT, EdgeEvent.NODE_KEEP_ALIVE]:
-            # the cloud needs to know which gateway the node belongs to
             event_data = event_data.to_cloud(self.gateway.info.address)
         data = EdgeEvent.to_bytes(event_type) + event_data.to_bytes()
         self.mqtt_interface.send_data_to_cloud(data)
 
     # ============================ Utility methods =============================
 
-    def latency_test_enable(self):
-        if self.latency_tester is None:
-            self.latency_tester = LatencyTester(self)
-            self.latency_tester.start()
+    def metrics_test_enable(self):
+        self.metrics_tester.start()
 
-    def latency_test_disable(self):
-        if self.latency_tester is not None:
-            self.latency_tester.stop()
-            self.latency_tester = None
+    def metrics_test_disable(self):
+        self.metrics_tester.stop()
 
     # ============================ Private methods =============================
 
     def _is_test_packet(self, payload: bytes) -> bool:
-        """Determines if a packet is for testing purposes (load or latency)."""
-        is_latency = payload.startswith(LATENCY_PACKET_MAGIC)
-        is_load = payload == LOAD_PACKET_PAYLOAD
-        return is_latency or is_load
+        """Determines if a packet sent FROM the edge is for testing purposes."""
+        payload = DefaultPayload().from_bytes(payload)
+        return payload.type_ in [DefaultPayloadType.LOAD_TEST, DefaultPayloadType.LATENCY_TEST]

marilib/metrics.py

@@ -0,0 +1,141 @@
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from rich import print
+from marilib.mari_protocol import Frame, DefaultPayloadType
+from marilib.mari_protocol import MetricsProbePayload
+from marilib.model import MariGateway, MariNode
+
+if TYPE_CHECKING:
+    from marilib.marilib_edge import MarilibEdge
+
+
+class MetricsTester:
+    """A thread-based class to periodically test metrics to all nodes."""
+
+    def __init__(self, marilib: "MarilibEdge", interval: float = 3):
+        self.marilib = marilib
+        self.interval = interval
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+
+    def start(self):
+        """Starts the metrics testing thread."""
+        print("[yellow]Metrics tester started.[/]")
+        self._thread.start()
+
+    def stop(self):
+        """Stops the metrics testing thread."""
+        self._stop_event.set()
+        if self._thread.is_alive():
+            self._thread.join()
+        print("[yellow]Metrics tester stopped.[/]")
+
+    def _run(self):
+        """The main loop for the testing thread."""
+        # Initial delay to allow nodes to join
+        self._stop_event.wait(self.interval)
+
+        while not self._stop_event.is_set():
+            nodes = list(self.marilib.nodes)
+            if not nodes:
+                self._stop_event.wait(self.interval)
+                continue
+
+            for node in nodes:
+                if self._stop_event.is_set():
+                    break
+                self.send_metrics_request(node, "edge")
+                # Spread the requests evenly over the interval
+                sleep_duration = self.interval / len(nodes)
+                self._stop_event.wait(sleep_duration)
+
+    def timestamp_us(self) -> int:
+        """Returns the current time in microseconds."""
+        return int(time.time() * 1000 * 1000)
+
+    def send_metrics_request(self, node: MariNode, marilib_type: str):
+        """Sends a metrics request packet to a specific address."""
+        payload = MetricsProbePayload()
+        if marilib_type == "edge":
+            payload.edge_tx_ts_us = self.timestamp_us()
+            payload.edge_tx_count = node.probe_increment_tx_count()
+        elif marilib_type == "cloud":
+            payload.cloud_tx_ts_us = self.timestamp_us()
+            payload.cloud_tx_count = node.probe_increment_tx_count()
+        # print(f">>> sending metrics probe to {node.address:016x}: {payload}")
+        payload = payload.to_bytes()
+        # print(f"    size is {len(payload)} bytes: {payload.hex()}\n")
+        self.marilib.send_frame(node.address, payload)
+
+    def handle_response_edge(self, frame: Frame):
+        """
+        Processes a metrics response frame.
+        This should be called when a LATENCY_DATA event is received.
+        """
+        node = self.marilib.gateway.get_node(frame.header.source)
+        if not node:
+            print(f"[red]Node not found: {frame.header.source:016x}[/]")
+            return
+
+        try:
+            payload = MetricsProbePayload().from_bytes(frame.payload)
+            if payload.type_ != DefaultPayloadType.METRICS_PROBE:
+                print(f"[red]Expected METRICS_PROBE, got {payload.type_}[/]")
+                return
+
+        except Exception as e:
+            print(f"[red]Error parsing metrics response: {e}[/]")
+            return
+
+        payload.edge_rx_ts_us = self.timestamp_us()
+        payload.edge_rx_count = node.probe_increment_rx_count()
+
+        node.save_probe_stats(payload)
+
+        # print(f"<<< received metrics probe from {frame.header.source:016x}: {payload}")
+        # print(f"    size is {len(frame.payload)} bytes: {frame.payload.hex()}\n")
+
+        # print(f"    latency_roundtrip_node_edge_ms: {payload.latency_roundtrip_node_edge_ms()}")
+        # print(f"    pdr_uplink_radio: {payload.pdr_uplink_radio(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_downlink_radio: {payload.pdr_downlink_radio(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_uplink_uart: {payload.pdr_uplink_uart(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_downlink_uart: {payload.pdr_downlink_uart(node.probe_stats_start_epoch)}")
+        # print(f"    rssi_at_node_dbm: {payload.rssi_at_node_dbm()}")
+        # print(f"    rssi_at_gw_dbm: {payload.rssi_at_gw_dbm()}")
+
+        return payload
+
+    def handle_response_cloud(self, frame: Frame, gateway: MariGateway, node: MariNode):
+        """
+        Processes a metrics response frame.
+        This should be called when a LATENCY_DATA event is received.
+        """
+        try:
+            payload = MetricsProbePayload().from_bytes(frame.payload)
+            if payload.type_ != DefaultPayloadType.METRICS_PROBE:
+                print(f"[red]Expected METRICS_PROBE, got {payload.type_}[/]")
+                return
+
+        except Exception as e:
+            print(f"[red]Error parsing metrics response: {e}[/]")
+            return
+
+        payload.cloud_rx_ts_us = self.timestamp_us()
+        payload.cloud_rx_count = node.probe_increment_rx_count()
+
+        node.save_probe_stats(payload)
+
+        # print(f"<<< received metrics probe from {frame.header.source:016x}: {payload}")
+        # print(f"    size is {len(frame.payload)} bytes: {frame.payload.hex()}\n")
+
+        # print(f"    latency_roundtrip_node_edge_ms: {payload.latency_roundtrip_node_edge_ms()}")
+        # print(f"    pdr_uplink_radio: {payload.pdr_uplink_radio(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_downlink_radio: {payload.pdr_downlink_radio(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_uplink_uart: {payload.pdr_uplink_uart(node.probe_stats_start_epoch)}")
+        # print(f"    pdr_downlink_uart: {payload.pdr_downlink_uart(node.probe_stats_start_epoch)}")
+        # print(f"    rssi_at_node_dbm: {payload.rssi_at_node_dbm()}")
+        # print(f"    rssi_at_gw_dbm: {payload.rssi_at_gw_dbm()}")
+
+        return payload