ZblLogManager.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblLogManager.cpp
 * Created on: 4/19/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZblLogManager.h"
#include "ZApplication.h"
#include "ZblException.h"
#include "ZTableModel.h"
#include "ZSettings.h"
#include "zglobal.h"
#include "ZblApp.h"
#include "ZblLogWorker.h"
#include "ZblLogMessage.h"
#include <QMutexLocker>
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QCoreApplication>
#include <QDateTime>
#include <QDir>
//#include <QStringBuilder>
#include <QTemporaryFile>
#include <QStringBuilder>
#include <QVariant>


namespace Zbl
{

ZblLogManager* ZblLogManager::m_zLog = nullptr;


ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZblLogManager)

const QString ZblLogManager::m_zubleSettingsBundleId = "default";
const QString ZblLogManager::m_currentLogSettingsBundleId = "current-log-profile";
const QString ZblLogManager::m_defaultOutputFilePath = "";

int ZblLogManager::m_maxBufferSize = 1000;

// WARNING: m_logBufRoleCount must match number of log buffer roles
const int ZblLogManager::m_logBufRoleCount = 7;

const QString ZblLogManager::m_logFilterRulesKey = "log-filter-rules";

const QString ZblLogManager::m_profileMetadata =

"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
"<appsettings\n"
"xmlns=\"http://zuble.org/schema/zuble/settings\"\n"
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
"\n"
"xsi:schemaLocation=\"http://zuble.org/schema/zuble/settings zublesettings01.xsd\">\n"
"  <organization>zuble.org</organization> \n"
"   <name>Zuble</name> \n"
"   <setgroups> \n"
"          <setgroup xml:id=\"log-histogram\"> \n"
"                  <name>Log Histogram</name> \n"
"           </setgroup> \n"
"           <setgroup xml:id=\"log-output\"> \n"
"                  <name>Log Output</name> \n"
"           </setgroup> \n"
"           <setgroup xml:id=\"log-input\"> \n"
"                  <name>Log Input</name> \n"
"           </setgroup> \n"
"   </setgroups> \n"
"       <settings> \n"
"        <setting xml:id=\"histogram-enabled\" group=\"log-histogram\"> \n"
"           <name>Enabled</name> \n"
"           <type>bool</type> \n"
"           <default>false</default> \n"
"           <status> \n"
"              <state value=\"false\">Disabled</state> \n"
"              <state value=\"true\">Enabled</state> \n"
"           </status> \n"
"           <desc>Enable the log histogram buffer.</desc> \n"
"        </setting> \n"
"         <setting xml:id=\"histogram-buffer-size\" group=\"log-histogram\"> \n"
"            <name>Buffer Size</name> \n"
"            <type>string</type> \n"
"            <default>1000</default> \n"
"            <desc>Set the number of log records the histogram will hold.</desc> \n"
"         </setting> \n"
"           <setting xml:id=\"log-file-enabled\" group=\"log-output\"> \n"
"              <name>Log To File</name> \n"
"              <type>bool</type> \n"
"              <default>false</default> \n"
"              <status> \n"
"                 <state value=\"false\">Disabled</state> \n"
"                 <state value=\"true\">Enabled</state> \n"
"              </status> \n"
"              <desc>Send log output to a file.</desc> \n"
"           </setting> \n"
"           <setting xml:id=\"log-stdout-enabled\" group=\"log-output\"> \n"
"              <name>Log To stdout</name> \n"
"              <type>bool</type> \n"
"              <default>true</default> \n"
"              <status> \n"
"                 <state value=\"false\">Disabled</state> \n"
"                 <state value=\"true\">Enabled</state> \n"
"              </status> \n"
"              <desc>Send log output to stdout.</desc> \n"
"           </setting> \n"
"              <setting xml:id=\"log-file-format\" group=\"log-output\"> \n"
"                <name>Log File Format</name> \n"
"                <type>choice</type> \n"
"                <default>text</default> \n"
"                <choiceItems> \n"
"                <choiceItem> \n"
"                  <name>Plain Text</name> \n"
"                  <desc>Output simple utf8 text strings.</desc> \n"
"                  <value>text</value> \n"
"                </choiceItem> \n"
"                <choiceItem> \n"
"                  <name>XML</name> \n"
"                  <desc>Output XML-encoded log records.</desc> \n"
"                  <value>xml</value> \n"
"                </choiceItem> \n"
"                <choiceItem> \n"
"                  <name>JSON</name> \n"
"                  <desc>Output JSON-encoded log records.</desc> \n"
"                  <value>json</value> \n"
"                </choiceItem> \n"
"                </choiceItems> \n"
"                <desc>Select the log record output format.</desc> \n"
"               </setting> \n"
"               <setting xml:id=\"show-record-details\" group=\"log-input\"> \n"
"                  <name>Show Details</name> \n"
"                  <type>bool</type> \n"
"                  <default>false</default> \n"
"                  <status> \n"
"                     <state value=\"false\">Disabled</state> \n"
"                     <state value=\"true\">Enabled</state> \n"
"                  </status> \n"
"                  <desc>Include file name, line number and function with each log record.</desc> \n"
"               </setting> \n"
"               <setting xml:id=\"timestamps-enabled\" group=\"log-input\"> \n"
"                  <name>Enable Timestamps</name> \n"
"                  <type>bool</type> \n"
"                  <default>false</default> \n"
"                  <status> \n"
"                     <state value=\"false\">Disabled</state> \n"
"                     <state value=\"true\">Enabled</state> \n"
"                  </status> \n"
"                  <desc>Include a timestamp with each log record.</desc> \n"
"               </setting> \n"
"               <setting xml:id=\"thread-id-enabled\" group=\"log-input\"> \n"
"                  <name>Enable Thread Identifiers</name> \n"
"                  <type>bool</type> \n"
"                  <default>false</default> \n"
"                  <status> \n"
"                     <state value=\"false\">Disabled</state> \n"
"                     <state value=\"true\">Enabled</state> \n"
"                  </status> \n"
"                  <desc>Include a thread identifier with each log record.</desc> \n"
"               </setting> \n"
"         </settings> \n"
" </appsettings> \n";


