def logging_defaults():
def setupLogStream(logger, logFormat):
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter(fmt=logFormat, datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler(handler)
return logger
setupLogStream(logging.getLogger(), '%(asctime)s - %(name)s:%(levelname)s - %(message)s')
setupLogStream(logging.getLogger('user'), '%(message)s').propagate = False
setupLogStream(logging.getLogger('user.time'), '%(asctime)s - %(message)s').propagate = False
getFilteredLogger('user.once', LogOnce())
getFilteredLogger('user.time.once', LogOnce())
# Default exception logging to stderr and file in gc / tmp / user directory
logException = logging.getLogger("exception")
handlerException_stdout = logging.StreamHandler(sys.stderr)
handlerException_file = None
formatterException_stdout = ExceptionFormatter()
for fnLog in [os.path.join(os.environ['GC_PACKAGES_PATH'], '..', 'debug.log'), '/tmp/gc.debug.%d' % os.getuid(), '~/gc.debug']:
fnLog = os.path.abspath(os.path.normpath(os.path.expanduser(fnLog)))
try:
handlerException_file = GCLogHandler(fnLog, 'w')
formatterException_stdout = ExceptionFormatter(showCode = False, showVariables = False)
break
except Exception:
pass
handlerException_stdout.setFormatter(formatterException_stdout)
logException.addHandler(handlerException_stdout)
if handlerException_file:
handlerException_file.setFormatter(ExceptionFormatter())
logException.addHandler(handlerException_file)
logException.propagate = False
def logging_defaults():
setupLogStream(
'',
log_handler=StdoutStreamHandler(),
log_format='%(asctime)s - %(name)s:%(levelname)s - %(message)s')
setupLogStream('user',
log_handler=StdoutStreamHandler(),
log_format='%(message)s',
log_propagate=False)
setupLogStream('user.time',
log_handler=StdoutStreamHandler(),
log_format='%(asctime)s - %(message)s',
log_propagate=False)
setupLogStream('user.once', log_filter=LogOnce())
setupLogStream('user.time.once', log_filter=LogOnce())
# External libraries
logging.getLogger('requests').setLevel(logging.WARNING)
# Default exception logging to stderr and file in gc / tmp / user directory
excFormatterQuiet = ExceptionFormatter(showCodeContext=0,
showVariables=0,
showFileStack=0)
excFormatterVerbose = ExceptionFormatter(showCodeContext=2,
showVariables=1,
showFileStack=1)
logException = logging.getLogger("exception")
handlerException_stdout = StderrStreamHandler()
handlerException_stdout.setFormatter(excFormatterVerbose)
logException.addHandler(handlerException_stdout)
try:
handlerException_file = GCLogHandler(None, 'w')
handlerException_file.setFormatter(excFormatterVerbose)
logException.addHandler(handlerException_file)
handlerException_stdout.setFormatter(excFormatterQuiet)
except Exception:
pass
logException.propagate = False
# Adding log_process_result to Logging class
def log_process(self, proc, level=logging.WARNING, files=None):
status = proc.status(timeout=0)
record = self.makeRecord(
self.name, level, '<process>', 0,
'Process %s finished with exit code %s' %
(proc.get_call(), status), None, None)
record.proc = proc
record.call = proc.get_call()
record.proc_status = status
record.files = files or {}
self.handle(record)
logging.Logger.log_process = log_process
def logging_create_handlers(config, logger_name):
# Configure general setup of loggers - destinations, level and propagation
logger = logging.getLogger(logger_name.lower().replace('exception', 'abort').replace('root', ''))
# Setup handlers
handler_list = config.get_list(logger_name + ' handler', [], on_change=None)
if handler_list: # remove any standard handlers:
for handler in list(logger.handlers):
logger.removeHandler(handler)
else:
for handler in logger.handlers:
logging_configure_handler(config, logger_name, '', handler)
for handler_str in UniqueList(handler_list): # add only unique output handlers
if handler_str == 'stdout':
handler = StdoutStreamHandler()
elif handler_str == 'stderr':
handler = StderrStreamHandler() # pylint:disable=redefined-variable-type
elif handler_str == 'file':
handler = logging.FileHandler(config.get(logger_name + ' file', on_change=None), 'w')
elif handler_str == 'debug_file':
handler = GCLogHandler(config.get_fn_list(logger_name + ' debug file',
get_debug_file_candidates(), on_change=None, must_exist=False), 'w')
else:
raise Exception('Unknown handler %s for logger %s' % (handler_str, logger_name))
logger.addHandler(logging_configure_handler(config, logger_name, handler_str, handler))
logger.propagate = False
# Set propagate status
logger.propagate = config.get_bool(logger_name + ' propagate',
bool(logger.propagate), on_change=None)
# Set logging level
logger.setLevel(config.get_enum(logger_name + ' level',
LogLevelEnum, logger.level, on_change=None))
def logging_defaults():
formatter_verbose = GCFormatter(ex_context=2,
ex_vars=1,
ex_fstack=1,
ex_tree=2)
root_logger = clean_logger()
root_logger.manager.loggerDict.clear()
root_logger.setLevel(logging.DEFAULT)
root_handler = register_handler(root_logger, StdoutStreamHandler(),
formatter_verbose)
# Setup logger used for abort messages
abort_logger = clean_logger('abort')
abort_logger.propagate = False
abort_handler = register_handler(abort_logger, StderrStreamHandler(),
formatter_verbose)
# Output verbose exception information into dedicated GC log (in gc / tmp / user directory) if possible
try:
register_handler(abort_logger,
GCLogHandler(get_debug_file_candidates(), mode='w'),
formatter_verbose)
formatter_quiet = GCFormatter(ex_context=0,
ex_vars=0,
ex_fstack=0,
ex_tree=1)
abort_handler.setFormatter(formatter_quiet)
root_handler.setFormatter(formatter_quiet)
except Exception: # otherwise use verbose settings for default output
clear_current_exception()
# External libraries
logging.getLogger('requests').setLevel(logging.WARNING)
# Adding log_process_result to Logging class
def log_process(self, proc, level=logging.WARNING, files=None, msg=None):
msg = msg or 'Process %(call)s finished with exit code %(proc_status)s'
status = proc.status(timeout=0)
record = self.makeRecord(self.name, level, '<process>', 0, msg,
tuple(), None)
record.proc = proc
record.call = proc.get_call()
record.proc_status = status
record.files = files or {}
record.msg = record.msg % record.__dict__
self.handle(record)
logging.Logger.log_process = log_process
# Adding log with time prefix to Logging class
def log_time(self, level, msg, *args, **kwargs):
if self.isEnabledFor(level):
tmp = self.findCaller()
record = self.makeRecord(self.name, level, tmp[0], tmp[1], msg,
args, kwargs.pop('exc_info', None))
record.print_time = True
self.handle(record)
logging.Logger.log_time = log_time
def logging_defaults():
setupLogStream('', log_handler = StdoutStreamHandler(),
log_format = '%(asctime)s - %(name)s:%(levelname)s - %(message)s')
setupLogStream('user', log_handler = StdoutStreamHandler(),
log_format = '%(message)s', log_propagate = False)
setupLogStream('user.time', log_handler = StdoutStreamHandler(),
log_format = '%(asctime)s - %(message)s', log_propagate = False)
setupLogStream('user.once', log_filter = LogOnce())
setupLogStream('user.time.once', log_filter = LogOnce())
# External libraries
logging.getLogger('requests').setLevel(logging.WARNING)
# Default exception logging to stderr and file in gc / tmp / user directory
excFormatterQuiet = ExceptionFormatter(showCodeContext = 0, showVariables = 0, showFileStack = 0)
excFormatterVerbose = ExceptionFormatter(showCodeContext = 2, showVariables = 1, showFileStack = 1)
logException = logging.getLogger("exception")
handlerException_stdout = StderrStreamHandler()
handlerException_stdout.setFormatter(excFormatterVerbose)
logException.addHandler(handlerException_stdout)
handlerException_file = None
for fnLog in [os.path.join(os.environ['GC_PACKAGES_PATH'], '..', 'debug.log'), '/tmp/gc.debug.%d' % os.getuid(), '~/gc.debug']:
fnLog = os.path.abspath(os.path.normpath(os.path.expanduser(fnLog)))
try:
handlerException_file = GCLogHandler(fnLog, 'w')
handlerException_file.setFormatter(excFormatterVerbose)
logException.addHandler(handlerException_file)
handlerException_stdout.setFormatter(excFormatterQuiet)
break
except Exception:
pass
logException.propagate = False
# Adding log_process_result to Logging class
def log_process(self, proc, level = logging.WARNING, files = None):
status = proc.status(timeout = 0)
record = self.makeRecord(self.name, level, '<process>', 0,
'Process %s finished with exit code %s' % (proc.get_call(), status), None, None)
record.proc = proc
record.call = proc.get_call()
record.proc_status = status
record.files = files or {}
self.handle(record)
logging.Logger.log_process = log_process
def _register_debug_log(abort_logger, abort_handler, formatter_verbose,
root_handler):
_register_handler(abort_logger,
GCLogHandler(_get_debug_file_candidates(), mode='w'),
formatter_verbose)
formatter_quiet = GCFormatter(ex_context=0,
ex_vars=0,
ex_fstack=0,
ex_tree=1,
ex_threads=0)
abort_handler.setFormatter(formatter_quiet)
root_handler.setFormatter(formatter_quiet)
def logging_create_handlers(config, logger_name):
LogLevelEnum = makeEnum(
lmap(lambda level: logging.getLevelName(level).upper(), irange(51)))
logger = logging.getLogger(logger_name.lower())
# Set logging level
logger.setLevel(
config.getEnum(logger_name + ' level',
LogLevelEnum,
logger.level,
onChange=None))
# Set propagate status
logger.propagate = config.getBool(logger_name + ' propagate',
bool(logger.propagate),
onChange=None)
# Setup handlers
if logger_name + ' handler' in config.getOptions():
# remove any standard handlers:
for handler in list(logger.handlers):
logger.removeHandler(handler)
handler_list = config.getList(logger_name + ' handler', [],
onChange=None)
for handler_str in set(
handler_list): # add only unique output handlers
if handler_str == 'stdout':
handler = StdoutStreamHandler()
elif handler_str == 'stderr':
handler = StderrStreamHandler()
elif handler_str == 'file':
handler = logging.FileHandler(
config.get(logger_name + ' file', onChange=None), 'w')
elif handler_str == 'debug_file':
handler = GCLogHandler(
config.get(logger_name + ' debug file', onChange=None),
'w')
else:
raise Exception('Unknown handler %s for logger %s' %
(handler_str, logger_name))
logger.addHandler(
logging_configure_handler(config, logger_name, handler_str,
handler))