Un peu de modularité.

cranslib/clogger.py

@@ -25,37 +25,67 @@ class CLogger(logging.Logger):
         """
         super(CLogger, self).__init__(loggerName)
 
+        self.c_formatter = None
+        self.c_file_handler = None
+        self.c_sh = None
+        self.c_level = level
+
         # When no service is specified, we don't put the reference in the format.
         if service is None:
-            fmt = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            self.c_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
         else:
-            fmt = "%%(asctime)s - %%(name)s - %(service)s - %%(levelname)s - %%(message)s" % {'service': service}
+            self.c_format = "%%(asctime)s - %%(name)s - %(service)s - %%(levelname)s - %%(message)s" % {'service': service}
 
-        # Computes the file handler name using service name.
+        self.create_formatter()
-        file_handler_path = os.path.join(LDIRPATH, "%s.log" % (loggerName,))
+        self.apply_file_handler(loggerName)
+        if debug:
+            self.apply_stream_handler()
 
-        # Creates FileHandler
+    def get_file_handler_path(self):
-        self.fh = logging.FileHandler(file_handler_path)
+        """Returns the file handler path"""
+        if self.__file_handler_path is None:
+            return ''
+        return self.__file_handler_path
 
-        # Catches appropriate level in logging.
+    def create_formatter(self):
-        self.fhlevel = getattr(logging, level.upper(), logging.INFO)
+        """Creates a formatter based on CFormatter class.
-        self.fh.setLevel(self.fhlevel)
+        It uses self.format as a source."""
+
+        if self.c_formatter is not None:
+            return
 
         # Creates formatter
-        self.formatter = CFormatter(fmt, "%Y-%m-%dT%H:%M:%S.%f%z")
+        self.c_formatter = CFormatter(self.c_format, "%Y-%m-%dT%H:%M:%S.%f%z")
+
+    def apply_stream_handler(self):
+        """Creates a streamhandler that prints to stdout.
+        Its level is debug"""
+        self.c_sh = logging.StreamHandler()
+        self.c_shlevel = logging.DEBUG
+        self.c_sh.setLevel(self.c_shlevel)
+        self.c_sh.setFormatter(self.c_formatter)
+        self.addHandler(self.c_sh)
+
+    def apply_file_handler(self, loggerName):
+        """Creates a file handler which level is given by self.c_level"""
+        if self.c_file_handler is not None:
+            return
+
+        # Computes the file handler name using service name.
+        self.__file_handler_path = os.path.join(LDIRPATH, "%s.log" % (loggerName,))
+
+        # Creates FileHandler
+        self.c_file_handler = logging.FileHandler(self.__file_handler_path)
+
+        # Catches appropriate level in logging.
+        self.c_file_handler_level = getattr(logging, self.c_level.upper(), logging.INFO)
+        self.c_file_handler.setLevel(self.c_file_handler_level)
 
         # Adds formatter to FileHandler
-        self.fh.setFormatter(self.formatter)
+        self.c_file_handler.setFormatter(self.c_formatter)
-
-        if debug:
-            self.sh = logging.StreamHandler()
-            self.shlevel = logging.DEBUG
-            self.sh.setLevel(self.shlevel)
-            self.sh.setFormatter(self.formatter)
-            self.addHandler(self.sh)
 
         # Adds FileHandler to Handlers
-        self.addHandler(self.fh)
+        self.addHandler(self.c_file_handler)
 
 class CFormatter(logging.Formatter):
     """