logging: Improve the logging module.

iabdalkader · iabdalkader · commit 06575c8d76de · 2022-11-25T08:22:43.000+01: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/example_logging.py b/python-stdlib/logging/example_logging.py
@@ -1,20 +1,43 @@
 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)
+
+# 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)
+
+# Add handlers to logger
+logger.addHandler(stream_handler)
+logger.addHandler(file_handler)
+
+# Log some messages
+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:
-    log.exception("Some trouble (%s)", "expected")
-
+    logger.error("Some trouble (%s)", "expected")
 
+# Custom handler example
 class MyHandler(logging.Handler):
     def emit(self, record):
         print("levelname=%(levelname)s name=%(name)s message=%(message)s" % record.__dict__)
diff --git a/python-stdlib/logging/logging.py b/python-stdlib/logging/logging.py
@@ -1,4 +1,5 @@
 import sys
+import time
 
 CRITICAL = 50
 ERROR = 40
@@ -8,68 +9,116 @@
 NOTSET = 0
 
 _level_dict = {
-    CRITICAL: "CRIT",
+    CRITICAL: "CRITICAL",
     ERROR: "ERROR",
-    WARNING: "WARN",
+    WARNING: "WARNING",
     INFO: "INFO",
     DEBUG: "DEBUG",
+    NOTSET: "NOTSET",
 }
 
-_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__ = {}
-
-    def __getattr__(self, key):
-        return self.__dict__[key]
+    def set(self, name, level, message):
+        self.name = name
+        self.levelno = level
+        self.levelname = _level_dict[level]
+        self.message = message
+        self.ct = time.time()
+        self.msecs = int((self.ct - int(self.ct)) * 1000)
+        self.asctime = None
 
 
 class Handler:
-    def __init__(self):
-        pass
+    def __init__(self, level=NOTSET):
+        self.level = level
+        self.formatter = None
 
-    def setFormatter(self, fmtr):
+    def close(self):
         pass
 
+    def setLevel(self, level):
+        self.level = level
+
+    def setFormatter(self, formatter):
+        self.formatter = formatter
 
-class Logger:
+    def format(self, record):
+        return self.formatter.format(record)
+
+
+class StreamHandler(Handler):
+    def __init__(self, stream=sys.stderr):
+        self.stream = stream
+        self.terminator = "\n"
+
+    def close(self):
+        if hasattr(self.stream, "flush"):
+            self.stream.flush()
 
-    level = NOTSET
-    handlers = []
-    record = LogRecord()
+    def emit(self, record):
+        if record.levelno >= 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 Formatter:
+    def __init__(self, fmt=_default_fmt, datefmt=_default_datefmt):
+        self.fmt = fmt
+        self.datefmt = datefmt
+
+    def usesTime(self):
+        return "asctime" in self.fmt
+
+    def formatTime(self, datefmt, record):
+        if hasattr(time, "strftime"):
+            return time.strftime(datefmt, time.localtime(record.ct))
+        return ""
+
+    def format(self, record):
+        if self.usesTime():
+            record.asctime = self.formatTime(self.datefmt, record)
+        return self.fmt % {
+            "name": record.name,
+            "message": record.message,
+            "msecs": record.msecs,
+            "asctime": record.asctime,
+            "levelname": record.levelname,
+        }
+
+
+class Logger:
     def __init__(self, name):
         self.name = name
-
-    def _level_str(self, level):
-        l = _level_dict.get(level)
-        if l is not None:
-            return l
-        return "LVL%s" % level
+        self.level = NOTSET
+        self.handlers = []
+        self.record = LogRecord()
 
     def setLevel(self, level):
         self.level = level
 
     def isEnabledFor(self, level):
-        return level >= (self.level or _level)
+        return level >= self.level
 
     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)
+        if self.isEnabledFor(level) and self.handlers:
+            if args and isinstance(args[0], dict):
+                args = args[0]
+            for h in self.handlers:
+                self.record.set(self.name, level, msg % args)
+                h.emit(self.record)
 
     def debug(self, msg, *args):
         self.log(DEBUG, msg, *args)
@@ -86,27 +135,17 @@ def error(self, msg, *args):
     def critical(self, msg, *args):
         self.log(CRITICAL, msg, *args)
 
-    def exc(self, e, msg, *args):
-        self.log(ERROR, msg, *args)
-        sys.print_exception(e, _stream)
-
     def exception(self, msg, *args):
-        self.exc(sys.exc_info()[1], msg, *args)
-
-    def addHandler(self, hndlr):
-        self.handlers.append(hndlr)
-
-
-_level = INFO
-_loggers = {}
+        self.log(ERROR, msg, *args)
+        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 addHandler(self, handler):
+        self.handlers.append(handler)
 
-def getLogger(name="root"):
-    if name in _loggers:
-        return _loggers[name]
-    l = Logger(name)
-    _loggers[name] = l
-    return l
+    def hasHandlers(self):
+        return len(self.handlers) > 0
 
 
 def info(msg, *args):
@@ -117,12 +156,71 @@ def debug(msg, *args):
     getLogger().debug(msg, *args)
 
 
-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 warning(msg, *args):
+    getLogger().warning(msg, *args)
+
+
+def error(msg, *args):
+    getLogger().error(msg, *args)
+
+
+def critical(msg, *args):
+    getLogger().critical(msg, *args)
+
+
+def exception(msg, *args):
+    getLogger().exception(msg, *args)
+
+
+def shutdown():
+    for k, logger in _loggers.items():
+        for h in logger.handlers:
+            h.close()
+        _loggers.pop(logger, None)
+
+
+if hasattr(sys, "atexit"):
+    sys.atexit(shutdown)
+
+
+def addLevelName(level, name):
+    _level_dict[level] = name
+
+
+def log(level, msg, *args):
+    getLogger().log(level, msg, *args)
+
+
+def getLogger(name="root"):
+    if name not in _loggers:
+        _loggers[name] = Logger(name)
+        if name == "root":
+            basicConfig()
+    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/manifest.py b/python-stdlib/logging/manifest.py
@@ -1,3 +1,3 @@
-metadata(version="0.3")
+metadata(version="0.4")
 
 module("logging.py")

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-metadata(version="0.3")`
	`1`	`+metadata(version="0.4")`
`2`	`2`
`3`	`3`	`module("logging.py")`