event_logger.py

# py27

import os
import sys
import logging

class EvenLogger(logging.Logger):
    from logging import NOTSET

    def __init__(self, name, level=NOTSET):
        super(self.__class__, self).__init__(name, level=level)

    def _log(self, level, msg, args, exc_info=None, extra=None):
        """
        Low-level logging routine which creates a LogRecord and then calls
        all the handlers of this logger to handle the record.
        """
        _srcfile = srcfile
        # VaderProject hack end

        if _srcfile:
            #IronPython doesn't track Python frames, so findCaller raises an
            #exception on some versions of IronPython. We trap it here so that
            #IronPython can use logging.
            try:
                fn, lno, func = self.findCaller()
            except ValueError:
                fn, lno, func = "(unknown file)", 0, "(unknown function)"
        else:
            fn, lno, func = "(unknown file)", 0, "(unknown function)"
        if exc_info:
            if not isinstance(exc_info, tuple):
                exc_info = sys.exc_info()
        record = self.makeRecord(self.name, level, fn, lno, msg, args, exc_info, func, extra)
        self.handle(record)


logger = logging.getLogger('my_event')
# Patch findCaller by dynamically change logger instance's __class__,
# do NOT use logging.setLoggerClass(), we won't use this EventLogger as default Logger class project globally
logger.__class__ = EvenLogger


# srcfile is used in `my_app.utils.log.EventLogger`
# This code block is a full copy of `logging._srcfile`
#
# srcfile is used when walking the stack to check when we've got the first
# caller stack frame.
#
if hasattr(sys, 'frozen'): #support for py2exe
    _srcfile = "logging%s__init__%s" % (os.sep, __file__[-4:])
elif __file__[-4:].lower() in ['.pyc', '.pyo']:
    _srcfile = __file__[:-4] + '.py'
else:
    _srcfile = __file__
srcfile = os.path.normcase(_srcfile)


def log(event_spec, msg='', *args):
    """
    event.log() will send a INFO level message to UDP server via `vader.utils.log.UPDHandler`. See config in `logging.yml`
    Usage see test_event.TestEvent.test_log()
    :param tuple(int, str) event_spec:
    :param str msg:
    :param tuple args: see docs of `logging.Logger.log()`
    :return: None
    """
    event_code, event_name = event_spec
    logger.info(msg, *args, extra={'event_name': event_name, 'event_code': event_code})


from collections import namedtuple
EventSpec = namedtuple('EventSpec', 'event_code, event_name')
# define your event_spec here. eg. something_happened = 100, 'something happened'
StackOverflowed = EventSpec(100, 'stack overflowed')