def test_add_stream_handler(self):
lcd = LCDictBasic()
lcd.set_root_level('DEBUG'
).add_stream_handler('h_stream', 'ext://sys.stderr'
).attach_root_handlers('h_stream')
# Swap stderr BEFORE lcd.config:
_stderr = sys.stderr
sio_err = io.StringIO()
sys.stderr = sio_err
lcd.config()
# log stuff
logger = logging.getLogger()
if PY2:
logger.debug(u"Hi 0")
logger.debug(u"Hi 1")
else:
logger.debug("Hi 0")
logger.debug("Hi 1")
# unswap stderr, needlessly
sys.stderr = _stderr
# print("sio_err.getvalue(): '%s'" % sio_err.getvalue()) # TODO DEBUG COMMENT OUT
self.assertEqual(sio_err.getvalue(), "Hi 0\nHi 1\n")
def test_filter_on_root(self):
class CountGEWarning(logging.Filter):
def filter(self_, record):
"""Filter that counts messages with loglevel >= WARNING.
:param self_: "self" for CountGEWarning object (unused)
:param record: logging.LogRecord
:return: bool -- True ==> let record through, False ==> squelch
"""
if record.levelno >= logging.WARNING:
self.ge_warning_count += 1
return True
lcd = LCDictBasic(root_level='DEBUG')
lcd.add_formatter(
'msg',
format='%(message)s'
)
my_stream = io.StringIO()
lcd.add_handler(
'console',
class_='logging.StreamHandler',
stream=my_stream,
# class_='logging.NullHandler', # . <-- suppress output
level='INFO',
formatter='msg'
).attach_root_handlers('console')
lcd.add_filter(
'count_gew',
** {'()': CountGEWarning}
).attach_root_filters( # coverage ho'dom
).attach_logger_filters('' # coverage ho'dom
).attach_logger_filters('', 'count_gew') # coverage; defers to attach_root_filters
lcd.config()
logger = logging.getLogger()
if PY2:
logger.debug(u"Hi 1")
logger.debug(u"Hi 2")
logger.info(u"Hi 3")
logger.warning(u"Hi 4")
logger.error(u"Hi 5")
logger.critical(u"Hi 6")
else:
logger.debug("Hi 1")
logger.debug("Hi 2")
logger.info("Hi 3")
logger.warning("Hi 4")
logger.error("Hi 5")
logger.critical("Hi 6")
self.assertEqual(my_stream.getvalue(),
"Hi 3\n"
"Hi 4\n"
"Hi 5\n"
"Hi 6\n"
)
self.assertEqual(self.ge_warning_count, 3)
def test_one_filter_on_logger(self):
class CountInfo(logging.Filter):
def filter(self_, record):
"""
:param self_: "self" for the CountInfo object (unused)
:param record: logging.LogRecord
:return: bool -- True ==> let record through, False ==> squelch
"""
if record.levelno == logging.INFO:
self.info_count += 1
return True
lcd = LCDictBasic(root_level='DEBUG')
lcd.add_formatter(
'msg',
format='%(message)s'
)
my_stream = io.StringIO()
lcd.add_handler(
'console',
class_='logging.StreamHandler',
stream=my_stream,
# level='INFO',
formatter='msg'
).set_handler_level(
'console', 'DEBUG')
lcd.attach_logger_handlers('', 'console') # coverage; defers to attach_root_handlers
lcd.add_filter(
'count_i',
** {'()': CountInfo}
)
lcd.add_logger('abc') # , filters='count_i'
lcd.attach_logger_filters('abc', 'count_i')
lcd.config()
logger = logging.getLogger('abc')
if PY2:
logger.debug(u"Yo 1")
logger.debug(u"Yo 2")
logger.info(u"Yo 3")
else:
logger.debug("Yo 1")
logger.debug("Yo 2")
logger.info("Yo 3")
self.assertEqual(self.info_count, 1)
def test_add_logger_one_handler(self):
lcd = LCDictBasic(root_level='DEBUG')
lcd.add_formatter(
'msg',
format='%(message)s'
).add_handler(
'console',
class_='logging.StreamHandler',
level='INFO',
# formatter='msg'
).set_handler_formatter( # coverage
'console', 'msg'
)
lcd.warnings = 0
lcd.add_logger(
'default',
level='DEBUG',
# handlers='console',
propagate=False # for coverage
)
# lcd.dump() # | DEBUG comment out
lcd.attach_logger_handlers('default', 'console')
# lcd.dump() # | DEBUG comment out
self.assertEqual(
lcd['handlers'],
{'console': {'class': 'logging.StreamHandler',
'formatter': 'msg',
'level': 'INFO'}}
)
self.assertEqual(
lcd['loggers'],
{'default': {'handlers': ['console'],
'level': 'DEBUG',
'propagate': False}}
)
lcd.config()
def test_filters_on_handler(self):
class FilterOutOddRecords(logging.Filter):
def filter(_self_, record):
"""If level of record is >= INFO, let record through;
o/w, increment self.info_count += 1;
if self.info_count odd, allow record through.
:param self_: "self" for the CountInfo object (unused)
:param record: logging.LogRecord
:return: bool -- True ==> let record through, False ==> squelch
"""
if record.levelno < logging.INFO:
return True
self.info_count += 1
if self.info_count % 2:
self.test_filters_on_handler__messages.append(self.info_count - 1)
return self.info_count % 2
lcd = LCDictBasic()
lcd.set_root_level('DEBUG')
lcd.add_filter(
'filter_odd',
** {'()': FilterOutOddRecords}
).add_formatter(
'msg',
format='%(message)s'
).add_handler(
'console',
class_='logging.StreamHandler', # writes messages
# class_='logging.NullHandler', # can't do this to suppress output: filter won't be called
level='INFO',
formatter='msg',
)
lcd.attach_handler_filters('console') # coverage
lcd.attach_handler_filters('console', 'filter_odd')
lcd.attach_root_handlers('console')
# Swap stderr BEFORE lcd.config:
_stderr = sys.stderr
sio_err = io.StringIO()
sys.stderr = sio_err
# NOW do lcd.config:
lcd.config(disable_existing_loggers=False)
# log stuff
logger = logging.getLogger()
logger.debug("Hi 0")
logger.debug("Hi 1")
if PY2:
logger.info(u"0") # passes filter
logger.info(u"1")
logger.info(u"2") # passes filter
logger.info(u"3")
else:
logger.info("0") # passes filter
logger.info("1")
logger.info("2") # passes filter
logger.info("3")
# unswap stderr, unnecessarily
sys.stderr = _stderr
# print("sio_err.getvalue(): '%s'" % sio_err.getvalue())
self.assertEqual(sio_err.getvalue(), "0\n2\n")
self.assertEqual(self.info_count, 4)
self.assertEqual(self.test_filters_on_handler__messages, [0, 2])
def test_filters_on_logger(self):
def _count_debug(record):
"""
:param record: logging.LogRecord
:return: bool -- True ==> let record through, False ==> squelch
"""
if record.levelno == logging.DEBUG:
self.debug_count += 1
return True
class CountInfo(logging.Filter):
def filter(self_, record):
"""
:param self_: "self" for the CountInfo object (unused)
:param record: logging.LogRecord
:return: bool -- True ==> let record through, False ==> squelch
"""
if record.levelno == logging.INFO:
self.info_count += 1
return True
if PY2:
# Note: If Python 2.x, filter can't be just
# . any callable taking a logging record as arg;
# . it must have an attribute .filter
# . which must be a callable taking a LogRecord as arg.
# . Typically one does this:
_count_debug.filter = _count_debug
lcd = LCDictBasic()
lcd.set_root_level('DEBUG')
lcd.add_formatter(
'msg',
format='%(message)s'
).add_null_handler(
'console',
level='INFO',
).set_handler_level(
'console', 'DEBUG')
lcd.attach_root_handlers('console')
lcd.add_filter(
'count_d',
** {'()': lambda: _count_debug }
).add_filter(
'count_i',
** {'()': CountInfo}
)
lcd.add_logger('h', filters=['count_d', 'count_i'])
# shameless bid for more coverage
lcd.set_logger_level('h', level='DEBUG')
lcd.config(disable_existing_loggers=False)
logger = logging.getLogger('h')
if PY2:
logger.debug(u"Hi 1")
logger.debug(u"Hi 2")
logger.info(u"Hi 3")
else:
logger.debug("Hi 1")
logger.debug("Hi 2")
logger.info("Hi 3")
self.assertEqual(self.debug_count, 2)
self.assertEqual(self.info_count, 1)