ZblLogManager::ZblLogManager(QObject *parent) :
    QObject(parent),
    m_logParam(LogFormatJSON,
               false,
               false,
               false,
               "data://logs/",
               false,
               false),
    m_logBuffer(nullptr),
    m_logWorker(nullptr),
    m_logRules(nullptr),
    m_logSettings(nullptr),
    m_profileSettings(nullptr),
    m_syncProfiles(true),
    m_loadingProfile(false),
    m_LogSource("Zuble"),
    m_originalMsgHandler(nullptr)
{

}

ZblLogManager::~ZblLogManager()
{
    m_logSettings->deleteLater();

    stopLogThread();
}


ZblLogManager& ZblLogManager::zInit(QObject* parent)
{
    if(m_zLog)
        throw ZblException(
                "Zbl::ZblLogManager::zInstance programming error: "
                      "Singleton ZblLogManager object already initialized!");

    zDebug() << "ZblLogManager initialization thread = " << ZApplication::getCurrentThreadAddress();

    // create the one and only log manager

    ZTableModel::registerLogCategory();

    m_zLog = new ZblLogManager(parent);

    // set up logger thread

    m_zLog->startLogThread();

    // create the background worker object

    m_zLog->m_logWorker = new ZblLogWorker();

    qDebug() << "Log worker object initial thread: "
             << ZApplication::getObjectThreadAddress(m_zLog->m_logWorker);

    QVariant vModules = qApp->property("org_zuble_logModules");

    ZblLogOutput::zLogModuleList modules = vModules.value<ZblLogOutput::zLogModuleList>();

    ZblLogOutput* module;

    foreach(module,modules)
    {
        if(qobject_cast<ZblLogOutput*>(module))
            qDebug() << "WE GOT SOMETHING!!!!";

        if(qobject_cast<ZblLogTextFormatterIF*>(module))
            qDebug() << "WE GOT A WINNER!!!!!";

        module->setParent(m_zLog->m_logWorker);
    }

    // move the worker object to the background thread

    m_zLog->m_logWorker->moveToThread(&m_zLog->m_logThread);

    qDebug() << "Log worker object background thread: "
             << ZApplication::getObjectThreadAddress(m_zLog->m_logWorker);

    connect(m_zLog->m_logWorker, &ZblLogWorker::outputParametersUpdated,
            m_zLog, &ZblLogManager::onLogWorkerOutputParametersUpdated,
            Qt::BlockingQueuedConnection);

    // set up the log histogram buffer

    m_zLog->m_logBuffer = m_zLog->createLogBufferModel();

    m_zLog->m_logWorker->zInit(
                m_zLog->m_LogSource, m_zLog->m_logBuffer);

    m_zLog->createRuleModel();

    ZBL_REGISTER_LOGGED_OBJECT

    m_zLog->populateRegisteredRules();

    m_zLog->loadFilterRules(m_currentLogSettingsBundleId);

    // enable "qml" category TBD: expose as options to QML user

    QLoggingCategory::setFilterRules(QStringLiteral("qml.debug=true"));
    QLoggingCategory::setFilterRules(QStringLiteral("qml.info=true"));
    QLoggingCategory::setFilterRules(QStringLiteral("qml.warning=true"));
    QLoggingCategory::setFilterRules(QStringLiteral("qml.critical=true"));

    return *m_zLog;
}

