logging: Improve the logging module.

iabdalkader · iabdalkader · commit b1112b6438ff · 2022-07-16T18:04:26.000+02:00
* Add support for all format specifiers, support for `datefmt`
using strftime, and support for Stream and File handlers.
* Ports/boards that need to use `FileHandlers` should enable
`MICROPY_PY_SYS_ATEXIT`, and enabled `MICROPY_PY_SYS_EXC_INFO`
if using `logging.exception()`.
diff --git a/python-stdlib/logging/__init__.py b/python-stdlib/logging/__init__.py
@@ -0,0 +1,15 @@
+from .logging import Logger
+from .logging import Handler
+from .logging import Formatter
+from .logging import FileHandler
+from .logging import StreamHandler
+from .logging import DEBUG, INFO, WARNING, ERROR, CRITICAL
+from .logging import debug, info, warning, error, critical, exception
+from .logging import shutdown
+from .logging import getLogger
+from .logging import basicConfig
+
+import sys
+
+if hasattr(sys, "atexit"):
+    sys.atexit(shutdown)
diff --git a/python-stdlib/logging/example_logging.py b/python-stdlib/logging/example_logging.py
@@ -1,24 +1,39 @@
 import logging
 
-logging.basicConfig(level=logging.INFO)
-log = logging.getLogger("test")
-log.debug("Test message: %d(%s)", 100, "foobar")
-log.info("Test message2: %d(%s)", 100, "foobar")
-log.warning("Test message3: %d(%s)")
-log.error("Test message4")
-log.critical("Test message5")
-logging.info("Test message6")
+# Create logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
 
-try:
-    1 / 0
-except:
-    log.exception("Some trouble (%s)", "expected")
+# Create console handler and set level to debug
+stream_handler = logging.StreamHandler()
+stream_handler.setLevel(logging.DEBUG)
+
+# Create file handler and set level to error
+file_handler = logging.FileHandler("error.log", mode="w")
+file_handler.setLevel(logging.ERROR)
+
+# Create a formatter
+formatter = logging.Formatter("%(asctime)s.%(msecs)03d - %(name)s - %(levelname)s - %(message)s")
 
+# Add formatter to the handlers
+stream_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
 
-class MyHandler(logging.Handler):
-    def emit(self, record):
-        print("levelname=%(levelname)s name=%(name)s message=%(message)s" % record.__dict__)
+# Add hadlers to logger
+logger.addHandler(stream_handler)
+logger.addHandler(file_handler)
 
+# Lapplication' code
+logger.debug('debug message')
+logger.info('info message')
+logger.warning('warn message')
+logger.error('error message')
+logger.critical('critical message')
+logger.info("message %s %d", "arg", 5)
+logger.info("message %(foo)s %(bar)s", {"foo": 1, "bar": 20})
+
+try:
+    1 / 0
+except:
+    logger.exception("Some trouble (%s)", "expected")
 
-logging.getLogger().addHandler(MyHandler())
-logging.info("Test message7")
diff --git a/python-stdlib/logging/logging.py b/python-stdlib/logging/logging.py
@@ -1,128 +1,202 @@
 import sys
+import time
 
-CRITICAL = 50
-ERROR = 40
-WARNING = 30
-INFO = 20
-DEBUG = 10
 NOTSET = 0
+DEBUG = 10
+INFO = 20
+WARNING = 30
+ERROR = 40
+CRITICAL = 50
 
