--- /dev/null
+import sys, logging, traceback, inspect, os.path
+from logging import handlers
+from manifold.util.singleton import Singleton
+from manifold.util.options import Options
+from manifold.util.misc import caller_name, make_list
+from manifold.util import colors
+
+# TODO Log should take separately message strings and arguments to be able to
+# remember which messages are seen several times, and also to allow for
+# translation
+# TODO How to log to stdout without putting None in self.log
+
+class Log(object):
+ __metaclass__ = Singleton
+
+ DEFAULTS = {
+ # Logging
+ "rsyslog_enable" : False,
+ "rsyslog_host" : None, #"log.top-hat.info",
+ "rsyslog_port" : None, #28514,
+ "log_file" : "/var/log/manifold.log",
+ "log_level" : "DEBUG",
+ "debug" : "default",
+ "log_duplicates" : False
+ }
+
+ # COLORS
+ color_ansi = {
+ 'DEBUG' : colors.MYGREEN,
+ 'INFO' : colors.MYBLUE,
+ 'WARNING': colors.MYWARNING,
+ 'ERROR' : colors.MYRED,
+ 'HEADER' : colors.MYHEADER,
+ 'END' : colors.MYEND,
+ 'RECORD' : colors.MYBLUE,
+ 'TMP' : colors.MYRED,
+ }
+
+ @classmethod
+ def color(cls, color):
+ return cls.color_ansi[color] if color else ''
+
+ # To remove duplicate messages
+ seen = {}
+
+ def __init__(self, name='(default)'):
+ self.log = None # logging.getLogger(name)
+ self.files_to_keep = []
+ self.init_log()
+ self.color = True
+
+
+ @classmethod
+ def init_options(self):
+ opt = Options()
+
+ opt.add_option(
+ "--rsyslog-enable", action = "store_false", dest = "rsyslog_enable",
+ help = "Specify if log have to be written to a rsyslog server.",
+ default = self.DEFAULTS["rsyslog_enable"]
+ )
+ opt.add_option(
+ "--rsyslog-host", dest = "rsyslog_host",
+ help = "Rsyslog hostname.",
+ default = self.DEFAULTS["rsyslog_host"]
+ )
+ opt.add_option(
+ "--rsyslog-port", type = "int", dest = "rsyslog_port",
+ help = "Rsyslog port.",
+ default = self.DEFAULTS["rsyslog_port"]
+ )
+ opt.add_option(
+ "-o", "--log-file", dest = "log_file",
+ help = "Log filename.",
+ default = self.DEFAULTS["log_file"]
+ )
+ opt.add_option(
+ "-L", "--log-level", dest = "log_level",
+ choices = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+ help = "Log level",
+ default = self.DEFAULTS["log_level"]
+ )
+ opt.add_option(
+ "-d", "--debug", dest = "debug",
+ help = "Debug paths (a list of coma-separated python path: path.to.module.function).",
+ default = self.DEFAULTS["debug"]
+ )
+ opt.add_option(
+ "", "--log_duplicates", action = "store_true", dest = "log_duplicates",
+ help = "Remove duplicate messages in logs",
+ default = self.DEFAULTS["log_duplicates"]
+ )
+
+ def init_log(self, options=object()):
+ # Initialize self.log (require self.files_to_keep)
+ if self.log: # for debugging by using stdout, log may be equal to None
+ if Options().rsyslog_host:
+ shandler = self.make_handler_rsyslog(
+ Options().rsyslog_host,
+ Options().rsyslog_port,
+ Options().log_level
+ )
+ elif Options().log_file:
+ shandler = self.make_handler_locallog(
+ Options().log_file,
+ Options().log_level
+ )
+
+ #------------------------------------------------------------------------
+ # Log
+ #------------------------------------------------------------------------
+
+ def make_handler_rsyslog(self, rsyslog_host, rsyslog_port, log_level):
+ """
+ \brief (Internal usage) Prepare logging via rsyslog
+ \param rsyslog_host The hostname of the rsyslog server
+ \param rsyslog_port The port of the rsyslog server
+ \param log_level Log level
+ """
+ # Prepare the handler
+ shandler = handlers.SysLogHandler(
+ (rsyslog_host, rsyslog_port),
+ facility = handlers.SysLogHandler.LOG_DAEMON
+ )
+
+ # The log file must remain open while daemonizing
+ self.prepare_handler(shandler, log_level)
+ return shandler
+
+ def make_handler_locallog(self, log_filename, log_level):
+ """
+ \brief (Internal usage) Prepare local logging
+ \param log_filename The file in which we write the logs
+ \param log_level Log level
+ """
+ # Create directory in which we store the log file
+ log_dir = os.path.dirname(log_filename)
+ if log_dir and not os.path.exists(log_dir):
+ try:
+ os.makedirs(log_dir)
+ except OSError, why:
+ # XXX here we don't log since log is not initialized yet
+ print "OS error: %s" % why
+
+ # Prepare the handler
+ shandler = logging.handlers.RotatingFileHandler(
+ log_filename,
+ backupCount = 0
+ )
+
+ # The log file must remain open while daemonizing
+ self.files_to_keep.append(shandler.stream)
+ self.prepare_handler(shandler, log_level)
+ return shandler
+
+ def prepare_handler(self, shandler, log_level):
+ """
+ \brief (Internal usage)
+ \param shandler Handler used to log information
+ \param log_level Log level
+ """
+ shandler.setLevel(log_level)
+ formatter = logging.Formatter("%(asctime)s: %(name)s: %(levelname)s %(message)s")
+ shandler.setFormatter(formatter)
+ self.log.addHandler(shandler)
+ self.log.setLevel(getattr(logging, log_level, logging.INFO))
+
+ def get_logger(self):
+ return self.log
+
+ @classmethod
+ def print_msg(cls, msg, level=None, caller=None):
+ sys.stdout.write(cls.color(level))
+ if level:
+ print "%s" % level,
+ if caller:
+ print "[%30s]" % caller,
+ print msg,
+ print cls.color('END')
+
+ #---------------------------------------------------------------------
+ # Log: logger abstraction
+ #---------------------------------------------------------------------
+
+ @classmethod
+ def build_message_string(cls, msg, ctx):
+ if ctx:
+ msg = [m % ctx for m in msg]
+ if isinstance(msg, (tuple, list)):
+ msg = map(lambda s : "%s" % s, msg)
+ msg = " ".join(msg)
+ else:
+ msg = "%s" % msg
+ return msg
+
+ @classmethod
+ def log_message(cls, level, msg, ctx):
+ """
+ \brief Logs an message
+ \param level (string) Log level
+ \param msg (string / list of strings) Message string, or List of message strings
+ \param ctx (dict) Context for the message strings
+ """
+ caller = None
+
+ if not Options().log_duplicates:
+ try:
+ count = cls.seen.get(msg, 0)
+ cls.seen[msg] = count + 1
+ except TypeError, e:
+ # Unhashable types in msg
+ count = 0
+
+ if count == 1:
+ msg += (" -- REPEATED -- Future similar messages will be silently ignored. Please use the --log_duplicates option to allow for duplicates",)
+ elif count > 1:
+ return
+
+ if level == 'DEBUG':
+ caller = caller_name(skip=3)
+ # Eventually remove "" added to the configuration file
+ try:
+ paths = tuple(s.strip(' \t\n\r') for s in Options().debug.split(','))
+ except:
+ paths = None
+ if not paths or not caller.startswith(paths):
+ return
+
+ logger = Log().get_logger()
+ msg_str = cls.build_message_string(msg, ctx)
+
+ if logger:
+ logger_fct = getattr(logger, level.lower())
+ logger_fct("%s(): %s" % (inspect.stack()[2][3], msg_str))
+ else:
+ cls.print_msg(msg_str, level, caller)
+
+
+ @classmethod
+ def critical(cls, *msg, **ctx):
+ if not Options().log_level in ['CRITICAL']:
+ return
+ cls.log_message('CRITICAL', msg, ctx)
+ sys.exit(0)
+
+ @classmethod
+ def error(cls, *msg, **ctx):
+ if not Options().log_level in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']:
+ return
+ cls.log_message('ERROR', msg, ctx)
+ logger = Log().get_logger()
+ if not Log().get_logger():
+ traceback.print_exc()
+ sys.exit(0)
+
+ @classmethod
+ def warning(cls, *msg, **ctx):
+ if not Options().log_level in ['DEBUG', 'INFO', 'WARNING']:
+ return
+ cls.log_message('WARNING', msg, ctx)
+
+ @classmethod
+ def info(cls, *msg, **ctx):
+ if not Options().log_level in ['DEBUG', 'INFO']:
+ return
+ cls.log_message('INFO', msg, ctx)
+
+ @classmethod
+ def debug(cls, *msg, **ctx):
+ if not Options().log_level in ['DEBUG']:
+ return
+ cls.log_message('DEBUG', msg, ctx)
+
+ @classmethod
+ def tmp(cls, *msg):
+ cls.print_msg(' '.join(map(lambda x: "%r"%x, make_list(msg))), 'TMP', caller_name())
+
+ @classmethod
+ def record(cls, *msg):
+ #cls.print_msg(' '.join(map(lambda x: "%r"%x, make_list(msg))), 'RECORD', caller_name())
+ pass
+
+ @classmethod
+ def deprecated(cls, new):
+ #cls.print_msg("Function %s is deprecated, please use %s" % (caller_name(skip=3), new))
+ pass
+
+Log.init_options()
git://git.onelab.eu / unfold.git / blobdiff