void ZblLogManager::setApplicationObject(ZApplication* appObject)
{
    static bool alreadyCalled = false;

    if(alreadyCalled)
    {
        zDebug() << "Programming error - setApplicationObject must only be called once.";
        return;
    }

    alreadyCalled = true;

    if(ZSettings::containsBundle(m_zubleSettingsBundleId))
    {
        updateApplicationSettings();
        loadCurrentLogProfile();
    }

    connect(appObject, &ZApplication::settingsBundleAvailable,
         this, &ZblLogManager::onSettingsBundleAvailable);
}


void ZblLogManager::onSettingsBundleAvailable(QString bundleId)
{
    zDebug() << "SETTINGS BUNDLE AVAILABLE: " << bundleId;

    if( bundleId == m_zubleSettingsBundleId)
    {
        updateApplicationSettings();
        //updateLogProfileSettings(); // Why call this when loadCurrentLogProfile() calls it too?
        loadCurrentLogProfile();
    }
    else if(bundleId == m_currentLogSettingsBundleId)
    {
        zDebug() << "Current log settings bundle available for id: "
                 << m_currentLogSettingsBundleId;
        //updateLogProfileSettings();
        loadCurrentLogProfile();
    }

}

void ZblLogManager::updateApplicationSettings()
{
    zDebug() << "Updating application settings bundle";

    if(m_logSettings)
    {
        disconnect(m_logSettings, &ZSettings::settingsModified, this, &ZblLogManager::onZubleSettingsModified);

        m_logSettings->deleteLater();
    }

    m_logSettings = ZSettings::getBundleSettings(m_zubleSettingsBundleId);

    connect(m_logSettings, &ZSettings::settingsModified, this, &ZblLogManager::onZubleSettingsModified);

    m_logSettings->setFileWatcher(true);
}

void ZblLogManager::updateLogProfileSettings()
{
    zDebug() << "Updating log profile settings bundle";

    if(m_profileSettings)
    {
        disconnect(m_profileSettings, &ZSettings::settingsModified, this, &ZblLogManager::onLogProfileModified);
        m_profileSettings->deleteLater();
    }

    m_profileSettings = ZSettings::getBundleSettings(m_currentLogSettingsBundleId);

    connect(m_profileSettings, &ZSettings::settingsModified, this, &ZblLogManager::onLogProfileModified);

    m_profileSettings->setFileWatcher(true);

    setLogOutputParameters();
}


