#生成并發(fā)送日志
import logging
from logging.handlers import HTTPHandler
import logging.config

def save():
  logger = logging.getLogger(__name__)
  # 生成一個log實例，如果括號為空則返回root logger
  hh = HTTPHandler(host='127.0.0.1:5000', url='/log', method='POST')
  #用HTTPHandler直接發(fā)送日志，而并不是寫文件再傳文件。
  logger.setLevel(logging.INFO)
  #設置日志最低輸出級別為info
  logger.addHandler(hh)
  #添加Handler對象給記錄器（為logger添加的日志處理器，可以自定義日志處理器讓其輸出到其他地方）
  logger.info('存入600元') # 輸出日志，內(nèi)容為‘存入600元'
save()

#flask接收日志
from flask import Flask,request
app = Flask(__name__)



@app.route('/log',methods=['POST'])
def say_hello():
  #查看傳過來的數(shù)據(jù)格式：
  print(request.mimetype)
  #HTTPHandler傳過來的是個form表單
  print(request.form.to_dict())
  return '<h1>Hello, Flask!</h1>'


if __name__ == '__main__':
  app.run()


輸出：
#這是傳過來的數(shù)據(jù)格式，是個form表單
application/x-www-form-urlencoded 

#這是form.to_dict解析出來的內(nèi)容（直接解析成了字典）
{'name': '__main__', 'msg': '存入600元', 'args': '()', 'levelname': 'INFO', 'levelno': '20', 'pathname': 'C:/Users/huawei/Desktop/code/log/send_log.py', 
'filename': 'send_log.py', 'module': 'send_log', 'exc_info': 'None', 'exc_text': 'None', 'stack_info': 'None', 'lineno': '15', 
'funcName': 'save', 'created': '1593581146.172768', 'msecs': '172.76811599731445', 'relativeCreated': '176.5270233154297',
 'thread': '13904', 'threadName': 'MainThread', 'processName': 'MainProcess', 'process': '3656'}

import logging
logging.basicConfig(level=logging.DEBUG,
  format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
  datefmt='%a, %d %b %Y %H:%M:%S',
  filename='myapp.log',
  filemode='w')
#################################################################################################
#定義一個StreamHandler，將INFO級別或更高的日志信息打印到標準錯誤，并將其添加到當前的日志處理對象#
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
#################################################################################################
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
 
屏幕上打印:
root : INFO This is info message
root : WARNING This is warning message
./myapp.log文件中內(nèi)容為:
Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message
Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message
Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

import logging
import sys
# 獲取logger實例，如果參數(shù)為空則返回root logger
logger = logging.getLogger("AppName")
# 指定logger輸出格式
formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s')
# 文件日志
file_handler = logging.FileHandler("test.log")
file_handler.setFormatter(formatter) # 可以通過setFormatter指定輸出格式
# 控制臺日志
console_handler = logging.StreamHandler(sys.stdout)
console_handler.formatter = formatter # 也可以直接給formatter賦值
# 為logger添加的日志處理器，可以自定義日志處理器讓其輸出到其他地方
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# 指定日志的最低輸出級別，默認為WARN級別
logger.setLevel(logging.INFO)
# 輸出不同級別的log
logger.debug('this is debug info')
logger.info('this is information')
logger.warn('this is warning message')
logger.error('this is error message')
logger.fatal('this is fatal message, it is same as logger.critical')
logger.critical('this is critical message')
# 2016-10-08 21:59:19,493 INFO : this is information
# 2016-10-08 21:59:19,493 WARNING : this is warning message
# 2016-10-08 21:59:19,493 ERROR : this is error message
# 2016-10-08 21:59:19,493 CRITICAL: this is fatal message, it is same as logger.critical
# 2016-10-08 21:59:19,493 CRITICAL: this is critical message
# 移除一些日志處理器
logger.removeHandler(file_handler)

logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)
info(log_message, [*args[, **kwargs]])

logger.info("Houston, we have a %s", "interesting problem", exc_info=1)
warning(log_message, [*args[, **kwargs]])

logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)
error(log_message, [*args[, **kwargs]])

logger.error("Houston, we have a %s", "major problem", exc_info=1)
critical(log_message, [*args[, **kwargs]])

logger.critical("Houston, we have a %s", "major disaster", exc_info=1)
exception(message[, *args]) 
self.error(*((msg,) + args), **{'exc_info': 1})
log(log_level, log_message, [*args[, **kwargs]])

