Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-16 16:36:55 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

LogHandler class stores regexps rather than always recreating

Browse source 
General efficiency tweaks; move to C++11.
This commit is contained in:
Simon Walton 2018-03-09 13:36:43 -08:00
parent 42a686ad93
commit 4b27cd73ff
2 changed files with 40 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
libraries/shared/src/LogHandler.cpp
View file

@ -22,7 +22,6 @@
#include <QtCore/QDateTime>
#include <QtCore/QDebug>
#include <QtCore/QMutexLocker>
#include <QtCore/QRegExp>
#include <QtCore/QThread>
#include <QtCore/QTimer>
@ -92,12 +91,13 @@ void LogHandler::setShouldDisplayMilliseconds(bool shouldDisplayMilliseconds) {
void LogHandler::flushRepeatedMessages() {
QMutexLocker lock(&_mutex);
QHash<QString, int>::iterator message = _repeatMessageCountHash.begin();
while (message != _repeatMessageCountHash.end()) {
for(auto& message: _repeatedMessages) {
if (message.value() > 0) {
if (message->messageCount > 1) {
QString repeatMessage = QString("%1 repeated log entries matching \"%2\" - Last entry: \"%3\"")
.arg(message.value()).arg(message.key()).arg(_lastRepeatedMessage.value(message.key()));
.arg(message->messageCount - 1)
.arg(message->regexp.pattern())
.arg(message->lastMessage);
QMessageLogContext emptyContext;
lock.unlock();
@ -105,8 +105,7 @@ void LogHandler::flushRepeatedMessages() {
lock.relock();
}
_lastRepeatedMessage.remove(message.key());
message = _repeatMessageCountHash.erase(message);
message->messageCount = 0;
}
}
@ -118,44 +117,25 @@ QString LogHandler::printMessage(LogMsgType type, const QMessageLogContext& cont
if (type == LogDebug) {
// for debug messages, check if this matches any of our regexes for repeated log messages
foreach(const QString& regexString, getInstance()._repeatedMessageRegexes) {
QRegExp repeatRegex(regexString);
if (repeatRegex.indexIn(message) != -1) {
if (!_repeatMessageCountHash.contains(regexString)) {
// we have a match but didn't have this yet - output the first one
_repeatMessageCountHash[regexString] = 0;
// break the foreach so we output the first match
break;
} else {
// we have a match - add 1 to the count of repeats for this message and set this as the last repeated message
_repeatMessageCountHash[regexString] += 1;
_lastRepeatedMessage[regexString] = message;
// return out, we're not printing this one
return QString();
}
for(auto& repeatRegex: _repeatedMessages) {
if (repeatRegex->regexp.indexIn(message) != -1) {
// If we've printed the first one then return out.
if (repeatRegex->messageCount++ == 0) break;
repeatRegex->lastMessage = message;
return QString();
}
}
}
if (type == LogDebug) {
// see if this message is one we should only print once
foreach(const QString& regexString, getInstance()._onlyOnceMessageRegexes) {
QRegExp onlyOnceRegex(regexString);
if (onlyOnceRegex.indexIn(message) != -1) {
if (!_onlyOnceMessageCountHash.contains(message)) {
// we have a match and haven't yet printed this message.
_onlyOnceMessageCountHash[message] = 1;
// break the foreach so we output the first match
break;
} else {
// We've already printed this message, don't print it again.
return QString();
for(auto& onceOnly : _onetimeMessages) {
if (onceOnly->regexp.indexIn(message) != -1) {
if (onceOnly->messageCount++ == 0) break; // we have a match and haven't yet printed this message.
else return QString(); // We've already printed this message, don't print it again.
}
}
}
}
// log prefix is in the following format
// [TIMESTAMP] [DEBUG] [PID] [TID] [TARGET] logged string
@ -217,10 +197,16 @@ const QString& LogHandler::addRepeatedMessageRegex(const QString& regexString) {
QMetaObject::invokeMethod(this, "setupRepeatedMessageFlusher");
QMutexLocker lock(&_mutex);
return *_repeatedMessageRegexes.insert(regexString);
std::unique_ptr<_RepeatedMessage> repeatRecord(new _RepeatedMessage());
repeatRecord->regexp = QRegExp(regexString);
_repeatedMessages.insert(std::move(repeatRecord));
return regexString;
}
const QString& LogHandler::addOnlyOnceMessageRegex(const QString& regexString) {
QMutexLocker lock(&_mutex);
return *_onlyOnceMessageRegexes.insert(regexString);
std::unique_ptr<_OnceOnlyMessage> onetimeMessage(new _OnceOnlyMessage());
onetimeMessage->regexp = QRegExp(regexString);
_onetimeMessages.insert(std::move(onetimeMessage));
return regexString;
}

22
libraries/shared/src/LogHandler.h
View file

@ -13,11 +13,12 @@
#ifndef hifi_LogHandler_h
#define hifi_LogHandler_h
#include <QHash>
#include <QObject>
#include <QSet>
#include <QString>
#include <QRegExp>
#include <QMutex>
#include <set>
#include <memory>
const int VERBOSE_LOG_INTERVAL_SECONDS = 5;
@ -66,12 +67,19 @@ private:
bool _shouldOutputProcessID { false };
bool _shouldOutputThreadID { false };
bool _shouldDisplayMilliseconds { false };
QSet<QString> _repeatedMessageRegexes;
QHash<QString, int> _repeatMessageCountHash;
QHash<QString, QString> _lastRepeatedMessage;
QSet<QString> _onlyOnceMessageRegexes;
QHash<QString, int> _onlyOnceMessageCountHash;
struct _RepeatedMessage {
QRegExp regexp;
int messageCount { 0 };
QString lastMessage;
};
std::set<std::unique_ptr<_RepeatedMessage>> _repeatedMessages;
struct _OnceOnlyMessage {
QRegExp regexp;
int messageCount { 0 };
};
std::set<std::unique_ptr<_OnceOnlyMessage>> _onetimeMessages;
static QMutex _mutex;
};