QString ZblLogManager::getLogSettingsMetadata()
{
    // TBD: it's gonna get a lot hotter in here real soon

    // loop creating the metadata from the modules

    QVariant vModules = qApp->property("org_zuble_logModules");

    ZblLogOutput::zLogModuleList modules = vModules.value<ZblLogOutput::zLogModuleList>();

    ZblLogOutput* module;

    foreach(module,modules)
    {
        if(qobject_cast<ZblLogOutput*>(module))
            qDebug() << "CREATING SETTINGS METADATA FOR LOG OUTPUT MODULE!!!!";

        if(qobject_cast<ZblLogTextFormatterIF*>(module))
            qDebug() << "OUTPUT FORMATTER!!!!!";
        else
            qDebug() << "OUTPUT TARGET!!!!!";

    }


    return m_profileMetadata;
}

bool ZblLogManager::loadCurrentLogProfile()
{
    if(m_loadingProfile)
        return false;

    m_loadingProfile = true;

    QString logProfilePath = ZApplication::resolvePath(
                m_logSettings->value("zuble/log-profile-path").toString(),
                false);

    QString actualPath = logProfilePath;

    if(logProfilePath.isEmpty())
    {
        qWarning() << "Zuble log manager can't locate applicaiton setting: "
                      "zuble/log-profile-path";
    }
    else
    {
        m_syncProfiles = m_logSettings->value("zuble/sync-log-profile",
                                                QVariant(true)).toBool();

        if(!m_syncProfiles)
        {
            actualPath =
                    createTemporaryLogProfile("~current-log-settings-XXXXXX", true);

            QFile logProfile(logProfilePath);

            if(logProfile.exists())
            {
                if(!logProfile.copy(actualPath))
                {
                    qWarning() << "Zuble log manager can't decouple log profile";
                    actualPath = logProfilePath;
                }
            }
        }

        ZSettings::insertBundle(m_currentLogSettingsBundleId,
                                 ZblLogManager::getLogSettingsMetadata(),
                                 actualPath, true);

        updateLogProfileSettings();

        QVariant filterRules = m_profileSettings->value(m_logFilterRulesKey);

        if(filterRules.isNull())
        {
            saveFilterRules();
        }
        else
        {
            loadFilterRules(m_currentLogSettingsBundleId);
        }
    }

    m_loadingProfile = false;

    return true;
}

QString ZblLogManager::createTemporaryLogProfile(
    const QString& nameTemplate,
    bool remove)
{
    QString logProfileDir(ZApplication::resolvePath("data://log-profiles/", false));
    QString logProfilePath;

    QDir qDir;

    if(!qDir.mkpath(logProfileDir))
    {
        qCritical() << "Zuble can't create log profile directory: " << logProfileDir;

        logProfilePath = QDir::tempPath();
        logProfilePath += '/';
    }
    else
    {
        logProfilePath = logProfileDir;
    }

    logProfilePath += nameTemplate;


    qDebug() << "log profile path = " << logProfilePath;

    QTemporaryFile temp(logProfilePath);

    if(!temp.open())
    {
        qWarning() << "Zuble can't open temporary log profile.";
    }
    else
    {
        logProfilePath = temp.fileName();
        qDebug() << "temporary log profile = " << logProfilePath;

        temp.setAutoRemove(remove);
        temp.close();
    }

    return logProfilePath;
}

bool ZblLogManager::isCommandLineLogging()
{
    bool logging = false;

    // check command line argument

    QStringList args(QCoreApplication::arguments());
    const int argCount = args.length();

    for(int i=0; i<argCount; i++)
    {
        if(args.at(i) == "-zl")
        {
            logging = true;
            break;
        }
    }
    return logging;
}


