def test_replace_logger_handlers(self):
logger = logging.getLogger('test_replace_logger_handlers')
handlers1 = reconplogger.logger_setup(
logger_name='plain_logger').handlers
handlers2 = reconplogger.logger_setup(
logger_name='json_logger').handlers
self.assertNotEqual(logger.handlers, handlers1)
self.assertNotEqual(logger.handlers, handlers2)
reconplogger.replace_logger_handlers('test_replace_logger_handlers',
'plain_logger')
self.assertEqual(logger.handlers, handlers1)
self.assertNotEqual(logger.handlers, handlers2)
reconplogger.replace_logger_handlers('test_replace_logger_handlers',
'json_logger')
self.assertEqual(logger.handlers, handlers2)
self.assertNotEqual(logger.handlers, handlers1)
self.assertRaises(
ValueError,
lambda: reconplogger.replace_logger_handlers(logger, False))
self.assertRaises(
ValueError,
lambda: reconplogger.replace_logger_handlers(False, False))
def test_log_level(self):
"""Test load config with the default config and plain logger changing the log level."""
logger = reconplogger.logger_setup(level='INFO')
self.assertEqual(logger.handlers[0].level, logging.INFO)
logger = reconplogger.logger_setup(level='ERROR')
self.assertEqual(logger.handlers[0].level, logging.ERROR)
os.environ['LOGGER_LEVEL'] = 'WARNING'
logger = reconplogger.logger_setup(level='INFO', env_prefix='LOGGER')
self.assertEqual(logger.handlers[0].level, logging.WARNING)
del os.environ['LOGGER_LEVEL']
def test_json_logger_setup(self):
"""Test logger_setup without specifying environment variable names but changing logger name."""
logger = reconplogger.logger_setup(logger_name='json_logger')
info_msg = 'info message'
with LogCapture(names='json_logger') as log:
logger.info(info_msg)
log.check(('json_logger', 'INFO', info_msg))
def test_plain_logger_setup(self):
"""Test logger_setup without specifying environment variable names."""
logger = reconplogger.logger_setup()
info_msg = 'info message'
with LogCapture(names='plain_logger') as log:
logger.info(info_msg)
log.check(('plain_logger', 'INFO', info_msg))
def test_init_messages(self):
logger = reconplogger.logger_setup(init_messages=True)
with self.assertLogs(logger='plain_logger', level='WARNING') as log:
reconplogger.test_logger(logger)
self.assertTrue(
any([
'WARNING' in v and 'reconplogger' in v for v in log.output
]))
def test_add_file_handler(self):
"""Test the use of add_file_handler."""
tmpdir = tempfile.mkdtemp(prefix='_reconplogger_test_')
error_msg = 'error message'
debug_msg = 'debug message'
log_file = os.path.join(tmpdir, 'file1.log')
logger = reconplogger.logger_setup(logger_name='plain_logger',
level='ERROR')
reconplogger.add_file_handler(logger,
file_path=log_file,
level='DEBUG')
self.assertEqual(logger.handlers[0].level, logging.ERROR)
self.assertEqual(logger.handlers[1].level, logging.DEBUG)
logger.error(error_msg)
logger.debug(debug_msg)
logger.handlers[1].close()
self.assertTrue(
any([error_msg in line for line in open(log_file).readlines()]))
self.assertTrue(
any([debug_msg in line for line in open(log_file).readlines()]))
log_file = os.path.join(tmpdir, 'file2.log')
logger = reconplogger.logger_setup(logger_name='plain_logger',
level='DEBUG',
reload=True)
reconplogger.add_file_handler(logger,
file_path=log_file,
level='ERROR')
self.assertEqual(logger.handlers[0].level, logging.DEBUG)
self.assertEqual(logger.handlers[1].level, logging.ERROR)
logger.error(error_msg)
logger.debug(debug_msg)
logger.handlers[1].close()
self.assertTrue(
any([error_msg in line for line in open(log_file).readlines()]))
self.assertFalse(
any([debug_msg in line for line in open(log_file).readlines()]))
self.assertRaises(
ValueError, lambda: reconplogger.add_file_handler(
logger, file_path=log_file, level='INVALID'))
shutil.rmtree(tmpdir)
def test_logger_property(self):
class MyClass(reconplogger.RLoggerProperty):
pass
myclass = MyClass()
myclass.rlogger = False
self.assertEqual(myclass.rlogger, reconplogger.null_logger)
myclass.rlogger = True
self.assertEqual(myclass.rlogger, reconplogger.logger_setup())
logger = logging.Logger('test_logger_property')
myclass.rlogger = logger
self.assertEqual(myclass.rlogger, logger)
def test_logger_setup_env_prefix(self):
"""Test logger setup with specifying environment prefix."""
env_prefix = 'RECONPLOGGER'
os.environ['RECONPLOGGER_NAME'] = 'example_logger'
os.environ['RECONPLOGGER_CFG'] = """{
"version": 1,
"formatters": {
"verbose": {
"format": "%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s"
}
},
"handlers": {
"console":{
"level": "DEBUG",
"class": "logging.StreamHandler",
"formatter": "verbose"
}
},
"loggers": {
"example_logger": {
"handlers": ["console"],
"level": "DEBUG"
}
}
}"""
logger = reconplogger.logger_setup(env_prefix=env_prefix)
info_msg = 'info message env logger'
with LogCapture(names='example_logger') as log:
logger.info(info_msg)
log.check(('example_logger', 'INFO', info_msg))
del os.environ['RECONPLOGGER_CFG']
del os.environ['RECONPLOGGER_NAME']
self.assertRaises(ValueError,
lambda: reconplogger.logger_setup(env_prefix=None))
self.assertRaises(ValueError,
lambda: reconplogger.logger_setup(env_prefix=''))
def logger(self, logger):
if logger is None or (isinstance(logger, bool) and not logger):
self._logger = null_logger
elif isinstance(logger, (bool, str, dict)) and logger:
levels = {'CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'}
level = logging.WARNING
if isinstance(
logger,
dict) and len(set(logger.keys()) - {'name', 'level'}) > 0:
value = {
k: v
for k, v in logger.items() if k not in {'name', 'level'}
}
raise ValueError(f'Unexpected logger value {value}.')
if isinstance(logger, dict) and 'level' in logger:
if logger['level'] not in levels:
raise ValueError(f'Logger level must be one of {levels}.')
level = getattr(logging, logger['level'])
if isinstance(logger, bool) or (isinstance(logger, dict)
and 'name' not in logger):
try:
import reconplogger
logger = reconplogger.logger_setup(level=level)
except (ImportError, ValueError):
pass
if not isinstance(logger, logging.Logger):
name = type(self).__name__
if isinstance(logger, str):
name = logger
elif isinstance(logger, dict) and 'name' in logger:
name = logger['name']
logger = logging.getLogger(name)
if len(logger.handlers) == 0:
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
))
logger.addHandler(handler)
logger.setLevel(level)
self._logger = logger
elif not isinstance(logger, logging.Logger):
raise ValueError(
'Expected logger to be an instance of logging.Logger or bool or str or dict or None.'
)
else:
self._logger = logger
def test_logger_setup_invalid_level(self):
self.assertRaises(ValueError,
lambda: reconplogger.logger_setup(level='INVALID'))
self.assertRaises(ValueError,
lambda: reconplogger.logger_setup(level=True))
def test_undefined_logger(self):
"""Test setting up a logger not already defined."""
self.assertRaises(
ValueError, lambda: reconplogger.logger_setup('undefined_logger'))
# Using try except to give to not get a error while building wheel without reconplogger
try:
import reconplogger
logger = reconplogger.logger_setup(level='INFO')
except ImportError:
print("*********reconplogger missing********")