| 1 |
/* |
| 2 |
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. |
| 3 |
* |
| 4 |
* This file is part of the reasoning system Konclude. |
| 5 |
* For details and support, see <http://konclude.com/>. |
| 6 |
* |
| 7 |
* Konclude is free software: you can redistribute it and/or modify |
| 8 |
* it under the terms of version 3 of the GNU Lesser General Public |
| 9 |
* License (LGPLv3) as published by the Free Software Foundation. |
| 10 |
* |
| 11 |
* Konclude is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 |
* GNU (Lesser) General Public License for more details. |
| 15 |
* |
| 16 |
* You should have received a copy of the GNU (Lesser) General Public |
| 17 |
* License along with Konclude. If not, see <http://www.gnu.org/licenses/>. |
| 18 |
* |
| 19 |
*/ |
| 20 |
#include "CLogger.h" |
| 21 |
|
| 22 |
|
| 23 |
QString logTr(const char *sourceText, const char *comment, int n) { |
| 24 |
return QObject::tr(sourceText,comment,n); |
| 25 |
} |
| 26 |
|
| 27 |
|
| 28 |
namespace Konclude { |
| 29 |
|
| 30 |
namespace Logger { |
| 31 |
|
| 32 |
CLogger *CLogger::mInstance=0; |
| 33 |
|
| 34 |
QMutex *CLogger::mInstanceCreationMutex = new QMutex(); |
| 35 |
|
| 36 |
|
| 37 |
CLogger::CLogger() |
| 38 |
: CIntervalThread("Logger") { |
| 39 |
|
| 40 |
unsavedMessagesCount = 0; |
| 41 |
savedMessageCount = 0; |
| 42 |
totalMessageCount = 0; |
| 43 |
lastInMemoryMessage = 0; |
| 44 |
|
| 45 |
nextMessageID = 0; |
| 46 |
|
| 47 |
mMaxLogMessageCount = -1; |
| 48 |
mMinLoggingLevel = 0; |
| 49 |
mCurrentLogMessageCount = 0; |
| 50 |
|
| 51 |
startThread(); |
| 52 |
} |
| 53 |
|
| 54 |
|
| 55 |
CLogger::~CLogger() { |
| 56 |
stopThread(); |
| 57 |
} |
| 58 |
|
| 59 |
|
| 60 |
|
| 61 |
void CLogger::shutdownLogger() { |
| 62 |
mInstance->waitSynchronization(); |
| 63 |
mInstanceCreationMutex->lock(); |
| 64 |
mInstance->stopThread(); |
| 65 |
// wait until the thread is stopped |
| 66 |
mInstance->wait(); |
| 67 |
delete mInstance; |
| 68 |
mInstance = 0; |
| 69 |
mInstanceCreationMutex->unlock(); |
| 70 |
} |
| 71 |
|
| 72 |
|
| 73 |
|
| 74 |
CCallbackRequestLogMessagesContext *CLogger::getLogMessages(qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList<void *> objects) { |
| 75 |
CBlockingCallbackData *blockingCallback = new CBlockingCallbackData(); |
| 76 |
getLogMessages(blockingCallback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects); |
| 77 |
blockingCallback->waitForCallback(); |
| 78 |
CCallbackRequestLogMessagesContext *context = (CCallbackRequestLogMessagesContext *)blockingCallback->takeCallbackDataContext(); |
| 79 |
delete blockingCallback; |
| 80 |
return context; |
| 81 |
} |
| 82 |
|
| 83 |
|
| 84 |
void CLogger::getLogMessages(CCallbackData *callback, qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList<void *> objects) { |
| 85 |
postEvent(new CRequestLogMessagesEvent(callback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects)); |
| 86 |
} |
| 87 |
|
| 88 |
|
| 89 |
void CLogger::releaseLogMessages(QLinkedList<CLogMessage *> &logMessages) { |
| 90 |
postEvent(new CReleaseLogMessagesEvent(logMessages)); |
| 91 |
} |
| 92 |
|
| 93 |
|
| 94 |
double CLogger::getMinLoggingLevel() { |
| 95 |
return mMinLoggingLevel; |
| 96 |
} |
| 97 |
|
| 98 |
|
| 99 |
bool CLogger::hasMinLoggingLevel(double level) { |
| 100 |
return level >= mMinLoggingLevel; |
| 101 |
} |
| 102 |
|
| 103 |
|
| 104 |
void CLogger::configureLogger(qint64 maxLogMessages, double minLoggingLevel) { |
| 105 |
postEvent(new CConfigureLoggerEvent(maxLogMessages,minLoggingLevel)); |
| 106 |
} |
| 107 |
|
| 108 |
|
| 109 |
void CLogger::addLogMessage(QString message, double level, QString domain, void *object) { |
| 110 |
postEvent(new CLoggingEvent(new CLogMessage(domain,message,level,object))); |
| 111 |
} |
| 112 |
|
| 113 |
void CLogger::addLogObserver(CAbstractLogObserver *observer, double level, QStringList domains) { |
| 114 |
if (domains.count() <= 0) { |
| 115 |
domains<<"::"; |
| 116 |
} |
| 117 |
observerSyncMutex.lock(); |
| 118 |
CLogObserverData *obsData = new CLogObserverData(observer,level,domains); |
| 119 |
addObserverToDomains(obsData,domains); |
| 120 |
observerHash.insertMulti(observer,obsData); |
| 121 |
observerSyncMutex.unlock(); |
| 122 |
CThread::waitSynchronization(); |
| 123 |
} |
| 124 |
|
| 125 |
|
| 126 |
void CLogger::removeObserverFromAllDomains(CAbstractLogObserver *observer) { |
| 127 |
observerSyncMutex.lock(); |
| 128 |
if (observerHash.contains(observer)) { |
| 129 |
QList<CLogObserverData *> obsDataList(observerHash.values(observer)); |
| 130 |
foreach (CLogObserverData *obsData, obsDataList) { |
| 131 |
if (observerDomainHash.contains(obsData)) { |
| 132 |
QList<CLogDomain *> domainList(observerDomainHash.values(obsData)); |
| 133 |
foreach (CLogDomain *domain, domainList) { |
| 134 |
domain->removeLogObserver(obsData); |
| 135 |
} |
| 136 |
} |
| 137 |
delete obsData; |
| 138 |
} |
| 139 |
observerHash.remove(observer); |
| 140 |
} |
| 141 |
observerSyncMutex.unlock(); |
| 142 |
} |
| 143 |
|
| 144 |
void CLogger::removeObserverFromDomains(CAbstractLogObserver *observer, QStringList remDomains) { |
| 145 |
observerSyncMutex.lock(); |
| 146 |
QSet<QString> removeDomainsSet; |
| 147 |
|
| 148 |
if (observerHash.contains(observer)) { |
| 149 |
QList<CLogObserverData *> obsDataList(observerHash.values(observer)); |
| 150 |
foreach (QString domain,remDomains) { |
| 151 |
removeDomainsSet.insert(domain); |
| 152 |
} |
| 153 |
foreach (CLogObserverData *obsData, obsDataList) { |
| 154 |
QStringList domainList(obsData->getLogDomains()); |
| 155 |
foreach (QString domain, domainList) { |
| 156 |
if (removeDomainsSet.contains(domain)) { |
| 157 |
if (domainHash.contains(domain)) { |
| 158 |
CLogDomain *logDomain = domainHash.value(domain); |
| 159 |
logDomain->removeLogObserver(obsData); |
| 160 |
} |
| 161 |
obsData->removeLogDomain(domain); |
| 162 |
} |
| 163 |
} |
| 164 |
} |
| 165 |
} |
| 166 |
observerSyncMutex.unlock(); |
| 167 |
} |
| 168 |
|
| 169 |
|
| 170 |
|
| 171 |
void CLogger::addObserverToDomains(CLogObserverData *obsData, QStringList domains) { |
| 172 |
foreach (QString domainString, domains) { |
| 173 |
CLogDomain *domain = 0; |
| 174 |
if (domainHash.contains(domainString)) { |
| 175 |
domain = domainHash.value(domainString); |
| 176 |
} else { |
| 177 |
domain = new CLogDomain(domainString); |
| 178 |
domainHash.insert(domainString,domain); |
| 179 |
} |
| 180 |
if (domain) { |
| 181 |
obsData->addLogDomain(domainString); |
| 182 |
domain->addLogObserver(obsData); |
| 183 |
observerDomainHash.insert(obsData,domain); |
| 184 |
} |
| 185 |
} |
| 186 |
} |
| 187 |
|
| 188 |
|
| 189 |
|
| 190 |
void CLogger::threadStarted() { |
| 191 |
CIntervalThread::threadStarted(); |
| 192 |
startTimerWithInterval(SAVETOFILETIMERID,1000); |
| 193 |
} |
| 194 |
|
| 195 |
void CLogger::threadStopped() { |
| 196 |
CIntervalThread::threadStopped(); |
| 197 |
qDeleteAll(loglist); |
| 198 |
} |
| 199 |
|
| 200 |
|
| 201 |
|
| 202 |
bool CLogger::deleteOldLogMessages() { |
| 203 |
bool messagesDeleted = false; |
| 204 |
if (mCurrentLogMessageCount > mMaxLogMessageCount && mMaxLogMessageCount >= 0) { |
| 205 |
while (mCurrentLogMessageCount > mMaxLogMessageCount && !loglist.isEmpty()) { |
| 206 |
CLogMessage* deleteLM = loglist.takeLast(); |
| 207 |
idMessageHash.remove(deleteLM->getLogID()); |
| 208 |
delete deleteLM; |
| 209 |
messagesDeleted = true; |
| 210 |
--mCurrentLogMessageCount; |
| 211 |
} |
| 212 |
} |
| 213 |
return messagesDeleted; |
| 214 |
} |
| 215 |
|
| 216 |
|
| 217 |
|
| 218 |
bool CLogger::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { |
| 219 |
if (CIntervalThread::processCustomsEvents(type,event)) { |
| 220 |
return true; |
| 221 |
} else if (type == Konclude::Logger::EVENTLOGMESSAGE) { |
| 222 |
SETTASKDESCRIPTION("Process Log Message"); |
| 223 |
CLoggingEvent *le = (CLoggingEvent *)event; |
| 224 |
CLogMessage *lm = le->getLogMessage(); |
| 225 |
|
| 226 |
QString domain = lm->getDomain(); |
| 227 |
QStringList domainList(domain.split("::",QString::SkipEmptyParts)); |
| 228 |
|
| 229 |
loglist.append(lm); |
| 230 |
unsavedMessagesCount++; |
| 231 |
totalMessageCount++; |
| 232 |
|
| 233 |
observerSyncMutex.lock(); |
| 234 |
|
| 235 |
lm->setLogID(nextMessageID); |
| 236 |
idMessageHash.insert(nextMessageID,lm); |
| 237 |
++nextMessageID; |
| 238 |
++mCurrentLogMessageCount; |
| 239 |
|
| 240 |
propagateLogMessageToDomain("::",lm); |
| 241 |
|
| 242 |
QString accDomain; |
| 243 |
|
| 244 |
foreach (QString endDomain, domainList) { |
| 245 |
accDomain.append("::"); |
| 246 |
accDomain.append(endDomain); |
| 247 |
propagateLogMessageToDomain(accDomain,lm); |
| 248 |
propagateLogMessageToDomain(endDomain,lm); |
| 249 |
} |
| 250 |
observerSyncMutex.unlock(); |
| 251 |
|
| 252 |
deleteOldLogMessages(); |
| 253 |
|
| 254 |
return true; |
| 255 |
|
| 256 |
} else if (type == Konclude::Logger::EVENTCONFIGURELOGGER) { |
| 257 |
SETTASKDESCRIPTION("Configure Logger"); |
| 258 |
CConfigureLoggerEvent* cle = (CConfigureLoggerEvent *)event; |
| 259 |
|
| 260 |
mMaxLogMessageCount = cle->getMaxLogMessageCount(); |
| 261 |
mMinLoggingLevel = cle->getMinLoggingLevel(); |
| 262 |
|
| 263 |
deleteOldLogMessages(); |
| 264 |
|
| 265 |
return true; |
| 266 |
|
| 267 |
} else if (type == Konclude::Logger::EVENTRELEASELOGMESSAGES) { |
| 268 |
SETTASKDESCRIPTION("Release Log Message"); |
| 269 |
CReleaseLogMessagesEvent *rlm = (CReleaseLogMessagesEvent *)event; |
| 270 |
|
| 271 |
QLinkedList<CLogMessage *> releaseLogMessageList(rlm->getLogMessages()); |
| 272 |
|
| 273 |
foreach (CLogMessage *logMessage, releaseLogMessageList) { |
| 274 |
logMessage->decLockCount(); |
| 275 |
} |
| 276 |
|
| 277 |
return true; |
| 278 |
|
| 279 |
} else if (type == Konclude::Logger::EVENTREQUESTLOGMESSAGES) { |
| 280 |
SETTASKDESCRIPTION("Create Log Message Collection Response"); |
| 281 |
CRequestLogMessagesEvent *rlm = (CRequestLogMessagesEvent *)event; |
| 282 |
|
| 283 |
CCallbackRequestLogMessagesContext *logMessageContext = new CCallbackRequestLogMessagesContext(); |
| 284 |
|
| 285 |
double beginLevel = rlm->getBeginLevel(); |
| 286 |
double endLevel = rlm->getEndLevel(); |
| 287 |
|
| 288 |
qint64 beginID = rlm->getMessageBeginID(); |
| 289 |
qint64 endID = rlm->getMessageEndID(); |
| 290 |
if (endID == -1) { |
| 291 |
endID = nextMessageID; |
| 292 |
} |
| 293 |
endID = qMax(endID,beginID); |
| 294 |
|
| 295 |
QStringList domainGetList = rlm->getDomains(); |
| 296 |
CCallbackData *callback = rlm->getCallback(); |
| 297 |
|
| 298 |
QSet<QString> domainGetSet; |
| 299 |
foreach (QString domain, domainGetList) { |
| 300 |
domainGetSet.insert(domain); |
| 301 |
} |
| 302 |
|
| 303 |
QLinkedList<void *> objectList = rlm->getObjects(); |
| 304 |
|
| 305 |
for (qint64 startID = qMax(beginID,lastInMemoryMessage); startID != endID; ++startID) { |
| 306 |
|
| 307 |
if (idMessageHash.contains(startID)) { |
| 308 |
CLogMessage *message = idMessageHash.value(startID); |
| 309 |
|
| 310 |
double logLevel = message->getLogLevel(); |
| 311 |
if (logLevel >= beginLevel && logLevel <= endLevel) { |
| 312 |
|
| 313 |
bool messageRequested = false; |
| 314 |
if (domainGetList.isEmpty()) { |
| 315 |
messageRequested = true; |
| 316 |
} else { |
| 317 |
if (domainGetSet.contains("::")) { |
| 318 |
messageRequested = true; |
| 319 |
} else { |
| 320 |
QStringList domainList(message->getDomain().split("::",QString::SkipEmptyParts)); |
| 321 |
QString accDomain; |
| 322 |
foreach (const QString& endDomain, domainList) { |
| 323 |
accDomain.append("::"); |
| 324 |
accDomain.append(endDomain); |
| 325 |
if (domainGetSet.contains(accDomain) || domainGetSet.contains(endDomain)) { |
| 326 |
messageRequested = true; |
| 327 |
break; |
| 328 |
} |
| 329 |
} |
| 330 |
|
| 331 |
} |
| 332 |
} |
| 333 |
|
| 334 |
|
| 335 |
if (messageRequested) { |
| 336 |
logMessageContext->addLogMessage(message); |
| 337 |
message->incLockCount(); |
| 338 |
} |
| 339 |
|
| 340 |
} |
| 341 |
|
| 342 |
|
| 343 |
} |
| 344 |
|
| 345 |
} |
| 346 |
|
| 347 |
callback->setCallbackDataContext(logMessageContext); |
| 348 |
|
| 349 |
callback->doCallback(); |
| 350 |
return true; |
| 351 |
|
| 352 |
} |
| 353 |
return false; |
| 354 |
} |
| 355 |
|
| 356 |
|
| 357 |
void CLogger::propagateLogMessageToDomain(QString domain, CLogMessage *message) { |
| 358 |
CLogDomain *logDomain = domainHash.value(domain); |
| 359 |
if (logDomain) { |
| 360 |
logDomain->postLogMessage(message); |
| 361 |
} |
| 362 |
} |
| 363 |
|
| 364 |
|
| 365 |
|
| 366 |
bool CLogger::processTimer(qint64 timerID) { |
| 367 |
if (timerID == SAVETOFILETIMERID) { |
| 368 |
return true; |
| 369 |
} |
| 370 |
return false; |
| 371 |
} |
| 372 |
|
| 373 |
|
| 374 |
// returns the Instance of the CLogger and creates it when necessary |
| 375 |
CLogger *CLogger::getInstance() { |
| 376 |
if (mInstance == nullptr) { |
| 377 |
mInstanceCreationMutex->lock(); |
| 378 |
if (mInstance == 0) { |
| 379 |
mInstance = new CLogger(); |
| 380 |
} |
| 381 |
mInstanceCreationMutex->unlock(); |
| 382 |
} |
| 383 |
return mInstance; |
| 384 |
} |
| 385 |
|
| 386 |
|
| 387 |
|
| 388 |
}; // end namespace Logger |
| 389 |
|
| 390 |
}; // end namespace Konclude |