文档章节

logconfig.py

kuerant
 kuerant
发布于 2013/03/06 16:59
字数 751
阅读 102
收藏 0
点赞 0
评论 0

实现 python logging client & server的配置,借鉴了 tornadoweb的日志配置模块。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#

__VERSION__='0.1.0'


import datetime
import logging
import logging.handlers
import re
import sys
import time

import pickle
import SocketServer
import struct


# For pretty log messages, if available
try:
    import curses
except:
    curses = None


# max size of log files before rollover
LOG_FILE_MAX_SIZE = 128 * 1024 * 1024

# number of log files to keep
LOG_FILE_NUM_BACKUPS = 10


def configure( level='info', file_prefix=None, file_max_size=0, file_num_backups=0, servers='' ) :
    """Turns on formatted logging output as configured."""

    root_logger = logging.getLogger()

    if not level :
        level = 'info'
    root_logger.setLevel(getattr(logging, level.upper()))

    if file_prefix:
        if not file_max_size :
            file_max_size = LOG_FILE_MAX_SIZE
        if not file_num_backups :
            file_num_backups = LOG_FILE_NUM_BACKUPS

        channel = logging.handlers.RotatingFileHandler(
                        filename = file_prefix,
                        maxBytes = file_max_size,
                        backupCount = file_num_backups )
        channel.setFormatter( _LogFormatter(color=False) )
        root_logger.addHandler( channel )

    elif not root_logger.handlers :
        # Set up color if we are in a tty and curses is installed
        color = False
        if curses and sys.stderr.isatty():
            try:
                curses.setupterm()
                if curses.tigetnum("colors") > 0:
                    color = True
            except:
                pass
        channel = logging.StreamHandler()
        channel.setFormatter(_LogFormatter(color=color))
        root_logger.addHandler(channel)

    #host = '127.0.0.1'
    #port = logging.handlers.DEFAULT_TCP_LOGGING_PORT
    ## servers FORMAT : SERVER1:PORT1,SERVER2:PORT2,SERVER3:PORT3
    if servers :
        server_list = [ x.strip() for x in servers.split(',') ]
        for server in server_list :
            host,port = server.split(':')
            socketHandler = logging.handlers.SocketHandler(host, int(port))
            root_logger.addHandler(socketHandler)

    #### configure()



class _LogFormatter(logging.Formatter):

    def __init__(self, color, *args, **kwargs):
        logging.Formatter.__init__(self, *args, **kwargs)
        self._color = color
        if color:
            fg_color = curses.tigetstr("setaf") or curses.tigetstr("setf") or ""
            self._colors = {
                logging.DEBUG: curses.tparm(fg_color, 4), # Blue
                logging.INFO: curses.tparm(fg_color, 2), # Green
                logging.WARNING: curses.tparm(fg_color, 3), # Yellow
                logging.ERROR: curses.tparm(fg_color, 1), # Red
            }
            self._normal = curses.tigetstr("sgr0")

    def format(self, record):
        try:
            record.message = record.getMessage()
        except Exception, e:
            record.message = "Bad message (%r): %r" % (e, record.__dict__)
        record.asctime = time.strftime(
            "%Y-%m-%d %H:%M:%S", self.converter(record.created))
        prefix = '%(asctime)s %(levelname)1.1s %(name)s %(process)d %(module)s:%(lineno)d' % \
            record.__dict__
        if self._color:
            prefix = (self._colors.get(record.levelno, self._normal) +
                      prefix + self._normal)
        formatted = prefix + " " + record.message
        if record.exc_info:
            if not record.exc_text:
                record.exc_text = self.formatException(record.exc_info)
        if record.exc_text:
            formatted = formatted.rstrip() + "\n" + record.exc_text
        return formatted.replace("\n", "\n    ")


    #### _LogFormatter


########----------------        ########        ----------------########


class LogRecordStreamHandler(SocketServer.StreamRequestHandler):
    """Handler for a streaming logging request.

    This basically logs the record using whatever logging policy is
    configured locally.
    """

    def handle(self):
        """
        Handle multiple requests - each expected to be a 4-byte length,
        followed by the LogRecord in pickle format. Logs the record
        according to whatever policy is configured locally.
        """
        while True:
            chunk = self.connection.recv(4)
            if len(chunk) < 4:
                break
            slen = struct.unpack('>L', chunk)[0]
            chunk = self.connection.recv(slen)
            while len(chunk) < slen:
                chunk = chunk + self.connection.recv(slen - len(chunk))
            obj = self.unPickle(chunk)
            record = logging.makeLogRecord(obj)
            self.handleLogRecord(record)

    def unPickle(self, data):
        return pickle.loads(data)

    def handleLogRecord(self, record):
        # if a name is specified, we use the named logger rather than the one
        # implied by the record.
        if self.server.logname is not None:
            name = self.server.logname
        else:
            name = record.name
        logger = logging.getLogger(name)
        # N.B. EVERY record gets logged. This is because Logger.handle
        # is normally called AFTER logger-level filtering. If you want
        # to do filtering, do it at the client end to save wasting
        # cycles and network bandwidth!
        logger.handle(record)

class LogServer(SocketServer.ThreadingTCPServer):
    """
    Simple TCP socket-based logging receiver suitable for testing.
    """

    allow_reuse_address = 1

    def __init__(self, host='0.0.0.0',
                 port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
                 handler=LogRecordStreamHandler,
                 level='info', file_prefix=None, file_max_size=0, file_num_backups=0 ):
        SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
        self.abort = 0
        self.timeout = 1
        self.logname = None

        configure( level, file_prefix, file_max_size, file_num_backups )
        #### __init__()


    def serve_until_stopped(self):
        import select
        abort = 0
        while not abort:
            rd, wr, ex = select.select([self.socket.fileno()],
                                       [], [],
                                       self.timeout)
            if rd:
                self.handle_request()
            abort = self.abort

        #### serve_until_stopped()            

    #### class LogServer

