示例#1
0
文件: log.py 项目: ra2003/chert
       ' - {duration_ms:>8.3f}ms'
       ' - {parent_depth_indent}{end_message}')

begin_fmt = ('{status_char}+{import_delta_s}'
             ' --------------'
             ' {parent_depth_indent}{begin_message}')

stderr_fmtr = SensibleFormatter(fmt, begin=begin_fmt)
stderr_emtr = StreamEmitter('stderr')
stderr_filter = SensibleFilter(success='info',
                               failure='debug',
                               exception='debug')
stderr_sink = SensibleSink(formatter=stderr_fmtr,
                           emitter=stderr_emtr,
                           filters=[stderr_filter])
chert_log.add_sink(stderr_sink)

try:
    from lithoxyl.emitters import SyslogEmitter
except Exception:
    pass
else:
    syslog_filter = SensibleFilter(success='critical',
                                   failure='critical',
                                   exception='critical')
    syslog_emt = SyslogEmitter('chert')
    syslog_sink = SensibleSink(formatter=stderr_fmtr,
                               emitter=syslog_emt,
                               filters=[syslog_filter])
    if os.getenv('CHERT_SYSLOG'):
        chert_log.add_sink(syslog_sink)
示例#2
0
文件: mw.py 项目: aissatech/montage
class LoggingMiddleware(Middleware):
    provides = (
        'api_log',
        'api_act',
    )

    def __init__(self, log_path, act_name='API'):
        self.log_path = os.path.abspath(log_path)
        root, ext = os.path.splitext(self.log_path)
        self.exc_log_path = '%s.exc%s' % (root, ext)
        self.act_name = act_name

        self._setup_api_log()

    def request(self, next, request, _route):
        try:
            act_name = '%s%s' % (request.method, _route.pattern)
            with self.api_log.critical(act_name) as api_act:
                # basic redacted url
                api_act['path'] = request.path
                api_act.data_map.update(request.args.items())
                try:
                    ret = next(api_act=api_act, api_log=self.api_log)
                except clastic.errors.BadRequest as br:
                    api_act.data_map.update(br.to_dict())
                    api_act.failure()
                    ret = br
                api_act['code'] = ret.status_code
        except Exception:
            exc_info = ExceptionInfo.from_current()
            text = u'\n\n' + exc_info.get_formatted() + '\n\n'
            self.exc_log_file_obj.write(text.encode('utf8'))
            self.exc_log_file_obj.flush()
            raise
        return ret

    def endpoint(self, next, api_act):
        ret = next()
        try:
            api_act['username'] = ret['user'].username
        except Exception:
            pass
        return ret

    def _setup_api_log(self):
        self.log_file_obj = open(self.log_path, 'ab')
        self.exc_log_file_obj = open(self.exc_log_path, 'ab')

        self.api_log = Logger(self.act_name.lower() + '_log')
        self._api_fmtr = SensibleFormatter(API_LOG_FMT)
        self._api_emtr = StreamEmitter(self.log_file_obj)
        self._api_fltr = SensibleFilter(success='info',
                                        failure='debug',
                                        exception='debug')
        self._api_sink = SensibleSink(formatter=self._api_fmtr,
                                      emitter=self._api_emtr,
                                      filters=[self._api_fltr])
        self.api_log.add_sink(self._api_sink)

        self._exc_emtr = StreamEmitter(self.exc_log_file_obj)
        self._exc_fltr = SensibleFilter(success=None,
                                        failure=None,
                                        exception='info')
        self._exc_sink = SensibleSink(formatter=self._api_fmtr,
                                      emitter=self._exc_emtr,
                                      filters=[self._exc_fltr])
        self.api_log.add_sink(self._exc_sink)
示例#3
0
文件: log.py 项目: mahmoud/chert
       ' - {parent_depth_indent}{end_message}')

begin_fmt = ('{status_char}+{import_delta_s}'
             ' --------------'
             ' {parent_depth_indent}{begin_message}')

stderr_fmtr = SensibleFormatter(fmt,
                                begin=begin_fmt)
stderr_emtr = StreamEmitter('stderr')
stderr_filter = SensibleFilter(success='info',
                               failure='debug',
                               exception='debug')
stderr_sink = SensibleSink(formatter=stderr_fmtr,
                           emitter=stderr_emtr,
                           filters=[stderr_filter])
