Logger in all nodes. (#217)

* Logging added to the parsers and host nodes.

* E2E logger.

* Update docker image.

* Logger in tests.

* Log fixes.

* Snap producer logs.

* Fix MapOutputParser log.

Author: kkeroo

depthai_nodes/logging.py

@@ -39,7 +39,9 @@ def setup_logging(level: Optional[str] = None, file: Optional[str] = None):
     if not used_level:
         used_level = LogLevel.WARN
 
-    format = file_format = "%(asctime)s [depthai-nodes] [%(levelname)s] %(message)s"
+    format = (
+        file_format
+    ) = "%(asctime)s [depthai-nodes] [%(levelname)s] [%(name)s] %(message)s"
     datefmt = "[%Y-%m-%d %H:%M:%S]"
 
     console_handler = logging.StreamHandler()

depthai_nodes/node/apply_colormap.py

@@ -39,6 +39,10 @@ def __init__(
         self.setMaxValue(max_value)
         self.setInstanceToSemanticMask(instance_to_semantic_mask)
 
+        self._logger.debug(
+            f"ApplyColormap initialized with colormap_value={colormap_value}, max_value={max_value}, instance_to_semantic_mask={instance_to_semantic_mask}",
+        )
+
     def setColormap(self, colormap_value: int) -> None:
         """Sets the applied color mapping.
 
@@ -50,6 +54,7 @@ def setColormap(self, colormap_value: int) -> None:
         colormap = cv2.applyColorMap(np.arange(256, dtype=np.uint8), colormap_value)
         colormap[0] = [0, 0, 0]  # Set zero values to black
         self._colormap = colormap
+        self._logger.debug(f"Colormap set to {self._colormap}")
 
     def setMaxValue(self, max_value: int) -> None:
         """Sets the maximum frame value for normalization.
@@ -60,6 +65,7 @@ def setMaxValue(self, max_value: int) -> None:
         if not isinstance(max_value, int):
             raise ValueError("max_value must be an integer.")
         self._max_value = max_value
+        self._logger.debug(f"Max value set to {self._max_value}")
 
     def setInstanceToSemanticMask(self, instance_to_semantic_mask: bool) -> None:
         """Sets the instance to semantic mask flag.
@@ -71,6 +77,9 @@ def setInstanceToSemanticMask(self, instance_to_semantic_mask: bool) -> None:
         if not isinstance(instance_to_semantic_mask, bool):
             raise ValueError("instance_to_semantic_mask must be a boolean.")
         self._instance_to_semantic_mask = instance_to_semantic_mask
+        self._logger.debug(
+            f"Instance to semantic mask set to {self._instance_to_semantic_mask}"
+        )
 
     def build(self, arr: dai.Node.Output) -> "ApplyColormap":
         """Configures the node connections.
@@ -81,6 +90,7 @@ def build(self, arr: dai.Node.Output) -> "ApplyColormap":
         @rtype: ApplyColormap
         """
         self.link_args(arr)
+        self._logger.debug("ApplyColormap built")
         return self
 
     def process(self, msg: dai.Buffer) -> None:
@@ -92,7 +102,7 @@ def process(self, msg: dai.Buffer) -> None:
             segmentation masks to semantic segmentation masks.
         @type instance_to_semantic_segmentation: bool
         """
-
+        self._logger.debug("Processing new input")
         msg_copy = copy_message(msg)
 
         if isinstance(msg, SegmentationMask):
@@ -140,4 +150,8 @@ def process(self, msg: dai.Buffer) -> None:
         frame.setTimestamp(msg.getTimestamp())
         frame.setSequenceNum(msg.getSequenceNum())
 
+        self._logger.debug("ImgFrame message created")
+
         self.out.send(frame)
+
+        self._logger.debug("Message sent successfully")

depthai_nodes/node/base_host_node.py

@@ -2,6 +2,8 @@
 
 import depthai as dai
 
+from depthai_nodes.logging import get_logger
+
 HostNodeMeta = type(dai.node.HostNode)  # metaclass of dai.node.HostNode
 
 
@@ -33,5 +35,7 @@ def __init__(self) -> None:
                 f"No dai.ImgFrame.Type defined for platform {self._platform}."
             ) from e
 
+        self._logger = get_logger(self.__class__.__name__)
+
     def process(self) -> None:
         pass

depthai_nodes/node/depth_merger.py

@@ -38,6 +38,9 @@ def __init__(self, shrinking_factor: float = 0) -> None:
         )
 
         self.shrinking_factor = shrinking_factor
