ZblLogWorker.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblLogWorker.cpp
 * Created on: 11/2/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 "ZblLogWorker.h"
#include "ZSettings.h"
#include "ZTableModel.h"
#include "ZblLogManager.h"
#include "ZblLogCategory.h"
#include "ZApplication.h"
#include "ZblLogMessage.h"
#include "ZblApp.h"
#include <QDateTime>
#include <QTimeZone>
#include <QDir>
#include <QStringBuilder>
#include <QTemporaryFile>
#include <QQmlEngine>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QVariant>
#include <QUuid>
#include <QCoreApplication>
#include "zglobal.h"
#include <iostream>


namespace Zbl {


ZblLogWorker::ZblLogWorker(QObject *parent) :
    QObject(parent),
    m_logParam(LogFormatJSON,
               false,
               false,
               false,
               "data://logs/",
               false,
               false),
    m_outFileActive(false),
    m_nextRecordNumber(0),
    m_hostVersionMajor(0),
    m_hostVersionMinor(0),
    m_hostVersionPatch(0)

{

}

bool ZblLogWorker::zInit(const QString& logSource,
                         ZTableModel* logBuffer)
{
    // WARNING: call this method from the main thread AFTER
    // moving ZblLogWorker object to background thread.

    static bool initialized = false;

    if(initialized)
        return false;
    else
        initialized = true;

    m_logBuffer = logBuffer;
    m_logSource = logSource;

    // TBD: doesn't the following code violate Qt threading policy since qApp is in
    // the foreground thread and this object is in a background thread?

    m_appName = qApp->property("org_zuble_appName").toString();
    m_hostName = qApp->property("org_zuble_host_name").toString();
    m_hostVersionMajor = qApp->property("org_zuble_host_versionMajor").toInt();
    m_hostVersionMinor = qApp->property("org_zuble_host_versionMinor").toInt();
    m_hostVersionPatch = qApp->property("org_zuble_host_versionPatch").toInt();
    m_hostVersionBulid = qApp->property("org_zuble_host_versionBuild").toString();

    return initialized;

}

bool ZblLogWorker::createLogFile()
{

    //ZScopedSettings settings(ZSettings::getBundleSettings(logProfileBundleID));

    //QString logFileLocation = settings->value("zuble/log-output-dir",
    //                                        QVariant("data://logs/")).toString();

    closeLogFile();

    QString actualLocation = m_logParam.m_logOutputDir;

    qDebug() << "LOG FILE LOCATION: " << actualLocation;

    actualLocation = ZApplication::resolvePath(actualLocation, false);

    qDebug() << "LOG FILE DESTINATION: " << actualLocation;

    QDir logDir(actualLocation);

    if(!logDir.exists())
    {
        logDir.mkpath(actualLocation);

        if(!logDir.exists())
            return false;
    }

    QDateTime now = QDateTime::currentDateTime();
    QString nowString = now.toString("yyyy:MM:dd:hh:mm:ss:zzz");

    QString logFilePath(QDir::cleanPath(actualLocation));

    logFilePath += '/';

    logFilePath += nowString;

    switch(m_logParam.m_fileFormat)
    {
    case LogFormatText:
        logFilePath += ".log";
        break;
    case LogFormatJSON:
        logFilePath += ".log.json";
        break;
    case LogFormatXML:
        logFilePath += ".log.not-xml";
        break;
    }

    qDebug() << "LOG FILE PATH: " << logFilePath;

    m_outputFile.setFileName(logFilePath);

    if(!m_outputFile.open(QFile::WriteOnly | QFile::Truncate | QIODevice::Text))
    {
       qCritical() << "WARNING: Can't open log output file: " << logFilePath;
       return false;
    }

    if(m_logParam.m_fileFormat == LogFormatText)
    {
        m_outputStream.setDevice(&m_outputFile);
    }
    else if(m_logParam.m_fileFormat == LogFormatJSON)
    {
        if(!writeFileInformation(m_outputFile, nowString, now.timeZone().id()))
        {
            qCritical() << "WARNING: Can't write log file information record: "
                            << logFilePath;

            closeLogFile();

            return false;
        }
    }

    m_outFileActive = true;

    return true;
}

void ZblLogWorker::closeLogFile()
{
    if(!m_outFileActive)
        return;

    m_outputStream.flush();

    m_outputFile.close();

    m_outFileActive = false;
}

bool ZblLogWorker::writeFileInformation(
        QFile& logFile,
        QString creationTime,
        QByteArray creationZone)
{
    QUuid uuid(QUuid::createUuid());

    QByteArray ba(uuid.toByteArray());

    qint64 bytesWritten = logFile.write(ba);

    if(bytesWritten == -1)
        return false;

    QVariantMap info;

    QString hostVersion("%1.%2.%3");
    hostVersion = hostVersion.arg(m_hostVersionMajor);
    hostVersion = hostVersion.arg(m_hostVersionMinor);
    hostVersion = hostVersion.arg(m_hostVersionPatch);

    //.arg(m_hostVersionMinor).arg(m_hostVersionPatch);
    //hostVersion = hostVersion.arg(m_hostVersionMajor,m_hostVersionMinor,m_hostVersionPatch);

    info.insert("app-name", m_appName);
    info.insert("host-name", m_hostName);
    info.insert("host-version", hostVersion);
    info.insert("host-build", m_hostVersionBulid);

    info.insert("creation-zone", creationZone);
    info.insert("creation-time", creationTime);

    QJsonObject jsonInfo(QJsonObject::fromVariantMap(info));

    QJsonDocument doc(jsonInfo);

    ba = doc.toJson(QJsonDocument::Compact);

    ba.append('\n');

    bytesWritten = logFile.write(ba);

    return (bytesWritten != -1);
}


void ZblLogWorker::outputLogMessage(QVariant message)
{
    if(!message.canConvert<Zbl::ZblLogMessage>())
        return;

    ZblLogMessage logMsg = message.value<Zbl::ZblLogMessage>();

    bool bLogToFile = m_logParam.m_enableFileOutput && m_outFileActive;

    if(bLogToFile)
    {
        switch(m_logParam.m_fileFormat)
        {
        case LogFormatText:
            outputTextMessage(logMsg);
            break;

        case LogFormatJSON:
            outputJsonMessage(logMsg);
            break;

        case LogFormatXML:
            // NO XML OUTPUT SUPPORT YET
            break;
        }

    }

    if(m_logParam.m_enableStdOutput)
        std::cout << formatTextMessage(logMsg).toUtf8().constData()
                  << std::endl;

    if(m_logParam.m_enableModelOutput)
    {
        ZDataRow row;

        // begin order dependent fields

        row.append(QVariant(m_nextRecordNumber));
        row.append(QVariant(logMsg.m_category));
        row.append(QVariant(m_logSource));
        row.append(QVariant(logMsg.m_text));
        row.append(QVariant(logMsg.m_function));
        row.append(QVariant::fromValue<int>(logMsg.m_line));
        row.append(QVariant(logMsg.m_file));

        // end order dependent fields

        m_logBuffer->appendCells(row);
    }

    m_nextRecordNumber++;

    if(logMsg.m_flush)
        closeLogFile();
}

void ZblLogWorker::setOutputParameters(QVariant logParams)
{
    //LogFileFormat format = LogFileFormat(fileType);

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

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

    if(params == m_logParam)
        return;

    bool fileParamsChanged = false;

    if(params.m_fileFormat != m_logParam.m_fileFormat
            || params.m_logOutputDir != m_logParam.m_logOutputDir)
        fileParamsChanged = true;

    m_logParam = params;

    if(m_logParam.m_fileFormat == LogFormatXML)
        m_logParam.m_fileFormat = LogFormatText; // we don't support XML yet

    if(!m_logParam.m_enableLogging)
        closeLogFile();
    else if(fileParamsChanged && m_logParam.m_enableFileOutput)
        createLogFile();

    emit outputParametersUpdated(logParams);
}

void ZblLogWorker::outputTextMessage(const ZblLogMessage& msg)
{
        m_outputStream << formatTextMessage(msg) << endl;
}

QString ZblLogWorker::formatTextMessage(const ZblLogMessage& msg)
{
    QString msgBuffer;

    QTextStream str(&msgBuffer);

    switch (msg.m_msgType) {
    case QtDebugMsg:
        //str << "\nDebug#";
        break;
    case QtWarningMsg:
        str << "WARNING: ";
        break;
    case QtCriticalMsg:
        str << "CRITICAL: ";
        break;
    case QtFatalMsg:
        str << "FATAL ERROR: ";
        break;
    }

    str << msg.m_category << ": " << msg.m_text;

    if(m_logParam.m_enableDetails)
        str << "\n>line: " << msg.m_line
        << " >file: " << msg.m_file
        << " >function: " << msg.m_function
        << " >record: " << m_nextRecordNumber
        << " >source: " << m_logSource;

    return msgBuffer;
}

void ZblLogWorker::outputJsonMessage(const ZblLogMessage& msg)
{

    QJsonArray logRecord;

    logRecord.push_back(QJsonValue(static_cast<qint64>(m_nextRecordNumber)));
    logRecord.push_back(QJsonValue(msg.m_category));
    logRecord.push_back(QJsonValue(QString(m_logSource)));
    logRecord.push_back(QJsonValue(msg.m_text));
    logRecord.push_back(QJsonValue(msg.m_function));
    logRecord.push_back(QJsonValue(msg.m_line));
    logRecord.push_back(QJsonValue(msg.m_file));

    QJsonDocument doc;

    doc.setArray(logRecord);

    QByteArray ba(doc.toJson(QJsonDocument::Compact));

    m_outputFile.write(ba);

    m_outputFile.write("\n");

    m_outputFile.flush();

}




} // Zbl