-_level_dict = {
-    CRITICAL: "CRIT",
-    ERROR: "ERROR",
-    WARNING: "WARN",
-    INFO: "INFO",
+levelname = {
+    NOTSET: "NOTSET",
     DEBUG: "DEBUG",
+    INFO: "INFO",
+    WARNING: "WARNING",
+    ERROR: "ERROR",
+    CRITICAL: "CRITICAL",
 }
 
-_stream = sys.stderr
+loggers = {}
+default_fmt = "%(levelname)s:%(name)s:%(message)s"
+default_datefmt = "%Y-%m-%d %H:%M:%S"
 
 
-class LogRecord:
-    def __init__(self):
-        self.__dict__ = {}
+class Handler:
+    def __init__(self, level=NOTSET):
+        self.level = level
+        self.formatter = None
 
-    def __getattr__(self, key):
-        return self.__dict__[key]
+    def close(self):
+        pass
 
+    def setLevel(self, level):
+        self.level = level
 
-class Handler:
-    def __init__(self):
-        pass
+    def setFormatter(self, formatter):
+        self.formatter = formatter
 
-    def setFormatter(self, fmtr):
-        pass
+    def format(self, record):
+        return self.formatter.format(record)
 
 
-class Logger:
+class StreamHandler(Handler):
+    def __init__(self, stream=sys.stderr):
+        self.stream = stream
+        self.terminator = "\n"
 
-    level = NOTSET
-    handlers = []
-    record = LogRecord()
+    def close(self):
+        if hasattr(self.stream, "flush"):
+            self.stream.flush()
 
-    def __init__(self, name):
+    def emit(self, record):
+        if record.level >= self.level:
+            self.stream.write(self.format(record) + self.terminator)
+
+
+class FileHandler(StreamHandler):
+    def __init__(self, filename, mode="a", encoding="UTF-8"):
+        super().__init__(stream=open(filename, mode=mode, encoding=encoding))
+
+    def close(self):
+        super().close()
+        self.stream.close()
+
+
+class Record:
+    def set(self, name, level, message):
         self.name = name
+        self.level = level
+        self.message = message
+        self.ts = time.time()
+        self.msecs = int((self.ts - int(self.ts)) * 1000)
+
+
+class Formatter:
+    def __init__(self, fmt=default_fmt, datefmt=default_datefmt):
+        self.fmt = fmt
+        self.datefmt = datefmt
+
+    def formatTime(self, datefmt):
+        if hasattr(time, "strftime"):
+            return time.strftime(datefmt, time.localtime())
+        return ""
+
+    def format(self, record):
+        return self.fmt % {
+            "name": record.name,
+            "message": record.message,
+            "msecs": record.msecs,
+            "asctime": self.formatTime(self.datefmt),
+            "levelname": levelname[record.level],
+        }
 
-    def _level_str(self, level):
-        l = _level_dict.get(level)
-        if l is not None:
-            return l
-        return "LVL%s" % level
+
+class Logger:
+    def __init__(self, name):
+        self.name = name
+        self.level = NOTSET
+        self.handlers = []
+        self.record = Record()
 
     def setLevel(self, level):
         self.level = level
 
-    def isEnabledFor(self, level):
-        return level >= (self.level or _level)
+    def addHandler(self, handler):
+        self.handlers.append(handler)
 
-    def log(self, level, msg, *args):
-        if self.isEnabledFor(level):
-            levelname = self._level_str(level)
-            if args:
-                msg = msg % args
-            if self.handlers:
-                d = self.record.__dict__
-                d["levelname"] = levelname
-                d["levelno"] = level
-                d["message"] = msg
-                d["name"] = self.name
-                for h in self.handlers:
-                    h.emit(self.record)
-            else:
-                print(levelname, ":", self.name, ":", msg, sep="", file=_stream)
+    def hasHandlers(self):
+        return len(self.handlers) > 0
 
-    def debug(self, msg, *args):
-        self.log(DEBUG, msg, *args)
+    def debug(self, message, *args, **kwargs):
+        self.log(DEBUG, message, *args, **kwargs)
 
-    def info(self, msg, *args):
-        self.log(INFO, msg, *args)
+    def info(self, message, *args, **kwargs):
+        self.log(INFO, message, *args, **kwargs)
 
-    def warning(self, msg, *args):
-        self.log(WARNING, msg, *args)
+    def warning(self, message, *args, **kwargs):
+        self.log(WARNING, message, *args, **kwargs)
 
-    def error(self, msg, *args):
-        self.log(ERROR, msg, *args)
+    def error(self, message, *args, **kwargs):
+        self.log(ERROR, message, *args, **kwargs)
 
-    def critical(self, msg, *args):
-        self.log(CRITICAL, msg, *args)
+    def critical(self, message, *args, **kwargs):
+        self.log(CRITICAL, message, *args, **kwargs)
 
-    def exc(self, e, msg, *args):
-        self.log(ERROR, msg, *args)
-        sys.print_exception(e, _stream)
+    def exception(self, message, *args, **kwargs):
+        self.log(ERROR, message, *args, **kwargs)
+        if hasattr(sys, "exc_info"):
+            for h in filter(lambda h: isinstance(h, StreamHandler), self.handlers):
+                sys.print_exception(sys.exc_info()[1], h.stream)
 
-    def exception(self, msg, *args):
-        self.exc(sys.exc_info()[1], msg, *args)
+    def log(self, level, message, *args, **kwargs):
+        if level >= self.level:
+            if args and isinstance(args[0], dict):
+                args = args[0]
+            for h in self.handlers:
+                self.record.set(self.name, level, message % args)
+                h.emit(self.record)
 
-    def addHandler(self, hndlr):
-        self.handlers.append(hndlr)
 
+def debug(message, *args, **kwargs):
+    getLogger().log(DEBUG, message, *args, **kwargs)
 
-_level = INFO
-_loggers = {}
 
+def info(message, *args, **kwargs):
+    getLogger().log(INFO, message, *args, **kwargs)
 
-def getLogger(name="root"):
-    if name in _loggers:
-        return _loggers[name]
-    l = Logger(name)
-    _loggers[name] = l
-    return l
+
+def warning(message, *args, **kwargs):
+    getLogger().log(WARNING, message, *args, **kwargs)
 
 
-def info(msg, *args):
-    getLogger().info(msg, *args)
+def error(message, *args, **kwargs):
+    getLogger().log(ERROR, message, *args, **kwargs)
 
 
-def debug(msg, *args):
-    getLogger().debug(msg, *args)
+def critical(message, *args, **kwargs):
+    getLogger().log(CRITICAL, message, *args, **kwargs)
 
 
-def basicConfig(level=INFO, filename=None, stream=None, format=None):
-    global _level, _stream
-    _level = level
-    if stream:
-        _stream = stream
-    if filename is not None:
-        print("logging.basicConfig: filename arg is not supported")
-    if format is not None:
-        print("logging.basicConfig: format arg is not supported")
+def exception(message, *args, **kwargs):
+    getLogger().exception(message, *args, **kwargs)
+
+
+def shutdown():
+    for k, logger in loggers.items():
+        for h in logger.handlers:
+            h.close()
+        loggers.pop(logger, None)
+
+
+def getLogger(name="root"):
+    if name not in loggers:
+        loggers[name] = Logger(name)
+    return loggers[name]
+
+
+def basicConfig(
+    filename=None,
+    filemode="a",
+    format=default_fmt,
+    datefmt=default_datefmt,
+    level=WARNING,
+    stream=sys.stderr,
+    encoding="UTF-8",
+    force=False,
+):
+    logger = getLogger()
+    if force or not logger.handlers:
+        for h in logger.handlers:
+            h.close()
+
+        if filename is None:
+            handler = StreamHandler(stream)
+        else:
+            handler = FileHandler(filename, filemode, encoding)
+
+        handler.setLevel(level)
+        handler.setFormatter(Formatter(format, datefmt))
+
+        logger.setLevel(level)
+        logger.addHandler(handler)
diff --git a/python-stdlib/logging/metadata.txt b/python-stdlib/logging/metadata.txt
@@ -1,3 +1,3 @@
 srctype = micropython-lib
 type = module
-version = 0.3
+version = 0.4
diff --git a/python-stdlib/logging/setup.py b/python-stdlib/logging/setup.py
@@ -10,7 +10,7 @@
 
 setup(
     name="micropython-logging",
-    version="0.3",
+    version="0.4",
     description="logging module for MicroPython",
     long_description="This is a module reimplemented specifically for MicroPython standard library,\nwith efficient and lean design in mind. Note that this module is likely work\nin progress and likely supports just a subset of CPython's corresponding\nmodule. Please help with the development if you are interested in this\nmodule.",
     url="https://github.com/micropython/micropython-lib",
