SystemLogger.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-
 
 
 
import sys
import traceback
import time
import threading
import logging
import logging.handlers
 
logger = None
 
 
 
class Logger:
  """
  """
 
  SILENT    = 0  # ()
  FATAL     = 41 # (FATAL)
  ERROR     = 40 # (FATAL, ERROR)
  WARN      = 30 # (FATAL, ERROR, WARN)
  INFO      = 20 # (FATAL, ERROR, WARN, INFO)
  DEBUG     = 10 # (FATAL, ERROR, WARN, INFO, DEBUG)
  TRACE     = 9  # (FATAL, ERROR, WARN, INFO, DEBUG, TRACE)
  VERBOSE   = 8  # (FATAL, ERROR, WARN, INFO, DEBUG, TRACE, VERBOSE)
  PARANOID  = 7  # (FATAL, ERROR, WARN, INFO, DEBUG, TRACE, VERBOSE, PARA)
 
 
  
  def strToLogLevel(self, lv):
    if lv == "SILENT":
      return Logger.SILENT
    elif lv == "FATAL":
      return Logger.FATAL
    elif lv == "ERROR":
      return Logger.ERROR
    elif lv == "WARN":
      return Logger.WARN
    elif lv == "INFO":
      return Logger.INFO
    elif lv == "DEBUG":
      return Logger.DEBUG
    elif lv == "TRACE":
      return Logger.TRACE
    elif lv == "VERBOSE":
      return Logger.VERBOSE
    elif lv == "PARANOID":
      return Logger.PARANOID
    else:
      return Logger.INFO
 
 
 
  
  def __init__(self, *args):
    self._mutex = threading.RLock()
    self._fhdlr = None
 
 
  def init(*args):
    global logger
 
    if logger is not None:
      return logger
 
 
    logger = Logger()
    mode = None
    fileName = None
 
    if len(args) == 0:
      return
    elif len(args) == 2:
      name = args[0]
      mode = args[1]
    elif len(args) == 3:
      name = args[0]
      mode = args[1]
      fileName = args[2]
 
 
    logging.PARANOID  = logging.DEBUG - 3
    logging.VERBOSE   = logging.DEBUG - 2
    logging.TRACE     = logging.DEBUG - 1
    logging.FATAL     = logging.ERROR + 1
 
    logging.addLevelName(logging.PARANOID,  "PARANOID")
    logging.addLevelName(logging.VERBOSE,   "VERBOSE")
    logging.addLevelName(logging.TRACE,     "TRACE")
    logging.addLevelName(logging.FATAL,     "FATAL")
 
    """
    logging.root.setLevel([logging.NOTSET,
                           logging.PARANOID,
                           logging.VERBOSE,
                           logging.TRACE,
                           logging.DEBUG,
                           logging.INFO,
                           logging.WARNING,
                           logging.ERROR,
                           logging.FATAL,
                           logging.CRITICAL])
    """
 
    
    formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
 
    if mode is None or mode == "FILE":
      if fileName:
        logger._fhdlr = logging.FileHandler(fileName)
      else:
        logger._fhdlr = logging.FileHandler('rtcsystem.log')
 
      mhdlr = logging.handlers.MemoryHandler(1024,logging.NOTSET, logger._fhdlr)
      logger._fhdlr.setFormatter(formatter)
      logging.getLogger("").addHandler(mhdlr)
      logging.getLogger("").setLevel(logging.NOTSET)
      
    elif mode == "STDOUT":
      ch = logging.StreamHandler()
      ch.setLevel(logging.NOTSET)
      ch.setFormatter(formatter)
      logging.getLogger("").addHandler(ch)
 
    return logger
 
  init = staticmethod(init)
 
 
 
  
  def __del__(self):
    #if self._fhdlr is not None:
    #  self._fhdlr.close()
    #  self._fhdler = None
    pass
 
  
  def printf(self, fmt):
    return fmt
 
 
  def addHandler(self, *args):
    mode = None
    fileName = None
 
    if len(args) == 0:
      return
    elif len(args) == 1:
      mode = args[0]
    elif len(args) == 2:
      mode = args[0]
      fileName = args[1]
    
    formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
 
    if mode is None or mode == "FILE":
      if fileName:
        self._fhdlr = logging.FileHandler(fileName)
      else:
        self._fhdlr = logging.FileHandler('rtcsystem.log')
 
      mhdlr = logging.handlers.MemoryHandler(1024,logging.NOTSET, self._fhdlr)
      self._fhdlr.setFormatter(formatter)
      logging.getLogger("").addHandler(mhdlr)
      
    elif mode.lower() == "stdout":
      ch = logging.StreamHandler()
      ch.setLevel(logging.NOTSET)
      ch.setFormatter(formatter)
      logging.getLogger("").addHandler(ch)
 
 
  
  def print_exception():
    if sys.version_info[0:3] >= (2, 4, 0):
      return traceback.format_exc()
    else:
      _exc_list = traceback.format_exception(*sys.exc_info())
      _exc_str = "".join(_exc_list)
      return _exc_str
    
  print_exception = staticmethod(print_exception)
 
 
 
 