logger.log(level, "We have a %s", "mysterious problem", exc_info=1)
logging.getLogger([name])

class Handler(Filterer): 
 def emit(self, record):
 """
 Do whatever it takes to actually log the specified logging record.
 This version is intended to be implemented by subclasses and so
 raises a NotImplementedError.
 """
 raise NotImplementedError, 'emit must be implemented '\
     'by Handler subclasses'
 def flush(self):
 """
 Ensure all logging output has been flushed.
 This version does nothing and is intended to be implemented by
 subclasses.
 """
 pass
 def close(self):
 """ 
 Tidy up any resources used by the handler.
 This version does removes the handler from an internal list
 of handlers which is closed when shutdown() is called. Subclasses
 should ensure that this gets called from overridden close()
 methods.
 """
 #get the module data lock, as we're updating a shared structure.
 _acquireLock()
 try: #unlikely to raise an exception, but you never know...
  if self in _handlers:
  del _handlers[self]
  if self in _handlerList:
  _handlerList.remove(self)
 finally:
  _releaseLock()

class StreamHandler(Handler): 
 def __init__(self, strm=None):
 Handler.__init__(self)
 if strm is None:
  strm = sys.stderr
 self.stream = strm
 def flush(self):
 if self.stream and hasattr(self.stream, "flush"):
  self.stream.flush()
 def emit(self, record):
 try:
  msg = self.format(record)
  stream = self.stream
  fs = "%s\n"
  if not hasattr(types, "UnicodeType"): #if no unicode support...
  stream.write(fs % msg)
  else:
  try:
   if (isinstance(msg, unicode) and
   getattr(stream, 'encoding', None)):
   fs = fs.decode(stream.encoding)
   try:
    stream.write(fs % msg)
   except UnicodeEncodeError:
    #Printing to terminals sometimes fails. For example,
    #with an encoding of 'cp1251', the above write will
    #work if written to a stream opened or wrapped by
    #the codecs module, but fail when writing to a
    #terminal even when the codepage is set to cp1251.
    #An extra encoding step seems to be needed.
    stream.write((fs % msg).encode(stream.encoding))
   else:
   stream.write(fs % msg)
  except UnicodeError:
   stream.write(fs % msg.encode("UTF-8"))
  self.flush()
 except (KeyboardInterrupt, SystemExit):
  raise
 except:
  self.handleError(record)

import logging 
import sys 
logger = logging.getLogger(__name__) 
filter = logging.Filter(__name__) 
formatter = logging.Formatter("%(asctime)s|%(name)-12s|%(message)s", "%F %T")
stream_handler = logging.StreamHandler(sys.stdout) 
stream_handler.addFilter(filter) 
stream_handler.setLevel(logging.DEBUG) 
stream_handler.setFormatter(formatter)
logger.setLevel(logging.DEBUG) 
logger.addFilter(filter) 
logger.addHandler(stream_handler)
if __name__ == "__main__": 
 logger.info("info")

運行這個腳本，輸出結(jié)果是:

2015-12-16 13:52:17|__main__ |info

import logging 
import logging.config
logging.config.fileConfig("logging.conf")
if __name__ == "__main__": 
 logger = logging.getLogger("test_logging.sublogger")
 logger.info("info")

[loggers]
keys = root,logger
[handlers]
keys = stream_handler
[formatters]
keys = formatter
[logger_root]
handlers = stream_handler
[logger_logger]
handlers = stream_handler 
level = DEBUG 
propagate = 1 
qualname = test_logging
[handler_stream_handler]
class = StreamHandler 
args = (sys.stdout,) 
formatter = formatter 
level = DEBUG
[formatter_formatter]
format = %(asctime)s|%(name)-12s|%(message)s 
datefmt = %F %T

import logging.config 
import logging 
import time
logging.config.fileConfig("logging.conf") 
logger = logging.getLogger("test_logging.listen")
t = logging.config.listen(9999) 
t.setDaemon(True) 
t.start()
try: 
 while True:
 logger.info('running.')
 time.sleep(3)
except (KeyboardInterrupt, SystemExit, Exception): 
 logging.config.stopListening()

import socket 
import struct
HOST = 'localhost' 
PORT = 9999 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.connect((HOST, PORT)) 
print "connected..." 
data_to_send = open("logging.conf").read() 
s.send(struct.pack(">L", len(data_to_send))) 
s.send(data_to_send) 
print "closing..." 
s.close()