#if 0
bool ZblLogManager::updateMessageHandlerStatus()
{
    bool captureLogMessages = false;

    // check command line argument

    QStringList args(QCoreApplication::arguments());
    const int argCount = args.length();

    for(int i=0; i<argCount; i++)
    {
        if(args.at(i) == "-zl")   
        {
            captureLogMessages = true;
            break;
        }
    }

    // if command line doesn't enable check the application log settings

    if(!captureLogMessages)
    {
        ZScopedSettings settings(ZSettings::getBundleSettings(m_zubleSettingsBundleId));

        captureLogMessages =
                settings->value("zuble/enable-zuble-logging", captureLogMessages).toBool();
    }

    // set a timer for flushing the histogram buffer

    m_zLog->m_timerID = m_zLog->startTimer(200);

    // install the message handler if zuble logging is enabled

    if(captureLogMessages)
       qInstallMessageHandler(ZblLogManager::zMessageHandler);

    return captureLogMessages;
}
#endif

ZblLogManager& ZblLogManager::zInstance()
{
    if(!m_zLog)
        throw ZblException(
          "Zbl::ZblLogManager::zInstance programming error: "
                "Singleton ZblLogManager object not initialized! "
                "Call ZblLogManager::zInit before calling this method.");

    return *m_zLog;
}

void ZblLogManager::zMessageHandler(QtMsgType msgType,
                                    const QMessageLogContext& logCtx,
                                    const QString& text)
{
    bool fatal = msgType == QtFatalMsg ? true : false;

    //static int recursionCounter = 0;

    //Qt::ConnectionType con;

#if 1
    QThread* workerThread = &m_zLog->m_logThread;

    QThread* thisThread = QThread::currentThread();

    if(workerThread != thisThread)
#else
    if(!inObjectThread(&(m_zLog->m_logThread)))
#endif
    {
        ZblLogMessage msg;
        msg.m_msgType = msgType;
        msg.m_text = text;
        msg.m_line = logCtx.line;
        msg.m_file = logCtx.file;
        msg.m_function = logCtx.function;
        msg.m_category = logCtx.category;
        msg.m_flush = fatal;

        QVariant zMsg = QVariant::fromValue<Zbl::ZblLogMessage>(msg);

        // block if fatal so message will be output before aborting program (with luck)

        Qt::ConnectionType conType = fatal ? Qt::BlockingQueuedConnection : Qt::QueuedConnection;

        QMetaObject::invokeMethod(m_zLog->m_logWorker,"outputLogMessage",
                                  conType,
                                  Q_ARG(QVariant, zMsg));
    }


    //std::cout << "hello there\n";
    //std::cout << text.toUtf8().data() << std::endl;

    if(fatal)
    {
        //std::cout << "FATAL ERROR: " << text.toUtf8().data() << std::endl;

        m_zLog->stopLogThread();
        abort();
    }

}

void ZblLogManager::timerEvent(QTimerEvent * event)
{
    killTimer(m_timerID);

    m_logBuffer->truncate(m_maxBufferSize, true);

    m_timerID = startTimer(2000);
}


QObject* ZblLogManager::getLogBuffer()
{
    return m_logBuffer;
}

int ZblLogManager::getLogBufferRoleCount()
{
    return m_logBufRoleCount;
}


QObject* ZblLogManager::getLogRules()
{
    return m_logRules;
}


#if 0
void ZblLogManager::appendModelColumn(
        int columnNumber,
        const QByteArray& columnName,
        ZTableModel& model,
        ZRoleNames& roles)
{
    roles.insert(columnNumber, columnName);
    model->addRole(columnNumber);
}
#endif

bool ZblLogManager::registerLogCategory(const QString logCategory)
{
    bool retval = false;

    QString actualName(logCategory);

    ZBL_SLOT_BEGIN_TRY
    {
        if(logCategory.indexOf('.') != -1)
        {
            //actualName.replace('.', QLatin1String("$"));
            actualName.replace('.', QLatin1Char('$'));

            zWarning() << "Logging category name: " << logCategory
                         << "can't contain the period character (dot \".\"), "
                         "converting name to: " << actualName;

        }
        zDebug() << "Registering log category: " << actualName;

        ZblLogCategory category(actualName);
        category.registerCategory();
    }

    ZBL_SLOT_END_RETURN(retval,  retval,
    Z_FAC_JS, registerLogCategory, registerLogCategory failed)
}



