Python日志操作手册

classZeroMQSocketListener(QueueListener):
def__init__(self,uri,*handlers,**kwargs):
self.ctx=kwargs.get('ctx')orzmq.Context()
socket=zmq.Socket(self.ctx,zmq.SUB)
socket.setsockopt_string(zmq.SUBSCRIBE,'')# subscribe to everything
socket.connect(uri)
super().__init__(socket,*handlers,**kwargs)
defdequeue(self):
msg=self.queue.recv_json()
returnlogging.makeLogRecord(msg)

LOGGING={
'version':1,
'disable_existing_loggers':True,
'formatters':{
'verbose':{
'format':'%(levelname)s%(asctime)s%(module)s%(process)d%(thread)d%(message)s'
},
'simple':{
'format':'%(levelname)s%(message)s'
},
},
'filters':{
'special':{
'()':'project.logging.SpecialFilter',
'foo':'bar',
}
},
'handlers':{
'null':{
'level':'DEBUG',
'class':'django.utils.log.NullHandler',
},
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
'formatter':'simple'
},
'mail_admins':{
'level':'ERROR',
'class':'django.utils.log.AdminEmailHandler',
'filters':['special']
}
},
'loggers':{
'django':{
'handlers':['null'],
'propagate':True,
'level':'INFO',
},
'django.request':{
'handlers':['mail_admins'],
'level':'ERROR',
'propagate':False,
},
'myproject.custom':{
'handlers':['console','mail_admins'],
'level':'INFO',
'filters':['special']
}
}
}

defnamer(name):
returnname+".gz"
defrotator(source,dest):
withopen(source,"rb")assf:
data=sf.read()
compressed=zlib.compress(data,9)
withopen(dest,"wb")asdf:
df.write(compressed)
os.remove(source)
rh=logging.handlers.RotatingFileHandler(...)
rh.rotator=rotator
rh.namer=namer

importlogging
importlogging.config
importlogging.handlers
frommultiprocessingimportProcess,Queue,Event,current_process
importos
importrandom
importtime
classMyHandler:
"""
    A simple handler for logging events. It runs in the listener process and
    dispatches events to loggers based on the name in the received record,
    which then get dispatched, by the logging system, to the handlers
    configured for those loggers.
    """
defhandle(self,record):
logger=logging.getLogger(record.name)
# The process name is transformed just to show that it's the listener
# doing the logging to files and console
record.processName='%s (for %s)'%(current_process().name,record.processName)
logger.handle(record)
deflistener_process(q,stop_event,config):
"""
    This could be done in the main process, but is just done in a separate
    process for illustrative purposes.
    This initialises logging according to the specified configuration,
    starts the listener and waits for the main process to signal completion
    via the event. The listener is then stopped, and the process exits.
    """
logging.config.dictConfig(config)
listener=logging.handlers.QueueListener(q,MyHandler())
listener.start()
ifos.name=='posix':
# On POSIX, the setup logger will have been configured in the
# parent process, but should have been disabled following the
# dictConfig call.
# On Windows, since fork isn't used, the setup logger won't
# exist in the child, so it would be created and the message
# would appear - hence the "if posix" clause.
logger=logging.getLogger('setup')
logger.critical('Should not appear, because of disabled logger ...')
stop_event.wait()
listener.stop()
defworker_process(config):
"""
    A number of these are spawned for the purpose of illustration. In
    practice, they could be a heterogeneous bunch of processes rather than
    ones which are identical to each other.
    This initialises logging according to the specified configuration,
    and logs a hundred messages with random levels to randomly selected
    loggers.
    A small sleep is added to allow other processes a chance to run. This
    is not strictly needed, but it mixes the output from the different
    processes a bit more than if it's left out.
    """
