def configure_logging(pre_chain):
"""
Configure logging to use ProcessorFormatter.
"""
return logging.config.dictConfig({
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"plain": {
"()": ProcessorFormatter,
"processor": ConsoleRenderer(colors=False),
"foreign_pre_chain": pre_chain,
"format": "%(message)s [in %(funcName)s]"
}
},
"handlers": {
"default": {
"level": "DEBUG",
"class": "logging.StreamHandler",
"formatter": "plain",
},
},
"loggers": {
"": {
"handlers": ["default"],
"level": "DEBUG",
"propagate": True,
},
}
})
def get_logger_handler(self):
logger_handler = logging.StreamHandler(self.stdout)
formatter = ProcessorFormatter(
ConsoleRenderer() # colorize=True
) # TODO: some kind of logging.getFormatter (using key, passed to dictConfig)?
logger_handler.setFormatter(formatter)
return logger_handler
def alternate_dev_formatter():
debugging = ConsoleRenderer()
def with_memoized_loggers(logger, call_name, event_dict):
if logger.getEffectiveLevel() > logging.DEBUG:
return info_formatter(logger, call_name, event_dict)
return standard(logger, call_name, event_dict)
return debugging(logger, call_name, event_dict)
return with_memoized_loggers
def setup(sentry: str, debug: bool = False) -> None:
processors = [
filter_by_level,
add_log_level,
add_logger_name,
PositionalArgumentsFormatter(),
StackInfoRenderer(),
format_exc_info,
UnicodeDecoder(),
]
configure(
logger_factory=LoggerFactory(),
wrapper_class=BoundLogger,
cache_logger_on_first_use=True,
)
if debug:
styles = ConsoleRenderer.get_default_level_styles()
styles["debug"] = DIM
processors += [
TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
ConsoleRenderer(level_styles=styles),
]
else:
handler = StreamHandler()
formatter = CustomJsonFormatter("%(levelname)s %(name)s %(message)s")
handler.setFormatter(formatter)
for module in ("tornado", "tortoise", "aiomysql"):
getLogger(module).addHandler(handler)
sentry_logging = LoggingIntegration(level=INFO, event_level=ERROR)
init(sentry, integrations=[sentry_logging])
processors.append(JSONRenderer())
handler = StreamHandler()
configure(processors=processors)
log = get_logger("api")
log.addHandler(handler)
log.propagate = False
log.setLevel(DEBUG if debug else INFO)
def configure_logging():
log_level = logging.INFO
debug = os.getenv("FLASK_ENV") == "development"
if debug:
log_level = logging.DEBUG
log_handler = logging.StreamHandler(sys.stdout)
log_handler.setLevel(log_level)
log_handler.addFilter(lambda record: record.levelno <= logging.WARNING)
error_log_handler = logging.StreamHandler(sys.stderr)
error_log_handler.setLevel(logging.ERROR)
logging.basicConfig(level=log_level,
format="%(message)s",
handlers=[error_log_handler, log_handler])
# Set werkzeug logging level
werkzeug_logger = logging.getLogger("werkzeug")
werkzeug_logger.setLevel(level=log_level)
def parse_exception(_, __, event_dict):
if debug:
return event_dict
exception = event_dict.get("exception")
if exception:
event_dict["exception"] = exception.replace('"', "'").split("\n")
return event_dict
# setup file logging
renderer_processor = (ConsoleRenderer() if debug else JSONRenderer(
serializer=json_dumps))
processors = [
add_log_level,
TimeStamper(key="created", fmt="iso"),
add_service,
format_exc_info,
parse_exception,
renderer_processor,
]
configure(
context_class=wrap_dict(dict),
logger_factory=LoggerFactory(),
processors=processors,
cache_logger_on_first_use=True,
)
def tail(self, pretty):
'''
Tail the logs of a topic
'''
master = self.ensure_master()
if not self.state['default_topic']:
err_msg = 'No default topic'
prRed(err_msg)
sys.exit(1)
else:
topic_name = self.state['default_topic']['topic_name']
tail_logs_url = self.TAIL_LOGS_URL.format(host=master.host,
port=master.port,
topic_name=topic_name)
try:
session = requests.session()
resp = session.get(tail_logs_url, stream=True)
c = ConsoleRenderer()
for line in resp.iter_lines():
log = dict()
try:
result = json.loads(line.decode('utf-8'))
result = result.get('result')
if result: log = json.loads(result)
else: continue
except ValueError:
print(Exception('ValueError log:{}'.format(result)))
continue
if pretty:
print(c(None, None, log))
else:
print(log)
except requests.exceptions.ConnectionError:
err_msg = 'Cannot request master'
prRed(err_msg)
sys.exit(1)
except Exception as e:
if resp: resp.close()
raise e
sys.exit(1)
def configure_logging():
# set up some sane logging, as opposed to what flask does by default
log_format = "%(message)s"
levels = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG,
}
handler = logging.StreamHandler()
logging.basicConfig(level=levels[EQ_LOG_LEVEL],
format=log_format,
handlers=[handler])
# turn boto logging to critical as it logs far too much and it's only used
# for cloudwatch logging
logging.getLogger("botocore").setLevel(logging.ERROR)
if EQ_CLOUDWATCH_LOGGING:
_setup_cloud_watch_logging()
# Set werkzeug logging level
werkzeug_logger = logging.getLogger('werkzeug')
werkzeug_logger.setLevel(level=levels[EQ_WERKZEUG_LOG_LEVEL])
# setup file logging
rotating_log_file = RotatingFileHandler(filename="eq.log",
maxBytes=1048576,
backupCount=10)
logging.getLogger().addHandler(rotating_log_file)
renderer_processor = ConsoleRenderer(
) if EQ_DEVELOPER_LOGGING else JSONRenderer()
processors = [
add_log_level,
TimeStamper(key='created', fmt='iso'), add_service, format_exc_info,
renderer_processor
]
configure(context_class=wrap_dict(dict),
logger_factory=LoggerFactory(),
processors=processors,
cache_logger_on_first_use=True)
def configure_logging():
# set up some sane logging, as opposed to what flask does by default
log_format = "%(message)s"
levels = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG,
}
handler = logging.StreamHandler()
logging.basicConfig(level=levels[EQ_LOG_LEVEL],
format=log_format,
handlers=[handler])
# Set werkzeug logging level
werkzeug_logger = logging.getLogger('werkzeug')
werkzeug_logger.setLevel(level=levels[EQ_WERKZEUG_LOG_LEVEL])
def parse_exception(_, __, event_dict):
if EQ_DEVELOPER_LOGGING:
return event_dict
exception = event_dict.get('exception')
if exception:
event_dict['exception'] = exception.replace("\"", "'").split("\n")
return event_dict
# setup file logging
renderer_processor = ConsoleRenderer(
) if EQ_DEVELOPER_LOGGING else JSONRenderer()
processors = [
add_log_level,
TimeStamper(key='created', fmt='iso'), add_service, format_exc_info,
parse_exception, renderer_processor
]
configure(context_class=wrap_dict(dict),
logger_factory=LoggerFactory(),
processors=processors,
cache_logger_on_first_use=True)
# Author: Shane R. Spencer <*****@*****.**>
# Structlog: https://github.com/hynek/structlog
from structlog import get_logger
from structlog.dev import ConsoleRenderer, set_exc_info, _has_colorama
from structlog.processors import TimeStamper, StackInfoRenderer, format_exc_info
from structlog.contextvars import merge_contextvars
_logger = get_logger(processors=[
merge_contextvars,
StackInfoRenderer(),
set_exc_info,
format_exc_info,
TimeStamper(fmt="%Y-%m-%d %H:%M.%S", utc=False),
ConsoleRenderer(colors=_has_colorama),
])
access_log = _logger.bind()
app_log = _logger.bind()
gen_log = _logger.bind()
class Wut(object):
def __init__(self):
...
def stuff() -> None:
return None
def main():
c = ConsoleRenderer()
for line in sys.stdin:
d = json.loads(line)
print(c(None, None, d))
def __init__(self):
self._worse_console_renderer = ConsoleRenderer(
level_styles=_level_styles())
import os.path
import glob
import re
import sys
import subprocess
import shlex
from pathlib import Path
from functools import cmp_to_key
from structlog import get_logger, wrap_logger
from structlog.dev import ConsoleRenderer
import yaml
import semver
import pkgconfig
glog = wrap_logger(get_logger(), processors=[ConsoleRenderer(pad_event=42, colors=True)])
cc = os.getenv('CC', 'gcc')
cxx = os.getenv('CXX', 'g++')
syslibs = []
libpaths = re.findall(r'SEARCH_DIR\("(.+?)"\);', subprocess.check_output(shlex.split('bash -c "ld --verbose | grep SEARCH_DIR"')).decode('utf-8')) + os.getenv('LD_LIBRARY_PATH', '').split(':')
def find_lib(lib, pth):
glog.info('find_lib()', lib=lib)
for lp in pth:
if os.path.isfile(lp + '/' + lib):
return lp + '/' + lib
glog.failure('unable to find a library', lib=lib)
sys.exit(1)
