importloggingimportauxiliary_module# create logger with 'spam_application'logger=logging.getLogger('spam_application')logger.setLevel(logging.DEBUG)# create file handler which logs even debug messagesfh=logging.FileHandler('spam.log')fh.setLevel(logging.DEBUG)# create console handler with a higher log levelch=logging.StreamHandler()ch.setLevel(logging.ERROR)# create formatter and add it to the handlersformatter=logging.Formatter('%(asctime)s -%(name)s -%(levelname)s -%(message)s')fh.setFormatter(formatter)ch.setFormatter(formatter)# add the handlers to the loggerlogger.addHandler(fh)logger.addHandler(ch)logger.info('creating an instance of auxiliary_module.Auxiliary')a=auxiliary_module.Auxiliary()logger.info('created an instance of auxiliary_module.Auxiliary')logger.info('calling auxiliary_module.Auxiliary.do_something')a.do_something()logger.info('finished auxiliary_module.Auxiliary.do_something')logger.info('calling auxiliary_module.some_function()')auxiliary_module.some_function()logger.info('done with auxiliary_module.some_function()')

importlogging# create loggermodule_logger=logging.getLogger('spam_application.auxiliary')classAuxiliary:def__init__(self):self.logger=logging.getLogger('spam_application.auxiliary.Auxiliary')self.logger.info('creating an instance of Auxiliary')defdo_something(self):self.logger.info('doing something')a=1+1self.logger.info('done doing something')defsome_function():module_logger.info('received a call to "some_function"')

2005-03-23 23:47:11,663 - spam_application - INFO -   creating an instance of auxiliary_module.Auxiliary2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -   creating an instance of Auxiliary2005-03-23 23:47:11,665 - spam_application - INFO -   created an instance of auxiliary_module.Auxiliary2005-03-23 23:47:11,668 - spam_application - INFO -   calling auxiliary_module.Auxiliary.do_something2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -   doing something2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -   done doing something2005-03-23 23:47:11,670 - spam_application - INFO -   finished auxiliary_module.Auxiliary.do_something2005-03-23 23:47:11,671 - spam_application - INFO -   calling auxiliary_module.some_function()2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -   received a call to 'some_function'2005-03-23 23:47:11,673 - spam_application - INFO -   done with auxiliary_module.some_function()

importloggingimportthreadingimporttimedefworker(arg):whilenotarg['stop']:logging.debug('Hi from myfunc')time.sleep(0.5)defmain():logging.basicConfig(level=logging.DEBUG,format='%(relativeCreated)6d%(threadName)s%(message)s')info={'stop':False}thread=threading.Thread(target=worker,args=(info,))thread.start()whileTrue:try:logging.debug('Hello from main')time.sleep(0.75)exceptKeyboardInterrupt:info['stop']=Truebreakthread.join()if__name__=='__main__':main()

   0 Thread-1 Hi from myfunc   3 MainThread Hello from main 505 Thread-1 Hi from myfunc 755 MainThread Hello from main1007 Thread-1 Hi from myfunc1507 MainThread Hello from main1508 Thread-1 Hi from myfunc2010 Thread-1 Hi from myfunc2258 MainThread Hello from main2512 Thread-1 Hi from myfunc3009 MainThread Hello from main3013 Thread-1 Hi from myfunc3515 Thread-1 Hi from myfunc3761 MainThread Hello from main4017 Thread-1 Hi from myfunc4513 MainThread Hello from main4518 Thread-1 Hi from myfunc

importlogginglogger=logging.getLogger('simple_example')logger.setLevel(logging.DEBUG)# create file handler which logs even debug messagesfh=logging.FileHandler('spam.log')fh.setLevel(logging.DEBUG)# create console handler with a higher log levelch=logging.StreamHandler()ch.setLevel(logging.ERROR)# create formatter and add it to the handlersformatter=logging.Formatter('%(asctime)s -%(name)s -%(levelname)s -%(message)s')ch.setFormatter(formatter)fh.setFormatter(formatter)# add the handlers to loggerlogger.addHandler(ch)logger.addHandler(fh)# 'application' codelogger.debug('debug message')logger.info('info message')logger.warning('warn message')logger.error('error message')logger.critical('critical message')