+        self._logger.debug(
+            f"DepthMerger initialized with shrinking_factor={shrinking_factor}"
+        )
 
     def build(
         self,
@@ -50,11 +53,17 @@ def build(
         self.link_args(output_2d, output_depth)
         self.shrinking_factor = shrinking_factor
         self.host_spatials_calc = HostSpatialsCalc(calib_data, depth_alignment_socket)
+        self._logger.debug(
+            f"DepthMerger built with shrinking_factor={shrinking_factor}"
+        )
         return self
 
     def process(self, message_2d: dai.Buffer, depth: dai.ImgFrame) -> None:
+        self._logger.debug("Processing new input")
         spatial_dets = self._transform(message_2d, depth)
+        self._logger.debug("Spatial detections message created")
         self.output.send(spatial_dets)  # type: ignore
+        self._logger.debug("Message sent successfully")
 
     def _transform(
         self, message_2d: dai.Buffer, depth: dai.ImgFrame

depthai_nodes/node/gather_data.py

@@ -14,6 +14,7 @@
 import depthai as dai
 
 from depthai_nodes import GatheredData
+from depthai_nodes.logging import get_logger
 
 
 @runtime_checkable
@@ -63,6 +64,9 @@ def __init__(self) -> None:
         self.input_reference = self.createInput()
         self.out = self.createOutput()
 
+        self._logger = get_logger(__name__)
+        self._logger.debug("GatherData initialized")
+
     @staticmethod
     def _default_wait_count_fn(reference: TReference) -> int:
         assert isinstance(reference, HasDetections)
@@ -106,14 +110,17 @@ def build(
         if wait_count_fn is None:
             wait_count_fn = self._default_wait_count_fn
         self.set_wait_count_fn(wait_count_fn)
+        self._logger.debug(f"GatherData built with camera_fps={camera_fps}")
         return self
 
     def set_camera_fps(self, fps: int) -> None:
         if fps <= 0:
             raise ValueError(f"Camera FPS must be positive, got {fps}")
         self._camera_fps = fps
+        self._logger.debug(f"Camera FPS set to {fps}")
 
     def run(self) -> None:
+        self._logger.debug("GatherData run started")
         if not self._camera_fps:
             raise ValueError("Camera FPS not set. Call build() before run().")
 
@@ -124,9 +131,11 @@ def run(self) -> None:
             except dai.MessageQueue.QueueException:
                 break
             if input_data:
+                self._logger.debug("Input data received")
                 self._add_data(input_data)
                 self._send_ready_data()
             if input_reference:
+                self._logger.debug("Input reference received")
                 self._add_reference(input_reference)
                 self._send_ready_data()
 
@@ -137,6 +146,7 @@ def _send_ready_data(self) -> None:
         if ready_data:
             self._clear_old_data(ready_data)
             self.out.send(ready_data)
+            self._logger.debug("Gathered data sent")
 
     def _add_data(self, data: TGathered) -> None:
         data_ts = self._get_total_seconds_ts(data)

depthai_nodes/node/img_detections_bridge.py

@@ -26,6 +26,7 @@ def __init__(self) -> None:
         self._log = True
         self._ignore_angle = False
         self._label_encoding = {}
+        self._logger.debug("ImgDetectionsBridge initialized")
 
     def setIgnoreAngle(self, ignore_angle: bool) -> bool:
         """Sets whether to ignore the angle of the detections during transformation.
@@ -36,6 +37,7 @@ def setIgnoreAngle(self, ignore_angle: bool) -> bool:
         if not isinstance(ignore_angle, bool):
             raise ValueError("ignore_angle must be a boolean.")
         self._ignore_angle = ignore_angle
+        self._logger.debug(f"Ignore angle set to {self._ignore_angle}")
 
     def setLabelEncoding(self, label_encoding: Dict[int, str]) -> None:
         """Sets the label encoding.
@@ -47,6 +49,7 @@ def setLabelEncoding(self, label_encoding: Dict[int, str]) -> None:
         if not isinstance(label_encoding, Dict):
             raise ValueError("label_encoding must be a dictionary.")
         self._label_encoding = label_encoding
+        self._logger.debug(f"Label encoding set to {self._label_encoding}")
 
     def build(
         self,
@@ -70,6 +73,9 @@ def build(
         self.setIgnoreAngle(ignore_angle)
         if label_encoding is not None:
             self.setLabelEncoding(label_encoding)
+        self._logger.debug(
+            f"ImgDetectionsBridge built with ignore_angle={ignore_angle}, label_encoding={label_encoding}"
+        )
         return self
 
     def process(self, msg: dai.Buffer) -> None:
@@ -78,7 +84,7 @@ def process(self, msg: dai.Buffer) -> None:
         @param msg: The input message for the ImgDetections object.
         @type msg: dai.ImgDetections or ImgDetectionsExtended
         """
-
+        self._logger.debug("Processing new input")
         if isinstance(msg, dai.ImgDetections):
             msg_transformed = self._img_det_to_img_det_ext(msg)
         elif isinstance(msg, ImgDetectionsExtended):
@@ -96,8 +102,13 @@ def process(self, msg: dai.Buffer) -> None:
         msg_transformed.setTimestamp(msg.getTimestamp())
         msg_transformed.setSequenceNum(msg.getSequenceNum())
         msg_transformed.setTransformation(msg.getTransformation())
+
+        self._logger.debug("Detection message created")
+
         self.out.send(msg_transformed)
 
+        self._logger.debug("Message sent successfully")
+
     def _img_det_to_img_det_ext(
         self, img_dets: dai.ImgDetections
     ) -> ImgDetectionsExtended:

depthai_nodes/node/img_detections_filter.py

@@ -36,6 +36,7 @@ def __init__(self):
         self._confidence_threshold = None
         self._max_detections = None
         self._sort_by_confidence = False
+        self._logger.debug("ImgDetectionsFilter initialized")
 
     def setLabels(self, labels: List[int], keep: bool) -> None:
         """Sets the labels to keep or reject.
@@ -57,6 +58,10 @@ def setLabels(self, labels: List[int], keep: bool) -> None:
             self._labels_to_keep = None
             self._labels_to_reject = labels
 
+        self._logger.debug(
+            f"Labels set to {self._labels_to_keep if keep else self._labels_to_reject}"
+        )
+
     def setConfidenceThreshold(self, confidence_threshold: float) -> None:
         """Sets the confidence threshold.
 
@@ -69,6 +74,7 @@ def setConfidenceThreshold(self, confidence_threshold: float) -> None:
         ):
             raise ValueError("confidence_threshold must be a float.")
         self._confidence_threshold = confidence_threshold
+        self._logger.debug(f"Confidence threshold set to {self._confidence_threshold}")
 
     def setMaxDetections(self, max_detections: int) -> None:
         """Sets the maximum number of detections.
@@ -79,6 +85,7 @@ def setMaxDetections(self, max_detections: int) -> None:
         if not isinstance(max_detections, int) and max_detections is not None:
             raise ValueError("max_detections must be an integer.")
         self._max_detections = max_detections
+        self._logger.debug(f"Max detections set to {self._max_detections}")
 
     def setSortByConfidence(self, sort_by_confidence: bool) -> None:
         """Sets whether to sort the detections by confidence before subsetting.
@@ -89,6 +96,7 @@ def setSortByConfidence(self, sort_by_confidence: bool) -> None:
         if not isinstance(sort_by_confidence, bool):
             raise ValueError("sort_by_confidence must be a boolean.")
         self._sort_by_confidence = sort_by_confidence
+        self._logger.debug(f"Sort by confidence set to {self._sort_by_confidence}")
 
     def build(
         self,
@@ -120,9 +128,14 @@ def build(
 
         self.setSortByConfidence(sort_by_confidence)
 
+        self._logger.debug(
+            f"ImgDetectionsFilter built with labels_to_keep={labels_to_keep}, labels_to_reject={labels_to_reject}, confidence_threshold={confidence_threshold}, max_detections={max_detections}, sort_by_confidence={sort_by_confidence}"
+        )
+
         return self
 
     def process(self, msg: dai.Buffer) -> None:
+        self._logger.debug("Processing new input")
         assert isinstance(
             msg,
             (
@@ -159,4 +172,8 @@ def process(self, msg: dai.Buffer) -> None:
 
         msg_new.detections = filtered_detections[: self._max_detections]
 
+        self._logger.debug("Detections message created")
+
         self.out.send(msg_new)
+
+        self._logger.debug("Message sent successfully")

depthai_nodes/node/img_frame_overlay.py

@@ -24,6 +24,7 @@ class ImgFrameOverlay(BaseHostNode):
     def __init__(self, alpha: float = 0.5) -> None:
         super().__init__()
         self.setAlpha(alpha)
+        self._logger.debug(f"ImgFrameOverlay initialized with alpha={alpha}")
 
     def setAlpha(self, alpha: float) -> None:
         """Sets the alpha.
@@ -36,6 +37,7 @@ def setAlpha(self, alpha: float) -> None:
         if not 0.0 <= alpha <= 1.0:
             raise ValueError("Alpha must be between 0.0 and 1.0")
         self._alpha = alpha
+        self._logger.debug(f"Alpha set to {self._alpha}")
 
     def build(
         self, frame1: dai.Node.Output, frame2: dai.Node.Output, alpha: float = None
@@ -56,6 +58,8 @@ def build(
         if alpha is not None:
             self.setAlpha(alpha)
 
+        self._logger.debug(f"ImgFrameOverlay built with alpha={alpha}")
+
         return self
 
     def process(self, frame1: dai.Buffer, frame2: dai.Buffer) -> None:
@@ -66,6 +70,7 @@ def process(self, frame1: dai.Buffer, frame2: dai.Buffer) -> None:
         @param frame2: The input message for the foreground frame.
         @type frame2: dai.ImgFrame
         """
+        self._logger.debug("Processing new input")
         assert isinstance(frame1, dai.ImgFrame)
         assert isinstance(frame2, dai.ImgFrame)
 
@@ -95,4 +100,8 @@ def process(self, frame1: dai.Buffer, frame2: dai.Buffer) -> None:
         overlay.setTimestamp(frame1.getTimestamp())
         overlay.setSequenceNum(frame1.getSequenceNum())
 
+        self._logger.debug("ImgFrame message created")
+
         self.out.send(overlay)
+
+        self._logger.debug("Message sent successfully")

depthai_nodes/node/parsers/base_parser.py

@@ -3,6 +3,8 @@
 
 import depthai as dai
 
+from depthai_nodes.logging import get_logger
+
 
 class BaseMeta(ABCMeta, type(dai.node.ThreadedHostNode)):
     pass
@@ -28,6 +30,7 @@ def __init__(self) -> None:
         super().__init__()
         self._input = self.createInput()
         self._out = self.createOutput()
+        self._logger = get_logger(self.__class__.__name__)
 
     @property
     @abstractmethod