Merge pull request #101 from CarletonURocketry/eh/logging_refactor

Update logging and error handling

Author: linguini1

modules/serial/serial_rn2483_radio.py

@@ -34,7 +34,7 @@ def rn2483_radio_process(
         except SerialException:
             serial_status.put("rn2483_connected False")
             serial_status.put("rn2483_port null")
-            logger.info("RN2483 Radio: Error communicating with serial device.")
+            logger.error("RN2483 Radio: Error communicating with serial device.")
             time.sleep(3)
 
     # Get transmissions

modules/telemetry/telemetry_utils.py

@@ -76,28 +76,36 @@ def parse_radio_block(pkt_version: int, block_header: BlockHeader, hex_block_con
     block_bytes: bytes = bytes.fromhex(hex_block_contents)
 
     try:
-        # TODO Make an interface to support multiple v1/v2/v3 objects
         block_subtype = v1db.DataBlockSubtype(block_header.message_subtype)
-        block_contents = v1db.DataBlock.parse(block_subtype, block_bytes)
-        block_name = block_subtype.name.lower()
-
-        logger.info(str(block_contents))
-
-        # TODO fix at some point
-        # if block == DataBlockSubtype.STATUS:
-        #     self.status.rocket = jsp.RocketData.from_data_block(block)
-        #     return
-
-        return ParsedBlock(block_name, block_header, dict(block_contents))  # type: ignore
-
     except ValueError:
-        logger.error("Invalid data block subtype")
+        logger.error(f"Invalid data block subtype {block_header.message_subtype}!")
+        return
 
+    try:
+        # TODO Make an interface to support multiple v1/v2/v3 objects
+        block_contents = v1db.DataBlock.parse(block_subtype, block_bytes)
     except NotImplementedError:
         logger.warning(
             f"Block parsing for type {block_header.message_type}, with subtype {block_header.message_subtype} not \
                 implemented!"
         )
+        return
+    except v1db.DataBlockException as e:
+        logger.error(e)
+        logger.error(f"Block header: {block_header}")
+        logger.error(f"Block contents: {hex_block_contents}")
+        return
+
+    block_name = block_subtype.name.lower()
+
+    logger.debug(str(block_contents))
+
+    # TODO fix at some point
+    # if block == DataBlockSubtype.STATUS:
+    #     self.status.rocket = jsp.RocketData.from_data_block(block)
+    #     return
+
+    return ParsedBlock(block_name, block_header, dict(block_contents))  # type: ignore
 
 
 def parse_rn2483_transmission(data: str, config: Config) -> Optional[ParsedTransmission]:
@@ -124,7 +132,7 @@ def parse_rn2483_transmission(data: str, config: Config) -> Optional[ParsedTrans
     from_approved_callsign(pkt_hdr, config.approved_callsigns)
 
     if len(pkt_hdr) <= 32:  # If this packet nothing more than just the header
-        logger.info(f"{pkt_hdr}")
+        logger.debug(f"{pkt_hdr}")
 
     blocks = data[32:]  # Remove the packet header
 
@@ -164,7 +172,7 @@ def from_approved_callsign(pkt_hdr: PacketHeader, approved_callsigns: dict[str,
 
     # Ensure packet is from an approved call sign
     if pkt_hdr.callsign in approved_callsigns:
-        logger.info(f"Incoming packet from {pkt_hdr.callsign} ({approved_callsigns.get(pkt_hdr.callsign)})")
+        logger.debug(f"Incoming packet from {pkt_hdr.callsign} ({approved_callsigns.get(pkt_hdr.callsign)})")
     else:
         logger.warning(f"Incoming packet from unauthorized call sign {pkt_hdr.callsign}")
         return False

modules/telemetry/v1/data_block.py

@@ -8,20 +8,13 @@
 from modules.misc.converter import metres_to_feet, milli_degrees_to_celsius, pascals_to_psi
 
 
-class BlockException(Exception):
-    pass
+class DataBlockException(Exception):
+    """Exception raised when an error occurs while parsing a data block."""
 
-
-class BlockUnknownException(BlockException):
-    pass
-
-
-class DataBlockException(BlockException):
-    pass
-
-
-class DataBlockUnknownException(BlockUnknownException):
-    pass
+    def __init__(self, subtype_name: str, error: str):
+        self.subtype_name = subtype_name
+        self.error = error
+        super().__init__(f"Error parsing {subtype_name} block: {error}")
 
 
 class DataBlockSubtype(IntEnum):
@@ -119,7 +112,12 @@ def parse(block_subtype: DataBlockSubtype, payload: bytes) -> DataBlock:
         if subtype is None:
             raise NotImplementedError
 
-        return subtype.from_bytes(payload=payload)
+        try:
+            subtype_instance = subtype.from_bytes(payload)
+        except Exception as e:
+            raise DataBlockException(subtype.__name__, str(e))
+
+        return subtype_instance
 
 
 class DebugMessageDB(DataBlock):

tests/parsing/test_full_telemetry_parsing.py

@@ -58,7 +58,7 @@ def test_radio_block(pkt_version: int, block_header: BlockHeader, hex_block_cont
 
 @pytest.fixture
 def not_implemented_datablock_subtype() -> BlockHeader:
-    return BlockHeader.from_hex("02000600")
+    return BlockHeader.from_hex("02000a00")
 
 
 def test_invalid_datablock_subtype(pkt_version: int, hex_block_contents: str):
@@ -72,15 +72,6 @@ def test_invalid_datablock_subtype(pkt_version: int, hex_block_contents: str):
         parse_radio_block(pkt_version, BlockHeader.from_hex("02009A00"), hex_block_contents)
 
 
-def test_not_implemented_error(
-    pkt_version: int, not_implemented_datablock_subtype: BlockHeader, hex_block_contents: str
-) -> None:
-    """
-    test for a subtye that exists but is not implemented
-    """
-    assert parse_radio_block(pkt_version, not_implemented_datablock_subtype, hex_block_contents) is None
-
-
 config = load_config("config.json")
 
 # Fixtures and tests to ensure that from_approved_callsign works as expected
@@ -110,7 +101,7 @@ def non_approved_callsign() -> PacketHeader:
 def test_is_approved_pkt_hdr(
     valid_packet_header: PacketHeader, approved_callsigns: dict[str, str], caplog: LogCaptureFixture
 ) -> None:
-    caplog.set_level(logging.INFO)
+    caplog.set_level(logging.DEBUG)
     assert from_approved_callsign(valid_packet_header, approved_callsigns)
     assert (
         f"Incoming packet from {valid_packet_header.callsign} ({approved_callsigns.get(valid_packet_header.callsign)})"