/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CLogger.h" QString logTr(const char *sourceText, const char *comment, int n) { return QObject::tr(sourceText,comment,n); } namespace Konclude { namespace Logger { CLogger *CLogger::mInstance=0; QMutex *CLogger::mInstanceCreationMutex = new QMutex(); CLogger::CLogger() : CIntervalThread("Logger") { unsavedMessagesCount = 0; savedMessageCount = 0; totalMessageCount = 0; lastInMemoryMessage = 0; nextMessageID = 0; mMaxLogMessageCount = -1; mMinLoggingLevel = 0; mCurrentLogMessageCount = 0; startThread(); } CLogger::~CLogger() { stopThread(); } void CLogger::shutdownLogger() { mInstance->waitSynchronization(); mInstanceCreationMutex->lock(); mInstance->stopThread(); // wait until the thread is stopped mInstance->wait(); delete mInstance; mInstance = 0; mInstanceCreationMutex->unlock(); } CCallbackRequestLogMessagesContext *CLogger::getLogMessages(qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList objects) { CBlockingCallbackData *blockingCallback = new CBlockingCallbackData(); getLogMessages(blockingCallback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects); blockingCallback->waitForCallback(); CCallbackRequestLogMessagesContext *context = (CCallbackRequestLogMessagesContext *)blockingCallback->takeCallbackDataContext(); delete blockingCallback; return context; } void CLogger::getLogMessages(CCallbackData *callback, qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList objects) { postEvent(new CRequestLogMessagesEvent(callback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects)); } void CLogger::releaseLogMessages(QLinkedList &logMessages) { postEvent(new CReleaseLogMessagesEvent(logMessages)); } double CLogger::getMinLoggingLevel() { return mMinLoggingLevel; } bool CLogger::hasMinLoggingLevel(double level) { return level >= mMinLoggingLevel; } void CLogger::configureLogger(qint64 maxLogMessages, double minLoggingLevel) { postEvent(new CConfigureLoggerEvent(maxLogMessages,minLoggingLevel)); } void CLogger::addLogMessage(QString message, double level, QString domain, void *object) { postEvent(new CLoggingEvent(new CLogMessage(domain,message,level,object))); } void CLogger::addLogObserver(CAbstractLogObserver *observer, double level, QStringList domains) { if (domains.count() <= 0) { domains<<"::"; } observerSyncMutex.lock(); CLogObserverData *obsData = new CLogObserverData(observer,level,domains); addObserverToDomains(obsData,domains); observerHash.insertMulti(observer,obsData); observerSyncMutex.unlock(); CThread::waitSynchronization(); } void CLogger::removeObserverFromAllDomains(CAbstractLogObserver *observer) { observerSyncMutex.lock(); if (observerHash.contains(observer)) { QList obsDataList(observerHash.values(observer)); foreach (CLogObserverData *obsData, obsDataList) { if (observerDomainHash.contains(obsData)) { QList domainList(observerDomainHash.values(obsData)); foreach (CLogDomain *domain, domainList) { domain->removeLogObserver(obsData); } } delete obsData; } observerHash.remove(observer); } observerSyncMutex.unlock(); } void CLogger::removeObserverFromDomains(CAbstractLogObserver *observer, QStringList remDomains) { observerSyncMutex.lock(); QSet removeDomainsSet; if (observerHash.contains(observer)) { QList obsDataList(observerHash.values(observer)); foreach (QString domain,remDomains) { removeDomainsSet.insert(domain); } foreach (CLogObserverData *obsData, obsDataList) { QStringList domainList(obsData->getLogDomains()); foreach (QString domain, domainList) { if (removeDomainsSet.contains(domain)) { if (domainHash.contains(domain)) { CLogDomain *logDomain = domainHash.value(domain); logDomain->removeLogObserver(obsData); } obsData->removeLogDomain(domain); } } } } observerSyncMutex.unlock(); } void CLogger::addObserverToDomains(CLogObserverData *obsData, QStringList domains) { foreach (QString domainString, domains) { CLogDomain *domain = 0; if (domainHash.contains(domainString)) { domain = domainHash.value(domainString); } else { domain = new CLogDomain(domainString); domainHash.insert(domainString,domain); } if (domain) { obsData->addLogDomain(domainString); domain->addLogObserver(obsData); observerDomainHash.insert(obsData,domain); } } } void CLogger::threadStarted() { CIntervalThread::threadStarted(); startTimerWithInterval(SAVETOFILETIMERID,1000); } void CLogger::threadStopped() { CIntervalThread::threadStopped(); qDeleteAll(loglist); } bool CLogger::deleteOldLogMessages() { bool messagesDeleted = false; if (mCurrentLogMessageCount > mMaxLogMessageCount && mMaxLogMessageCount >= 0) { while (mCurrentLogMessageCount > mMaxLogMessageCount && !loglist.isEmpty()) { CLogMessage* deleteLM = loglist.takeLast(); idMessageHash.remove(deleteLM->getLogID()); delete deleteLM; messagesDeleted = true; --mCurrentLogMessageCount; } } return messagesDeleted; } bool CLogger::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { if (CIntervalThread::processCustomsEvents(type,event)) { return true; } else if (type == Konclude::Logger::EVENTLOGMESSAGE) { SETTASKDESCRIPTION("Process Log Message"); CLoggingEvent *le = (CLoggingEvent *)event; CLogMessage *lm = le->getLogMessage(); QString domain = lm->getDomain(); QStringList domainList(domain.split("::",QString::SkipEmptyParts)); loglist.append(lm); unsavedMessagesCount++; totalMessageCount++; observerSyncMutex.lock(); lm->setLogID(nextMessageID); idMessageHash.insert(nextMessageID,lm); ++nextMessageID; ++mCurrentLogMessageCount; propagateLogMessageToDomain("::",lm); QString accDomain; foreach (QString endDomain, domainList) { accDomain.append("::"); accDomain.append(endDomain); propagateLogMessageToDomain(accDomain,lm); propagateLogMessageToDomain(endDomain,lm); } observerSyncMutex.unlock(); deleteOldLogMessages(); return true; } else if (type == Konclude::Logger::EVENTCONFIGURELOGGER) { SETTASKDESCRIPTION("Configure Logger"); CConfigureLoggerEvent* cle = (CConfigureLoggerEvent *)event; mMaxLogMessageCount = cle->getMaxLogMessageCount(); mMinLoggingLevel = cle->getMinLoggingLevel(); deleteOldLogMessages(); return true; } else if (type == Konclude::Logger::EVENTRELEASELOGMESSAGES) { SETTASKDESCRIPTION("Release Log Message"); CReleaseLogMessagesEvent *rlm = (CReleaseLogMessagesEvent *)event; QLinkedList releaseLogMessageList(rlm->getLogMessages()); foreach (CLogMessage *logMessage, releaseLogMessageList) { logMessage->decLockCount(); } return true; } else if (type == Konclude::Logger::EVENTREQUESTLOGMESSAGES) { SETTASKDESCRIPTION("Create Log Message Collection Response"); CRequestLogMessagesEvent *rlm = (CRequestLogMessagesEvent *)event; CCallbackRequestLogMessagesContext *logMessageContext = new CCallbackRequestLogMessagesContext(); double beginLevel = rlm->getBeginLevel(); double endLevel = rlm->getEndLevel(); qint64 beginID = rlm->getMessageBeginID(); qint64 endID = rlm->getMessageEndID(); if (endID == -1) { endID = nextMessageID; } endID = qMax(endID,beginID); QStringList domainGetList = rlm->getDomains(); CCallbackData *callback = rlm->getCallback(); QSet domainGetSet; foreach (QString domain, domainGetList) { domainGetSet.insert(domain); } QLinkedList objectList = rlm->getObjects(); for (qint64 startID = qMax(beginID,lastInMemoryMessage); startID != endID; ++startID) { if (idMessageHash.contains(startID)) { CLogMessage *message = idMessageHash.value(startID); double logLevel = message->getLogLevel(); if (logLevel >= beginLevel && logLevel <= endLevel) { bool messageRequested = false; if (domainGetList.isEmpty()) { messageRequested = true; } else { if (domainGetSet.contains("::")) { messageRequested = true; } else { QStringList domainList(message->getDomain().split("::",QString::SkipEmptyParts)); QString accDomain; foreach (const QString& endDomain, domainList) { accDomain.append("::"); accDomain.append(endDomain); if (domainGetSet.contains(accDomain) || domainGetSet.contains(endDomain)) { messageRequested = true; break; } } } } if (messageRequested) { logMessageContext->addLogMessage(message); message->incLockCount(); } } } } callback->setCallbackDataContext(logMessageContext); callback->doCallback(); return true; } return false; } void CLogger::propagateLogMessageToDomain(QString domain, CLogMessage *message) { CLogDomain *logDomain = domainHash.value(domain); if (logDomain) { logDomain->postLogMessage(message); } } bool CLogger::processTimer(qint64 timerID) { if (timerID == SAVETOFILETIMERID) { return true; } return false; } // returns the Instance of the CLogger and creates it when necessary CLogger *CLogger::getInstance() { if (mInstance == nullptr) { mInstanceCreationMutex->lock(); if (mInstance == 0) { mInstance = new CLogger(); } mInstanceCreationMutex->unlock(); } return mInstance; } }; // end namespace Logger }; // end namespace Konclude