The Python logging.Logger class is supposed being
extensible by overriding the makeRecord() method. 

This is not completely true because the public logging
method (log(), debug(), info()...) call the less public
_log(), which in turn call makeRecord(). While the
public methods have a signature such:

    def info(self, msg, *args, **kwargs):
        ...
        apply(self._log, (INFO, msg, args), kwargs)

thus leaving room for expansion, the _log() method is
not so much flexible:

    def _log(self, level, msg, args, exc_info=None):
        # ...interesting stuff here...
        record = self.makeRecord(self.name, level, fn,
lno, msg, args, exc_info)
        self.handle(record)

The makeRecord signature is:

    def makeRecord(self, name, level, fn, lno, msg,
args, exc_info):

So if anybody wants to add a keyword to makeRecord, he
also needs to re-implement the "interesting stuff" in
the supposed private _log (finding the source row,
reading the stack trace...).

The attached patch should leave the _log behavior
unchanged but all unknown keyword arguments are passed
to makeRecord.

If a wrong parameter is passed to any public method,
the logger as before raises an exception, which is
raised on the makeRecord() call instead of _log()'s.

With the patch on, use case for an user that want to
log extra keywords is:

    import logging
    
    # Logger customization

    class MyLogRecord(logging.LogRecord):
        """Add a foo to a log record."""
        def __init__(self, name, level, pathname, 
                     lineno, msg, args, exc_info, foo):
            logging.LogRecord.__init__(self, name,
level, pathname,
                                       lineno, msg,
args, exc_info)
            self.foo = foo
    
    class MyLogger(logging.Logger):
        """Can log foos too."""
        def makeRecord(self, name, level, fn, 
                       lno, msg, args, exc_info, foo):
            return MyLogRecord(name, level, fn, 
                               lno, msg, args,
exc_info, foo)
    
    class MyHandler(logging.Handler):
        """Can handle foo records."""
        def emit(self, record):
            if isinstance(record, MyLogRecord):
                print self.format(record), record.foo
    
    # Logger configuration

    logging.setLoggerClass(MyLogger)
    logger = logging.getLogger('test')
    logger.setLevel(logging.INFO)
    
    hndl = MyHandler(level=logging.INFO)
    hndl.setFormatter(
        logging.Formatter("%(message)s at line
#%(lineno)d"))
    logger.addHandler(hndl)
    
    # Logger usage

    logger.info("Message", foo='pippo')
    # prints something like "Message at line #40 pippo"