importlogging# set up logging to file - see previous section for more detailslogging.basicConfig(level=logging.DEBUG,format='%(asctime)s%(name)-12s%(levelname)-8s%(message)s',datefmt='%m-%d %H:%M',filename='/tmp/myapp.log',filemode='w')# define a Handler which writes INFO messages or higher to the sys.stderrconsole=logging.StreamHandler()console.setLevel(logging.INFO)# set a format which is simpler for console useformatter=logging.Formatter('%(name)-12s:%(levelname)-8s%(message)s')# tell the handler to use this formatconsole.setFormatter(formatter)# add the handler to the root loggerlogging.getLogger('').addHandler(console)# Now, we can log to the root logger, or any other logger. First the root...logging.info('Jackdaws love my big sphinx of quartz.')# Now, define a couple of other loggers which might represent areas in your# application:logger1=logging.getLogger('myapp.area1')logger2=logging.getLogger('myapp.area2')logger1.debug('Quick zephyrs blow, vexing daft Jim.')logger1.info('How quickly daft jumping zebras vex.')logger2.warning('Jail zesty vixen who grabbed pay from quack.')logger2.error('The five boxing wizards jump quickly.')

root        : INFO     Jackdaws love my big sphinx of quartz.myapp.area1 : INFO     How quickly daft jumping zebras vex.myapp.area2 : WARNING  Jail zesty vixen who grabbed pay from quack.myapp.area2 : ERROR    The five boxing wizards jump quickly.

10-22 22:19 root         INFO     Jackdaws love my big sphinx of quartz.10-22 22:19 myapp.area1  DEBUG    Quick zephyrs blow, vexing daft Jim.10-22 22:19 myapp.area1  INFO     How quickly daft jumping zebras vex.10-22 22:19 myapp.area2  WARNING  Jail zesty vixen who grabbed pay from quack.10-22 22:19 myapp.area2  ERROR    The five boxing wizards jump quickly.

{"version":1,"disable_existing_loggers":false,"formatters":{"simple":{"format":"%(levelname)-8s - %(message)s"}},"handlers":{"stdout":{"class":"logging.StreamHandler","level":"INFO","formatter":"simple","stream":"ext://sys.stdout"},"stderr":{"class":"logging.StreamHandler","level":"ERROR","formatter":"simple","stream":"ext://sys.stderr"},"file":{"class":"logging.FileHandler","formatter":"simple","filename":"app.log","mode":"w"}},"root":{"level":"DEBUG","handlers":["stderr","stdout","file"]}}

{"filters":{"warnings_and_below":{"()":"__main__.filter_maker","level":"WARNING"}}}

{"stdout":{"class":"logging.StreamHandler","level":"INFO","formatter":"simple","stream":"ext://sys.stdout","filters":["warnings_and_below"]}}

deffilter_maker(level):level=getattr(logging,level)deffilter(record):returnrecord.levelno<=levelreturnfilter

importjsonimportloggingimportlogging.configCONFIG='''{    "version": 1,    "disable_existing_loggers": false,    "formatters": {        "simple": {            "format": "%(levelname)-8s -%(message)s"        }    },    "filters": {        "warnings_and_below": {            "()" : "__main__.filter_maker",            "level": "WARNING"        }    },    "handlers": {        "stdout": {            "class": "logging.StreamHandler",            "level": "INFO",            "formatter": "simple",            "stream": "ext://sys.stdout",            "filters": ["warnings_and_below"]        },        "stderr": {            "class": "logging.StreamHandler",            "level": "ERROR",            "formatter": "simple",            "stream": "ext://sys.stderr"        },        "file": {            "class": "logging.FileHandler",            "formatter": "simple",            "filename": "app.log",            "mode": "w"        }    },    "root": {        "level": "DEBUG",        "handlers": [            "stderr",            "stdout",            "file"        ]    }}'''deffilter_maker(level):level=getattr(logging,level)deffilter(record):returnrecord.levelno<=levelreturnfilterlogging.config.dictConfig(json.loads(CONFIG))logging.debug('A DEBUG message')logging.info('An INFO message')logging.warning('A WARNING message')logging.error('An ERROR message')logging.critical('A CRITICAL message')

pythonmain.py2>stderr.log>stdout.log

$more*.log::::::::::::::app.log::::::::::::::DEBUG-ADEBUGmessageINFO-AnINFOmessageWARNING-AWARNINGmessageERROR-AnERRORmessageCRITICAL-ACRITICALmessage::::::::::::::stderr.log::::::::::::::ERROR-AnERRORmessageCRITICAL-ACRITICALmessage::::::::::::::stdout.log::::::::::::::INFO-AnINFOmessageWARNING-AWARNINGmessage