ZTableModel* ZblLogManager::createLogBufferModel(QObject* parent)
{
    QObject* p = parent ? parent : m_zLog;

    ZTableModel* logBuffer = new ZTableModel(p);

    if(!logBuffer)
        return NULL;

    //QQmlEngine::setObjectOwnership(m_logRules, QQmlEngine::CppOwnership);

    logBuffer->setColumnCount(1);

    //WARNING: number of roles added here must match m_logBufRoleCount!

    logBuffer->addRole(LogFieldRecordNum, "RecordNumber");
    logBuffer->addRole(LogFieldCategory, "Category");
    logBuffer->addRole(LogFieldSource, "Source");
    logBuffer->addRole(LogFieldMessage, "Message");
    logBuffer->addRole(LogFieldFunction, "Function");
    logBuffer->addRole(LogFieldLine, "Line");
    logBuffer->addRole(LogFieldFile, "File");

    if(logBuffer->getRoleCount() != m_logBufRoleCount)
    {
        zCritical() << "Zuble programing error: log buffer role count mismatch!";
    }

    return logBuffer;

}



bool ZblLogManager::startLogThread()
{
    // this thread runs the message pump for the logger while
    // the Zuble applicaiton is initializing in the main  thread.

   // if(!m_logRules)
   //     throw ZblException("Logging rules data model not initialized! "
   //                        "Call createRuleModel() before calling this method.");

    // TBD: why are we making this connection?

    //connect(&m_logThread, SIGNAL(finished()), m_logRules,
    //        SLOT(deleteLater()));

    //connect(this, &Controller::operate, worker, &Worker::doWork);
    //connect(worker, &Worker::resultReady, this, &Controller::handleResults);

    if(m_logThread.isRunning())
        return false;

    m_logThread.start();


    return true;
}

void ZblLogManager::stopLogThread()
{
    m_logThread.quit();
    m_logThread.wait();
}




void ZblLogManager::onLogProfileModified(const QString& path)
{
    // Zuble's basic log settings have been modified
    zDebug() << "LOGGER GOT CURRENT LOG PROFILE MODIFIED SIGNAL!";

    setLogOutputParameters();
}

void ZblLogManager::setLogOutputParameters()
{
    ZblLogParams logParams;

    // from Zuble settings

    logParams.m_enableLogging = m_logSettings->
            value("zuble/enable-zuble-logging").toBool();
    logParams.m_logOutputDir = m_logSettings->
            value("zuble/log-output-dir").toString();

    // from log profile

    logParams.m_enableFileOutput = m_profileSettings->
            value("log-output/log-file-enabled").toBool();
    logParams.m_enableStdOutput = m_profileSettings->
            value("log-output/log-stdout-enabled").toBool();
    logParams.m_enableModelOutput = m_profileSettings->
            value("log-histogram/histogram-enabled").toBool();
    logParams.m_enableDetails = m_profileSettings->
            value("log-input/show-record-details").toBool();
    logParams.m_fileFormat = fileFormatFromString(m_profileSettings->
            value("log-output/log-file-format").toString().toLower());




    // TBD: we are not saving/restoring previous message handler should we?

    if(m_logParam.m_enableLogging)
        if(!logParams.m_enableLogging)
            qInstallMessageHandler(nullptr);

    QVariant vParams(QVariant::fromValue<ZblLogParams>(logParams));

    QMetaObject::invokeMethod(m_logWorker,"setOutputParameters",
                              Qt::QueuedConnection,
                              Q_ARG(QVariant, vParams));
}

