'''

This library is provided to allow standard python logging

to output log data as JSON formatted strings

'''

import logging

import json

import re

import six

import traceback

from datetime import date, datetime, time

from inspect import istraceback

from os import getenv

#Support order in python 2.7 and 3

try:

from collections import OrderedDict

except ImportError:

pass

# skip natural LogRecord attributes

# http://docs.python.org/library/logging.html#logrecord-attributes

RESERVED_ATTRS = (

'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')

# 1ticket allowed logging fields:

ALLOWED_KEYS = [

'userid', 'listingid', 'remoteid', 'appname',

'orderid', 'invoiceid', 'accountid', 'jobid', 'logurl'

]

MAX_KEYS = 5

APP_NAME = getenv('APP_NAME', '')

JOB_ID = getenv('AWS_BATCH_JOB_ID', '')

class AppNameFilter(logging.Filter):

def filter(self, record):

record.appname = APP_NAME

return True

class JobIdFilter(logging.Filter):

def filter(self, record):

record.jobid = JOB_ID

return True

def merge_record_extra(record, target, reserved, prefix=""):

"""

Merges extra attributes from LogRecord object into target dictionary

:param record: logging.LogRecord

:param target: dict to update

:param reserved: dict or list with reserved keys to skip

"""

default_json = {}

for key, value in record.__dict__.items():

if (key not in reserved

and not (hasattr(key, "startswith")

and key.startswith('_'))):

if key not in ALLOWED_KEYS:

continue

if isinstance(value, dict):

continue

if prefix:

target[prefix + key] = str(value)

else:

target[key] = str(value)

for key, value in default_json.items():

if key not in target:

target[key] = value

return target

class JsonEncoder(json.JSONEncoder):

"""

A custom encoder extending the default JSONEncoder

"""

def default(self, obj):

if isinstance(obj, (date, datetime, time)):

return self.format_datetime_obj(obj)

elif istraceback(obj):

return ''.join(traceback.format_tb(obj)).strip()

elif type(obj) == Exception \

or isinstance(obj, Exception) \

or type(obj) == type:

return str(obj)

try:

return super(JsonEncoder, self).default(obj)

except TypeError:

try:

return str(obj)

except Exception:

return None

def format_datetime_obj(self, obj):

return obj.isoformat()

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 json_indent: an optional :meth:`json.dumps`-compatible numeric value

that will be used to customize the indent of the output json.

:param prefix: an optional string prefix added at the beginning of

the formatted string

:param json_indent: indent parameter for json.dumps

:param json_ensure_ascii: ensure_ascii parameter for json.dumps

:param reserved_attrs: an optional list of fields that will be skipped when

outputting json log record. Defaults to all log record attributes:

http://docs.python.org/library/logging.html#logrecord-attributes

:param timestamp: an optional string/boolean field to add a timestamp when

outputting the json log record. If string is passed, timestamp will be added

to log record using string as key. If True boolean is passed, timestamp key

will be "timestamp". Defaults to False/off.

"""

self.json_default = kwargs.pop("json_default", None)

self.json_encoder = kwargs.pop("json_encoder", None)

self.json_serializer = kwargs.pop("json_serializer", json.dumps)

self.json_indent = kwargs.pop("json_indent", None)

self.json_ensure_ascii = kwargs.pop("json_ensure_ascii", True)

self.prefix = kwargs.pop("prefix", "")

reserved_attrs = kwargs.pop("reserved_attrs", RESERVED_ATTRS)

self.reserved_attrs = dict(zip(reserved_attrs, reserved_attrs))

self.timestamp = kwargs.pop("timestamp", False)

self.key_prefix = ''

#super(JsonFormatter, self).__init__(*args, **kwargs)

logging.Formatter.__init__(self, *args, **kwargs)

if not self.json_encoder and not self.json_default:

self.json_encoder = JsonEncoder

self._required_fields = self.parse()

self._skip_fields = dict(zip(self._required_fields,

self._required_fields))

self._skip_fields.update(self.reserved_attrs)

def parse(self):

"""

Parses format string looking for substitutions

This method is responsible for returning a list of fields (as strings)

to include in all log messages.

"""

standard_formatters = re.compile(r'\((.+?)\)', re.IGNORECASE)

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.

"""

for field in self._required_fields:

log_record[field] = record.__dict__.get(field)

log_record.update(message_dict)

merge_record_extra(record, log_record, reserved=self._skip_fields, prefix=self.key_prefix)

if self.timestamp:

key = self.timestamp if type(self.timestamp) == str else 'timestamp'

log_record[key] = datetime.utcnow()

def process_log_record(self, log_record):

"""

Override this method to implement custom logic

on the possibly ordered dictionary.

"""

return log_record

def jsonify_log_record(self, log_record):

"""Returns a json string of the log record."""

return self.json_serializer(log_record,

default=self.json_default,

cls=self.json_encoder,

indent=self.json_indent,

ensure_ascii=self.json_ensure_ascii)

def format(self, record):

"""Formats a log record and serializes to json"""

message_dict = {}

new_message_dict = {}

if isinstance(record.msg, dict):

record.message = json.dumps(record.msg)

else:

record.message = record.getMessage()

# only format time if needed

if "asctime" in self._required_fields:

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'):

new_message_dict['exc_info'] = self.formatException(record.exc_info)

if not message_dict.get('exc_info') and record.exc_text:

new_message_dict['exc_info'] = record.exc_text

try:

log_record = OrderedDict()

except NameError:

log_record = {}

self.add_fields(log_record, record, new_message_dict)

log_record = self.process_log_record(log_record)

return "%s%s" % (self.prefix, self.jsonify_log_record(log_record))