Your raise exc_info[0], exc_info[1], exc_info[2] is incorrect, at least, in Python 2.5!

            logging.getLogger().error("Exception in cleanup ignored due to a pending exception on stack", exc_info=1)

or simply:

            logging.getLogger().exception("Exception in cleanup ignored due to a pending exception on stack")

logging.getLogger("Exception ignored during finally", exc_info=1)

However, what I like to do in such a scenario is is to conditionally propagate the exception, something like this (for a db operation):

success = 0
try:
    do_db_operation()
    success = 1
finally:
    if not success:
        try:
            do_rollback()
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            logging.getLogger("Exception in cleanup ignored due to a pending exception on stack", exc_info=1)
    else:
        do_commit()

The advantage is that if the db operation fails (say a constraint violation), then it does a rollback (while making sure to not stomp on the original exception), but when the operation succeeds, any exception in commit is taken seriously and so is propagated.

def reraise(exc_info=(None, None, None), errorMsg=''):
    """Re-raise the latest exception given by exc_info tuple (as returned by
    sys.exc_info()) with additional errorMsg text.
    Exceptions with non-standard constructors get re-raised as derived
    exceptions, with recorded original error message and original traceback.
    Parameters:
        exc_info: (<exception class>, <exception instance>, <traceback object>)
            tuple
        errorMsg: error message text to add to the exception error message
    """
    excClass, exc, tb = exc_info
    try:
        # re-raise original exception with added custom error message
        raise excClass, excClass("%s: %s" % (exc, errorMsg)), tb
    except TypeError:
        if excClass == TypeError:
            # original exception is TypeError, which has a standard constructor:
            # safe to re-raise this way
            raise excClass, excClass("%s: %s" % (exc, errorMsg)), tb

        # TypeError due to non-standard exception constructor 
        if isinstance(excClass, (types.ClassType, type)) \
           and issubclass(excClass, Exception):
            # raise derived exception class with added custom error message
            class CustomInfoException(excClass):
                def __init__(self, info='', args=[]):
                    self._info = info
                    excClass.__init__(self, *args)

                def __str__(self):
                    return "%s: %s" % (excClass.__str__(self), self._info)

            CustomInfoException.__name__ = excClass.__name__
            raise CustomInfoException, \
                  CustomInfoException(info=errorMsg, args=exc.args), tb
        else:
            # raise base Exception class with added original exception
            # message plus custom error message. Safe for old string exceptions.
            raise Exception, \
                  Exception("%s: %s: %s"
                            % (getattr(excClass, '__name__', excClass), exc or
                               excClass, errorMsg)), tb

The issue of re-raising base Exception instead of the original exception to avoid non-standard exception class constructors (like e.g. UnicodeEncodeError) could be addressed by dynamically creating a derived exception class:

def reraise(exc_info=(None, None, None), errorMsg=''):
    """Re-raise the latest exception given by exc_info tuple (as returned by
    sys.exc_info()) with additional errorMsg text.
    Exceptions with non-standard constructors get re-raised as derived
    exceptions, with recorded original error message and original traceback.
    Parameters:
        exc_info: (, , )
            tuple
        errorMsg: error message text to add to the exception error message
    """
    excClass, exc, tb = exc_info
    try:
        # re-raise original exception with added custom error message
        raise excClass, excClass("%s: %s" % (exc, errorMsg)), tb
    except TypeError:
        if excClass == TypeError:
            # original exception is TypeError, which has a standard constructor:
            # safe to re-raise this way
            raise excClass, excClass("%s: %s" % (exc, errorMsg)), tb

        # TypeError due to non-standard exception constructor 
        if issubclass(excClass, Exception):
            # raise derived exception class with added custom error message
            class CustomInfoException(excClass):
                def __init__(self, info='', args=[]):
                    self._info = info
                    excClass.__init__(self, *args)

                def __str__(self):
                    return "%s: %s" % (excClass.__str__(self), self._info)

            CustomInfoException.__name__ = excClass.__name__
            raise CustomInfoException, \
                  CustomInfoException(info=errorMsg, args=exc.args), tb
        else:
            # raise base Exception class with added original exception
            # message plus custom error message. Safe for old string exceptions.
            raise Exception, \
                  Exception("%s: %s: %s"
                            % (getattr(excClass, '__name__', excClass), exc or
                               excClass, errorMsg)), tb

As a derived class, the re-raised exception would even be caught later on if a dedicated exception handler for the original exception existed somewhere further up the call stack.

In action:

>>> a = u'\xe4'
>>> def foo(s):
 ...     try:
 ...             b = str(s)
 ...     except:
 ...             reraise(sys.exc_info(), "really common problem")
 ...
 >>> foo(a)
 Traceback (most recent call last):
   File "", line 1, in ?
   File "", line 5, in foo
   File "", line 3, in foo
 __main__.UnicodeEncodeError: 'ascii' codec can't encode character u'\xe4' in position 0: ordinal
 not in range(128): really common problem
>>>

except Exception, exc:
    args = exc.args
    if not args:
        arg0 = ''
    else:
        arg0 = args[0]
    arg0 += ' at line %s' % lineno
    exc.args = arg0 + args[1:]
    raise

the second to last line should be

exc.args = (arg0,) + args[1:]

Here’s a slightly more worked-out example, maybe a little over-functional in style, but it’s flexible. With the prepend_exc_str function (defined later), you can do:

def prepend():
    try:
        dummy = b # throws NameError
    except Exception, exc:
        prepend_exc_str(exc, 'Message: ')
        raise
prepend()

and get the result:

Traceback (most recent call last):
  File "msg_add.py", line 44, in ?
    prepend()
  File "msg_add.py", line 31, in prepend
    dummy = b # throws NameError
NameError: Message: global name 'b' is not defined

Here’s the code, ready to change for other forms of message modification:

def prepend_str(main, str):
    return str + main

def append_str(main, str):
    return main + str

def modify_exc_str_func(func):
    def inner_func(exc, str):
        # modifies exception in-place, so no return value
        # based on original by Ian Bicking:
        # <a href="http://blog.ianbicking.org/2007/09/12/re-raising-exceptions/" rel="nofollow">http://blog.ianbicking.org/2007/09/12/re-raising-exceptions/</a>
        args = exc.args
        if not args:
            arg0 = ''
        else: arg0 = args[0]
        arg0 = func(arg0, str)
        exc.args = (arg0,) + args[1:]
    return inner_func

prepend_exc_str = modify_exc_str_func(prepend_str)
append_exc_str = modify_exc_str_func(append_str)

Traceback as an instance variable is a good start, combined with an optional ’cause exception’ instance variable would practically yield the Java solution. Well, this and support in the ‘language culture’ – making people actually use it :-)

Would the tb_next attribute of traceback objects serve this purpose?

Ross