homepage

I was having trouble with the logging module under Jython: I was getting seemingly sporadic wierd null pointer exceptions in the logging code. 
The problem seemed to be related to references that were passed to the logger, e.g.
logger.debug("My object: %s", myObject)
It seems that logging defers the actual string formatting (maybe only when logging to files). By the time the string is formatted, the reference to the object may no longer be valid. In my case, myObject was a reference to a Java-class that had been invalidated.
Initially, I thought this was only a Java issue. But it seems like this could be an issue with pure Python scripts as well. E.g., what happens if the object behind myObject is changed after the call to debug(), but before the actual log message is formatted?

Find attached a demo script that causes the erratic behavior in regular Python (2.7.5 on Windows).
The log file contains two lines, both show the new name of the object, although the first debug() was called befor the name change.
I think this problem could be avoided if the message was formatted earlier (i.e. synchronous to the debug() call).

The whole point of the logging API is that the message is *not* formatted unless the message is actually emitted. So this is just how logging works, not something that can be fixed, as far as I can see.

I see your point. 
The decision whether to log or not is actually made synchronously to the actual logging call, as far as I can tell (i.e. "if self.isEnabledFor..." is checked directly in debug()). So at this place, the formatting could already happen.
I don't see a reason to defer the formatting to the actual output of the messages (other than the current implementation of logging).

The decision as to whether or not to pass the message along to the next stage is made at numerous points in the pipeline.

> I don't see a reason to defer the formatting to the actual output of the messages (other than the current implementation of logging).
The current implementation of logging is like that for a reason, even though you may not see it - it defers doing work until it is needed (which improves throughput). This idiom is hardly uncommon.
If you don't want to delay formatting until output, you can always do
logger.debug("My object: %s" % myObject)

Thanks for the explanation. Throughput is a valid reason.
Your workaround does of course work, but it means that the string formatting is always done, even if the message is filtered out.
Is this delayed logging behavior documented in any way (maybe I have overread it)? I am just trying to help people who may stumble upon this, as it cost me quite some time to figure out the resulting weird errors (especially in conjunction with Jython, which doesn't make debugging easier).
By the way, my workaround is a little different: I "forked" logging and am catching exceptions during the string formatting. This way, I can at least print out the affected logging calls for me to fix.

> but it means that the string formatting is always done
Not if you use logger.isEnabledFor(level) as a guard to avoid unnecessary work :-)
> I "forked" logging and am catching exceptions during the string formatting
That might work with Jython and invalidated objects, but in the case of e.g. CPython (where the objects can't be invalidated/garbage collected as there is a reference to them in the LogRecord for the logged event) I don't see how that approach is generally applicable.

2014年07月03日 16:42 GMT+02:00 Vinay Sajip <report@bugs.python.org>:
> > I "forked" logging and am catching exceptions during the string
> formatting
>
> That might work with Jython and invalidated objects, but in the case of
> e.g. CPython (where the objects can't be invalidated/garbage collected as
> there is a reference to them in the LogRecord for the logged event) I don't
> see how that approach is generally applicable.
True, it only helps for Jython.
Still, I suggest adding this behavior to the documentation.

> Still, I suggest adding this behavior to the documentation.
It is already in the documentation. For example,
https://docs.python.org/2/library/logging.html#logging.Formatter.format
https://docs.python.org/2/howto/logging.html#optimization
This behaviour has been in logging from the beginning. Generally, people have regarded it as desirable (when an opinion has been expressed).