A fine maxim for a compiled and statically linked language where it is possible to predict what exception will be raised by a given code fragment.  Here, however, we're calling methods on objects that were passed in. Who knows what this method will encounter someday?  For example, that third argument is a reference to a processor, a very complicated object. This method just accesses the processor's logger, what could go wrong?  Unfortunately, the Python logging module doesn't document what exceptions it could raise.  From experience, I've seen string formatting errors and io errors raised, but I've no idea if that's a comprehensive list.  In addition, this method cannot be guaranteed that the logger system wasn't totally swapped out by some other system (via configman), so there is no way to predict what will be raised. 

Second, a primary design feature of Socorro is to be robust.  The more locally that exceptions are handled, the more easily it is to recover and continue.  Allowing an unanticipated exception to leave this method would make it nearly impossible to recover.  I do not want to risk that some unexpected exception will completely derail processing a crash because a logger format string problem. In this particular case, I'm logging the exception so that it won't be lost entirely,and I'm giving the classification system the chance to continue doing its work.