importloggingimportlogging.configimporttimeimportos# read initial config filelogging.config.fileConfig('logging.conf')# create and start listener on port 9999t=logging.config.listen(9999)t.start()logger=logging.getLogger('simpleExample')try:# loop through logging calls to see the difference# new configurations make, until Ctrl+C is pressedwhileTrue:logger.debug('debug message')logger.info('info message')logger.warning('warn message')logger.error('error message')logger.critical('critical message')time.sleep(5)exceptKeyboardInterrupt:# cleanuplogging.config.stopListening()t.join()

#!/usr/bin/env pythonimportsocket,sys,structwithopen(sys.argv[1],'rb')asf:data_to_send=f.read()HOST='localhost'PORT=9999s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)print('connecting...')s.connect((HOST,PORT))print('sending config...')s.send(struct.pack('>L',len(data_to_send)))s.send(data_to_send)s.close()print('complete')

que=queue.Queue(-1)# no limit on sizequeue_handler=QueueHandler(que)handler=logging.StreamHandler()listener=QueueListener(que,handler)root=logging.getLogger()root.addHandler(queue_handler)formatter=logging.Formatter('%(threadName)s:%(message)s')handler.setFormatter(formatter)listener.start()# The log output will display the thread which generated# the event (the main thread) rather than the internal# thread which monitors the internal queue. This is what# you want to happen.root.warning('Look out!')listener.stop()

MainThread: Look out!

importlogging,logging.handlersrootLogger=logging.getLogger('')rootLogger.setLevel(logging.DEBUG)socketHandler=logging.handlers.SocketHandler('localhost',logging.handlers.DEFAULT_TCP_LOGGING_PORT)# don't bother with a formatter, since a socket handler sends the event as# an unformatted picklerootLogger.addHandler(socketHandler)# Now, we can log to the root logger, or any other logger. First the root...logging.info('Jackdaws love my big sphinx of quartz.')# Now, define a couple of other loggers which might represent areas in your# application:logger1=logging.getLogger('myapp.area1')logger2=logging.getLogger('myapp.area2')logger1.debug('Quick zephyrs blow, vexing daft Jim.')logger1.info('How quickly daft jumping zebras vex.')logger2.warning('Jail zesty vixen who grabbed pay from quack.')logger2.error('The five boxing wizards jump quickly.')

