Exception levée dans le pool de multitraitement non détectée

Question

Il semble que lorsqu'une exception est levée à partir d'un processus multiprocessing.Pool, il n'y a aucune trace de pile ni aucune autre indication qu'il a échoué. Exemple:

 from multiprocessing import Pool 

def go():
    print(1)
    raise Exception()
    print(2)

p = Pool()
p.apply_async(go)
p.close()
p.join()

imprime 1 et s'arrête silencieusement. Fait intéressant, lever une BaseException fonctionne à la place. Existe-t-il un moyen de rendre le comportement de toutes les exceptions identique à celui de BaseException ?

Answer 1

J'ai réussi à enregistrer des exceptions avec ce décorateur :

 import traceback, functools, multiprocessing

def trace_unhandled_exceptions(func):
    @functools.wraps(func)
    def wrapped_func(*args, **kwargs):
        try:
            func(*args, **kwargs)
        except:
            print 'Exception in '+func.__name__
            traceback.print_exc()
    return wrapped_func

avec le code dans la question, c'est

 @trace_unhandled_exceptions
def go():
    print(1)
    raise Exception()
    print(2)

p = multiprocessing.Pool(1)

p.apply_async(go)
p.close()
p.join()

Décorez simplement la fonction que vous transmettez à votre pool de processus. La clé de ce fonctionnement est @functools.wraps(func) sinon le multitraitement génère un PicklingError .

le code ci-dessus donne

 1
Exception in go
Traceback (most recent call last):
  File "<stdin>", line 5, in wrapped_func
  File "<stdin>", line 4, in go
Exception

Answer 2

import logging
from multiprocessing import Pool

def proc_wrapper(func, *args, **kwargs):
    """Print exception because multiprocessing lib doesn't return them right."""
    try:
        return func(*args, **kwargs)
    except Exception as e:
        logging.exception(e)
        raise

def go(x):
    print x
    raise Exception("foobar")

p = Pool()
p.apply_async(proc_wrapper, (go, 5))
p.join()
p.close()