implement rotating file logger

zariiii9003 · zariiii9003 · commit 763842045eba · 2020-08-01T13:23:06.000+02:00
diff --git a/can/__init__.py b/can/__init__.py
@@ -24,7 +24,7 @@ class CanError(IOError):
 
 from .listener import Listener, BufferedReader, RedirectReader, AsyncBufferedReader
 
-from .io import Logger, Printer, LogReader, MessageSync
+from .io import Logger, RotatingFileLogger, Printer, LogReader, MessageSync
 from .io import ASCWriter, ASCReader
 from .io import BLFReader, BLFWriter
 from .io import CanutilsLogReader, CanutilsLogWriter
diff --git a/can/io/__init__.py b/can/io/__init__.py
@@ -4,7 +4,7 @@
 """
 
 # Generic
-from .logger import Logger
+from .logger import Logger, RotatingFileLogger
 from .player import LogReader, MessageSync
 
 # Format specific
diff --git a/can/io/logger.py b/can/io/logger.py
@@ -3,13 +3,14 @@
 """
 
 import pathlib
-import typing
+from typing import Optional, Callable
 
 from pkg_resources import iter_entry_points
 import can.typechecking
 
+from ..message import Message
 from ..listener import Listener
-from .generic import BaseIOHandler
+from .generic import BaseIOHandler, MessageWriter
 from .asc import ASCWriter
 from .blf import BLFWriter
 from .canutils import CanutilsLogWriter
@@ -51,7 +52,7 @@ class Logger(BaseIOHandler, Listener):  # pylint: disable=abstract-method
 
     @staticmethod
     def __new__(
-        cls, filename: typing.Optional[can.typechecking.StringPathLike], *args, **kwargs
+        cls, filename: Optional[can.typechecking.StringPathLike], *args, **kwargs
     ):
         """
         :param filename: the filename/path of the file to write to,
@@ -78,3 +79,97 @@ def __new__(
             raise ValueError(
                 f'No write support for this unknown log format "{suffix}"'
             ) from None
+
+
+class RotatingFileLogger(Listener):
+    """Log CAN messages to a sequence of files with a given maximum size.
+
+    The log file name and path must be returned by the function`filename_func`
+    as a path-like object (e.g. a string). The log file format is defined by
+    the suffix of the path-like object.
+
+    The RotatingFileLogger currently supports
+      * .asc: :class:`can.ASCWriter`
+      * .blf :class:`can.BLFWriter`
+      * .csv: :class:`can.CSVWriter`
+      * .log :class:`can.CanutilsLogWriter`
+      * .txt :class:`can.Printer`
+
+    The log files may be incomplete until `stop()` is called due to buffering.
+
+    Example::
+
+        from can import Notifier
+        from can.interfaces.vector import VectorBus
+        from can import RotatingFileLogger
+
+        bus = VectorBus(channel=[0], app_name="CANape", fd=True)
+        logger = RotatingFileLogger(
+            filename_func=lambda idx: f"CAN_Log_{idx:03}.txt",  # filename with three digit counter
+            max_bytes=5 * 1024 ** 2,  # =5MB
+            initial_file_number=23,  # start with number 23
+        )
+        notifier = Notifier(bus=bus, listeners=[logger])
+
+    """
+
+    supported_writers = {
+        ".asc": ASCWriter,
+        ".blf": BLFWriter,
+        ".csv": CSVWriter,
+        ".log": CanutilsLogWriter,
+        ".txt": Printer,
+    }
+
+    def __init__(
+        self,
+        filename_func: Callable[[int], can.typechecking.StringPathLike],
+        max_bytes: int,
+        initial_file_number: int = 0,
+        *args,
+        **kwargs,
+    ):
+        """
+        :param filename_func:
+            A function or lambda expression that returns the path of the new
+            log file e.g. `lambda file_number: f"C:\\my_can_logfile_{file_number:03}.asc"`.
+        :param max_bytes:
+            The file size threshold in bytes at which a new file is created.
+        :param initial_file_number:
+            The first log file will start with number `initial_file_number`.
+        :raises ValueError:
+            The filename's suffix is not supported.
+        """
+        self.filename_func = filename_func
+        self.max_bytes = max_bytes
+        self.file_number = initial_file_number
+
+        self.writer_args = args
+        self.writer_kwargs = kwargs
+
+        self.writer: MessageWriter = self._get_new_writer()
+
+    def on_message_received(self, msg: Message):
+        if self.writer.file is not None and self.writer.file.tell() >= self.max_bytes:
+            self.writer.stop()
+            self.file_number += 1
+            self.writer = self._get_new_writer()
+
+        self.writer.on_message_received(msg)
+
+    def on_error(self, exc: Exception):
+        self.writer.on_error(exc)
+
+    def stop(self):
+        self.writer.stop()
+
+    def _get_new_writer(self) -> MessageWriter:
+        filename = self.filename_func(self.file_number)
+        suffix = pathlib.Path(filename).suffix.lower()
+        try:
+            writer_class = self.supported_writers[suffix]
+        except KeyError:
+            raise ValueError(
+                f'Log format "{suffix} is not supported by RotatingFileLogger."'
+            )
+        return writer_class(filename, *self.writer_args, **self.writer_kwargs)
diff --git a/doc/listeners.rst b/doc/listeners.rst
@@ -75,6 +75,9 @@ create log files with different file types of the messages received.
 .. autoclass:: can.Logger
     :members:
 
+.. autoclass:: can.RotatingFileLogger
+    :members:
+
 
 Printer
 -------
