Tengo un gran programa que lleva mucho tiempo y necesita un registro amplio. Tengo una GUI que está en el front-end que incluye un controlador de registro personalizado como se define a continuación:

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())

Tengo la interfaz gráfica de usuario principal (QMainWindow) que agrega este controlador a través de:

# 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') 

Y tengo la función de controlador que inicializa el controlador de registro a través de:

# 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)

Una vez que se levanta la GUI y se inicia el registro, termino la ejecución de Python con:

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

La GUI tiene algunas ranuras conectadas a las señales de los botones que generan hilos para realizar el procesamiento real. Cada subproceso de procesamiento tiene su propia llamada de registro que parece funcionar según lo previsto. Se definen de la siguiente manera:

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

Cuando ejecuto mi aplicación sin una GUI o incluso con la GUI minimizada, siempre funciona bien. Puedo ver mis mensajes de registro en la consola (ya sea símbolo del sistema ospyder).

Si ejecuto la misma aplicación sin minimizar la GUI, veré los mensajes de registro en la GUI para la inicialización y algunas de las primeras partes del proceso de subprocesos, pero luego se bloqueará en momentos aparentemente aleatorios. No hay mensaje de error y el uso de la CPU parece estar al máximo para el núcleo único que se está utilizando. Incluí un candado solo para asegurarme delogging no venía de diferentes hilos, pero eso tampoco ayudó.

He intentado ir a unaQPlainTextEdit y unQListWidget pero me sale el mismo problema cada vez.

¿Alguien tiene una idea de por qué este elemento de la GUI haría que todo el intérprete de Python se bloqueara cuando esté a la vista y los mensajes se registren en él?