logging.config.dictConfig(config)
levels=[logging.DEBUG,logging.INFO,logging.WARNING,logging.ERROR,
logging.CRITICAL]
loggers=['foo','foo.bar','foo.bar.baz',
'spam','spam.ham','spam.ham.eggs']
ifos.name=='posix':
# On POSIX, the setup logger will have been configured in the
# parent process, but should have been disabled following the
# dictConfig call.
# On Windows, since fork isn't used, the setup logger won't
# exist in the child, so it would be created and the message
# would appear - hence the "if posix" clause.
logger=logging.getLogger('setup')
logger.critical('Should not appear, because of disabled logger ...')
foriinrange(100):
lvl=random.choice(levels)
logger=logging.getLogger(random.choice(loggers))
logger.log(lvl,'Message no. %d',i)
time.sleep(0.01)
defmain():
q=Queue()
# The main process gets a simple configuration which prints to the console.
config_initial={
'version':1,
'formatters':{
'detailed':{
'class':'logging.Formatter',
'format':'%(asctime)s%(name)-15s%(levelname)-8s%(processName)-10s%(message)s'
}
},
'handlers':{
'console':{
'class':'logging.StreamHandler',
'level':'INFO',
},
},
'root':{
'level':'DEBUG',
'handlers':['console']
},
}
# The worker process configuration is just a QueueHandler attached to the
# root logger, which allows all messages to be sent to the queue.
# We disable existing loggers to disable the "setup" logger used in the
# parent process. This is needed on POSIX because the logger will
# be there in the child following a fork().
config_worker={
'version':1,
'disable_existing_loggers':True,
'handlers':{
'queue':{
'class':'logging.handlers.QueueHandler',
'queue':q,
},
},
'root':{
'level':'DEBUG',
'handlers':['queue']
},
}
# The listener process configuration shows that the full flexibility of
# logging configuration is available to dispatch events to handlers however
# you want.
# We disable existing loggers to disable the "setup" logger used in the
# parent process. This is needed on POSIX because the logger will
# be there in the child following a fork().
config_listener={
'version':1,
'disable_existing_loggers':True,
'formatters':{
'detailed':{
'class':'logging.Formatter',
'format':'%(asctime)s%(name)-15s%(levelname)-8s%(processName)-10s%(message)s'
},
'simple':{
'class':'logging.Formatter',
'format':'%(name)-15s%(levelname)-8s%(processName)-10s%(message)s'
}
},
'handlers':{
'console':{
'class':'logging.StreamHandler',
'level':'INFO',
'formatter':'simple',
},
'file':{
'class':'logging.FileHandler',
'filename':'mplog.log',
'mode':'w',
'formatter':'detailed',
},
'foofile':{
'class':'logging.FileHandler',
'filename':'mplog-foo.log',
'mode':'w',
'formatter':'detailed',
},
'errors':{
'class':'logging.FileHandler',
'filename':'mplog-errors.log',
'mode':'w',
'level':'ERROR',
'formatter':'detailed',
},
},
'loggers':{
'foo':{
'handlers':['foofile']
}
},
'root':{
'level':'DEBUG',
'handlers':['console','file','errors']
},
}
# Log some initial events, just to show that logging in the parent works
# normally.
logging.config.dictConfig(config_initial)
logger=logging.getLogger('setup')
logger.info('About to create workers ...')
workers=[]
foriinrange(5):
wp=Process(target=worker_process,name='worker %d'%(i+1),
args=(config_worker,))
workers.append(wp)
wp.start()
logger.info('Started worker: %s',wp.name)
logger.info('About to create listener ...')
stop_event=Event()
lp=Process(target=listener_process,name='listener',
args=(q,stop_event,config_listener))
lp.start()
logger.info('Started listener')
# We now hang around for the workers to finish their work.
forwpinworkers:
wp.join()
# Workers all done, listening can now stop.
# Logging in the parent still works normally.
logger.info('Telling listener to stop ...')
stop_event.set()
lp.join()
logger.info('All done.')
if__name__=='__main__':
main()

importjson
importlogging
classStructuredMessage(object):
def__init__(self,message,**kwargs):
self.message=message
self.kwargs=kwargs
def__str__(self):
return'%s >>> %s'%(self.message,json.dumps(self.kwargs))
_=StructuredMessage# optional, to improve readability
logging.basicConfig(level=logging.INFO,format='%(message)s')
logging.info(_('message 1',foo='bar',bar='baz',num=123,fnum=123.456))

message 1 >>> {"fnum": 123.456, "num": 123, "bar": "baz", "foo": "bar"}

from__future__importunicode_literals
importjson
importlogging
# This next bit is to ensure the script runs unchanged on 2.x and 3.x
try:
unicode
exceptNameError:
unicode=str
classEncoder(json.JSONEncoder):
defdefault(self,o):
ifisinstance(o,set):
returntuple(o)
elifisinstance(o,unicode):
returno.encode('unicode_escape').decode('ascii')
returnsuper(Encoder,self).default(o)
classStructuredMessage(object):
def__init__(self,message,**kwargs):
self.message=message
self.kwargs=kwargs
def__str__(self):
s=Encoder().encode(self.kwargs)
return'%s >>> %s'%(self.message,s)
_=StructuredMessage# optional, to improve readability
defmain():
logging.basicConfig(level=logging.INFO,format='%(message)s')
logging.info(_('message 1',set_value={1,2,3},snowman='\u2603'))
if__name__=='__main__':
main()

