Problem logging my application (QMessageLogger )

[hbatalha]

@sierdzio Thanks for the tip, I've decided to prepare myown logging function and register it with qInstallMessageHandler.

What are are the downsides of writing my own logging system and when, if ever, should I do it?

[JonB]

@hbatalha said in Problem logging my application (QMessageLogger ):

What are are the downsides of writing my own logging system

None.

when, if ever, should I do it?

Whenever you like! Just make sure you take the configuration setting from a file (like via QSettings) so you can heighten/lower the level at runtime.

[hbatalha]

@JonB said in Problem logging my application (QMessageLogger ):

Just make sure you take the configuration setting from a file (like via QSettings) so you can heighten/lower the level at runtime.

Didn't understand, could you elaborate?

[JonB]

@hbatalha
The signature for the message handler function is void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);. If you are going to write your own logging stuff you are passed the enum QtMsgType. You might want to detect this to distinguish between, say, errors versus info, and log/not log the messages. I always think it is nice to be able to switch that level on/off at runtime, so controlled by say a setting in QSettings.

[SGaist]

Hi,

For fine grained control about logging, QLoggingCategory is a good tool and you can pretty easily build rules to log more or less, specific parts of your application, etc.

[hbatalha]

@JonB I understand now thanks

[JonB]

@hbatalha
Just to say: I realise what i wrote is a bit "advanced". Get your logging working simply, then add in that stuff. You will want to look at @SGaist 's mention of adding your own categories too.

[hbatalha]

@SGaist I couldn't understand how to use QLoggingCategory in my app. And based on myMessageHandler I created my own Logger:

Logger.h

#ifndef LOGGER_H
#define LOGGER_H

#include <QObject>


class Logger : public QObject
{
    Q_OBJECT

public:
    Logger();

    // SPY is just a silly name since it will be registering every step taken in the app
    enum class Type {ERROR_, WARNING, DEBUG, SPY};
    Q_ENUM(Type);

    void log(Type type, const QString& msg);
    void logSettings();
    void starting();

private:
    QString debug_file;
    QString errorAndWarings_file;
    QString flow_file; // register every step taken in the app

};

#endif // LOGGER_H

Logger.cpp

#include "logger.h"

#include <QStandardPaths>
#include <QFile>
#include <QDir>
#include <QDateTime>
#include <QSettings>

Logger::Logger()
{
    QString logDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/Log";
    QDir dir(logDir);

    debug_file = logDir + "/debug.log";
    errorAndWarings_file = logDir + "/errors_and_warnings.log";
    flow_file = logDir + "/flow.log";

    if( ! dir.exists())
        dir.mkdir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/Log");

    if( ! QFile::exists(debug_file))
    {
        QFile file(debug_file);
        file.open(QIODevice::Text | QIODevice::ReadWrite);
    }
    if( ! QFile::exists(errorAndWarings_file))
    {
        QFile file(errorAndWarings_file);
        file.open(QIODevice::Text | QIODevice::ReadWrite);
    }
    if( ! QFile::exists(flow_file))
    {
        QFile file(flow_file);
        file.open(QIODevice::Text | QIODevice::ReadWrite);
    }
}

void Logger::starting()
{
    QFile debugFile(debug_file);
    debugFile.open(QIODevice::Text | QIODevice::ReadWrite | QIODevice::Append);
    QTextStream log(&debugFile);

    log << "\n[" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz") << "]" << '\n' << '\n';

    QFile flowFile(flow_file);
    flowFile.open(QIODevice::Text | QIODevice::ReadWrite | QIODevice::Append);
    log.setDevice(&flowFile);

    log << '\n';
}

void Logger::log(Type type, const QString &msg)
{
    QString logFile;
    QString msgType;

    switch (type)
    {
    case Type::SPY:
        logFile = flow_file;
        msgType = "Flow: ";
        break;
    case Type::DEBUG:
        logFile = debug_file;
        break;
    case Type::ERROR_:
        logFile = errorAndWarings_file;
        msgType = "Error: ";
        break;
    case Type::WARNING:
        logFile = errorAndWarings_file;
        msgType = "Warning: ";
        break;
    }

    QFile file(logFile);
    file.open(QIODevice::Text | QIODevice::ReadWrite | QIODevice::Append);
    QTextStream log(&file);

    if(type == Type::DEBUG)
        log << msg << '\n';
    else
    {
        log << "[" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz") << "] ";
        log << msgType << ": " << msg << '\n';
    }

    log.flush();
}

void Logger::logSettings()
{
    QFile flowFile(flow_file);
    flowFile.open(QIODevice::Text | QIODevice::ReadWrite | QIODevice::Append);
    QTextStream log(&flowFile);

    QSettings  qsettings(QSettings::IniFormat, QSettings::UserScope, "HBatalha", "my_app");

    log << "\n[Settings]\n";
   
    log << "confiron_exit: " <<                         qsettings.value("confiron_exit", "1").toBool()                          << '\n';
    
    log << "mimimize_to_tray: " <<                      qsettings.value("mimimize_to_tray", "0").toBool()                       << '\n';
    log << "close_to_tray: " <<                         qsettings.value("close_to_tray", "0").toBool()                          << '\n';
    log << "video_format: " <<                          qsettings.value("video_format", 0).toInt();


    log << "language: " <<                              qsettings.value("language", "0").toInt()                                << '\n';
    log << "theme: " <<                                 qsettings.value("theme", "0").toInt()                                   << '\n';
   

    log << "[----]\n";
}

[JonB]

@hbatalha
This is all fine, but it's just your own, standalone logging code, no use of qInstallMessageHandler or QLoggingCategory. That's OK, though not as flexible as it could be.

I notice that you re-open each file at the moment you want to log to it. Could be a bit slow; if you log a lot, you might want to keep open handles into the 3 files around.

[hbatalha]

@JonB

you might want to keep open handles into the 3 files around

How would I do that?

[JonB]

@hbatalha
Make your QFiles for sure, and possibly your QTextStreams too, member variables in Logger class. Open the files in the constructor or in starting, and leave them open. Although they will close automatically on program exit, you might add a finishing() method too and call it to explicitly, or from destructor, to close when shutting down.

[hbatalha]

@JonB I have done exactly that and it created another problem.
I use Logger in different classes aside from MainWindow and in those classes the logging won't work and I am guessing it is because the files will be already open. Is there a way to write to open files.
The solution I am thinking of is to have Logger object pointer in those classes to point to the one in MainWindow.