class LogStream:
  """
  """
 
  
  def __init__(self, *args):
    self._LogLock = False
    self._log_enable = False
    self._loggerObj = None
    name = ""
 
    if len(args) == 0:
      return
    elif len(args) > 0:
      name = args[0]
 
    self._loggerObj = Logger.init(*args)
    self._log_enable = True
    self.logger = logging.getLogger(name)
 
 
  def __del__(self):
    return
 
  def shutdown(self):
    logging.shutdown()
    return
 
  def addHandler(self, *args):
    if self._loggerObj is not None:
      self._loggerObj.addHandler(*args)
 
 
  
  def setLogLevel(self, level):
    if level == "INFO":
      self.logger.setLevel(logging.INFO)
    elif level == "FATAL":
      self.logger.setLevel(logging.FATAL)
    elif level == "ERROR":
      self.logger.setLevel(logging.ERROR)
    elif level == "WARN":
      self.logger.setLevel(logging.WARNING)
    elif level == "DEBUG":
      self.logger.setLevel(logging.DEBUG)
    elif level == "SILENT":
      self.logger.setLevel(logging.NOTSET)
    elif level == "TRACE":
      self.logger.setLevel(logging.TRACE)
    elif level == "VERBOSE":
      self.logger.setLevel(logging.VERBOSE)
    elif level == "PARANOID":
      self.logger.setLevel(logging.PARANOID)
    else:
      self.logger.setLevel(logging.INFO)
 
 
  
  def setLogLock(self, lock):
    if lock == 1:
      self._LogLock = True
    elif lock == 0:
      self._LogLock = False
 
 
  
  def enableLogLock(self):
    self._LogLock = True
 
 
  
  def disableLogLock(self):
    self._LogLock = False
 
 
  
  def acquire(self):
    if self._LogLock:
      self.guard = OpenRTM_aist.ScopedLock(self._mutex)
 
 
  
  def release(self):
    if self._LogLock:
      del self.guard
 
 
  
  def RTC_LOG(self, LV, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_LOG : argument error")
          return
 
      self.logger.log(LV,messages)
 
      self.release()
 
 
  
  def RTC_FATAL(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_FATAL : argument error")
          return
 
      self.logger.log(logging.FATAL,messages)
 
      self.release()
 
 
  
  def RTC_ERROR(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_ERROR : argument error")
          return
 
      self.logger.error(messages)
 
      self.release()
 
 
  
  def RTC_WARN(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_WARN : argument error")
          return
 
      self.logger.warning(messages)
 
      self.release()
 
 
  
  def RTC_INFO(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_INFO : argument error")
          return
 
      self.logger.info(messages)
    
      self.release()
 
 
  
  def RTC_DEBUG(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_DEBUG : argument error")
          return
        
      self.logger.debug(messages)
      
      self.release()
 
 
  
  def RTC_TRACE(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
 
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_TRACE : argument error")
          return
 
      self.logger.log(logging.TRACE,messages)
    
      self.release()
 
 
  
  def RTC_VERBOSE(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_VERBOSE : argument error")
          return
 
      self.logger.log(logging.VERBOSE,messages)
    
      self.release()
 
 
 
  
  def RTC_PARANOID(self, msg, opt=None):
    if self._log_enable:
      self.acquire()
 
      if opt is None:
        messages = msg
      else:
        try:
          messages = msg%(opt)
        except:
          print("RTC_PARANOID : argument error")
          return
 
      self.logger.log(logging.PARANOID,messages)
    
      self.release()