message 1 >>> {"snowman": "\u2603", "set_value": [1, 2, 3]}

defowned_file_handler(filename,mode='a',encoding=None,owner=None):
ifowner:
ifnotos.path.exists(filename):
open(filename,'a').close()
shutil.chown(filename,*owner)
returnlogging.FileHandler(filename,mode,encoding)

LOGGING={
'version':1,
'disable_existing_loggers':False,
'formatters':{
'default':{
'format':'%(asctime)s%(levelname)s%(name)s%(message)s'
},
},
'handlers':{
'file':{
# The values below are popped from this dictionary and
# used to create the handler, set the handler's level and
# its formatter.
'()':owned_file_handler,
'level':'DEBUG',
'formatter':'default',
# The values below are passed to the handler creator callable
# as keyword arguments.
'owner':['pulse','pulse'],
'filename':'chowntest.log',
'mode':'w',
'encoding':'utf-8',
},
},
'root':{
'handlers':['file'],
'level':'DEBUG',
},
}

importlogging,logging.config,os,shutil
defowned_file_handler(filename,mode='a',encoding=None,owner=None):
ifowner:
ifnotos.path.exists(filename):
open(filename,'a').close()
shutil.chown(filename,*owner)
returnlogging.FileHandler(filename,mode,encoding)
LOGGING={
'version':1,
'disable_existing_loggers':False,
'formatters':{
'default':{
'format':'%(asctime)s%(levelname)s%(name)s%(message)s'
},
},
'handlers':{
'file':{
# The values below are popped from this dictionary and
# used to create the handler, set the handler's level and
# its formatter.
'()':owned_file_handler,
'level':'DEBUG',
'formatter':'default',
# The values below are passed to the handler creator callable
# as keyword arguments.
'owner':['pulse','pulse'],
'filename':'chowntest.log',
'mode':'w',
'encoding':'utf-8',
},
},
'root':{
'handlers':['file'],
'level':'DEBUG',
},
}
logging.config.dictConfig(LOGGING)
logger=logging.getLogger('mylogger')
logger.debug('A debug message')

$ sudo python3.3 chowntest.py
$ cat chowntest.log
2013-11-05 09:34:51,128 DEBUG mylogger A debug message
$ ls -l chowntest.log
-rw-r--r-- 1 pulse pulse 55 2013-11-05 09:34 chowntest.log

'()':owned_file_handler,

'()':'ext://project.util.owned_file_handler',

classBraceMessage(object):
def__init__(self,fmt,*args,**kwargs):
self.fmt=fmt
self.args=args
self.kwargs=kwargs
def__str__(self):
returnself.fmt.format(*self.args,**self.kwargs)
classDollarMessage(object):
def__init__(self,fmt,**kwargs):
self.fmt=fmt
self.kwargs=kwargs
def__str__(self):
fromstringimportTemplate
returnTemplate(self.fmt).substitute(**self.kwargs)

>>> __=BraceMessage
>>> print(__('Message with {0}{1}',2,'placeholders'))
Message with 2 placeholders
>>> classPoint:pass
...
>>> p=Point()
>>> p.x=0.5
>>> p.y=0.5
>>> print(__('Message with coordinates: ({point.x:.2f}, {point.y:.2f})',point=p))
Message with coordinates: (0.50, 0.50)

>>> __=DollarMessage
>>> print(__('Message with $num $what',num=2,what='placeholders'))
Message with 2 placeholders
>>>

importlogging
importlogging.config
importsys
classMyFilter(logging.Filter):
def__init__(self,param=None):
self.param=param
deffilter(self,record):
ifself.paramisNone:
allow=True
else:
allow=self.paramnotinrecord.msg
ifallow:
record.msg='changed: '+record.msg
returnallow
LOGGING={
'version':1,
'filters':{
'myfilter':{
'()':MyFilter,
'param':'noshow',
}
},
'handlers':{
'console':{
'class':'logging.StreamHandler',
'filters':['myfilter']
}
},
'root':{
'level':'DEBUG',
'handlers':['console']
},
}
if__name__=='__main__':
logging.config.dictConfig(LOGGING)
logging.debug('hello')
logging.debug('hello - noshow')