importpickleimportloggingimportlogging.handlersimportsocketserverimportstructclassLogRecordStreamHandler(socketserver.StreamRequestHandler):"""Handler for a streaming logging request.    This basically logs the record using whatever logging policy is    configured locally.    """defhandle(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.        """whileTrue:chunk=self.connection.recv(4)iflen(chunk)<4:breakslen=struct.unpack('>L',chunk)[0]chunk=self.connection.recv(slen)whilelen(chunk)<slen:chunk=chunk+self.connection.recv(slen-len(chunk))obj=self.unPickle(chunk)record=logging.makeLogRecord(obj)self.handleLogRecord(record)defunPickle(self,data):returnpickle.loads(data)defhandleLogRecord(self,record):# if a name is specified, we use the named logger rather than the one# implied by the record.ifself.server.lognameisnotNone:name=self.server.lognameelse:name=record.namelogger=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)classLogRecordSocketReceiver(socketserver.ThreadingTCPServer):"""    Simple TCP socket-based logging receiver suitable for testing.    """allow_reuse_address=Truedef__init__(self,host='localhost',port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,handler=LogRecordStreamHandler):socketserver.ThreadingTCPServer.__init__(self,(host,port),handler)self.abort=0self.timeout=1self.logname=Nonedefserve_until_stopped(self):importselectabort=0whilenotabort:rd,wr,ex=select.select([self.socket.fileno()],[],[],self.timeout)ifrd:self.handle_request()abort=self.abortdefmain():logging.basicConfig(format='%(relativeCreated)5d%(name)-15s%(levelname)-8s%(message)s')tcpserver=LogRecordSocketReceiver()print('About to start TCP server...')tcpserver.serve_until_stopped()if__name__=='__main__':main()

About to start TCP server...   59 root            INFO     Jackdaws love my big sphinx of quartz.   59 myapp.area1     DEBUG    Quick zephyrs blow, vexing daft Jim.   69 myapp.area1     INFO     How quickly daft jumping zebras vex.   69 myapp.area2     WARNING  Jail zesty vixen who grabbed pay from quack.   69 myapp.area2     ERROR    The five boxing wizards jump quickly.

# webapplib.pyimportloggingimporttimelogger=logging.getLogger(__name__)defuseful():# Just a representative event logged from the librarylogger.debug('Hello from webapplib!')# Just sleep for a bit so other threads get to runtime.sleep(0.01)

# main.pyimportargparsefromcontextvarsimportContextVarimportloggingimportosfromrandomimportchoiceimportthreadingimportwebappliblogger=logging.getLogger(__name__)root=logging.getLogger()root.setLevel(logging.DEBUG)classRequest:"""    A simple dummy request class which just holds dummy HTTP request method,    client IP address and client username    """def__init__(self,method,ip,user):self.method=methodself.ip=ipself.user=user# A dummy set of requests which will be used in the simulation - we'll just pick# from this list randomly. Note that all GET requests are from 192.168.2.XXX# addresses, whereas POST requests are from 192.16.3.XXX addresses. Three users# are represented in the sample requests.REQUESTS=[Request('GET','192.168.2.20','jim'),Request('POST','192.168.3.20','fred'),Request('GET','192.168.2.21','sheila'),Request('POST','192.168.3.21','jim'),Request('GET','192.168.2.22','fred'),Request('POST','192.168.3.22','sheila'),]# Note that the format string includes references to request context information# such as HTTP method, client IP and usernameformatter=logging.Formatter('%(threadName)-11s%(appName)s%(name)-9s%(user)-6s%(ip)s%(method)-4s%(message)s')# Create our context variables. These will be filled at the start of request# processing, and used in the logging that happens during that processingctx_request=ContextVar('request')ctx_appname=ContextVar('appname')classInjectingFilter(logging.Filter):"""    A filter which injects context-specific information into logs and ensures    that only information for a specific webapp is included in its log    """def__init__(self,app):self.app=appdeffilter(self,record):request=ctx_request.get()record.method=request.methodrecord.ip=request.iprecord.user=request.userrecord.appName=appName=ctx_appname.get()returnappName==self.app.nameclassWebApp:"""    A dummy web application class which has its own handler and filter for a    webapp-specific log.    """def__init__(self,name):self.name=namehandler=logging.FileHandler(name+'.log','w')f=InjectingFilter(self)handler.setFormatter(formatter)handler.addFilter(f)root.addHandler(handler)self.num_requests=0defprocess_request(self,request):"""        This is the dummy method for processing a request. It's called on a        different thread for every request. We store the context information into        the context vars before doing anything else.        """ctx_request.set(request)ctx_appname.set(self.name)self.num_requests+=1logger.debug('Request processing started')webapplib.useful()logger.debug('Request processing finished')defmain():fn=os.path.splitext(os.path.basename(__file__))[0]adhf=argparse.ArgumentDefaultsHelpFormatterap=argparse.ArgumentParser(formatter_class=adhf,prog=fn,description='Simulate a couple of web ''applications handling some ''requests, showing how request ''context can be used to ''populate logs')aa=ap.add_argumentaa('--count','-c',type=int,default=100,help='How many requests to simulate')options=ap.parse_args()# Create the dummy webapps and put them in a list which we can use to select# from randomlyapp1=WebApp('app1')app2=WebApp('app2')apps=[app1,app2]threads=[]# Add a common handler which will capture all eventshandler=logging.FileHandler('app.log','w')handler.setFormatter(formatter)root.addHandler(handler)# Generate calls to process requestsforiinrange(options.count):try:# Pick an app at random and a request for it to processapp=choice(apps)request=choice(REQUESTS)# Process the request in its own threadt=threading.Thread(target=app.process_request,args=(request,))threads.append(t)t.start()exceptKeyboardInterrupt:break# Wait for the threads to terminatefortinthreads:t.join()forappinapps:print('%s processed%s requests'%(app.name,app.num_requests))if__name__=='__main__':main()

~/logging-contextual-webapp$pythonmain.pyapp1processed51requestsapp2processed49requests~/logging-contextual-webapp$wc-l*.log153app1.log147app2.log300app.log600total~/logging-contextual-webapp$head-3app1.logThread-3(process_request)app1__main__jim192.168.3.21POSTRequestprocessingstartedThread-3(process_request)app1webapplibjim192.168.3.21POSTHellofromwebapplib!Thread-5(process_request)app1__main__jim192.168.3.21POSTRequestprocessingstarted~/logging-contextual-webapp$head-3app2.logThread-1(process_request)app2__main__sheila192.168.2.21GETRequestprocessingstartedThread-1(process_request)app2webapplibsheila192.168.2.21GETHellofromwebapplib!Thread-2(process_request)app2__main__jim192.168.2.20GETRequestprocessingstarted~/logging-contextual-webapp$headapp.logThread-1(process_request)app2__main__sheila192.168.2.21GETRequestprocessingstartedThread-1(process_request)app2webapplibsheila192.168.2.21GETHellofromwebapplib!Thread-2(process_request)app2__main__jim192.168.2.20GETRequestprocessingstartedThread-3(process_request)app1__main__jim192.168.3.21POSTRequestprocessingstartedThread-2(process_request)app2webapplibjim192.168.2.20GETHellofromwebapplib!Thread-3(process_request)app1webapplibjim192.168.3.21POSTHellofromwebapplib!Thread-4(process_request)app2__main__fred192.168.2.22GETRequestprocessingstartedThread-5(process_request)app1__main__jim192.168.3.21POSTRequestprocessingstartedThread-4(process_request)app2webapplibfred192.168.2.22GETHellofromwebapplib!Thread-6(process_request)app1__main__jim192.168.3.21POSTRequestprocessingstarted~/logging-contextual-webapp$grepapp1app1.log|wc-l153~/logging-contextual-webapp$grepapp2app2.log|wc-l147~/logging-contextual-webapp$grepapp1app.log|wc-l153~/logging-contextual-webapp$grepapp2app.log|wc-l147

importcopyimportloggingdeffilter(record:logging.LogRecord):record=copy.copy(record)record.user='jim'returnrecordif__name__=='__main__':logger=logging.getLogger()logger.setLevel(logging.INFO)handler=logging.StreamHandler()formatter=logging.Formatter('%(message)s from%(user)-8s')handler.setFormatter(formatter)handler.addFilter(filter)logger.addHandler(handler)logger.info('A log message')

# You'll need these imports in your own codeimportloggingimportlogging.handlersimportmultiprocessing# Next two import lines for this demo onlyfromrandomimportchoice,randomimporttime## Because you'll want to define the logging configurations for listener and workers, the# listener and worker process functions take a configurer parameter which is a callable# for configuring logging for that process. These functions are also passed the queue,# which they use for communication.## In practice, you can configure the listener however you want, but note that in this# simple example, the listener does not apply level or filter logic to received records.# In practice, you would probably want to do this logic in the worker processes, to avoid# sending events which would be filtered out between processes.## The size of the rotated files is made small so you can see the results easily.deflistener_configurer():root=logging.getLogger()h=logging.handlers.RotatingFileHandler('mptest.log','a',300,10)f=logging.Formatter('%(asctime)s%(processName)-10s%(name)s%(levelname)-8s%(message)s')h.setFormatter(f)root.addHandler(h)# This is the listener process top-level loop: wait for logging events# (LogRecords)on the queue and handle them, quit when you get a None for a# LogRecord.deflistener_process(queue,configurer):configurer()whileTrue:try:record=queue.get()ifrecordisNone:# We send this as a sentinel to tell the listener to quit.breaklogger=logging.getLogger(record.name)logger.handle(record)# No level or filter logic applied - just do it!exceptException:importsys,tracebackprint('Whoops! Problem:',file=sys.stderr)traceback.print_exc(file=sys.stderr)# Arrays used for random selections in this demoLEVELS=[logging.DEBUG,logging.INFO,logging.WARNING,logging.ERROR,logging.CRITICAL]LOGGERS=['a.b.c','d.e.f']MESSAGES=['Random message #1','Random message #2','Random message #3',]# The worker configuration is done at the start of the worker process run.# Note that on Windows you can't rely on fork semantics, so each process# will run the logging configuration code when it starts.defworker_configurer(queue):h=logging.handlers.QueueHandler(queue)# Just the one handler neededroot=logging.getLogger()root.addHandler(h)# send all messages, for demo; no other level or filter logic applied.root.setLevel(logging.DEBUG)# This is the worker process top-level loop, which just logs ten events with# random intervening delays before terminating.# The print messages are just so you know it's doing something!defworker_process(queue,configurer):configurer(queue)name=multiprocessing.current_process().nameprint('Worker started:%s'%name)foriinrange(10):time.sleep(random())logger=logging.getLogger(choice(LOGGERS))level=choice(LEVELS)message=choice(MESSAGES)logger.log(level,message)print('Worker finished:%s'%name)# Here's where the demo gets orchestrated. Create the queue, create and start# the listener, create ten workers and start them, wait for them to finish,# then send a None to the queue to tell the listener to finish.defmain():queue=multiprocessing.Queue(-1)listener=multiprocessing.Process(target=listener_process,args=(queue,listener_configurer))listener.start()workers=[]foriinrange(10):worker=multiprocessing.Process(target=worker_process,args=(queue,worker_configurer))workers.append(worker)worker.start()forwinworkers:w.join()queue.put_nowait(None)listener.join()if__name__=='__main__':main()

importloggingimportlogging.configimportlogging.handlersfrommultiprocessingimportProcess,Queueimportrandomimportthreadingimporttimedeflogger_thread(q):whileTrue:record=q.get()ifrecordisNone:breaklogger=logging.getLogger(record.name)logger.handle(record)defworker_process(q):qh=logging.handlers.QueueHandler(q)root=logging.getLogger()root.setLevel(logging.DEBUG)root.addHandler(qh)levels=[logging.DEBUG,logging.INFO,logging.WARNING,logging.ERROR,logging.CRITICAL]loggers=['foo','foo.bar','foo.bar.baz','spam','spam.ham','spam.ham.eggs']foriinrange(100):lvl=random.choice(levels)logger=logging.getLogger(random.choice(loggers))logger.log(lvl,'Message no.%d',i)if__name__=='__main__':q=Queue()d={'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',},'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']},}workers=[]foriinrange(5):wp=Process(target=worker_process,name='worker%d'%(i+1),args=(q,))workers.append(wp)wp.start()logging.config.dictConfig(d)lp=threading.Thread(target=logger_thread,args=(q,))lp.start()# At this point, the main process could do some useful work of its own# Once it's done that, it can wait for the workers to terminate...forwpinworkers:wp.join()# And now tell the logging thread to finish up, tooq.put(None)lp.join()

