Appending traceback from exception in child thread

[Diez B. Roggisch]

Edd schrieb:
> Hi folks,
> 
> I have a some threadpool code that works like this :
> 
>     tp = ThreadPool(number_of_threads)
>     futures = [tp.future(t) for t in tasks] # each task is callable
>     for f in futures:
>         print f.value() # <-- may propagate an exception
> 
> The idea being that a Future object represents a value that may or may
> not have been computed yet and the .value() method will block until
> that value is ready.
> 
> As the comment on the last line indicates, looking at the .value() of
> a Future may give the return value of the associated task, or it may
> also propagate an exception that was raised in a child thread.
> 
> Inside the implementation I store caught exceptions with code that
> looks something like:
> 
>     try:
>         self.return_value = self.task()
>     except:
>         self.exception = sys.exc_info()[1]
> 
> The problem I have is that when an exception is propagated in to the
> parent thread by re-raising it, the part of the traceback from the
> child thread is lost. So if the program dies due to such an exception,
> I can't see what caused it by examining the printed traceback.
> 
> To solve this problem, I could of course grab the traceback in the
> child thread and create some kind of custom exception that stashes the
> trace inside. This could then be caught on the fringes of my code in
> order to combine the tracebacks of parent and child together before
> printing it. But I was wondering if there might be a nicer way that
> keeps the original exception object. Perhaps something akin to gluing
> the tracebacks together at the point where the exception is re-raised?

If you are only interested in the original traceback, you can get that 
with the traceback.format function.

Then you don't need to re-raise it in the main-thread, or if so, use the 
formatted stacktrace as payload to an exception.

Diez