void ZblLogManager::onLogWorkerOutputParametersUpdated(QVariant logParams)
{
    // TBD: this is woefully inadequate! we need to be able to turn logging
    // both on AND off and to avoid re-loading message handler inadvertently.
    // I just hate when this happens!

    if(!logParams.canConvert<Zbl::ZblLogParams>())
        return;

    ZblLogParams params = logParams.value<Zbl::ZblLogParams>();

    if(params == m_logParam)
        return;

    if(!m_logParam.m_enableLogging)
    {
        if(params.m_enableLogging)
        {
            m_logParam = params;
            qInstallMessageHandler(ZblLogManager::zMessageHandler);
            return;
        }
    }
    m_logParam = params;
}


void ZblLogManager::onZubleSettingsModified(const QString& path)
{
    // Zuble's basic log settings have been modified
    zDebug() << "LOGGER GOT ZUBLE SETTINGS MODIFIED SIGNAL!";

    if(m_logSettings->getFileName() == path)
    {

#if 1
        bool sync = m_logSettings->value("zuble/sync-log-profile",
                                         QVariant(false)).toBool();

        if(m_syncProfiles != sync)
            loadCurrentLogProfile();
#endif

        setLogOutputParameters();
    }

}


#if 0
QString ZblLogManager::getLogRuleBooleanString(int dataRole, int rowNumber)
{
    return toLiterallyTrue(m_logRules->getValue(dataRole, rowNumber).toBool());
}
#endif

bool ZblLogManager::populateMetaRules()
{
    // TBD: metarules are log filter rules loaded from the zblconfig.xml file.

    zCritical() << "Sorry, populateMetaRules method not yet implemented.";

    return false;
}



bool ZblLogManager::loadFilterRules(const QString& logProfileBundleID)
{
    ZScopedSettings settings(ZSettings::getBundleSettings(logProfileBundleID));

    if(!settings)
    {
        qWarning() << "Log Manager can't load log profile: " << logProfileBundleID;
        return false;
    }

    QVariantMap vFilterRules = settings->value(m_logFilterRulesKey).toMap();

    if(vFilterRules.isEmpty())
    {
        qWarning() << "Log Manager can't load current filter rules.";
        return false;
    }

    try
    {
        QJsonObject filterRules = QJsonObject::fromVariantMap(vFilterRules);

        if(filterRules.isEmpty())
        {
            qWarning() << "Log Manager can't locate previous filter rules.";
            return false;
        }

        m_logRules->putJsonData(filterRules);

        setQtLogRulesFromModel();
    }
    catch(ZblException ex)
    {
        qWarning() << "Error loading current filter fules: " << ex.message();
        return false;
    }

    return true;
}

QString ZblLogManager::getQtLogRulesForRow(int rowNumber)
{

    // both the category and the logging level must be enabled to turn logging on

    const QString category(m_logRules->getValue(RuleCategory, rowNumber).toString());
    const bool isCategoryEnabled = m_logRules->getValue(RuleEnabled, rowNumber).toBool();

    QString rules
    = getQtLogRule(category, "warning",
    isCategoryEnabled && m_logRules->getValue(RuleWarning, rowNumber).toBool())
    % getQtLogRule(category, "critical",
    isCategoryEnabled && m_logRules->getValue(RuleCritical, rowNumber).toBool())
    % getQtLogRule(category, "debug",
    isCategoryEnabled && m_logRules->getValue(RuleDebug, rowNumber).toBool());
    return rules;
}

QString ZblLogManager::getQtLogRule(const QString& category, const QString& level, bool enabled)
{
    return QString(category + '.' + level + "="
    + toLiterallyTrue(enabled) + '\n');
}

void ZblLogManager::setQtLogRulesFromModel()
{
    const int categoryCount = m_logRules->rowCount();

    QString rules;

    for(int i = 0; i < categoryCount; i++)
    {
        rules  = rules % getQtLogRulesForRow(i);
    }

    QLoggingCategory::setFilterRules(rules);
}

