X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/2f31098c394a4d6d54d9f137acc617eb31504e1e..c8549bfdac1f9e8bd12eb453067394f499be5c9e:/lib/logger.py diff --git a/lib/logger.py b/lib/logger.py index 8573ead..37573ee 100644 --- a/lib/logger.py +++ b/lib/logger.py @@ -23,6 +23,7 @@ This module abstracts the logging handling away from the rest of the Ganeti code. It offers some utility functions for easy logging. + """ # pylint: disable-msg=W0603,C0103 @@ -33,145 +34,89 @@ import os, os.path from ganeti import constants -_program = '(unknown)' -_errlog = None -_inflog = None -_dbglog = None -_stdout = None -_stderr = None -_debug = False - -def _SetDestination(name, filename, stream=None): - """Configure the destination for a given logger +def _CreateFileHandler(name): + return logging.FileHandler(os.path.join(constants.LOG_DIR, name)) - This function configures the logging destination for a given loger. - Parameters: - - name: the logger name - - filename: if not empty, log messages will be written (also) to this file - - stream: if not none, log messages will be output (also) to this stream - Returns: - - the logger identified by the `name` argument - """ - ret = logging.getLogger(name) +def SetupLogging(program='ganeti', debug=False): + """Setup logging for ganeti - if filename: - fmtr = logging.Formatter('%(asctime)s %(message)s') + On failure, a check is made whether process is run by root or not, + and an appropriate error message is printed on stderr, then process + exits. - hdlr = logging.FileHandler(filename) - hdlr.setFormatter(fmtr) - ret.addHandler(hdlr) + Args: + debug: Whether to enable verbose logging + program: Program name - if stream: - if name in ('error', 'info', 'debug'): - fmtr = logging.Formatter('%(asctime)s %(message)s') - else: - fmtr = logging.Formatter('%(message)s') - hdlr = logging.StreamHandler(stream) - hdlr.setFormatter(fmtr) - ret.addHandler(hdlr) + """ + fmt = "%(asctime)s " + program + ": %(message)s" + formatter = logging.Formatter(fmt) - ret.setLevel(logging.INFO) + stderr_fmt = "%(asctime)s: %(message)s" + stderr_formatter = logging.Formatter(stderr_fmt) - return ret + info_file = _CreateFileHandler("info") + info_file.setLevel(logging.INFO) + info_file.setFormatter(formatter) + errors_file = _CreateFileHandler("errors") + errors_file.setLevel(logging.ERROR) + errors_file.setFormatter(formatter) -def _GenericSetup(program, errfile, inffile, dbgfile, - twisted_workaround=False): - """Configure logging based on arguments + debug_file = _CreateFileHandler("debug") + debug_file.setLevel(logging.DEBUG) + debug_file.setFormatter(formatter) - Arguments: - - name of program - - error log filename - - info log filename - - debug log filename - - twisted_workaround: if true, emit all messages to stderr - """ - global _program - global _errlog - global _inflog - global _dbglog - global _stdout - global _stderr - - _program = program - if twisted_workaround: - _errlog = _SetDestination('error', None, sys.stderr) - _inflog = _SetDestination('info', None, sys.stderr) - _dbglog = _SetDestination('debug', None, sys.stderr) + stderr_file = logging.StreamHandler() + stderr_file.setFormatter(stderr_formatter) + if debug: + stderr_file.setLevel(logging.NOTSET) else: - _errlog = _SetDestination('error', errfile) - _inflog = _SetDestination('info', inffile) - _dbglog = _SetDestination('debug', dbgfile) + stderr_file.setLevel(logging.ERROR) - _stdout = _SetDestination('user', None, sys.stdout) - _stderr = _SetDestination('stderr', None, sys.stderr) + root_logger = logging.getLogger("") + root_logger.setLevel(logging.NOTSET) + root_logger.addHandler(info_file) + root_logger.addHandler(errors_file) + root_logger.addHandler(debug_file) + root_logger.addHandler(stderr_file) -def SetupLogging(twisted_workaround=False, debug=False, program='ganeti'): - """Setup logging for ganeti +def SetupDaemon(logfile, debug=False, stderr_logging=False): + """Configures the logging module for daemons - On failure, a check is made whether process is run by root or not, - and an appropriate error message is printed on stderr, then process - exits. - - This function is just a wraper over `_GenericSetup()` using specific - arguments. - - Parameter: - twisted_workaround: passed to `_GenericSetup()` - - """ - try: - _GenericSetup(program, - os.path.join(constants.LOG_DIR, "errors"), - os.path.join(constants.LOG_DIR, "info"), - os.path.join(constants.LOG_DIR, "debug"), - twisted_workaround) - except IOError: - # The major reason to end up here is that we're being run as a - # non-root user. We might also get here if xen has not been - # installed properly. This is not the correct place to enforce - # being run by root; nevertheless, here makes sense because here - # is where we first notice it. - if os.getuid() != 0: - sys.stderr.write('This program must be run by the superuser.\n') - else: - sys.stderr.write('Unable to open log files. Incomplete system?\n') - - sys.exit(2) - - global _debug - _debug = debug - - -def _WriteEntry(log, txt): """ - Write a message to a given log. - Splits multi-line messages up into a series of log writes, to - keep consistent format on lines in file. - - Parameters: - - log: the destination log - - txt: the message + if debug: + fmt = "%(asctime)s: %(levelname)s %(module)s:%(lineno)s %(message)s" + else: + fmt = "%(asctime)s: %(levelname)s %(message)s" + formatter = logging.Formatter(fmt) - """ - if log is None: - sys.stderr.write("Logging system not initialized while processing" - " message:\n") - sys.stderr.write("%s\n" % txt) - return + logfile_handler = logging.FileHandler(logfile) + logfile_handler.setFormatter(formatter) - lines = txt.split('\n') + stderr_handler = logging.StreamHandler() + stderr_handler.setFormatter(formatter) + if debug: + logfile_handler.setLevel(logging.DEBUG) + stderr_handler.setLevel(logging.NOTSET) + else: + logfile_handler.setLevel(logging.INFO) + stderr_handler.setLevel(logging.CRITICAL) - spaces = ' ' * len(_program) + '| ' + root_logger = logging.getLogger("") + root_logger.setLevel(logging.NOTSET) + root_logger.addHandler(logfile_handler) + if stderr_logging: + root_logger.addHandler(stderr_handler) - lines = ([ _program + ': ' + lines[0] ] + - map(lambda a: spaces + a, lines[1:])) - for line in lines: - log.log(logging.INFO, line) +# Backwards compatibility +Error = logging.error +Info = logging.info +Debug = logging.debug def ToStdout(txt): @@ -194,45 +139,3 @@ def ToStderr(txt): """ sys.stderr.write(txt + '\n') sys.stderr.flush() - - -def Error(txt): - """Write a message to our error log - - Parameters: - - dbg: if true, the message will also be output to stderr - - txt: the log message - - """ - _WriteEntry(_errlog, txt) - sys.stderr.write(txt + '\n') - - -def Info(txt): - """Write a message to our general messages log - - If the global debug flag is true, the log message will also be - output to stderr. - - Parameters: - - txt: the log message - - """ - _WriteEntry(_inflog, txt) - if _debug: - _WriteEntry(_stderr, txt) - - -def Debug(txt): - """Write a message to the debug log - - If the global debug flag is true, the log message will also be - output to stderr. - - Parameters: - - txt: the log message - - """ - _WriteEntry(_dbglog, txt) - if _debug: - _WriteEntry(_stderr, txt)