def setupLogHandlers(fname, formatter=None, log_dir='./', use_gelf=False, **kwargs):
"""
Adapted from CoinapultCommon.util.setupLogHandlers
Create a RotatingFileHandler to be used by a logger, and possibly a
GELFHandler.
By default the RotatingFileHandler stores 100 MB before starting a new
log file and the last 10 log files are kept. The default formatter shows
the logging level, current time, the function that created the log entry,
and the specified message.
:param str fname: path to the filename where logs will be written to
:param logging.Formatter formatter: a custom formatter for this logger
:param str log_dir: The directory the log file belongs in
:param bool use_gelf: Use GELF or not
:param kwargs: custom parameters for the RotatingFileHandler
:rtype: tuple
"""
if formatter is None:
formatter = logging.Formatter('%(levelname)s [%(asctime)s] %(funcName)s: %(message)s')
opts = {'maxBytes': 100 * 1024 * 1024, 'backupCount': 10}
opts.update(kwargs)
handler = RotatingFileHandler(os.path.join(log_dir, fname), **opts)
handler.setFormatter(formatter)
handlers = (handler, )
if use_gelf:
gelf_handler = GELFHandler(**use_gelf)
gelf_handler.setLevel(logging.INFO) # Ignore DEBUG messages.
handlers += (gelf_handler, )
return handlers
def on_configured(self):
self.gelf_logger = logging.getLogger("GELF")
self.gelf_logger.setLevel(logging.DEBUG)
self.gelf_logger.propagate = False
if self.gelf_protocol == "udp":
self.gelf_logger.addHandler(
GELFHandler(
host=self.gelf_host,
port=self.gelf_port,
facility=self.facility,
debugging_fields=False,
extra_fields=True,
)
)
elif self.gelf_protocol == "tcp":
handler = GELFTcpHandler(
host=self.gelf_host,
facility=self.facility,
port=self.gelf_port,
debugging_fields=False,
extra_fields=True,
)
handler.level = logging.DEBUG
self.gelf_logger.addHandler(handler)
else:
raise ConfigValidationError(
"/".join(("watchers", self.name)),
"Parameter gelf_protocol must be one of: udp, tcp but {} given".format(self.gelf_protocol),
)
def bootstrap_all_logging():
server_log = logging.getLogger("frontik.server")
if tornado.options.options.syslog:
syslog_handler = MaxLenSysLogHandler(
facility=MaxLenSysLogHandler.facility_names[
tornado.options.options.syslog_facility],
address=tornado.options.options.syslog_address,
msg_max_length=tornado.options.options.syslog_msg_max_length)
syslog_handler.setFormatter(
logging.Formatter(tornado.options.options.logformat))
logging.getLogger().addHandler(syslog_handler)
if tornado.options.options.graylog:
try:
from graypy import GELFHandler, WAN_CHUNK
graylog_handler = GELFHandler(tornado.options.options.graylog_host,
tornado.options.options.graylog_port,
WAN_CHUNK, False)
logging.getLogger().addHandler(graylog_handler)
except ImportError:
server_log.error(
'Graylog option is on, but can not import graypy and start graylog logging!'
)
if tornado.options.options.logfile is not None:
logging.getLogger().addHandler(MonikInfoLoggingHandler())
for log_channel_name in tornado.options.options.suppressed_loggers:
logging.getLogger(log_channel_name).setLevel(logging.WARN)
def make_message_dict(self, record):
msg_dict = dict(('_' + k, v) for k, v in self.extra_fields.items())
msg_dict.update(GELFHandler.make_message_dict(self, record))
# the request object, if added by Django's exception handler, is
# not picklable (which prevents graypy from sending this log record)
# and may contain sensitive information, so just remove it here. repr()
# may be used to obtain a string version of the request if needed
msg_dict.pop('_request', None)
# force full_message to be a full stack trace, if available
if record.exc_info:
import traceback
exception = traceback.format_exception_only(*record.exc_info[:2])
exception = '; '.join([part.strip() for part in exception])
stack_trace = '\n'.join(traceback.format_exception(*record.exc_info))
msg_dict['short_message'] += ' (%s)' % exception
msg_dict['full_message'] = stack_trace
return msg_dict
def on_configured(self):
self.gelf_logger = logging.getLogger('GELF')
self.gelf_logger.setLevel(logging.DEBUG)
self.gelf_logger.propagate = False
if self.gelf_protocol == 'udp':
self.gelf_logger.addHandler(
GELFHandler(host=self.gelf_host,
port=self.gelf_port,
debugging_fields=False,
extra_fields=True))
elif self.gelf_protocol == 'tcp':
handler = GELFTcpHandler(host=self.gelf_host,
port=self.gelf_port,
debugging_fields=False,
extra_fields=True)
handler.level = logging.DEBUG
self.gelf_logger.addHandler(handler)
else:
raise ConfigValidationError(
'/'.join(('watchers', self.name)),
"Parameter gelf_protocol must be one of: udp, tcp but {} given"
.format(self.gelf_protocol))
# !/usr/bin/env python
# -*- coding: utf-8 -*-
"""Simple example to use with Gelf logging module."""
import logging
from pylogging import HandlerType, setup_logger
from graypy import GELFHandler
logger = logging.getLogger(__name__)
# If want to add extra fields.
# logger = logging.LoggerAdapter(logger, {"app_name": "test-service"})
if __name__ == '__main__':
gelf_handler = GELFHandler(host="localhost",
port=12201,
level_names=True,
debugging_fields=False)
setup_logger(log_directory='./logs',
file_handler_type=HandlerType.TIME_ROTATING_FILE_HANDLER,
allow_console_logging=True,
allow_file_logging=True,
backup_count=100,
max_file_size_bytes=100000,
when_to_rotate='D',
change_log_level=None,
gelf_handler=gelf_handler)
logger.error("Error logs")
logger.debug("Debug logs")
logger.info("Info logs")
def __init__(self, *args, **kwargs):
self.extra_fields = kwargs.pop('extra_fields', {})
GELFHandler.__init__(self, *args, **kwargs)
