一个python的网络日志系统

服务器端的代码就是在python的官方文档上摘的，只是将日志的配置方式改为从文件读取。
服务器端LogServer.py代码

1. #coding:utf-8
2. import cPickle
3. import logging
4. import logging.handlers
5. import SocketServer
6. import struct
7. import logging.config
10. class LogRecordStreamHandler(SocketServer.StreamRequestHandler):
11.     """Handler for a streaming logging request.
13.     This basically logs the record using whatever logging policy is
14.     configured locally.
15.     """
17.     def handle(self):
18.         """
19.         Handle multiple requests - each expected to be a 4-byte length,
20.         followed by the LogRecord in pickle format. Logs the record
21.         according to whatever policy is configured locally.
22.         """
23.         while 1:
24.             chunk = self.connection.recv(4)
25.             if len(chunk) < 4:
26.                 break
27.             slen = struct.unpack(">L", chunk)[0]
28.             chunk = self.connection.recv(slen)
29.             while len(chunk) < slen:
30.                 chunk = chunk + self.connection.recv(slen - len(chunk))
31.             obj = self.unPickle(chunk)
32.             record = logging.makeLogRecord(obj)
33.             self.handleLogRecord(record)
35.     def unPickle(self, data):
36.         return cPickle.loads(data)
38.     def handleLogRecord(self, record):
39.         # if a name is specified, we use the named logger rather than the one
40.         # implied by the record.
41.         if self.server.logname is not None:
42.             name = self.server.logname
43.         else:
44.             name = record.name
45.         logger = logging.getLogger(name)
46.         # N.B. EVERY record gets logged. This is because Logger.handle
47.         # is normally called AFTER logger-level filtering. If you want
48.         # to do filtering, do it at the client end to save wasting
49.         # cycles and network bandwidth!
50.         logger.handle(record)
52. class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
53.     """simple TCP socket-based logging receiver suitable for testing.
54.     """
56.     allow_reuse_address = 1
58.     def __init__(self, host='localhost',
59.                  port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
60.                  handler=LogRecordStreamHandler):
61.         SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
62.         self.abort = 0
63.         self.timeout = 1
64.         self.logname = None
66.     def serve_until_stopped(self):
67.         import select
68.         abort = 0
69.         while not abort:
70.             rd, wr, ex = select.select([self.socket.fileno()],
71.                                        [], [],
72.                                        self.timeout)
73.             if rd:
74.                 self.handle_request()
75.             abort = self.abort
77. def main():
78.     logging.config.fileConfig('log.conf')    #通过配置文件来读取日志的配置
79.     tcpserver = LogRecordSocketReceiver()
80.     print "About to start TCP server..."
81.     tcpserver.serve_until_stopped()
83. if __name__ == "__main__":
84.     main()

客户端LogClient.py直接根据传过来的日志名来生成日志

1. #coding:utf-8
2. import logging, logging.handlers
4. def getLogger( loggerName ):
5.     logger = logging.getLogger( loggerName )
6.     logger.setLevel(logging.DEBUG)
7.     socketHandler = logging.handlers.SocketHandler('localhost',/
8.                     logging.handlers.DEFAULT_TCP_LOGGING_PORT)
9.     logger.addHandler(socketHandler)
10.     return logger
11.     
12. def setLevel( loggerName,level ):
13.     logger = logging.getLogger( "loggerName" )
14.     logger.setLevel( level )

下面是对python客户端的进一步封装，这样就更加方便对日志的使用
LogFunc.py

1. #coding:utf-8
2. import LogClient
4. logger = LogClient.getLogger("pgt")
6. def LogDebug(msg):
7.     logger.debug(msg)
8.     
9. def LogInfo(msg):
10.     logger.info(msg)
11.     
12. def LogWarn(msg):
13.     logger.warn(msg)
14.     
15. def LogError(msg):
16.     logger.error(msg)
17.     
18. def LogFatal(msg):
19.     logger.fatal(msg)

整个日志系统，服务器端的.py文件通过循环不断的接收和处理来自客户端的请求。
客户端通过一个SocketHandler与服务器端通讯。整个系统中服务器端和客户端可以部署在不同的机器上，记录的日志放在服务器端（可在服务器上的配置文件中指定日志文件存放的路径）。
LogFunc.py文件是客户端的进一步封装。方便了整个日志系统的使用。这样只要在要写的python文件中import了LogFunc，然后调用相关的LogInfo等函数就可以记录日志了。