114 lines
3.7 KiB
Python
Executable file
114 lines
3.7 KiB
Python
Executable file
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
from __future__ import absolute_import
|
|
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import re
|
|
import traceback
|
|
|
|
|
|
LOG_FORMAT_REGEXP = re.compile(r'\((.+?)\)', re.IGNORECASE)
|
|
|
|
|
|
def _json_default(obj):
|
|
"""
|
|
Coerce everything to strings.
|
|
All objects representing time get output as ISO8601.
|
|
"""
|
|
if isinstance(obj, (datetime.date, datetime.time, datetime.datetime)):
|
|
return obj.isoformat()
|
|
|
|
elif isinstance(obj, Exception):
|
|
return "Exception: %s" % str(obj)
|
|
|
|
return str(obj)
|
|
|
|
|
|
# skip natural LogRecord attributes
|
|
# http://docs.python.org/library/logging.html#logrecord-attributes
|
|
RESERVED_ATTRS = set([
|
|
'args', 'asctime', 'created', 'exc_info', 'exc_text', 'filename', 'funcName', 'levelname',
|
|
'levelno', 'lineno', 'module', 'msecs', 'message', 'msg', 'name', 'pathname', 'process',
|
|
'processName', 'relativeCreated', 'stack_info', 'thread', 'threadName'
|
|
])
|
|
|
|
|
|
class JsonFormatter(logging.Formatter):
|
|
"""
|
|
A custom formatter to format logging records as json strings.
|
|
extra values will be formatted as str() if nor supported by
|
|
json default encoder
|
|
"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""
|
|
:param json_default: a function for encoding non-standard objects
|
|
as outlined in http://docs.python.org/2/library/json.html
|
|
:param json_encoder: optional custom encoder
|
|
:param json_serializer: a :meth:`json.dumps`-compatible callable
|
|
that will be used to serialize the log record.
|
|
:param prefix: an optional key prefix to nest logs
|
|
"""
|
|
self.json_default = kwargs.pop("json_default", _json_default)
|
|
self.json_encoder = kwargs.pop("json_encoder", None)
|
|
self.json_serializer = kwargs.pop("json_serializer", json.dumps)
|
|
self.default_values = kwargs.pop("default_extra", {})
|
|
self.prefix_key = kwargs.pop("prefix_key", "data")
|
|
|
|
logging.Formatter.__init__(self, *args, **kwargs)
|
|
|
|
self._fmt_parameters = self._parse_format_string()
|
|
self._skip_fields = set(self._fmt_parameters)
|
|
self._skip_fields.update(RESERVED_ATTRS)
|
|
|
|
def _parse_format_string(self):
|
|
"""Parses format string looking for substitutions"""
|
|
standard_formatters = LOG_FORMAT_REGEXP
|
|
return standard_formatters.findall(self._fmt)
|
|
|
|
def add_fields(self, log_record, record, message_dict):
|
|
"""
|
|
Override this method to implement custom logic for adding fields.
|
|
"""
|
|
|
|
target = log_record
|
|
if self.prefix_key:
|
|
log_record[self.prefix_key] = {}
|
|
target = log_record[self.prefix_key]
|
|
|
|
for field, value in record.__dict__.iteritems():
|
|
if field in self._fmt_parameters and field in RESERVED_ATTRS:
|
|
log_record[field] = value
|
|
elif field not in RESERVED_ATTRS:
|
|
target[field] = value
|
|
|
|
target.update(message_dict)
|
|
target.update(self.default_values)
|
|
|
|
def format(self, record):
|
|
"""Formats a log record and serializes to json"""
|
|
message_dict = {}
|
|
if isinstance(record.msg, dict):
|
|
message_dict = record.msg
|
|
record.message = None
|
|
if "message" in message_dict:
|
|
record.message = message_dict.pop("message", "")
|
|
else:
|
|
record.message = record.getMessage()
|
|
|
|
# only format time if needed
|
|
if "asctime" in self._fmt_parameters:
|
|
record.asctime = self.formatTime(record, self.datefmt)
|
|
|
|
# Display formatted exception, but allow overriding it in the
|
|
# user-supplied dict.
|
|
if record.exc_info and not message_dict.get('exc_info'):
|
|
message_dict['exc_info'] = traceback.format_list(traceback.extract_tb(record.exc_info[2]))
|
|
log_record = {}
|
|
|
|
self.add_fields(log_record, record, message_dict)
|
|
|
|
return self.json_serializer(log_record, default=self.json_default, cls=self.json_encoder)
|