Tenho um programa grande que demora muito e precisa de um amplo registro. Eu tenho uma GUI no front-end que inclui um manipulador de log personalizado, conforme definido abaixo:

class QHandler(logging.Handler, QTextEdit):
    def __init__(self, parent=None):
        QTextEdit.__init__(self, parent)
        logging.Handler.__init__(self)

        self.setLineWrapMode(QTextEdit.NoWrap)
        self.setReadOnly(True)

        self.emit_lock = Lock()

    def emit(self, record):
        with self.emit_lock:
            self.append(self.format(record))
            self.autoScroll()

    def format(self, record):
        if (record.levelno <= logging.INFO):
            bgcolor = WHITE
            fgcolor = BLACK
        if (record.levelno <= logging.WARNING):
            bgcolor = YELLOW
            fgcolor = BLACK
        if (record.levelno <= logging.ERROR):
            bgcolor = ORANGE
            fgcolor = BLACK
        if (record.levelno <= logging.CRITICAL):
            bgcolor = RED
            fgcolor = BLACK
        else:
            bgcolor = BLACK
            fgcolor = WHITE

        self.setTextBackgroundColor(bgcolor)
        self.setTextColor(fgcolor)
        self.setFont(DEFAULT_FONT)
        record = logging.Handler.format(self, record)
        return record

    def autoScroll(self):
        self.verticalScrollBar().setSliderPosition(self.verticalScrollBar().maximum())

Tenho o principal GUI (QMainWindow) que adiciona esse manipulador via:

# inside __init__ of main GUI (QMainWindow):
self.status_handler = QHandler()
# Main gui is divided into tabs and the status handler box is added to the second tab
main_tabs.addTab(self.status_handler, 'Status') 

E eu tenho a função de controlador que inicializa o manipulador de log via:

# inside controller initializing function
gui = gui_class() # this is the main gui that initializes the handler among other things
logger = logging.getLogger()
gui.status_handler.setFormatter(file_formatter) # defined elsewhere
logger.addHandler(gui.status_handler)

Uma vez que a GUI é gerada e o log é inicializado, concluo a execução do python com:

app = QApplication.instance()
if (app is None):
    app = QApplication([])
    app.setStyle('Fusion')
app.exec_()

A GUI possui alguns slots conectados a sinais de botão que geram threads para o processamento real. Cada encadeamento de processamento possui sua própria chamada de log que parece funcionar conforme o esperado. Eles são definidos da seguinte forma:

class Subprocess_Thread(Thread):
    def __init__(self, <args>):
        Thread.__init__(self)
        self.logger = logging.getLogger(self.__class__.__name__)
        self.logger.info('Subprocess Thread Created')

    def run(self):
        # does a bunch of stuff
        self.logger.info('Running stuff')
        # iterates over other objects and calls on them to do stuff
        # where they also have a logger attached and called just like above

Quando executo meu aplicativo sem uma GUI ou mesmo com a GUI minimizada, ele sempre funciona bem. Consigo ver minhas mensagens de log no console (prompt de comando ouspyder).

Se eu executar o mesmo aplicativo sem minimizar a GUI, verei as mensagens de log na GUI para inicialização e algumas das primeiras partes do processo encadeado, mas ele será interrompido em momentos aparentemente aleatórios. Não há mensagem de erro e o uso da CPU parece estar no máximo para o núcleo único que está sendo usado. Incluí uma trava apenas para garantir quelogging não vinha de threads diferentes, mas isso também não ajudou.

Eu tentei ir a umQPlainTextEdit eQListWidget mas sempre tenho o mesmo problema.

Alguém tem uma idéia de por que esse elemento da GUI faria com que todo o intérprete Python travasse quando estiver sendo exibido e as mensagens forem registradas nel