importglobimportloggingimportlogging.handlersLOG_FILENAME='logging_rotatingfile_example.out'# Set up a specific logger with our desired output levelmy_logger=logging.getLogger('MyLogger')my_logger.setLevel(logging.DEBUG)# Add the log message handler to the loggerhandler=logging.handlers.RotatingFileHandler(LOG_FILENAME,maxBytes=20,backupCount=5)my_logger.addHandler(handler)# Log some messagesforiinrange(20):my_logger.debug('i =%d'%i)# See what files are createdlogfiles=glob.glob('%s*'%LOG_FILENAME)forfilenameinlogfiles:print(filename)

logging_rotatingfile_example.outlogging_rotatingfile_example.out.1logging_rotatingfile_example.out.2logging_rotatingfile_example.out.3logging_rotatingfile_example.out.4logging_rotatingfile_example.out.5

>>>importlogging>>>root=logging.getLogger()>>>root.setLevel(logging.DEBUG)>>>handler=logging.StreamHandler()>>>bf=logging.Formatter('{asctime}{name}{levelname:8s}{message}',...style='{')>>>handler.setFormatter(bf)>>>root.addHandler(handler)>>>logger=logging.getLogger('foo.bar')>>>logger.debug('This is a DEBUG message')2010-10-28 15:11:55,341 foo.bar DEBUG    This is a DEBUG message>>>logger.critical('This is a CRITICAL message')2010-10-28 15:12:11,526 foo.bar CRITICAL This is a CRITICAL message>>>df=logging.Formatter('$asctime $name ${levelname} $message',...style='$')>>>handler.setFormatter(df)>>>logger.debug('This is a DEBUG message')2010-10-28 15:13:06,924 foo.bar DEBUG This is a DEBUG message>>>logger.critical('This is a CRITICAL message')2010-10-28 15:13:11,494 foo.bar CRITICAL This is a CRITICAL message>>>

