你所不可或缺的 – logging

import logging
logging.basicConfig(level=logging.DEBUG)
# define a logger
logger = logging.getLogger(__name__)

#Info level msg
logger.info('Info level message')
#Debug level msg
logger.debug('Debug level message')
#Warning level msg
logger.info('Warning level message')

INFO:__main__: Info level message
DEBUG:__main__: Debug level message
WARN:__main__: Warning level message

try:
    open('file_not_exist.txt', 'wt')
except Exception, e:
    logger.error('Failed to write a file',exc_info=True)

handler = logging.handlers.RotatingFileHandler(
    LOG_FILENAME,
    maxBytes=20,
    backupCount=5,
)
my_logger.addHandler(handler)

import logging
import logging.handlers

rootLogger = 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 pickle
rootLogger.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.')

import logging
import logging.handlers
import pickle
import socketserver
import struct


class LogRecordStreamHandler(socketserver.StreamRequestHandler):
    """Handler for a streaming logging request.

    This basically logs the record using whatever logging policy is
    configured locally.
    """

    def handle(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.
	"""
	while True:
	    chunk = self.connection.recv(4)
	    if len(chunk) < 4:
		break
	    slen = struct.unpack('>L', chunk)[0]
	    chunk = self.connection.recv(slen)
	    while len(chunk) < 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):
    """
    Simple TCP socket-based logging receiver suitable for testing.
    """

    allow_reuse_address = True

    def __init__(self, host='localhost',
		 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='%(relativeCreated)5d %(name)-15s %(levelname)-8s %(message)s')
    tcpserver = LogRecordSocketReceiver()
    print('About to start TCP server...')
    tcpserver.serve_until_stopped()


if __name__ == '__main__':
    main()

{
    "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"]
	}
    }
}

import json
import logging.config


def setup_logging():
    """
    Setup logging configuration
    """
    with open('logging_configuration.json', 'rt') as f:
	config = json.load(f)
	logging.config.dictConfig(config)

import json
import logging


class StructuredMessage(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"}