logging: Improve the logging module.

iabdalkader · iabdalkader · commit e8dbc08027c2 · 2022-11-14T21:59:06.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/__init__.py b/python-stdlib/logging/__init__.py
@@ -0,0 +1,16 @@
+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
+from .logging import 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,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,128 +1,212 @@
 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",
+    NOTSET: "NOTSET",
     DEBUG: "DEBUG",
+    INFO: "INFO",
+    WARNING: "WARNING",
+    ERROR: "ERROR",
+    CRITICAL: "CRITICAL",
 }
 
-_stream = sys.stderr
+loggers = {}
+default_fmt = "%(_level_dict)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.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 LogRecord:
+    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 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,
+        }
 
-    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 = LogRecord()
 
     def setLevel(self, level):
         self.level = level
 
+    def addHandler(self, handler):
+        self.handlers.append(handler)
+
+    def hasHandlers(self):
+        return len(self.handlers) > 0
+
     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)
+    def debug(self, message, *args):
+        self.log(DEBUG, message, *args)
 
-    def debug(self, msg, *args):
-        self.log(DEBUG, msg, *args)
+    def info(self, message, *args):
+        self.log(INFO, message, *args)
 
-    def info(self, msg, *args):
-        self.log(INFO, msg, *args)
+    def warning(self, message, *args):
+        self.log(WARNING, message, *args)
 
-    def warning(self, msg, *args):
-        self.log(WARNING, msg, *args)
+    def error(self, message, *args):
+        self.log(ERROR, message, *args)
 
-    def error(self, msg, *args):
-        self.log(ERROR, msg, *args)
+    def critical(self, message, *args):
+        self.log(CRITICAL, message, *args)
 
-    def critical(self, msg, *args):
-        self.log(CRITICAL, msg, *args)
+    def exception(self, message, *args):
+        self.log(ERROR, message, *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 exc(self, e, msg, *args):
-        self.log(ERROR, msg, *args)
-        sys.print_exception(e, _stream)
+    def log(self, level, message, *args):
+        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, message % args)
+                h.emit(self.record)
 
-    def exception(self, msg, *args):
-        self.exc(sys.exc_info()[1], msg, *args)
 
-    def addHandler(self, hndlr):
-        self.handlers.append(hndlr)
+def debug(message, *args):
+    getLogger().log(DEBUG, message, *args)
 
 
-_level = INFO
-_loggers = {}
+def info(message, *args):
+    getLogger().log(INFO, message, *args)
 
 
-def getLogger(name="root"):
-    if name in _loggers:
-        return _loggers[name]
-    l = Logger(name)
-    _loggers[name] = l
-    return l
+def warning(message, *args):
+    getLogger().log(WARNING, message, *args)
 
 
-def info(msg, *args):
-    getLogger().info(msg, *args)
+def error(message, *args):
+    getLogger().log(ERROR, message, *args)
 
 
-def debug(msg, *args):
-    getLogger().debug(msg, *args)
+def critical(message, *args):
+    getLogger().log(CRITICAL, message, *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 exception(message, *args):
+    getLogger().exception(message, *args)
+
+
+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/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")`