update: logging.py

Author: JhosuaSparrow

code/logging.py

@@ -30,140 +30,189 @@
 import ql_fs
 import _thread
 
+__all__ = [
+    "CRITICAL", "FATAL", "ERROR", "WARNING", "WARN", "INFO", "DEBUG", "NOTSET",
+    "Logger", "getLogger", "setLogFile", "setSaveLog", "getSaveLog", "setLogLevel",
+    "getLogLevel", "setLogDebug", "getLogDebug",
+]
+
 _LOG_LOCK = _thread.allocate_lock()
-_LOG_LEVEL_CODE = {
-    "debug": 0,
-    "info": 1,
-    "warn": 2,
-    "error": 3,
-    "critical": 4,
+
+CRITICAL = 50
+FATAL = CRITICAL
+ERROR = 40
+WARNING = 30
+WARN = WARNING
+INFO = 20
+DEBUG = 10
+NOTSET = 0
+
+_levelToName = {
+    CRITICAL: 'CRITICAL',
+    ERROR: 'ERROR',
+    WARNING: 'WARNING',
+    INFO: 'INFO',
+    DEBUG: 'DEBUG',
+    NOTSET: 'NOTSET',
+}
+
+_nameToLevel = {
+    'CRITICAL': CRITICAL,
+    'FATAL': FATAL,
+    'ERROR': ERROR,
+    'WARNING': WARNING,
+    'WARN': WARN,
+    'INFO': INFO,
+    'DEBUG': DEBUG,
+    'NOTSET': NOTSET,
 }
 
-_log_dict = {}
-_log_path = "/usr/log/"
-_log_name = "pigeon_tracker.log"
-_log_file = _log_path + _log_name
-_log_save = False
-_log_size = 0x8000
-_log_back = 8
-_log_level = "debug"
-_log_debug = True
+_LOG_DICT = {}
+_LOG_PATH = "/usr/"
+_LOG_NAME = "project.log"
+_LOG_FILE = _LOG_PATH + _LOG_NAME
+_LOG_SAVE = False
+_LOG_SIZE = 0x8000
+_LOG_BACK = 8
+_LOG_LEVEL = DEBUG
+_LOG_DEBUG = True
 
 
 class Logger:
     def __init__(self, name):
         self.__name = name
+        self.__file = None
+
+    def __open_log(self):
+        global _LOG_FILE
+        if not self.__file:
+            self.__file = open(_LOG_FILE, "wb")
+
+    def __close_log(self):
+        if self.__file:
+            self.__file.close()
+            self.__file = None
+
+    def __write_log(self, msg):
+        if self.__file:
+            self.__file.write(msg)
+            self.__file.flush()
 
     def __save_log(self, msg):
-        global _log_path
-        global _log_file
         try:
+            msg += "\n" if not msg.endswith("\n") else ""
             log_size = 0
-            if not ql_fs.path_exists(_log_path):
-                uos.mkdir(_log_path[:-1])
-            if ql_fs.path_exists(_log_file):
-                log_size = ql_fs.path_getsize(_log_file)
-                if log_size + len(msg) >= _log_size:
-                    for i in range(_log_back, 0, -1):
-                        bak_file = _log_file + "." + str(i)
+            if not ql_fs.path_exists(_LOG_PATH):
+                uos.mkdir(_LOG_PATH[:-1])
+            if ql_fs.path_exists(_LOG_FILE):
+                log_size = ql_fs.path_getsize(_LOG_FILE)
+                if log_size + len(msg) >= _LOG_SIZE:
+                    self.__close_log()
+                    for i in range(_LOG_BACK, 0, -1):
+                        bak_file = _LOG_FILE + "." + str(i)
                         if ql_fs.path_exists(bak_file):
-                            if i == _log_back:
+                            if i == _LOG_BACK:
                                 uos.remove(bak_file)
                             else:
-                                uos.rename(bak_file, _log_file + "." + str(i + 1))
-                    uos.rename(_log_file, _log_file + ".1")
-            with open(_log_file, "a") as lf:
-                lf.write(msg)
+                                uos.rename(bak_file, _LOG_FILE + "." + str(i + 1))
+                    uos.rename(_LOG_FILE, _LOG_FILE + ".1")
+            self.__open_log()
+            self.__write_log(msg)
         except Exception as e:
             sys.print_exception(e)
 
     def __log(self, level, *message):
-        global _log_save
         with _LOG_LOCK:
-            if _log_debug is False:
-                if _log_level == "debug" and level == "debug":
-                    return
-                if _LOG_LEVEL_CODE.get(level) < _LOG_LEVEL_CODE.get(_log_level):
-                    return
+            if _LOG_DEBUG is False and ((_LOG_LEVEL == level == DEBUG) or level < _LOG_LEVEL):
+                return
             _time = "{}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(*utime.localtime())
-            msg = "[{}][{}][{}]".format(_time, self.__name, level)
+            msg = "[{}][{}][{}]".format(_time, self.__name, _levelToName[level])
             print(msg, *message)
-            if _log_save:
+            if _LOG_SAVE:
                 msg = msg + " " + " ".join(message) if message else msg
                 self.__save_log(msg)
 
     def critical(self, *message):
-        self.__log("critical", *message)
+        self.__log(CRITICAL, *message)
+
+    def fatal(self, *message):
+        self.critical(*message)
 
     def error(self, *message):
-        self.__log("error", *message)
+        self.__log(ERROR, *message)
+
+    def warning(self, *message):
+        self.__log(WARNING, *message)
 
     def warn(self, *message):
-        self.__log("warn", *message)
+        self.warning(*message)
 
     def info(self, *message):
-        self.__log("info", *message)
+        self.__log(INFO, *message)
 
     def debug(self, *message):
-        self.__log("debug", *message)
+        self.__log(DEBUG, *message)
 
 
 def getLogger(name):
-    global _log_dict
-    if not _log_dict.get(name):
-        _log_dict[name] = Logger(name)
-    return _log_dict[name]
+    global _LOG_DICT
+    if not _LOG_DICT.get(name):
+        _LOG_DICT[name] = Logger(name)
+    return _LOG_DICT[name]
 
 
 def setLogFile(path, name):
-    global _log_path, _log_name, _log_file
+    global _LOG_PATH, _LOG_NAME, _LOG_FILE
     if not path.endswith("/"):
         path += "/"
-    _log_path = path
-    _log_name = name
-    _log_file = _log_path + _log_name
+    _LOG_PATH = path
+    _LOG_NAME = name
+    _LOG_FILE = _LOG_PATH + _LOG_NAME
     return 0
 
 
 def setSaveLog(save, size=None, backups=None):
-    global _log_save, _log_size, _log_back
+    global _LOG_SAVE, _LOG_SIZE, _LOG_BACK
     if not isinstance(save, bool):
         return (1, "save is not bool.")
-    _log_save = save
-    if _log_save:
+    _LOG_SAVE = save
+    if _LOG_SAVE:
         if not isinstance(size, int):
             return (2, "size is not int.")
-        _log_size = size
+        _LOG_SIZE = size
         if not isinstance(backups, int):
             return (3, "backups is not int.")
-        _log_back = backups
+        _LOG_BACK = backups
     return (0, "success.")
 
 
 def getSaveLog():
-    return _log_save
+    return _LOG_SAVE
 
 
 def setLogLevel(level):
-    global _log_level
-    level = level.lower()
-    if level not in _LOG_LEVEL_CODE.keys():
-        return False
-    _log_level = level
-    return True
+    global _LOG_LEVEL
+    level = level.upper()
+    if _nameToLevel.get(level) is not None:
+        _LOG_LEVEL = _nameToLevel.get(level)
+        return True
+    if _levelToName.get(level) is not None:
+        _LOG_LEVEL = level
+        return True
+    return False
 
 
 def getLogLevel():
-    return _log_level
+    return _levelToName.get(_LOG_LEVEL)
 
 
 def setLogDebug(debug):
-    global _log_debug
+    global _LOG_DEBUG
     if isinstance(debug, bool):
-        _log_debug = debug
+        _LOG_DEBUG = debug
         return True
     return False
 
 
 def getLogDebug():
-    return _log_debug
+    return _LOG_DEBUG