KaptureControlGui/KCG/base/loghandler.py

import logging
from logging import handlers
import os
import sys
from PyQt4 import QtGui, QtCore

from .. import config

"""
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):
        """
        Emit a log record
        """
        self.acquire()
        self.text_area.append_signal.emit(record)
        self.release()


class Highlighter(QtGui.QSyntaxHighlighter):
    """
    Highlighter for the logging area
    """
    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):
        """
        Set the keywords to check for
        :param kw: the keywords
        """
        keyword = QtGui.QTextCharFormat()
        keyword.setForeground(QtCore.Qt.darkBlue)
        keyword.setFontWeight(QtGui.QFont.Bold)
        keywords = kw
        for word in keywords:
            pattern = QtCore.QRegExp("\\b" + word + "\\b")
            self.highlightingRules.append((pattern, keyword))

    def highlightBlock(self, text):
        """
        Highlight a block of text
        :param text: the text to check in
        """
        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 = pattern.indexIn(text, index + length)

        self.setCurrentBlockState(0)


class LogArea(QtGui.QTextEdit):
    """
    The log area for the KCG Gui
    """
    append_signal = QtCore.pyqtSignal(logging.LogRecord)

    def __init__(self):
        super(LogArea, self).__init__()
        self.highlighter = Highlighter(self, 'Classic')
        self.logHandler = None
        self.streamLogger = logging.StreamHandler(stream=sys.stdout)
        self.streamLogger.setLevel(config.log_level)
        self.streamLogger.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
        logging.getLogger().addHandler(self.streamLogger)
        self.fileLogHandler = handlers.RotatingFileHandler(config.config_path("kcg.log"), maxBytes=10**7, backupCount=5)
        self.fileLogHandler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
        self.fileLogHandler.setLevel(config.log_level)
        logging.getLogger().addHandler(self.fileLogHandler)
        self.append_signal.connect(self.append)

    def init_logging(self):
        """
        Initialize logging
        """
        self.logHandler = LogHandler(self)
        self.logHandler.setLevel(config.log_level)
        logging.getLogger().addHandler(self.logHandler)

    def append(self, record):
        """
        Append to the logarea
        :param record: the record to append
        """
        super(LogArea, self).append(self.logHandler.format(record))
        self.ensureCursorVisible()

    def setKeywords(self, kw):
        """
        Set the keywords for the highlighter
        :param kw: the keywords to set
        """
        self.highlighter.setKeywords(kw)