KaptureControlGui/KCG/base/loghandler.py

import logging
from PyQt4 import QtGui, QtCore

"""
This intends to be a QThread save logging handler with syntax highlighting
"""


class LogHandler(logging.Handler):
    """
    Handler Class to configure Logging
    This also enables logging to the output field in the gui
    """
    def __init__(self, log_area):
        logging.Handler.__init__(self)
        self.text_area = log_area
        self.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
        self._normal_weight = self.text_area.fontWeight()
        self._bold = 100

    def emit(self, record):
        self.acquire()
        self.text_area.append_signal.emit(record)
        self.release()


class Highlighter(QtGui.QSyntaxHighlighter):
    def __init__(self, parent, theme):
        super(Highlighter, self).__init__(parent, )
        self.parent = parent
        self.highlightingRules = []

        timestamp = QtGui.QTextCharFormat()
        timestamp.setForeground(QtCore.Qt.blue)
        timestamp.setFontWeight(QtGui.QFont.Bold)
        self.timestamp_pattern = QtCore.QRegExp(r"^.{23}")
        self.timestamp_pattern.setMinimal(True)
        self.highlightingRules.append((self.timestamp_pattern, timestamp))

        loglevel = QtGui.QTextCharFormat()
        loglevel.setForeground(QtCore.Qt.black)
        loglevel.setFontWeight(QtGui.QFont.Bold)
        self.loglevel_pattern = QtCore.QRegExp(r":[A-Z\_]{3,13}:")
        self.loglevel_pattern.setMinimal(True)
        self.highlightingRules.append((self.loglevel_pattern, loglevel))

        success = QtGui.QTextCharFormat()
        success.setForeground(QtGui.QColor(30, 210, 0))
        success.setFontWeight(QtGui.QFont.Bold)
        pattern = QtCore.QRegExp(r".*(S|s)uccess.*")
        self.highlightingRules.append((pattern, success))

        error = QtGui.QTextCharFormat()
        error.setBackground(QtGui.QColor(255, 50, 50))
        self.error_pattern = QtCore.QRegExp("ERROR")
        self.error_pattern.setMinimal(True)
        self.highlightingRules.append((self.error_pattern, error))

    def setKeywords(self, kw):
        keyword = QtGui.QTextCharFormat()
        keyword.setForeground(QtCore.Qt.darkBlue)
        keyword.setFontWeight(QtGui.QFont.Bold)
        keywords = QtCore.QStringList(kw)
        for word in keywords:
            pattern = QtCore.QRegExp("\\b" + word + "\\b")
            self.highlightingRules.append((pattern, keyword))

    def highlightBlock(self, text):
        for pattern, format in self.highlightingRules:
            start = 0
            if pattern not in [self.timestamp_pattern, self.error_pattern, self.loglevel_pattern]:
                start = self.loglevel_pattern.indexIn(text)
                start += self.loglevel_pattern.matchedLength()

            index = pattern.indexIn(text, offset=start)

            while index >= 0:
                length = pattern.matchedLength()
                pref_format = self.format(index)
                pref_format.merge(format)
                self.setFormat(index, length, pref_format)
                index = text.indexOf(pattern, index + length)

        self.setCurrentBlockState(0)


class LogArea(QtGui.QTextEdit):
    append_signal = QtCore.pyqtSignal(logging.LogRecord)

    def __init__(self):
        super(LogArea, self).__init__()
        self.highlighter = Highlighter(self, 'Classic')
        self.logHandler = None
        self.append_signal.connect(self.append)

    def init_logging(self):
        self.logHandler = LogHandler(self)
        logging.getLogger().addHandler(self.logHandler)

    def append(self, record):
        super(LogArea, self).append(self.logHandler.format(record))
        self.ensureCursorVisible()

    def setKeywords(self, kw):
        self.highlighter.setKeywords(kw)