chert_log.add_sink(stderr_sink)

try:
    from lithoxyl.emitters import SyslogEmitter
except Exception:
    pass
else:
    syslog_filter = SensibleFilter(success='critical',
                                   failure='critical',
                                   exception='critical')
    syslog_emt = SyslogEmitter('chert')
    syslog_sink = SensibleSink(formatter=stderr_fmtr,
                               emitter=syslog_emt,
                               filters=[syslog_filter])
    if os.getenv('CHERT_SYSLOG'):
        chert_log.add_sink(syslog_sink)
示例#4
0
    def __init__(self, filepath, encoding=None, **kwargs):
        self.encoding = encoding
        super(FixedFileEmitter, self).__init__(filepath, encoding, **kwargs)

CUR_PATH = os.path.dirname(os.path.abspath(__file__))
LOG_FILE_PATH = os.path.join(CUR_PATH, 'logs', 'update_log.txt')

tlog = Logger('toplog')

file_fmt = SensibleFormatter('{status_char}{iso_end_local_noms_notz} - {duration_s}s - {action_name} - {event_message}')
file_emt = FixedFileEmitter(LOG_FILE_PATH)
file_filter = SensibleFilter(success='critical',
                              failure='info',
                              exception='debug')
file_sink = SensibleSink(formatter=file_fmt,
                         emitter=file_emt,
                         filters=[file_filter])
tlog.add_sink(file_sink)


def set_debug(enable=True):
    if not enable:
        raise NotImplementedError()
    dbg_fmtr = file_fmt
    dbg_emtr = StreamEmitter('stderr')
    
    dbg_sink = SensibleSink(formatter=dbg_fmtr,
                            emitter=dbg_emtr)
    tlog.add_sink(dbg_sink)
    
示例#5
0
    return


for i in range(20):
    one_two()


import os
print os.getpid()


class CommentSink(object):
    def on_comment(self, comment_event):
        print comment_event, comment_event.message
        # import pdb;pdb.set_trace()


def emit_cur_time_hook(logger):
    logger.comment('simpler heartbeats for a simpler time')


log.preflush_hooks.append(emit_cur_time_hook)
log.add_sink(CommentSink())

# log.flush()


log.comment('{} {hah}', 'hah!', hah='HAH!')

import pdb;pdb.set_trace()
示例#6
0
from lithoxyl import Logger, SensibleSink, Formatter, StreamEmitter
from lithoxyl.filters import ThresholdFilter

tlog = Logger('toplog')

stderr_fmt = Formatter('{status_char}{end_local_iso8601_noms_notz} - {duration_secs}s - {record_name} - {message}')
stderr_emt = StreamEmitter('stderr')
stderr_filter = ThresholdFilter(success='debug',
                                failure='debug',
                                exception='debug')
stderr_sink = SensibleSink(formatter=stderr_fmt,
                           emitter=stderr_emt,
                           filters=[stderr_filter])
#                           on=['begin', 'complete'])  # TODO: clunk
tlog.add_sink(stderr_sink)


class DevDebugSink(object):
    # TODO: configurable max number of traceback signatures, after
    #       which exit/ignore?

    def __init__(self, reraise=False, post_mortem=False):
        self.reraise = reraise
        self.post_mortem = post_mortem

    #def on_complete(self, record):
    #    some conditions and a pdb perhaps

    def on_exception(self, record, exc_type, exc_obj, exc_tb):
        if self.post_mortem:
示例#7
0
        raise ValueError("oh no, one of those")
    return


for i in range(20):
    one_two()

import os
print os.getpid()


class CommentSink(object):
    def on_comment(self, comment_event):
        print comment_event, comment_event.message
        # import pdb;pdb.set_trace()


def emit_cur_time_hook(logger):
    logger.comment('simpler heartbeats for a simpler time')


log.preflush_hooks.append(emit_cur_time_hook)
log.add_sink(CommentSink())

# log.flush()

log.comment('{} {hah}', 'hah!', hah='HAH!')

import pdb
pdb.set_trace()
示例#8
0
文件: log.py 项目: hatnote/top
import os

from lithoxyl import Logger, SensibleSink, Formatter, StreamEmitter
from lithoxyl.filters import ThresholdFilter

tlog = Logger("toplog")