#def main():
#    s = LogServer()
#    #print('start LOG server...')
#    s.serve_until_stopped()
def test3() :
    configure(level='debug', file_prefix='test.log')

    logger = logging.getLogger()
    logger.fatal(">>>FATAL<<< %s", 'Hello, World.')
    logger.error(">>>ERROR<<< %s", 'Hello, World.')
    logger.warn(">>> WARN<<< %s", 'Hello, World.')
    logger.info(">>> INFO<<< %s", 'Hello, World.')
    logger.debug(">>>DEBUG<<< %s", 'Hello, World.')

    logger = logging.getLogger('test3')
    logger.fatal(">>>FATAL<<< %s", 'Hello, World.')
    logger.error(">>>ERROR<<< %s", 'Hello, World.')
    logger.warn(">>> WARN<<< %s", 'Hello, World.')
    logger.info(">>> INFO<<< %s", 'Hello, World.')
    logger.debug(">>>DEBUG<<< %s", 'Hello, World.')

    #### test3()

 

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
#

import sys, os, os.path, time
import signal

from tbox import logconfig


HOST = '0.0.0.0'
PORT = 9020

LOG_PREFIX = '/home/s/logs/pylogd/9020.log'
LOG_SIZE   = 512 * 1024 * 1024
LOG_BACKUP = 2000
log_server = None

def signal_handler(sig, flags) :
    global  log_server
    
    if log_server : log_server.shutdown()
    #### signal_handler()
 

if __name__ == '__main__' :
    signal.signal( signal.SIGINT, signal_handler )
    signal.signal( signal.SIGQUIT, signal_handler )
    signal.signal( signal.SIGTERM, signal_handler )
    log_server = logconfig.LogServer( host=HOST, port=PORT, file_prefix=LOG_PREFIX, file_max_size=LOG_SIZE, file_num_backups=LOG_BACKUP )
    #s.serve_until_stopped()
    log_server.serve_forever()

logging setting code

# Logging, obviously
logger = logging.getLogger('nsq')
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(filename)s@%(lineno)d: %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)

© 著作权归作者所有

共有 人打赏支持
kuerant
粉丝 9
博文 54
码字总数 12892
作品 0
通州

暂无文章

20位活跃在Github上的国内技术大牛 leij 何小鹏 亚信

本文列举了20位在Github上非常活跃的国内大牛,看看其中是不是很多熟悉的面孔? 1. lifesinger(玉伯) Github主页: https://github.com/lifesinger 微博:@ 玉伯也叫射雕 玉伯(王保平),...

海博1600
3分钟前
0
0
高性能服务器本质论

一 服务器分类 从软件性能角度,高性能服务器分:cpu密集型服务器/IO密集型服务器 (1)CPU密集型:该类服务器没有对io的访问/没有同步点,性能瓶颈在于对cpu的充分利用。 典型的如转发服务器/...

码代码的小司机
4分钟前
0
0
Mybatis收集配置

一、Mybatis取Clob数据 1、Mapper.xml配置 <resultMap type="com.test.User" id="user"> <result column="id" property="id"/> <result column="json_data" property="jsonData" ......

星痕2018
30分钟前
0
0
centos7设置以多用户模式启动

1、旧版本linux系统修改inittab文件,在新版本执行vi /etc/inittab 会有以下提示 # inittab is no longer used when using systemd. # # ADDING CONFIGURATION HERE WILL HAVE NO EFFECT ON......

haha360
今天
0
0
OSChina 周日乱弹 —— 局长:怕你不爱我

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @ andonny :分享周二珂的单曲《孤独她呀》 《孤独她呀》- 周二珂 手机党少年们想听歌,请使劲儿戳(这里) @孤星闵月 :没事干,看一遍红楼梦...

小小编辑
今天
158
9
Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式 Factory工厂模式 Singleton单例模式 Delegate委派模式 Strategy策略模式 Prototype原型模式 Template模板模式 Spring5 beans 接口实例化 代理Bean操作 ...

小致dad
今天
0
0
SpringBoot | 第十章:Swagger2的集成和使用

前言 前一章节介绍了mybatisPlus的集成和简单使用,本章节开始接着上一章节的用户表,进行Swagger2的集成。现在都奉行前后端分离开发和微服务大行其道,分微服务及前后端分离后,前后端开发的...

oKong
今天
10
0
Python 最小二乘法 拟合 二次曲线

Python 二次拟合 随机生成数据,并且加上噪声干扰 构造需要拟合的函数形式,使用最小二乘法进行拟合 输出拟合后的参数 将拟合后的函数与原始数据绘图后进行对比 import numpy as npimport...

阿豪boy
今天
17
0
云拿 无人便利店

附近(上海市-航南路)开了家无人便利店.特意进去体验了一下.下面把自己看到的跟大家分享下. 经得现场工作人员同意后拍了几张照片.从外面看是这样.店门口的指导里强调:不要一次扫码多个人进入....

周翔
昨天
1
0
Java设计模式学习之工厂模式

在Java(或者叫做面向对象语言)的世界中,工厂模式被广泛应用于项目中,也许你并没有听说过,不过也许你已经在使用了。 简单来说,工厂模式的出现源于增加程序序的可扩展性,降低耦合度。之...

路小磊
昨天
248
1

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部