logging: Improve the logging module.

Add support for all format specifiers, support for `datefmt` using (optional) 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()`.

Author: iabdalkader

python-stdlib/logging/examples/basic_example.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.warning("test")

python-stdlib/logging/example_logging.py renamed to python-stdlib/logging/examples/example_logging_1.py

@@ -0,0 +1,47 @@
+import logging
+
+# 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:
+ 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__)
+
+
+logging.getLogger().addHandler(MyHandler())
+logging.info("Test message7")

python-stdlib/logging/examples/example_logging_2.py

@@ -0,0 +1,7 @@
+import logging, sys
+
+logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
+for handler in logging.getLogger().handlers:
+ handler.setFormatter(logging.Formatter("[%(levelname)s]:%(name)s:%(message)s"))
+logging.info("hello upy")
+logging.getLogger("child").info("hello 2")

python-stdlib/logging/examples/root_logger.py

@@ -1,4 +1,8 @@
 import sys
+import time
+
+if hasattr(time, "strftime"):
+ from time import strftime
 
 CRITICAL = 50
 ERROR = 40
@@ -8,46 +12,104 @@
 NOTSET = 0
 
 _level_dict = {
- CRITICAL: "CRIT",
+ CRITICAL: "CRITICAL",
  ERROR: "ERROR",
- WARNING: "WARN",
+ WARNING: "WARNING",
  INFO: "INFO",
  DEBUG: "DEBUG",
+ NOTSET: "NOTSET",
 }
 
+_loggers = {}
 _stream = sys.stderr
+_level = INFO
+_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
 
-class Logger:
+ def setFormatter(self, formatter):
+ self.formatter = formatter
 
- level = NOTSET
- handlers = []
- record = LogRecord()
+ def format(self, record):
+ return self.formatter.format(record)
 
- 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
+class StreamHandler(Handler):
+ def __init__(self, stream=None):
+ self.stream = _stream if stream is None else stream
+ self.terminator = "\n"
+
+ def close(self):
+ if hasattr(self.stream, "flush"):
+ self.stream.flush()
+
+ 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=None, datefmt=None):
+ self.fmt = _default_fmt if fmt is None else fmt
+ self.datefmt = _default_datefmt if datefmt is None else datefmt
+
+ def usesTime(self):
+ return "asctime" in self.fmt
+
+ def formatTime(self, datefmt, record):
+ if hasattr(time, "strftime"):
+ return strftime(datefmt, time.localtime(record.ct))
+ return None
+
+ 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, level=NOTSET):
+ self.name = name
+ self.level = level
+ self.handlers = []
+ self.record = LogRecord()
 
  def setLevel(self, level):
  self.level = level
@@ -57,19 +119,16 @@ def isEnabledFor(self, level):
 
  def log(self, level, msg, *args):
  if self.isEnabledFor(level):
- levelname = self._level_str(level)
  if args:
+ if isinstance(args[0], dict):
+ args = args[0]
  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)
+ self.record.set(self.name, level, msg)
+ handlers = self.handlers
+ if not handlers:
+ handlers = getLogger().handlers
+ for h in handlers:
+ h.emit(self.record)
 
  def debug(self, msg, *args):
  self.log(DEBUG, msg, *args)
@@ -86,43 +145,98 @@ def error(self, msg, *args):
  def critical(self, msg, *args):
  self.log(CRITICAL, msg, *args)
 
- def exc(self, e, msg, *args):
+ def exception(self, msg, *args):
  self.log(ERROR, msg, *args)
- sys.print_exception(e, _stream)
+ if hasattr(sys, "exc_info"):
+ sys.print_exception(sys.exc_info()[1], _stream)
 
- def exception(self, msg, *args):
- self.exc(sys.exc_info()[1], msg, *args)
+ def addHandler(self, handler):
+ self.handlers.append(handler)
 
- def addHandler(self, hndlr):
- self.handlers.append(hndlr)
+ def hasHandlers(self):
+ return len(self.handlers) > 0
 
 
-_level = INFO
-_loggers = {}
+def getLogger(name=None):
+ if name is None:
+ name = "root"
+ if name not in _loggers:
+ _loggers[name] = Logger(name)
+ if name == "root":
+ basicConfig()
+ return _loggers[name]
+
 
+def log(level, msg, *args):
+ getLogger().log(level, msg, *args)
 
-def getLogger(name="root"):
- if name in _loggers:
- return _loggers[name]
- l = Logger(name)
- _loggers[name] = l
- return l
+
+def debug(msg, *args):
+ getLogger().debug(msg, *args)
 
 
 def info(msg, *args):
  getLogger().info(msg, *args)
 
 
-def debug(msg, *args):
- getLogger().debug(msg, *args)
+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)
+
+
+def addLevelName(level, name):
+ _level_dict[level] = name
+
+
+def basicConfig(
+ filename=None,
+ filemode="a",
+ format=None,
+ datefmt=None,
+ level=WARNING,
+ stream=None,
+ encoding="UTF-8",
+ force=False,
+):
+ if "root" not in _loggers:
+ _loggers["root"] = Logger("root")
+
+ logger = _loggers["root"]
+
+ if force or not logger.handlers:
+ for h in logger.handlers:
+ h.close()
+ logger.handlers = []
+
+ 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)
 
 
-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")
+if hasattr(sys, "atexit"):
+ sys.atexit(shutdown)

python-stdlib/logging/logging.py

@@ -1,3 +1,3 @@
-metadata(version="0.3")
+metadata(version="0.4")
 
 module("logging.py")