Fixed logging issues

examples/example3/ChildProcess3.py

@@ -11,8 +11,6 @@ class ChildProcess3(cmp.CProcess):
         super().__init__(state_queue, cmd_queue, kill_flag, *args, **kwargs)
         self.logger = None
 
-    def postrun_init(self):
-        self.logger = self.create_new_logger(f"{self.__class__.__name__}-({os.getpid()})")
 
     @cmp.CProcess.register_signal()
     def test_call(self, a):

examples/example3/example3.py

@@ -24,8 +24,8 @@ class Form(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
 
-        child_con = ChildProcessControl3(self, internal_log=True, internal_log_level=logging.INFO, log_file="log.log")
-        child_con.set_internal_log_level(logging.WARNING)
+        child_con = ChildProcessControl3(self, internal_log_level=logging.WARNING, log_file="log.log")
+        child_con.set_internal_log_level(logging.INFO)
         child_con.mp_finished.connect(self.updateUI)
 
 

src/cmp/CBase.py

 import logging
+import time
 
 from rich.logging import RichHandler
 
@@ -16,32 +17,45 @@ class CBase:
     def create_new_logger(self, logger_name: str,
                           logger_handler: logging.Handler = None,
                           logger_format: str = "%(asctime)s - %(name)s %(message)s",
-                          to_file=None) -> (logging.Logger, logging.Handler):
+                          to_file=None,
+                          enabled=True, level=logging.DEBUG) -> logging.Logger:
         """
         Creates a new logger with the given name and handler. If no handler is given, a RichHandler will be used.
 
+        :param enabled:
         :param logger_name:
         :param logger_handler:
         :param logger_format:
         :param to_file:
         :return:
         """
+        formatter = logging.Formatter(logger_format)
         if logger_handler is None:
+            time.sleep(1)
             logger_handler = RichHandler(rich_tracebacks=True)
-        logger_handler.setLevel(logging.DEBUG)
+
+        logger_handler.setLevel(level)
+        logger_handler.setFormatter(formatter)
+
         _internal_logger = logging.getLogger(logger_name)
         _internal_logger.handlers = [logger_handler]
         _internal_logger.setLevel(logging.DEBUG)
-        formatter = logging.Formatter(logger_format)
-        logger_handler.setFormatter(formatter)
+
 
         if to_file is not None:
             _file_handler = logging.FileHandler(to_file)
             _file_handler.setLevel(logging.DEBUG)
-            _file_handler_formated = logging.Formatter(f"%(levelname)s > {logger_format})")
-            _file_handler.setFormatter(_file_handler_formated)
+            _file_handler_formatter = logging.Formatter(f"%(levelname)s {logger_format})")
+            _file_handler.setFormatter(_file_handler_formatter)
             _internal_logger.addHandler(_file_handler)
 
+        if enabled:
+            _internal_logger.disabled = False
+            _internal_logger.info(f"Logger {logger_name} created with handlers {_internal_logger.handlers} and has been enabled (Level {level}).")
+        else:
+            _internal_logger.info(f"Logger {logger_name} created and has been disabled.")
+            _internal_logger.disabled = True
+
         return _internal_logger
 
 
@@ -93,7 +107,7 @@ class CBase:
             elif level == logging.CRITICAL:
                 self._internal_logger.info(f"Internal log level of {self.__class__.__name__} has been set to CRITICAL.")
             else:
-                self._internal_logger.info(f"Internal log level of {self.__class__.__name__} has been set to {level}.")
+                self._internal_logger.info(f"Internal log level of {self.__class__.__name__} has been set to level {level}.")
             self._internal_logger.handlers[0].setLevel(level)
         else:
             raise Exception("Can't set internal log level. Internal logger not initialized")

src/cmp/CProcess.py

@@ -58,14 +58,15 @@ class CProcess(CBase, Process):
         self._internal_logger = self.create_new_logger(
             f"(cmp) {self.name}",
             logger_handler=logging.handlers.QueueHandler(self.state_queue),
-            logger_format="%(message)s")
-        self.internal_log_enabled = self._internal_log_enabled_
-        self.internal_log_level = self._internal_log_level_
-
+            logger_format="%(message)s",
+            to_file=self.log_file,
+            enabled=self._internal_log_enabled_, level=self._internal_log_level_)
 
         self.logger = self.create_new_logger(
             f"{os.getpid()}({self.__class__.__name__})",
-            logger_handler=logging.handlers.QueueHandler(self.state_queue))
+            logger_handler=logging.handlers.QueueHandler(self.state_queue),
+            logger_format="%(message)s",
+            to_file=self.log_file)
 
 
         self._internal_logger.debug(f"Child process {self.__class__.__name__} started.")

src/cmp/CProcessControl.py

@@ -24,21 +24,15 @@ class CProcessControl(CBase, QObject):
 
     def __init__(self, parent: QObject = None,
                  signal_class: QObject = None,
-                 internal_log: bool = False,
-                 internal_log_level: int = logging.DEBUG,
-                 log_file: str = None):
+                 internal_log: bool = True, internal_log_level: int = logging.WARNING, log_file: str = None):
         QObject.__init__(self, parent)
         CBase.__init__(self)
-        self.log_file = log_file
-        self._internal_logger = self.create_new_logger(
-            f"(cmp) {self.name}",
-            to_file=self.log_file)
-        self.logger = self.create_new_logger(
-            f"{self.__class__.__name__}({os.getpid()})",
-            to_file=self.log_file)
-        self.internal_log_enabled = internal_log
-        self.internal_log_level = internal_log_level
 
+        self.log_file = log_file
+        self._internal_logger = self.create_new_logger(f"(cmp) {self.name}",
+                                                       to_file=self.log_file, enabled=internal_log, level=internal_log_level)
+        self.logger = self.create_new_logger(f"{self.__class__.__name__}({os.getpid()})",
+                                             to_file=self.log_file, enabled=internal_log, level=internal_log_level)
 
         if isinstance(parent, QWidget) or isinstance(parent, QWindow):
             parent.destroyed.connect(lambda: self.safe_exit(reason="Parent destroyed."))