def test_colorama_force_colors(self, styles, padded):
"""
If force_colors is True, use colors even if the destination is non-tty.
"""
cr = dev.ConsoleRenderer(colors=dev._has_colorama,
force_colors=dev._has_colorama)
rv = cr(None, None, {
"event": "test",
"level": "critical",
"foo": "bar"
})
# fmt: off
assert ("[" + dev.RED + styles.bright +
dev._pad("critical", cr._longest_level) + styles.reset + "] " +
padded + styles.kv_key + "foo" + styles.reset + "=" +
styles.kv_value + "bar" + styles.reset) == rv
# fmt: on
assert not dev._has_colorama or dev._ColorfulStyles is cr._styles
def test_init_accepts_overriding_levels(self, styles, padded):
"""
Stdlib levels are rendered aligned, in brackets, and color coded.
"""
my_styles = dev.ConsoleRenderer.get_default_level_styles(
colors=dev._has_colorama)
my_styles["MY_OH_MY"] = my_styles["critical"]
cr = dev.ConsoleRenderer(colors=dev._has_colorama,
level_styles=my_styles)
# this would blow up if the level_styles override failed
rv = cr(None, None, {
"event": "test",
"level": "MY_OH_MY",
"foo": "bar"
})
assert ("[" + dev.RED + styles.bright +
dev._pad("MY_OH_MY", cr._longest_level) + styles.reset + "] " +
padded + styles.kv_key + "foo" + styles.reset + "=" +
styles.kv_value + "bar" + styles.reset) == rv
def cr():
return dev.ConsoleRenderer()
def cr():
return dev.ConsoleRenderer(colors=dev._has_colorama)
def cre():
return dev.ConsoleRenderer(colors=dev._has_colorama,
event_key_name="message")
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"filters": {
"required_prod_or_stage": {
"()": "utils.structlog.base.RequireProdOrStage",
},
"required_dev_or_test": {
"()": "utils.structlog.base.RequiredDevOrTest",
},
},
"formatters": {
"plain_console": {
"()": stdlib.ProcessorFormatter,
"processor": dev.ConsoleRenderer(colors=True),
},
"json": {
"()": stdlib.ProcessorFormatter,
"processor": processors.JSONRenderer(),
},
},
"handlers": {
"console_json": {
"class": "logging.StreamHandler",
"formatter": "json",
"filters": ["required_prod_or_stage"],
},
"console_text": {
"class": "logging.StreamHandler",
"formatter": "plain_console",
import logging
import sys
from structlog import BoundLogger, configure, dev, get_logger, processors, stdlib
configure(
processors=[
stdlib.add_log_level,
processors.format_exc_info,
stdlib.ProcessorFormatter.wrap_for_formatter,
],
logger_factory=stdlib.LoggerFactory(),
)
formatter = stdlib.ProcessorFormatter(processor=dev.ConsoleRenderer())
handler = logging.StreamHandler()
handler.setFormatter(formatter)
root_logger: logging.Logger = None
def get_root_logger() -> BoundLogger:
return get_logger("root")
def setup_logging(level: str = "INFO",
style: str = "dev",
stream: str = "stdout"):
global root_logger
def configure_logging(debug=False,
syslog=False,
silenced_loggers=None,
level_overrides=None):
if silenced_loggers is None:
silenced_loggers = []
if level_overrides is None:
level_overrides = {}
level = 'DEBUG' if debug else 'INFO'
renderers = [
dev.ConsoleRenderer(),
] if debug else [
logstash_processor,
processors.JSONRenderer(separators=(',', ':')),
add_syslog_program(syslog),
]
structlog_processors = [
stdlib.filter_by_level,
stdlib.add_logger_name,
stdlib.add_log_level,
fix_logger_name,
format_request,
ensure_event,
stdlib.PositionalArgumentsFormatter(),
processors.TimeStamper(fmt="ISO", key='@timestamp'),
processors.StackInfoRenderer(),
processors.format_exc_info,
] + renderers
configure(
processors=structlog_processors,
context_class=dict,
logger_factory=stdlib.LoggerFactory(),
wrapper_class=stdlib.BoundLogger,
cache_logger_on_first_use=True,
)
structlog = {'handlers': ['raw'], 'level': level, 'propagate': False}
null = {'handlers': ['null'], 'propagate': False}
loggers = {
l: root(level_overrides.get(l, level))
for l, _, _ in logging_tree.tree()[2]
}
loggers['feedhq'] = structlog
for nulled_logger in silenced_loggers:
loggers[nulled_logger] = null
raw = {
'level': level,
'class': 'logging.handlers.SysLogHandler',
'address': '/dev/log',
'facility': 'local0',
} if syslog else {
'level': level,
'class': 'logging.StreamHandler',
}
return {
'version': 1,
'level': level,
'handlers': {
'root': {
'level': level,
'()': StructlogHandler,
},
'raw': raw,
'null': {
'class': 'logging.NullHandler',
},
},
'loggers': loggers,
'root': root(level),
}
