ZblLogManager.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblLogManager.h
 * 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
 *
 */

#ifndef ZBLLOGMANAGER_H
#define ZBLLOGMANAGER_H

#include <QObject>
#include <QMutex>
#include <QStringList>
#include <QFile>
#include "zglobal.h"
#include "ZTableModel.h"
#include "ZblLogParams.h"

#define zLogMan (Zbl::ZblLogManager::zInstance())

//Q_DECLARE_METATYPE(QtMsgType)
//Q_DECLARE_METATYPE(QMessageLogContext)

namespace Zbl
{
class ZblLogCategory;
class ZTableModel;
class ZSettings;
class ZApplication;
class ZblLogWorker;

class ZblLogManager : public QObject
{
    friend class Zblcore;
    friend class ZblLogCategory;
    friend class ZblLogWorker;
    //friend class ZLogReader;

    //typedef QHash<int, QByteArray> zLogFields;

    Q_OBJECT
    Q_ENUMS(logFields)


public:

    enum logFields
    {
        LogFieldRecordNum = 0,
        LogFieldCategory = 1,
        LogFieldSource = 2,
        LogFieldMessage = 3,
        LogFieldFunction = 4,
        LogFieldLine = 5,
        LogFieldFile = 6,
        LogFieldMark = 7
    };

    enum ruleFields
    {
        RuleCategory = 0,
        RuleRegistered = 1,
        RuleSaved = 2,
        RuleEnabled = 3,
        RuleWarning = 4,
        RuleCritical = 5,
        RuleDebug = 6
    };


    explicit ZblLogManager(QObject *parent = 0);

    virtual ~ZblLogManager();

    static ZblLogManager& zInit(QObject* parent);

    static ZblLogManager& zInstance();

     Q_INVOKABLE QObject* getLogBuffer();


     Q_INVOKABLE int getLogBufferRoleCount();



     Q_INVOKABLE QObject* getLogRules();



    virtual void timerEvent(QTimerEvent * event);

    ZTableModel* createLogBufferModel(QObject* parent = NULL);



    // return the list of registered categories for javascript

    // return the list of unregistered categories for javascript

    // read configuration files and apply default
    // algorithm

    // provide API for javascript to read/write configuration settings

     // write configuration files

signals:

public slots:

    bool registerLogCategory(const QString logCategory);



    void onLogProfileModified(const QString& path);

    void onZubleSettingsModified(const QString& path);

    void onLogWorkerOutputParametersUpdated(QVariant logParams);

    void onSettingsBundleAvailable(QString bundleId);

    bool loadFilterRules(const QString& logProfileBundleID);



    void onRuleModelModified(int dataRole, int rowNumber);

    void saveFilterRules();

    void populateRegisteredRules();

    bool appendRuleModelCategory(const QString& logCategory);




protected:

    ZBL_DECLARE_LOGGED_OBJECT

    QString getQtLogRule(const QString& category, const QString& level, bool enabled);

    QString getQtLogRulesForRow(int rowNumber);

    void setQtLogRulesFromModel();

    bool createRuleModel();


#if 0

    //bool updateMessageHandlerStatus();
#endif

    bool isCommandLineLogging();


    bool startLogThread();

    void stopLogThread();


    bool populateMetaRules();


    void setApplicationObject(ZApplication* appObject);

    void updateApplicationSettings();

    void updateLogProfileSettings();

    bool loadCurrentLogProfile();

    static QString createTemporaryLogProfile(
            const QString& nameTemplate,
            bool remove = false);

    static QString getLogSettingsMetadata();


    static LogFileFormat fileFormatFromString(const QString& logFileFormat);

    void setLogOutputParameters();


    static const QString m_currentLogSettingsBundleId;

    static const QString m_zubleSettingsBundleId;

    static const QString m_defaultOutputFilePath;

private:

    static void zMessageHandler(QtMsgType msgType,
                         const QMessageLogContext& logCtx,
                         const QString& text);


    ZblLogParams m_logParam;

    static ZblLogManager* m_zLog;

    int m_timerID;


    ZTableModel* m_logBuffer;

    ZRoleNames m_bufferRoles;


    QThread m_logThread;

    ZblLogWorker* m_logWorker;

    ZTableModel* m_logRules;

    ZDataRow m_modelCategoryRow;

    ZDataRow m_modelBooleanRow;


    ZRoleRow m_modelRoleRow;

    static const QString m_logFilterRulesKey;

    ZSettings* m_logSettings;

    ZSettings* m_profileSettings;



    static int m_maxBufferSize;

    static const QString m_profileMetadata;

    static const int m_logBufRoleCount;


    bool m_syncProfiles;

    bool m_loadingProfile;


    QString m_LogSource;

    QtMessageHandler m_originalMsgHandler;

};

} // Zbl

#endif // ZBLLOGMANAGER_H