^^&&^^

Edit File: logging-cookbook.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 <title>Logging Cookbook &mdash; Python 2.7.5 documentation</title>
 
 <link rel="stylesheet" href="../_static/default.css" type="text/css" />
 <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
 
 <script type="text/javascript">
 var DOCUMENTATION_OPTIONS = {
 URL_ROOT: '../',
 VERSION: '2.7.5',
 COLLAPSE_INDEX: false,
 FILE_SUFFIX: '.html',
 HAS_SOURCE: true
 };
 </script>
 <script type="text/javascript" src="../_static/jquery.js"></script>
 <script type="text/javascript" src="../_static/underscore.js"></script>
 <script type="text/javascript" src="../_static/doctools.js"></script>
 <script type="text/javascript" src="../_static/sidebar.js"></script>
 <link rel="search" type="application/opensearchdescription+xml"
 title="Search within Python 2.7.5 documentation"
 href="../_static/opensearch.xml"/>
 <link rel="author" title="About these documents" href="../about.html" />
 <link rel="copyright" title="Copyright" href="../copyright.html" />
 <link rel="top" title="Python 2.7.5 documentation" href="../index.html" />
 <link rel="up" title="Python HOWTOs" href="index.html" />
 <link rel="next" title="Regular Expression HOWTO" href="regex.html" />
 <link rel="prev" title="Logging HOWTO" href="logging.html" />
 <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
 <script type="text/javascript" src="../_static/copybutton.js"></script>

</head>
 <body>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 accesskey="I">index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="regex.html" title="Regular Expression HOWTO"
 accesskey="N">next</a> |</li>
 <li class="right" >
 <a href="logging.html" title="Logging HOWTO"
 accesskey="P">previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="http://www.python.org/">Python</a> &raquo;</li>
 <li>
 <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
 </li>

<li><a href="index.html" accesskey="U">Python HOWTOs</a> &raquo;</li> 
 </ul>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body">
 
 <div class="section" id="logging-cookbook">
<h1>Logging Cookbook<a class="headerlink" href="#logging-cookbook" title="Permalink to this headline">¶</a></h1>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Author:</th><td class="field-body">Vinay Sajip &lt;vinay_sajip at red-dove dot com&gt;</td>
</tr>
</tbody>
</table>
This page contains a number of recipes related to logging, which have been found
useful in the past.
<div class="section" id="using-logging-in-multiple-modules">
<h2>Using logging in multiple modules<a class="headerlink" href="#using-logging-in-multiple-modules" title="Permalink to this headline">¶</a></h2>
Multiple calls to <tt class="docutils literal">logging.getLogger('someLogger')</tt> return a reference to the
same logger object. This is true not only within the same module, but also
across modules as long as it is in the same Python interpreter process. It is
true for references to the same object; additionally, application code can
define and configure a parent logger in one module and create (but not
configure) a child logger in a separate module, and all logger calls to the
child will pass up to the parent. Here is a main module:
<div class="highlight-python"><div class="highlight"><pre>import logging
import auxiliary_module

