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)
  • 相关阅读:
    [leetcode]Evaluate Division
    [leetcode]Read N Characters Given Read4 II
    [leetcode]Shortest Palindrome
    vim基础
    mac 默认设置python3最新版本环境变量
    mac 如何获取最高权限(关闭安全保护机制)
    mac 终端成功执行scrapy命令
    解决虚拟机VMware下ubuntu16.04LTS打不开软件中心Ubuntu Software
    解决虚拟机VMware下ubuntu16.04LTS异常连不上网
    SOA 服务架构之简介及理解
  • 原文地址:https://www.cnblogs.com/allenz/p/4755942.html
Copyright © 2011-2022 走看看