stderr_fmt = Formatter("{status_char}{end_local_iso8601_noms_notz} - {duration_secs}s - {record_name} - {message}")
stderr_emt = StreamEmitter("stderr")
stderr_filter = ThresholdFilter(success="debug", failure="debug", exception="debug")
stderr_sink = SensibleSink(formatter=stderr_fmt, emitter=stderr_emt, filters=[stderr_filter])
#                           on=['begin', 'complete'])  # TODO: clunk
tlog.add_sink(stderr_sink)


class DevDebugSink(object):
    # TODO: configurable max number of traceback signatures, after
    #       which exit/ignore?

    def __init__(self, reraise=False, post_mortem=False):
        self.reraise = reraise
        self.post_mortem = post_mortem

    # def on_complete(self, record):
    #    some conditions and a pdb perhaps

    def on_exception(self, record, exc_type, exc_obj, exc_tb):
        if self.post_mortem:
            import pdb

            pdb.post_mortem()
示例#9
0
文件: log.py 项目: hatnote/hashtags
    def __init__(self, filepath, encoding=None, **kwargs):
        self.encoding = encoding
        super(FixedFileEmitter, self).__init__(filepath, encoding, **kwargs)

CUR_PATH = os.path.dirname(os.path.abspath(__file__))
LOG_FILE_PATH = os.path.join(CUR_PATH, 'logs', 'update_log.txt')

tlog = Logger('toplog')

file_fmt = Formatter('{status_char}{end_local_iso8601_noms_notz} - {duration_secs}s - {record_name} - {message}')
file_emt = FixedFileEmitter(LOG_FILE_PATH)
file_filter = ThresholdFilter(success='critical',
                              failure='info',
                              exception='debug')
file_sink = SensibleSink(formatter=file_fmt,
                         emitter=file_emt,
                         filters=[file_filter])
tlog.add_sink(file_sink)


def set_debug(enable=True):
    if not enable:
        raise NotImplementedError()
    dbg_fmtr = file_fmt
    dbg_emtr = StreamEmitter('stderr')
    
    dbg_sink = SensibleSink(formatter=dbg_fmtr,
                            emitter=dbg_emtr)
    tlog.add_sink(dbg_sink)
    
示例#10
0
from lithoxyl import (Logger, StreamEmitter, SensibleSink, SensibleFilter,
                      SensibleFormatter)

from lithoxyl.sinks import DevDebugSink

# import lithoxyl; lithoxyl.get_context().enable_async()

script_log = Logger('dev_script')

fmt = ('{status_char}+{import_delta_s}'
       ' - {duration_ms:>8.3f}ms'
       ' - {parent_depth_indent}{end_message}')

begin_fmt = ('{status_char}+{import_delta_s}'
             ' --------------'
             ' {parent_depth_indent}{begin_message}')

stderr_fmtr = SensibleFormatter(fmt, begin=begin_fmt)
stderr_emtr = StreamEmitter('stderr')
stderr_filter = SensibleFilter(success='info',
                               failure='debug',
                               exception='debug')
stderr_sink = SensibleSink(formatter=stderr_fmtr,
                           emitter=stderr_emtr,
                           filters=[stderr_filter])
script_log.add_sink(stderr_sink)

dds = DevDebugSink(post_mortem=bool(os.getenv('ENABLE_PDB')))
script_log.add_sink(dds)
示例#11
0
    begin=
    '{status_char}{iso_begin_notz} -   --   - {action_name} - {begin_message}')


def build_stream_sink(stream):
    emt = StreamEmitter(stream)
    file_filter = SensibleFilter(success='info',
                                 failure='debug',
                                 exception='debug')
    file_sink = SensibleSink(formatter=file_fmt,
                             emitter=emt,
                             filters=[file_filter])
    return file_sink


default_file_sink = build_stream_sink(open(LOG_PATH, 'a'))
tlog.add_sink(default_file_sink)

stderr_fmt = file_fmt
stderr_emt = StreamEmitter('stderr')
stderr_filter = SensibleFilter(success='critical',
                               failure='debug',
                               exception='debug')
stderr_sink = SensibleSink(formatter=stderr_fmt,
                           emitter=stderr_emt,
                           filters=[stderr_filter])


def enable_debug_log():
    tlog.add_sink(stderr_sink)