Logging messages with dictionary args in Python 2.4b1 leads to exception
steve at holdenweb.com
Wed Oct 20 17:25:34 CEST 2004
Stefan Behnel wrote:
> Paul Clinch schrieb:
>> logging.fatal( 'Test is %(test)s' % values)
>> is fine. An why shouldn't you use it in this fashion?
> I thought a logging API was usually trying to do costly things only when
> it knows it has to. You /could/ do that, but since it doesn't come for
> free - why not first do the check if you will actually log this message?
> Ok, I know there's an overhead anyway: function calls, object creation,
> etc. But copying strings and creating string representations of objects
> can be /very/ expensive and should only be done if the log message is
> definitely written.
Well that's as may be, but is the logging function going to be taking up
much of your program's run time? I'd suspect not. Premature
optimisation, etc., etc.
> I'd simply say that constructing a log message from arguments is such a
> common thing that it is worth providing efficient API support for it.
> And I think it's truely counter-pythonic to prevent the usage of
> dictionaries at this point.
Your original message observed that LogRecord performs
msg = msg % self.args
and you said "this should work"; that was where your mistake lay. The
call was constructed using
apply(root.log, (level, msg)+args, kwargs)
and I presume that args was actually obtained from a formal parameter
*args (allowing the functiopn call to aggregate all non-keyword
arguments). Thus for your call to work the usage in LogRecord would have
had to be
msg = msg % self.args
The point of the interface currently used is that it allows you to pass
a variable number of arguments for substitution into the message when
it's actually built. The *args construct neatly aggregates them into a
tuple. So when the substituion was performed inside LogRecord you were
actually providing a tuple whose single element was a dictionary, an
attempt doomed to failure.
A possible enhancement which might meet your arguments would allow the
user to provide EITHER a tuple of arguments OR a set of keyword
arguments. LogRecord could then say:
msg = msg % args
msg = msg % kwargs
and you would then be able to make a call like
logging.log(logging.FATAL, 'Test is %(test)s', **values)
But with the code you presented, it's no use bleating that "values *is*
a mapping". While this is certainly true, values was unfortunately just
the only element in the args tuple, and it's the args tuple that's
currently used for substituion. I presume the patch you sent Vijay will
do something similar?
Holden Web LLC +1 800 494 3119
More information about the Python-list