zoukankan      html  css  js  c++  java
  • 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.

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

    The follows logging class would avoid the multiple process problem.

     1 import logging
     2 #from cloghandler import ConcurrentRotatingFileHandler
     3 
     4 class NullHandler(logging.Handler):
     5     def emit(self,record):
     6         pass
     7 class GlobalLogging:
     8     log = None
     9     @staticmethod
    10     #def getInstance():
    11     def getLog():
    12         if GlobalLogging.log == None: 
    13             GlobalLogging.log = GlobalLogging()
    14         return GlobalLogging.log
    15         
    16     def __init__(self):
    17         self.logger = None
    18         self.handler = None
    19         self.level = logging.DEBUG
    20         self.logger = logging.getLogger("GlobalLogging")
    21         self.formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
    22         h = NullHandler()
    23         self.logger.addHandler(h)
    24         self.logger.setLevel(self.level)
    25         
    26         #fixme
    27         self.setLoggingToFile("/home/ronglian/project/taskschedule/logs/taskschedule.log")
    28         
    29     def setLoggingToFile(self,file): 
    30         #fh = ConcurrentRotatingFileHandler(file,"a", 512*1024, 5)    
    31         fh = logging.FileHandler(file)
    32         fh.setFormatter(self.formatter)
    33         self.logger.addHandler(fh)
    34               
    35     def setLoggingToConsole(self) : 
    36         ch = logging.StreamHandler()
    37         ch.setFormatter(self.formatter)
    38         self.logger.addHandler(ch)
    39               
    40     def setLoggingToHandler(self,handler): 
    41         self.handler = handler
    42               
    43     def setLoggingLevel(self,level):
    44         self.level = level
    45         self.logger.setLevel(level)
    46             
    47     def debug(self,s):
    48         self.logger.debug(s)
    49         if not self.handler == None and self.level <= logging.DEBUG :
    50             self.handler('-DEBUG-:' + s)
    51     def info(self,s):
    52 
    53         self.logger.info(s)
    54         if not self.handler == None and self.level <= logging.INFO:
    55             self.handler('-INFO-:' + s)
    56     def warn(self,s):
    57         self.logger.warn(s)
    58         if not self.handler == None and self.level <= logging.WARNING:
    59             self.handler('-WARN-:' + s)
    60     def error(self,s):
    61 
    62         self.logger.error(s)
    63         if not self.handler == None and self.level <= logging.ERROR:
    64             print 'enter error'
    65             self.handler('-ERROR-:' + s)
    66     def critical(self,s):
    67         self.logger.critical(s)
    68         if not self.handler == None and self.level <= logging.CRITICAL:
    69             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:

      1 import logging
      2 import datetime
      3 from logging.handlers import TimedRotatingFileHandler
      4 from logging.handlers import RotatingFileHandler
      5 #from cloghandler import ConcurrentRotatingFileHandler
      6 '''
      7 CRITICAL 50,ERROR 40,WARNING 30,INFO 20,DEBUG 10,NOTSET 0
      8 '''
      9 import os
     10 import sys
     11 Basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
     12 
     13 
     14 class NullHandler(logging.Handler):
     15 
     16     def emit(self, record):
     17         pass
     18 
     19 
     20 class GlobalLogging:
     21     log = None
     22 
     23     @staticmethod
     24     # def getInstance():
     25     def getLog():
     26         if GlobalLogging.log == None:
     27             GlobalLogging.log = GlobalLogging()
     28         return GlobalLogging.log
     29 
     30     def __init__(self):
     31         self.logger = None
     32         self.handler = None
     33         self.level = logging.INFO
     34         self.logger = logging.getLogger("GlobalLogging")
     35         self.formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
     36 
     37         self.logger.setLevel(self.level)
     38 
     39         # fixme
     40         date = datetime.datetime.now().strftime("%Y-%m-%d-%M")
     41         fname = str(Basedir) + '/logs/taskschedule.log'
     42         # if not os.path.exists(fname+'.'+date):
     43         #     os.mknod(fname)
     44         #     os.system('chmod 777 ' + fname)        
     45         h = TimedRotatingFileHandler(fname,
     46                                      when="midnight",
     47                                      interval=1,
     48                                      backupCount=100)
     49         # h= RotatingFileHandler(fname,
     50         #                         mode='a',
     51         #                         backupCount=20)
     52         h.setFormatter(self.formatter)
     53         self.logger.addHandler(h)
     54         # print fname
     55 
     56         #self.setLoggingToFile(fname)
     57 
     58     def setLoggingToFile(self, file):
     59         #fh = ConcurrentRotatingFileHandler(file,"a", 512*1024, 5)
     60         fh = logging.FileHandler(file)
     61         fh.setFormatter(self.formatter)
     62         self.logger.addHandler(fh)
     63 
     64     def setLoggingToConsole(self):
     65         ch = logging.StreamHandler()
     66         ch.setFormatter(self.formatter)
     67         self.logger.addHandler(ch)
     68 
     69     def setLoggingToHandler(self, handler):
     70         self.handler = handler
     71 
     72     def setLoggingLevel(self, level):
     73         self.level = level
     74         self.logger.setLevel(level)
     75 
     76     def debug(self, s):
     77         self.logger.debug(s)
     78         if not self.handler == None and self.level <= logging.DEBUG:
     79             self.handler('-DEBUG-:' + s)
     80 
     81     def info(self, s):
     82 
     83         self.logger.info(s)
     84         print self.handler,self.level
     85         if not self.handler == None and self.level <= logging.INFO:
     86             self.handler('-INFO-:' + s)
     87 
     88     def warn(self, s):
     89         self.logger.warn(s)
     90         if not self.handler == None and self.level <= logging.WARNING:
     91             self.handler('-WARN-:' + s)
     92 
     93     def error(self, s):
     94 
     95         self.logger.error(s)
     96         if not self.handler == None and self.level <= logging.ERROR:
     97             print 'enter error'
     98             self.handler('-ERROR-:' + s)
     99 
    100     def critical(self, s):
    101         self.logger.critical(s)
    102         if not self.handler == None and self.level <= logging.CRITICAL:
    103             self.handler('-CRITICAL-:' + s)
  • 相关阅读:
    .Spring事务管理
    什么叫事务;什么叫业务逻辑;什么叫持久化
    Hibernate基本应用01
    Maven整理
    责任链模式和观察者模式
    SpringBoot基础入门
    反射总结
    多线程
    IO流
    File类总结
  • 原文地址:https://www.cnblogs.com/allenz/p/4755942.html
Copyright © 2011-2022 走看看