>>>logger.error('This is an%s%s%s','other,','ERROR,','message')2010-10-28 15:19:29,833 foo.bar ERROR This is another, ERROR, message>>>

classBraceMessage:def__init__(self,fmt,/,*args,**kwargs):self.fmt=fmtself.args=argsself.kwargs=kwargsdef__str__(self):returnself.fmt.format(*self.args,**self.kwargs)classDollarMessage:def__init__(self,fmt,/,**kwargs):self.fmt=fmtself.kwargs=kwargsdef__str__(self):fromstringimportTemplatereturnTemplate(self.fmt).substitute(**self.kwargs)

>>>fromwhereverimportBraceMessageas__>>>print(__('Message with{0}{name}',2,name='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)>>>fromwhereverimportDollarMessageas__>>>print(__('Message with $num $what',num=2,what='placeholders'))Message with 2 placeholders>>>

importloggingclassMessage:def__init__(self,fmt,args):self.fmt=fmtself.args=argsdef__str__(self):returnself.fmt.format(*self.args)classStyleAdapter(logging.LoggerAdapter):deflog(self,level,msg,/,*args,stacklevel=1,**kwargs):ifself.isEnabledFor(level):msg,kwargs=self.process(msg,kwargs)self.logger.log(level,Message(msg,args),**kwargs,stacklevel=stacklevel+1)logger=StyleAdapter(logging.getLogger(__name__))defmain():logger.debug('Hello,{}','world!')if__name__=='__main__':logging.basicConfig(level=logging.DEBUG)main()

logger=logging.getLogger(__name__)

old_factory=logging.getLogRecordFactory()defrecord_factory(*args,**kwargs):record=old_factory(*args,**kwargs)record.custom_attribute=0xdecafbadreturnrecordlogging.setLogRecordFactory(record_factory)

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

importgzipimportloggingimportlogging.handlersimportosimportshutildefnamer(name):returnname+".gz"defrotator(source,dest):withopen(source,'rb')asf_in:withgzip.open(dest,'wb')asf_out:shutil.copyfileobj(f_in,f_out)os.remove(source)rh=logging.handlers.RotatingFileHandler('rotated.log',maxBytes=128,backupCount=5)rh.rotator=rotatorrh.namer=namerroot=logging.getLogger()root.setLevel(logging.INFO)root.addHandler(rh)f=logging.Formatter('%(asctime)s%(message)s')rh.setFormatter(f)foriinrange(1000):root.info(f'Message no.{i+1}')

$lsrotated.log*rotated.log       rotated.log.2.gz  rotated.log.4.gzrotated.log.1.gz  rotated.log.3.gz  rotated.log.5.gz$zcatrotated.log.1.gz2023-01-20 02:28:17,767 Message no. 9962023-01-20 02:28:17,767 Message no. 9972023-01-20 02:28:17,767 Message no. 998

importloggingimportlogging.configimportlogging.handlersfrommultiprocessingimportProcess,Queue,Event,current_processimportosimportrandomimporttimeclassMyHandler:"""    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):ifrecord.name=="root":logger=logging.getLogger()else:logger=logging.getLogger(record.name)iflogger.isEnabledFor(record.levelno):# The process name is transformed just to show that it's the listener# doing the logging to files and consolerecord.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,'handlers':{'console':{'class':'logging.StreamHandler','level':'INFO'}},'root':{'handlers':['console'],'level':'DEBUG'}}# 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':{'handlers':['queue'],'level':'DEBUG'}}# 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','formatter':'simple','level':'INFO'},'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','formatter':'detailed','level':'ERROR'}},'loggers':{'foo':{'handlers':['foofile']}},'root':{'handlers':['console','file','errors'],'level':'DEBUG'}}# 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()

importjsonimportloggingclassStructuredMessage:def__init__(self,message,/,**kwargs):self.message=messageself.kwargs=kwargsdef__str__(self):return'%s >>>%s'%(self.message,json.dumps(self.kwargs))_=StructuredMessage# optional, to improve readabilitylogging.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"}

importjsonimportloggingclassEncoder(json.JSONEncoder):defdefault(self,o):ifisinstance(o,set):returntuple(o)elifisinstance(o,str):returno.encode('unicode_escape').decode('ascii')returnsuper().default(o)classStructuredMessage:def__init__(self,message,/,**kwargs):self.message=messageself.kwargs=kwargsdef__str__(self):s=Encoder().encode(self.kwargs)return'%s >>>%s'%(self.message,s)_=StructuredMessage# optional, to improve readabilitydefmain():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)