bool ZblLogManager::createRuleModel()
{
    if(m_logRules)
    {
        qWarning() << "logging rule model already exists";
        return false;
    }

    ZTableModel* ruleModel = new ZTableModel(this);

    QQmlEngine::setObjectOwnership(ruleModel, QQmlEngine::CppOwnership);

    ruleModel->setColumnCount(1);

    ruleModel->addRole(RuleCategory,"category");
    ruleModel->addRole(RuleRegistered,"registered");
    ruleModel->addRole(RuleSaved,"saved");
    ruleModel->addRole(RuleEnabled,"active");
    ruleModel->addRole(RuleWarning,"warning");
    ruleModel->addRole(RuleCritical,"critical");
    ruleModel->addRole(RuleDebug,"debug");

    const int roleCount = 7;


    //ZDataRow categoryRow;
    m_modelCategoryRow.append(QVariant(""));

    //ZDataRow booleanRow;
    m_modelBooleanRow.append(QVariant(false));

    QList<int> roles = ruleModel->roles();

    for(int i=0; i<roleCount; i++)
    {
        const int nextRole = roles.at(i);

        if(nextRole != RuleCategory)
            m_modelRoleRow.insert(nextRole, m_modelBooleanRow);
    }

    m_modelRoleRow.insert(RuleCategory, m_modelCategoryRow);

    //QMetaObject::Connection conExec =
    connect(ruleModel, &ZTableModel::tableModified, this, &ZblLogManager::onRuleModelModified,
            Qt::QueuedConnection);

    m_logRules = ruleModel;

    return true;
}

bool ZblLogManager::appendRuleModelCategory(const QString& logCategory)
{
    if(!m_logRules)
        return false;

    //LOCK_ZLOGCATEGORIES

    //const int categoryIndex = m_logRules->findNextItemRow(0,logCategory,false);

//    if(categoryIndex != -1)
//        return false;

    ZDataRow categoryRow = m_modelCategoryRow;

    ZRoleRow roleRow = m_modelRoleRow;

    categoryRow.replace(0, QVariant(logCategory));

    roleRow.insert(RuleCategory, categoryRow);

    m_logRules->appendMissingRow(roleRow, logCategory);

    return true;
}

void ZblLogManager::onRuleModelModified(int dataRole, int rowNumber)
{
    // get category name, message type, enabled/disabled
    // concatenate rule string
    // call QLogCategory::setFilterRules()


    //QString rules = getQtLogRulesForRow(rowNumber);
    //QLoggingCategory::setFilterRules(rules);

    setQtLogRulesFromModel();

    saveFilterRules();
}

void ZblLogManager::saveFilterRules()
{
    m_logRules->sync();

    QJsonObject ruleData = m_logRules->getJsonData();

    //ZSettings* settings = ZSettings::getBundleSettings(m_currentLogSettingsBundleId);

    ZScopedSettings settings(ZSettings::getBundleSettings(m_currentLogSettingsBundleId));


    QVariant rulesmap = ruleData.toVariantMap();


    settings->setValue(m_logFilterRulesKey, QVariant(ruleData.toVariantMap()));

    settings->sync();
}

void ZblLogManager::populateRegisteredRules()
{
    LOCK_ZLOGCATEGORIES

    const int categoryCount = zLogCategories.count();

    for(int j=0; j<categoryCount; j++)
    {
        appendRuleModelCategory(zLogCategories.at(j));
    }

    saveFilterRules();

    qDebug() << "Begin dumping logging rule model.";

    if(m_logRules)
        m_logRules->dumpModelData();

    qDebug() << "end dumping logging rule model.";

}

LogFileFormat ZblLogManager::fileFormatFromString(const QString& logFileFormat)
{
    LogFileFormat format = LogFormatText;

    if(logFileFormat == "json")
    {
        format = LogFormatJSON;
    }
    else if(logFileFormat == "xml")
    {
        zWarning() << "Sorry, XML log format not yet implemented. "
                      "Using text format instead.";
    }
    else if(logFileFormat != "text")
    {
        zWarning() << "Invalid log format: " << logFileFormat <<
                      "Should be one of: \"text\", \"json\". Using text format.";
    }

    return format;
}

} // Zbl