A class for global logging

Some time we need to record the logging information in multiple module, however if we use the follows logging configuration would lead the log cannot write to the same file for the file stream would be lock in multiple process.

 import logging
 #setting the the logging configuration
 logging.basicConfig(level=logging.DEBUG,
                 filename='/home/ronglian/project/ebscn/log/fastlogin.log',
                 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                 datefmt='%a, %d %b %Y %H:%M:%S',
                 filemode='w')

The follows logging class would avoid the multiple process problem.

 import logging
 #from cloghandler import ConcurrentRotatingFileHandler

 class NullHandler(logging.Handler):
     def emit(self,record):
         pass
 class GlobalLogging:
     log = None
     @staticmethod
     #def getInstance():
     def getLog():
         if GlobalLogging.log == None:
             GlobalLogging.log = GlobalLogging()
         return GlobalLogging.log

     def __init__(self):
         self.logger = None
         self.handler = None
         self.level = logging.DEBUG
         self.logger = logging.getLogger("GlobalLogging")
         self.formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
         h = NullHandler()
         self.logger.addHandler(h)
         self.logger.setLevel(self.level)

         #fixme
         self.setLoggingToFile("/home/ronglian/project/taskschedule/logs/taskschedule.log")

     def setLoggingToFile(self,file):
         #fh = ConcurrentRotatingFileHandler(file,"a", 512*1024, 5)
         fh = logging.FileHandler(file)
         fh.setFormatter(self.formatter)
         self.logger.addHandler(fh)

     def setLoggingToConsole(self) :
         ch = logging.StreamHandler()
         ch.setFormatter(self.formatter)
         self.logger.addHandler(ch)

     def setLoggingToHandler(self,handler):
         self.handler = handler

     def setLoggingLevel(self,level):
         self.level = level
         self.logger.setLevel(level)

     def debug(self,s):
         self.logger.debug(s)
         if not self.handler == None and self.level <= logging.DEBUG :
             self.handler('-DEBUG-:' + s)
     def info(self,s):

         self.logger.info(s)
         if not self.handler == None and self.level <= logging.INFO:
             self.handler('-INFO-:' + s)
     def warn(self,s):
         self.logger.warn(s)
         if not self.handler == None and self.level <= logging.WARNING:
             self.handler('-WARN-:' + s)
     def error(self,s):

         self.logger.error(s)
         if not self.handler == None and self.level <= logging.ERROR:
             print 'enter error'
             self.handler('-ERROR-:' + s)
     def critical(self,s):
         self.logger.critical(s)
         if not self.handler == None and self.level <= logging.CRITICAL:
             self.handler('-CRITICAL-:' + s)

Sometimes, we need to generate the logs depend on the different time frequency, so we can use the rotate handler, such as the follows:

 import logging
 import datetime
 from logging.handlers import TimedRotatingFileHandler
 from logging.handlers import RotatingFileHandler
 #from cloghandler import ConcurrentRotatingFileHandler
 '''
 CRITICAL 50,ERROR 40,WARNING 30,INFO 20,DEBUG 10,NOTSET 0
 '''
 import os
 import sys
 Basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))

 class NullHandler(logging.Handler):

     def emit(self, record):
         pass

 class GlobalLogging:
     log = None

     @staticmethod
     # def getInstance():
     def getLog():
         if GlobalLogging.log == None:
             GlobalLogging.log = GlobalLogging()
         return GlobalLogging.log

     def __init__(self):
         self.logger = None
         self.handler = None
         self.level = logging.INFO
         self.logger = logging.getLogger("GlobalLogging")
         self.formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")

         self.logger.setLevel(self.level)

         # fixme
         date = datetime.datetime.now().strftime("%Y-%m-%d-%M")
         fname = str(Basedir) + '/logs/taskschedule.log'
         # if not os.path.exists(fname+'.'+date):
         #     os.mknod(fname)
         #     os.system('chmod 777 ' + fname)
         h = TimedRotatingFileHandler(fname,
                                      when="midnight",
                                      interval=1,
                                      backupCount=100)
         # h= RotatingFileHandler(fname,
         #                         mode='a',
         #                         backupCount=20)
         h.setFormatter(self.formatter)
         self.logger.addHandler(h)
         # print fname

         #self.setLoggingToFile(fname)

     def setLoggingToFile(self, file):
         #fh = ConcurrentRotatingFileHandler(file,"a", 512*1024, 5)
         fh = logging.FileHandler(file)
         fh.setFormatter(self.formatter)
         self.logger.addHandler(fh)

     def setLoggingToConsole(self):
         ch = logging.StreamHandler()
         ch.setFormatter(self.formatter)
         self.logger.addHandler(ch)

     def setLoggingToHandler(self, handler):
         self.handler = handler

     def setLoggingLevel(self, level):
         self.level = level
         self.logger.setLevel(level)

     def debug(self, s):
         self.logger.debug(s)
         if not self.handler == None and self.level <= logging.DEBUG:
             self.handler('-DEBUG-:' + s)

     def info(self, s):

         self.logger.info(s)
         print self.handler,self.level
         if not self.handler == None and self.level <= logging.INFO:
             self.handler('-INFO-:' + s)

     def warn(self, s):
         self.logger.warn(s)
         if not self.handler == None and self.level <= logging.WARNING:
             self.handler('-WARN-:' + s)

     def error(self, s):

         self.logger.error(s)
         if not self.handler == None and self.level <= logging.ERROR:
             print 'enter error'
             self.handler('-ERROR-:' + s)

     def critical(self, s):
         self.logger.critical(s)
         if not self.handler == None and self.level <= logging.CRITICAL:
             self.handler('-CRITICAL-:' + s)