# create logger with &#39;spam_application&#39;
logger = logging.getLogger(&#39;spam_application&#39;)
logger.setLevel(logging.DEBUG)
# create file handler which logs even debug messages
fh = logging.FileHandler(&#39;spam.log&#39;)
fh.setLevel(logging.DEBUG)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
# create formatter and add it to the handlers
formatter = logging.Formatter(&#39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&#39;)
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# add the handlers to the logger
logger.addHandler(fh)
logger.addHandler(ch)

logger.info(&#39;creating an instance of auxiliary_module.Auxiliary&#39;)
a = auxiliary_module.Auxiliary()
logger.info(&#39;created an instance of auxiliary_module.Auxiliary&#39;)
logger.info(&#39;calling auxiliary_module.Auxiliary.do_something&#39;)
a.do_something()
logger.info(&#39;finished auxiliary_module.Auxiliary.do_something&#39;)
logger.info(&#39;calling auxiliary_module.some_function()&#39;)
auxiliary_module.some_function()
logger.info(&#39;done with auxiliary_module.some_function()&#39;)
</pre></div>
</div>
Here is the auxiliary module:
<div class="highlight-python"><div class="highlight"><pre>import logging

# create logger
module_logger = logging.getLogger(&#39;spam_application.auxiliary&#39;)

class Auxiliary:
 def __init__(self):
 self.logger = logging.getLogger(&#39;spam_application.auxiliary.Auxiliary&#39;)
 self.logger.info(&#39;creating an instance of Auxiliary&#39;)
 def do_something(self):
 self.logger.info(&#39;doing something&#39;)
 a = 1 + 1
 self.logger.info(&#39;done doing something&#39;)

def some_function():
 module_logger.info(&#39;received a call to &quot;some_function&quot;&#39;)
</pre></div>
</div>
The output looks like this:
<div class="highlight-python"><pre>2005-03-23 23:47:11,663 - spam_application - INFO -
 creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
 creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
 created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
 calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
 doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
 done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
 finished auxiliary_module.Auxiliary.do_something
2005-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()</pre>
</div>
</div>
<div class="section" id="multiple-handlers-and-formatters">
<h2>Multiple handlers and formatters<a class="headerlink" href="#multiple-handlers-and-formatters" title="Permalink to this headline">¶</a></h2>
Loggers are plain Python objects. The <tt class="xref py py-func docutils literal">addHandler()</tt> method has no minimum
or maximum quota for the number of handlers you may add. Sometimes it will be
beneficial for an application to log all messages of all severities to a text
file while simultaneously logging errors or above to the console. To set this
up, simply configure the appropriate handlers. The logging calls in the
application code will remain unchanged. Here is a slight modification to the
previous simple module-based configuration example:
<div class="highlight-python"><div class="highlight"><pre>import logging

logger = logging.getLogger(&#39;simple_example&#39;)
logger.setLevel(logging.DEBUG)
# create file handler which logs even debug messages
fh = logging.FileHandler(&#39;spam.log&#39;)
fh.setLevel(logging.DEBUG)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
# create formatter and add it to the handlers
formatter = logging.Formatter(&#39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&#39;)
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# add the handlers to logger
logger.addHandler(ch)
logger.addHandler(fh)

# &#39;application&#39; code
logger.debug(&#39;debug message&#39;)
logger.info(&#39;info message&#39;)
logger.warn(&#39;warn message&#39;)
logger.error(&#39;error message&#39;)
logger.critical(&#39;critical message&#39;)
</pre></div>
</div>
Notice that the &#8216;application&#8217; code does not care about multiple handlers. All
that changed was the addition and configuration of a new handler named fh.
The ability to create new handlers with higher- or lower-severity filters can be
very helpful when writing and testing an application. Instead of using many
<tt class="docutils literal">print</tt> statements for debugging, use <tt class="docutils literal">logger.debug</tt>: Unlike the print
statements, which you will have to delete or comment out later, the logger.debug
statements can remain intact in the source code and remain dormant until you
need them again. At that time, the only change that needs to happen is to
modify the severity level of the logger and/or handler to debug.
</div>
<div class="section" id="logging-to-multiple-destinations">
<h2>Logging to multiple destinations<a class="headerlink" href="#logging-to-multiple-destinations" title="Permalink to this headline">¶</a></h2>
Let&#8217;s say you want to log to console and file with different message formats and
in differing circumstances. Say you want to log messages with levels of DEBUG
and higher to file, and those messages at level INFO and higher to the console.
Let&#8217;s also assume that the file should contain timestamps, but the console
messages should not. Here&#8217;s how you can achieve this:
<div class="highlight-python"><div class="highlight"><pre>import logging

# set up logging to file - see previous section for more details
logging.basicConfig(level=logging.DEBUG,
 format=&#39;%(asctime)s %(name)-12s %(levelname)-8s %(message)s&#39;,
 datefmt=&#39;%m-%d %H:%M&#39;,
 filename=&#39;/temp/myapp.log&#39;,
 filemode=&#39;w&#39;)
# define a Handler which writes INFO messages or higher to the sys.stderr
console = logging.StreamHandler()
console.setLevel(logging.INFO)
# set a format which is simpler for console use
formatter = logging.Formatter(&#39;%(name)-12s: %(levelname)-8s %(message)s&#39;)
# tell the handler to use this format
console.setFormatter(formatter)
# add the handler to the root logger
logging.getLogger(&#39;&#39;).addHandler(console)

# Now, we can log to the root logger, or any other logger. First the root...
logging.info(&#39;Jackdaws love my big sphinx of quartz.&#39;)

# Now, define a couple of other loggers which might represent areas in your
# application:

logger1 = logging.getLogger(&#39;myapp.area1&#39;)
logger2 = logging.getLogger(&#39;myapp.area2&#39;)

logger1.debug(&#39;Quick zephyrs blow, vexing daft Jim.&#39;)
logger1.info(&#39;How quickly daft jumping zebras vex.&#39;)
logger2.warning(&#39;Jail zesty vixen who grabbed pay from quack.&#39;)
logger2.error(&#39;The five boxing wizards jump quickly.&#39;)
</pre></div>
</div>
When you run this, on the console you will see
<div class="highlight-python"><pre>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.</pre>
</div>
and in the file you will see something like
<div class="highlight-python"><pre>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.</pre>
</div>
As you can see, the DEBUG message only shows up in the file. The other messages
are sent to both destinations.
This example uses console and file handlers, but you can use any number and
combination of handlers you choose.
</div>
<div class="section" id="configuration-server-example">
<h2>Configuration server example<a class="headerlink" href="#configuration-server-example" title="Permalink to this headline">¶</a></h2>
Here is an example of a module using the logging configuration server:
<div class="highlight-python"><div class="highlight"><pre>import logging
import logging.config
import time
import os

# read initial config file
logging.config.fileConfig(&#39;logging.conf&#39;)

# create and start listener on port 9999
t = logging.config.listen(9999)
t.start()

try:
 # loop through logging calls to see the difference
 # new configurations make, until Ctrl+C is pressed
 while True:
 logger.debug(&#39;debug message&#39;)
 logger.info(&#39;info message&#39;)
 logger.warn(&#39;warn message&#39;)
 logger.error(&#39;error message&#39;)
 logger.critical(&#39;critical message&#39;)
 time.sleep(5)
except KeyboardInterrupt:
 # cleanup
 logging.config.stopListening()
 t.join()
</pre></div>
</div>
And here is a script that takes a filename and sends that file to the server,
properly preceded with the binary-encoded length, as the new logging
configuration:
<div class="highlight-python"><div class="highlight"><pre>#!/usr/bin/env python
import socket, sys, struct

with open(sys.argv[1], &#39;rb&#39;) as f:
 data_to_send = f.read()

HOST = &#39;localhost&#39;
PORT = 9999
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print(&#39;connecting...&#39;)
s.connect((HOST, PORT))
print(&#39;sending config...&#39;)
s.send(struct.pack(&#39;&gt;L&#39;, len(data_to_send)))
s.send(data_to_send)
s.close()
print(&#39;complete&#39;)
</pre></div>
</div>
</div>
<div class="section" id="sending-and-receiving-logging-events-across-a-network">
<h2>Sending and receiving logging events across a network<a class="headerlink" href="#sending-and-receiving-logging-events-across-a-network" title="Permalink to this headline">¶</a></h2>
Let&#8217;s say you want to send logging events across a network, and handle them at
the receiving end. A simple way of doing this is attaching a
<tt class="xref py py-class docutils literal">SocketHandler</tt> instance to the root logger at the sending end:
<div class="highlight-python"><div class="highlight"><pre>import logging, logging.handlers

rootLogger = logging.getLogger(&#39;&#39;)
rootLogger.setLevel(logging.DEBUG)
socketHandler = logging.handlers.SocketHandler(&#39;localhost&#39;,
 logging.handlers.DEFAULT_TCP_LOGGING_PORT)
# don&#39;t bother with a formatter, since a socket handler sends the event as
# an unformatted pickle
rootLogger.addHandler(socketHandler)

# Now, define a couple of other loggers which might represent areas in your
# application:

class LogRecordStreamHandler(SocketServer.StreamRequestHandler):
 &quot;&quot;&quot;Handler for a streaming logging request.

This basically logs the record using whatever logging policy is
 configured locally.
 &quot;&quot;&quot;

def handle(self):
 &quot;&quot;&quot;
 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.
 &quot;&quot;&quot;
 while True:
 chunk = self.connection.recv(4)
 if len(chunk) &lt; 4:
 break
 slen = struct.unpack(&#39;&gt;L&#39;, chunk)[0]
 chunk = self.connection.recv(slen)
 while len(chunk) &lt; 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 LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
 &quot;&quot;&quot;
 Simple TCP socket-based logging receiver suitable for testing.
 &quot;&quot;&quot;

allow_reuse_address = 1

def __init__(self, host=&#39;localhost&#39;,
 port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
 handler=LogRecordStreamHandler):
 SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
 self.abort = 0
 self.timeout = 1
 self.logname = None

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

def main():
 logging.basicConfig(
 format=&#39;%(relativeCreated)5d %(name)-15s %(levelname)-8s %(message)s&#39;)
 tcpserver = LogRecordSocketReceiver()
 print(&#39;About to start TCP server...&#39;)
 tcpserver.serve_until_stopped()

if __name__ == &#39;__main__&#39;:
 main()
</pre></div>
</div>
First run the server, and then the client. On the client side, nothing is
printed on the console; on the server side, you should see something like:
<div class="highlight-python"><pre>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.</pre>
</div>
Note that there are some security issues with pickle in some scenarios. If
these affect you, you can use an alternative serialization scheme by overriding
the <tt class="xref py py-meth docutils literal">makePickle()</tt> method and implementing your alternative there, as
well as adapting the above script to use your alternative serialization.
</div>
<div class="section" id="adding-contextual-information-to-your-logging-output">
<h2>Adding contextual information to your logging output<a class="headerlink" href="#adding-contextual-information-to-your-logging-output" title="Permalink to this headline">¶</a></h2>
Sometimes you want logging output to contain contextual information in
addition to the parameters passed to the logging call. For example, in a
networked application, it may be desirable to log client-specific information
in the log (e.g. remote client&#8217;s username, or IP address). Although you could
use the extra parameter to achieve this, it&#8217;s not always convenient to pass
the information in this way. While it might be tempting to create
<a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a> instances on a per-connection basis, this is not a good idea
because these instances are not garbage collected. While this is not a problem
in practice, when the number of <a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a> instances is dependent on the
level of granularity you want to use in logging an application, it could
be hard to manage if the number of <a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a> instances becomes
effectively unbounded.
<div class="section" id="using-loggeradapters-to-impart-contextual-information">
<h3>Using LoggerAdapters to impart contextual information<a class="headerlink" href="#using-loggeradapters-to-impart-contextual-information" title="Permalink to this headline">¶</a></h3>
An easy way in which you can pass contextual information to be output along
with logging event information is to use the <a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a> class.
This class is designed to look like a <a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a>, so that you can call
<a class="reference internal" href="../library/logging.html#logging.debug" title="logging.debug"><tt class="xref py py-meth docutils literal">debug()</tt></a>, <a class="reference internal" href="../library/logging.html#logging.info" title="logging.info"><tt class="xref py py-meth docutils literal">info()</tt></a>, <a class="reference internal" href="../library/logging.html#logging.warning" title="logging.warning"><tt class="xref py py-meth docutils literal">warning()</tt></a>, <a class="reference internal" href="../library/logging.html#logging.error" title="logging.error"><tt class="xref py py-meth docutils literal">error()</tt></a>,
<a class="reference internal" href="../library/logging.html#logging.exception" title="logging.exception"><tt class="xref py py-meth docutils literal">exception()</tt></a>, <a class="reference internal" href="../library/logging.html#logging.critical" title="logging.critical"><tt class="xref py py-meth docutils literal">critical()</tt></a> and <a class="reference internal" href="../library/logging.html#logging.log" title="logging.log"><tt class="xref py py-meth docutils literal">log()</tt></a>. These methods have the
same signatures as their counterparts in <a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a>, so you can use the
two types of instances interchangeably.
When you create an instance of <a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a>, you pass it a
<a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a> instance and a dict-like object which contains your contextual
information. When you call one of the logging methods on an instance of
<a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a>, it delegates the call to the underlying instance of
<a class="reference internal" href="../library/logging.html#logging.Logger" title="logging.Logger"><tt class="xref py py-class docutils literal">Logger</tt></a> passed to its constructor, and arranges to pass the contextual
information in the delegated call. Here&#8217;s a snippet from the code of
<a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a>:
<div class="highlight-python"><div class="highlight"><pre>def debug(self, msg, *args, **kwargs):
 &quot;&quot;&quot;
 Delegate a debug call to the underlying logger, after adding
 contextual information from this adapter instance.
 &quot;&quot;&quot;
 msg, kwargs = self.process(msg, kwargs)
 self.logger.debug(msg, *args, **kwargs)
</pre></div>
</div>
The <tt class="xref py py-meth docutils literal">process()</tt> method of <a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a> is where the contextual
information is added to the logging output. It&#8217;s passed the message and
keyword arguments of the logging call, and it passes back (potentially)
modified versions of these to use in the call to the underlying logger. The
default implementation of this method leaves the message alone, but inserts
an &#8216;extra&#8217; key in the keyword argument whose value is the dict-like object
passed to the constructor. Of course, if you had passed an &#8216;extra&#8217; keyword
argument in the call to the adapter, it will be silently overwritten.
The advantage of using &#8216;extra&#8217; is that the values in the dict-like object are
merged into the <a class="reference internal" href="../library/logging.html#logging.LogRecord" title="logging.LogRecord"><tt class="xref py py-class docutils literal">LogRecord</tt></a> instance&#8217;s __dict__, allowing you to use
customized strings with your <a class="reference internal" href="../library/logging.html#logging.Formatter" title="logging.Formatter"><tt class="xref py py-class docutils literal">Formatter</tt></a> instances which know about
the keys of the dict-like object. If you need a different method, e.g. if you
want to prepend or append the contextual information to the message string,
you just need to subclass <a class="reference internal" href="../library/logging.html#logging.LoggerAdapter" title="logging.LoggerAdapter"><tt class="xref py py-class docutils literal">LoggerAdapter</tt></a> and override <tt class="xref py py-meth docutils literal">process()</tt>
to do what you need. Here&#8217;s an example script which uses this class, which
also illustrates what dict-like behaviour is needed from an arbitrary
&#8216;dict-like&#8217; object for use in the constructor:
<div class="highlight-python"><div class="highlight"><pre>import logging

class ConnInfo:
 &quot;&quot;&quot;
 An example class which shows how an arbitrary class can be used as
 the &#39;extra&#39; context information repository passed to a LoggerAdapter.
 &quot;&quot;&quot;

def __getitem__(self, name):
 &quot;&quot;&quot;
 To allow this instance to look like a dict.
 &quot;&quot;&quot;
 from random import choice
 if name == &#39;ip&#39;:
 result = choice([&#39;127.0.0.1&#39;, &#39;192.168.0.1&#39;])
 elif name == &#39;user&#39;:
 result = choice([&#39;jim&#39;, &#39;fred&#39;, &#39;sheila&#39;])
 else:
 result = self.__dict__.get(name, &#39;?&#39;)
 return result

def __iter__(self):
 &quot;&quot;&quot;
 To allow iteration over keys, which will be merged into
 the LogRecord dict before formatting and output.
 &quot;&quot;&quot;
 keys = [&#39;ip&#39;, &#39;user&#39;]
 keys.extend(self.__dict__.keys())
 return keys.__iter__()

if __name__ == &#39;__main__&#39;:
 from random import choice
 levels = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL)
 a1 = logging.LoggerAdapter(logging.getLogger(&#39;a.b.c&#39;),
 { &#39;ip&#39; : &#39;123.231.231.123&#39;, &#39;user&#39; : &#39;sheila&#39; })
 logging.basicConfig(level=logging.DEBUG,
 format=&#39;%(asctime)-15s %(name)-5s %(levelname)-8s IP: %(ip)-15s User: %(user)-8s %(message)s&#39;)
 a1.debug(&#39;A debug message&#39;)
 a1.info(&#39;An info message with %s&#39;, &#39;some parameters&#39;)
 a2 = logging.LoggerAdapter(logging.getLogger(&#39;d.e.f&#39;), ConnInfo())
 for x in range(10):
 lvl = choice(levels)
 lvlname = logging.getLevelName(lvl)
 a2.log(lvl, &#39;A message at %s level with %d %s&#39;, lvlname, 2, &#39;parameters&#39;)
</pre></div>
</div>
When this script is run, the output should look something like this:
<div class="highlight-python"><pre>2008-01-18 14:49:54,023 a.b.c DEBUG IP: 123.231.231.123 User: sheila A debug message
2008-01-18 14:49:54,023 a.b.c INFO IP: 123.231.231.123 User: sheila An info message with some parameters
2008-01-18 14:49:54,023 d.e.f CRITICAL IP: 192.168.0.1 User: jim A message at CRITICAL level with 2 parameters
2008-01-18 14:49:54,033 d.e.f INFO IP: 192.168.0.1 User: jim A message at INFO level with 2 parameters
2008-01-18 14:49:54,033 d.e.f WARNING IP: 192.168.0.1 User: sheila A message at WARNING level with 2 parameters
2008-01-18 14:49:54,033 d.e.f ERROR IP: 127.0.0.1 User: fred A message at ERROR level with 2 parameters
2008-01-18 14:49:54,033 d.e.f ERROR IP: 127.0.0.1 User: sheila A message at ERROR level with 2 parameters
2008-01-18 14:49:54,033 d.e.f WARNING IP: 192.168.0.1 User: sheila A message at WARNING level with 2 parameters
2008-01-18 14:49:54,033 d.e.f WARNING IP: 192.168.0.1 User: jim A message at WARNING level with 2 parameters
2008-01-18 14:49:54,033 d.e.f INFO IP: 192.168.0.1 User: fred A message at INFO level with 2 parameters
2008-01-18 14:49:54,033 d.e.f WARNING IP: 192.168.0.1 User: sheila A message at WARNING level with 2 parameters
2008-01-18 14:49:54,033 d.e.f WARNING IP: 127.0.0.1 User: jim A message at WARNING level with 2 parameters</pre>
</div>
</div>
<div class="section" id="using-filters-to-impart-contextual-information">
<h3>Using Filters to impart contextual information<a class="headerlink" href="#using-filters-to-impart-contextual-information" title="Permalink to this headline">¶</a></h3>
You can also add contextual information to log output using a user-defined
<a class="reference internal" href="../library/logging.html#logging.Filter" title="logging.Filter"><tt class="xref py py-class docutils literal">Filter</tt></a>. <tt class="docutils literal">Filter</tt> instances are allowed to modify the <tt class="docutils literal">LogRecords</tt>
passed to them, including adding additional attributes which can then be output
using a suitable format string, or if needed a custom <a class="reference internal" href="../library/logging.html#logging.Formatter" title="logging.Formatter"><tt class="xref py py-class docutils literal">Formatter</tt></a>.
For example in a web application, the request being processed (or at least,
the interesting parts of it) can be stored in a threadlocal
(<a class="reference internal" href="../library/threading.html#threading.local" title="threading.local"><tt class="xref py py-class docutils literal">threading.local</tt></a>) variable, and then accessed from a <tt class="docutils literal">Filter</tt> to
add, say, information from the request - say, the remote IP address and remote
user&#8217;s username - to the <tt class="docutils literal">LogRecord</tt>, using the attribute names &#8216;ip&#8217; and
&#8216;user&#8217; as in the <tt class="docutils literal">LoggerAdapter</tt> example above. In that case, the same format
string can be used to get similar output to that shown above. Here&#8217;s an example
script:
<div class="highlight-python"><div class="highlight"><pre>import logging
from random import choice

class ContextFilter(logging.Filter):
 &quot;&quot;&quot;
 This is a filter which injects contextual information into the log.

Rather than use actual contextual information, we just use random
 data in this demo.
 &quot;&quot;&quot;

USERS = [&#39;jim&#39;, &#39;fred&#39;, &#39;sheila&#39;]
 IPS = [&#39;123.231.231.123&#39;, &#39;127.0.0.1&#39;, &#39;192.168.0.1&#39;]

def filter(self, record):

record.ip = choice(ContextFilter.IPS)
 record.user = choice(ContextFilter.USERS)
 return True

if __name__ == &#39;__main__&#39;:
 levels = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL)
 logging.basicConfig(level=logging.DEBUG,
 format=&#39;%(asctime)-15s %(name)-5s %(levelname)-8s IP: %(ip)-15s User: %(user)-8s %(message)s&#39;)
 a1 = logging.getLogger(&#39;a.b.c&#39;)
 a2 = logging.getLogger(&#39;d.e.f&#39;)

f = ContextFilter()
 a1.addFilter(f)
 a2.addFilter(f)
 a1.debug(&#39;A debug message&#39;)
 a1.info(&#39;An info message with %s&#39;, &#39;some parameters&#39;)
 for x in range(10):
 lvl = choice(levels)
 lvlname = logging.getLevelName(lvl)
 a2.log(lvl, &#39;A message at %s level with %d %s&#39;, lvlname, 2, &#39;parameters&#39;)
</pre></div>
</div>
which, when run, produces something like:
<div class="highlight-python"><pre>2010-09-06 22:38:15,292 a.b.c DEBUG IP: 123.231.231.123 User: fred A debug message
2010-09-06 22:38:15,300 a.b.c INFO IP: 192.168.0.1 User: sheila An info message with some parameters
2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 127.0.0.1 User: sheila A message at CRITICAL level with 2 parameters
2010-09-06 22:38:15,300 d.e.f ERROR IP: 127.0.0.1 User: jim A message at ERROR level with 2 parameters
2010-09-06 22:38:15,300 d.e.f DEBUG IP: 127.0.0.1 User: sheila A message at DEBUG level with 2 parameters
2010-09-06 22:38:15,300 d.e.f ERROR IP: 123.231.231.123 User: fred A message at ERROR level with 2 parameters
2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 192.168.0.1 User: jim A message at CRITICAL level with 2 parameters
2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 127.0.0.1 User: sheila A message at CRITICAL level with 2 parameters
2010-09-06 22:38:15,300 d.e.f DEBUG IP: 192.168.0.1 User: jim A message at DEBUG level with 2 parameters
2010-09-06 22:38:15,301 d.e.f ERROR IP: 127.0.0.1 User: sheila A message at ERROR level with 2 parameters
2010-09-06 22:38:15,301 d.e.f DEBUG IP: 123.231.231.123 User: fred A message at DEBUG level with 2 parameters
2010-09-06 22:38:15,301 d.e.f INFO IP: 123.231.231.123 User: fred A message at INFO level with 2 parameters</pre>
</div>
</div>
</div>
<div class="section" id="logging-to-a-single-file-from-multiple-processes">
<h2>Logging to a single file from multiple processes<a class="headerlink" href="#logging-to-a-single-file-from-multiple-processes" title="Permalink to this headline">¶</a></h2>
Although logging is thread-safe, and logging to a single file from multiple
threads in a single process is supported, logging to a single file from
multiple processes is not supported, because there is no standard way to
serialize access to a single file across multiple processes in Python. If you
need to log to a single file from multiple processes, one way of doing this is
to have all the processes log to a <tt class="xref py py-class docutils literal">SocketHandler</tt>, and have a separate
process which implements a socket server which reads from the socket and logs
to file. (If you prefer, you can dedicate one thread in one of the existing
processes to perform this function.) <a class="reference internal" href="#network-logging">This section</a>
documents this approach in more detail and includes a working socket receiver
which can be used as a starting point for you to adapt in your own
applications.
If you are using a recent version of Python which includes the
<a class="reference internal" href="../library/multiprocessing.html#module-multiprocessing" title="multiprocessing: Process-based &quot;threading&quot; interface."><tt class="xref py py-mod docutils literal">multiprocessing</tt></a> module, you could write your own handler which uses the
<tt class="xref py py-class docutils literal">Lock</tt> class from this module to serialize access to the file from
your processes. The existing <a class="reference internal" href="../library/logging.handlers.html#logging.FileHandler" title="logging.FileHandler"><tt class="xref py py-class docutils literal">FileHandler</tt></a> and subclasses do not make
use of <a class="reference internal" href="../library/multiprocessing.html#module-multiprocessing" title="multiprocessing: Process-based &quot;threading&quot; interface."><tt class="xref py py-mod docutils literal">multiprocessing</tt></a> at present, though they may do so in the future.
Note that at present, the <a class="reference internal" href="../library/multiprocessing.html#module-multiprocessing" title="multiprocessing: Process-based &quot;threading&quot; interface."><tt class="xref py py-mod docutils literal">multiprocessing</tt></a> module does not provide
working lock functionality on all platforms (see
<a class="reference external" href="http://bugs.python.org/issue3770">http://bugs.python.org/issue3770</a>).
</div>
<div class="section" id="using-file-rotation">
<h2>Using file rotation<a class="headerlink" href="#using-file-rotation" title="Permalink to this headline">¶</a></h2>
Sometimes you want to let a log file grow to a certain size, then open a new
file and log to that. You may want to keep a certain number of these files, and
when that many files have been created, rotate the files so that the number of
files and the size of the files both remain bounded. For this usage pattern, the
logging package provides a <a class="reference internal" href="../library/logging.handlers.html#logging.handlers.RotatingFileHandler" title="logging.handlers.RotatingFileHandler"><tt class="xref py py-class docutils literal">RotatingFileHandler</tt></a>:
<div class="highlight-python"><div class="highlight"><pre>import glob
import logging
import logging.handlers

LOG_FILENAME = &#39;logging_rotatingfile_example.out&#39;

# Set up a specific logger with our desired output level
my_logger = logging.getLogger(&#39;MyLogger&#39;)
my_logger.setLevel(logging.DEBUG)

# Add the log message handler to the logger
handler = logging.handlers.RotatingFileHandler(
 LOG_FILENAME, maxBytes=20, backupCount=5)

my_logger.addHandler(handler)

# Log some messages
for i in range(20):
 my_logger.debug(&#39;i = %d&#39; % i)

# See what files are created
logfiles = glob.glob(&#39;%s*&#39; % LOG_FILENAME)

for filename in logfiles:
 print(filename)
</pre></div>
</div>
The result should be 6 separate files, each with part of the log history for the
application:
<div class="highlight-python"><pre>logging_rotatingfile_example.out
logging_rotatingfile_example.out.1
logging_rotatingfile_example.out.2
logging_rotatingfile_example.out.3
logging_rotatingfile_example.out.4
logging_rotatingfile_example.out.5</pre>
</div>
The most current file is always <tt class="file docutils literal">logging_rotatingfile_example.out</tt>,
and each time it reaches the size limit it is renamed with the suffix
<tt class="docutils literal">.1</tt>. Each of the existing backup files is renamed to increment the suffix
(<tt class="docutils literal">.1</tt> becomes <tt class="docutils literal">.2</tt>, etc.) and the <tt class="docutils literal">.6</tt> file is erased.
Obviously this example sets the log length much too small as an extreme
example. You would want to set maxBytes to an appropriate value.
</div>
<div class="section" id="an-example-dictionary-based-configuration">
<h2>An example dictionary-based configuration<a class="headerlink" href="#an-example-dictionary-based-configuration" title="Permalink to this headline">¶</a></h2>
Below is an example of a logging configuration dictionary - it&#8217;s taken from
the <a class="reference external" href="https://docs.djangoproject.com/en/1.3/topics/logging/#configuring-logging">documentation on the Django project</a>.
This dictionary is passed to <a class="reference internal" href="../library/logging.config.html#logging.config.dictConfig" title="logging.config.dictConfig"><tt class="xref py py-func docutils literal">dictConfig()</tt></a> to put the configuration into effect:
<div class="highlight-python"><div class="highlight"><pre>LOGGING = {
 &#39;version&#39;: 1,
 &#39;disable_existing_loggers&#39;: True,
 &#39;formatters&#39;: {
 &#39;verbose&#39;: {
 &#39;format&#39;: &#39;%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s&#39;
 },
 &#39;simple&#39;: {
 &#39;format&#39;: &#39;%(levelname)s %(message)s&#39;
 },
 },
 &#39;filters&#39;: {
 &#39;special&#39;: {
 &#39;()&#39;: &#39;project.logging.SpecialFilter&#39;,
 &#39;foo&#39;: &#39;bar&#39;,
 }
 },
 &#39;handlers&#39;: {
 &#39;null&#39;: {
 &#39;level&#39;:&#39;DEBUG&#39;,
 &#39;class&#39;:&#39;django.utils.log.NullHandler&#39;,
 },
 &#39;console&#39;:{
 &#39;level&#39;:&#39;DEBUG&#39;,
 &#39;class&#39;:&#39;logging.StreamHandler&#39;,
 &#39;formatter&#39;: &#39;simple&#39;
 },
 &#39;mail_admins&#39;: {
 &#39;level&#39;: &#39;ERROR&#39;,
 &#39;class&#39;: &#39;django.utils.log.AdminEmailHandler&#39;,
 &#39;filters&#39;: [&#39;special&#39;]
 }
 },
 &#39;loggers&#39;: {
 &#39;django&#39;: {
 &#39;handlers&#39;:[&#39;null&#39;],
 &#39;propagate&#39;: True,
 &#39;level&#39;:&#39;INFO&#39;,
 },
 &#39;django.request&#39;: {
 &#39;handlers&#39;: [&#39;mail_admins&#39;],
 &#39;level&#39;: &#39;ERROR&#39;,
 &#39;propagate&#39;: False,
 },
 &#39;myproject.custom&#39;: {
 &#39;handlers&#39;: [&#39;console&#39;, &#39;mail_admins&#39;],
 &#39;level&#39;: &#39;INFO&#39;,
 &#39;filters&#39;: [&#39;special&#39;]
 }
 }
}
</pre></div>
</div>
For more information about this configuration, you can see the <a class="reference external" href="https://docs.djangoproject.com/en/1.3/topics/logging/#configuring-logging">relevant
section</a>
of the Django documentation.
</div>
<div class="section" id="inserting-a-bom-into-messages-sent-to-a-sysloghandler">
<h2>Inserting a BOM into messages sent to a SysLogHandler<a class="headerlink" href="#inserting-a-bom-into-messages-sent-to-a-sysloghandler" title="Permalink to this headline">¶</a></h2>
<a class="reference external" href="http://tools.ietf.org/html/rfc5424">RFC 5424</a> requires that a
Unicode message be sent to a syslog daemon as a set of bytes which have the
following structure: an optional pure-ASCII component, followed by a UTF-8 Byte
Order Mark (BOM), followed by Unicode encoded using UTF-8. (See the <a class="reference external" href="http://tools.ietf.org/html/rfc5424#section-6">relevant
section of the specification</a>.)
In Python 2.6 and 2.7, code was added to
<a class="reference internal" href="../library/logging.handlers.html#logging.handlers.SysLogHandler" title="logging.handlers.SysLogHandler"><tt class="xref py py-class docutils literal">SysLogHandler</tt></a> to insert a BOM into the message, but
unfortunately, it was implemented incorrectly, with the BOM appearing at the
beginning of the message and hence not allowing any pure-ASCII component to
appear before it.
As this behaviour is broken, the incorrect BOM insertion code is being removed
from Python 2.7.4 and later. However, it is not being replaced, and if you
want to produce RFC 5424-compliant messages which include a BOM, an optional
pure-ASCII sequence before it and arbitrary Unicode after it, encoded using
UTF-8, then you need to do the following:
<ol class="arabic">
<li>Attach a <a class="reference internal" href="../library/logging.html#logging.Formatter" title="logging.Formatter"><tt class="xref py py-class docutils literal">Formatter</tt></a> instance to your
<a class="reference internal" href="../library/logging.handlers.html#logging.handlers.SysLogHandler" title="logging.handlers.SysLogHandler"><tt class="xref py py-class docutils literal">SysLogHandler</tt></a> instance, with a format string
such as:
<div class="highlight-python"><div class="highlight"><pre>u&#39;ASCII section\ufeffUnicode section&#39;
</pre></div>
</div>
The Unicode code point <tt class="docutils literal">u'\ufeff'</tt>, when encoded using UTF-8, will be
encoded as a UTF-8 BOM &#8211; the byte-string <tt class="docutils literal">'\xef\xbb\xbf'</tt>.
</li>
<li>Replace the ASCII section with whatever placeholders you like, but make sure
that the data that appears in there after substitution is always ASCII (that
way, it will remain unchanged after UTF-8 encoding).
</li>
<li>Replace the Unicode section with whatever placeholders you like; if the data
which appears there after substitution contains characters outside the ASCII
range, that&#8217;s fine &#8211; it will be encoded using UTF-8.
</li>
</ol>
If the formatted message is Unicode, it will be encoded using UTF-8 encoding
by <tt class="docutils literal">SysLogHandler</tt>. If you follow the above rules, you should be able to
produce RFC 5424-compliant messages. If you don&#8217;t, logging may not complain,
but your messages will not be RFC 5424-compliant, and your syslog daemon may
complain.
</div>
<div class="section" id="implementing-structured-logging">
<h2>Implementing structured logging<a class="headerlink" href="#implementing-structured-logging" title="Permalink to this headline">¶</a></h2>
Although most logging messages are intended for reading by humans, and thus not
readily machine-parseable, there might be cirumstances where you want to output
messages in a structured format which is capable of being parsed by a program
(without needing complex regular expressions to parse the log message). This is
straightforward to achieve using the logging package. There are a number of
ways in which this could be achieved, but the following is a simple approach
which uses JSON to serialise the event in a machine-parseable manner:
<div class="highlight-python"><div class="highlight"><pre>import json
import logging

class StructuredMessage(object):
 def __init__(self, message, **kwargs):
 self.message = message
 self.kwargs = kwargs

def __str__(self):
 return &#39;%s &gt;&gt;&gt; %s&#39; % (self.message, json.dumps(self.kwargs))

_ = StructuredMessage # optional, to improve readability

logging.basicConfig(level=logging.INFO, format=&#39;%(message)s&#39;)
logging.info(_(&#39;message 1&#39;, foo=&#39;bar&#39;, bar=&#39;baz&#39;, num=123, fnum=123.456))
</pre></div>
</div>
If the above script is run, it prints:
<div class="highlight-python"><pre>message 1 &gt;&gt;&gt; {"fnum": 123.456, "num": 123, "bar": "baz", "foo": "bar"}</pre>
</div>
Note that the order of items might be different according to the version of
Python used.
If you need more specialised processing, you can use a custom JSON encoder,
as in the following complete example:
<div class="highlight-python"><div class="highlight"><pre>from __future__ import unicode_literals

import json
import logging

# This next bit is to ensure the script runs unchanged on 2.x and 3.x
try:
 unicode
except NameError:
 unicode = str

class Encoder(json.JSONEncoder):
 def default(self, o):
 if isinstance(o, set):
 return tuple(o)
 elif isinstance(o, unicode):
 return o.encode(&#39;unicode_escape&#39;).decode(&#39;ascii&#39;)
 return super(Encoder, self).default(o)

def __str__(self):
 s = Encoder().encode(self.kwargs)
 return &#39;%s &gt;&gt;&gt; %s&#39; % (self.message, s)

_ = StructuredMessage # optional, to improve readability

def main():
 logging.basicConfig(level=logging.INFO, format=&#39;%(message)s&#39;)
 logging.info(_(&#39;message 1&#39;, set_value=set([1, 2, 3]), snowman=&#39;\u2603&#39;))

</div>
 </div>
 </div>
 <div class="sphinxsidebar">
 <div class="sphinxsidebarwrapper">
 <h3><a href="../contents.html">Table Of Contents</a></h3>
 <ul>
<li><a class="reference internal" href="#">Logging Cookbook</a><ul>
<li><a class="reference internal" href="#using-logging-in-multiple-modules">Using logging in multiple modules</a></li>
<li><a class="reference internal" href="#multiple-handlers-and-formatters">Multiple handlers and formatters</a></li>
<li><a class="reference internal" href="#logging-to-multiple-destinations">Logging to multiple destinations</a></li>
<li><a class="reference internal" href="#configuration-server-example">Configuration server example</a></li>
<li><a class="reference internal" href="#sending-and-receiving-logging-events-across-a-network">Sending and receiving logging events across a network</a></li>
<li><a class="reference internal" href="#adding-contextual-information-to-your-logging-output">Adding contextual information to your logging output</a><ul>
<li><a class="reference internal" href="#using-loggeradapters-to-impart-contextual-information">Using LoggerAdapters to impart contextual information</a></li>
<li><a class="reference internal" href="#using-filters-to-impart-contextual-information">Using Filters to impart contextual information</a></li>
</ul>
</li>
<li><a class="reference internal" href="#logging-to-a-single-file-from-multiple-processes">Logging to a single file from multiple processes</a></li>
<li><a class="reference internal" href="#using-file-rotation">Using file rotation</a></li>
<li><a class="reference internal" href="#an-example-dictionary-based-configuration">An example dictionary-based configuration</a></li>
<li><a class="reference internal" href="#inserting-a-bom-into-messages-sent-to-a-sysloghandler">Inserting a BOM into messages sent to a SysLogHandler</a></li>
<li><a class="reference internal" href="#implementing-structured-logging">Implementing structured logging</a></li>
</ul>
</li>
</ul>

<h4>Previous topic</h4>
 <a href="logging.html"
 title="previous chapter">Logging HOWTO</a>
 <h4>Next topic</h4>
 <a href="regex.html"
 title="next chapter">Regular Expression HOWTO</a>
<h3>This Page</h3>
<ul class="this-page-menu">
 <li><a href="../bugs.html">Report a Bug</a></li>
 <li><a href="../_sources/howto/logging-cookbook.txt"
 rel="nofollow">Show Source</a></li>
</ul>

<div id="searchbox" style="display: none">
 <h3>Quick search</h3>
 <form class="search" action="../search.html" method="get">
 <input type="text" name="q" />
 <input type="submit" value="Go" />
 <input type="hidden" name="check_keywords" value="yes" />
 <input type="hidden" name="area" value="default" />
 </form>
 
 Enter search terms or a module, class or function name.
 
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
 </div>
 </div>
 <div class="clearer"></div>
 </div>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 >index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="regex.html" title="Regular Expression HOWTO"
 >next</a> |</li>
 <li class="right" >
 <a href="logging.html" title="Logging HOWTO"
 >previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="http://www.python.org/">Python</a> &raquo;</li>
 <li>
 <a href="../index.html">Python 2.7.5 documentation</a> &raquo;
 </li>

<li><a href="index.html" >Python HOWTOs</a> &raquo;</li> 
 </ul>
 </div>
 <div class="footer">
 &copy; <a href="../copyright.html">Copyright</a> 1990-2020, Python Software Foundation.
 
 The Python Software Foundation is a non-profit corporation.
 <a href="http://www.python.org/psf/donations/">Please donate.</a>
 
 Last updated on Oct 13, 2020.
 <a href="../bugs.html">Found a bug</a>?
 
 Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
 </div>

</body>
</html>