logger.hpp

Go to the documentation of this file.

#ifndef LOGGER_HPP
#define LOGGER_HPP
 
/**
 * \file logger.hpp
 * \brief Manages application logging based on command-line arguments.
 * \author Le Bars, Yoann
 * \ingroup UtilsLogging
 *
 * This file is part of the pure C++ benchmark.
 *
 * This class sets up a custom Qt message handler to filter logs by level and
 * route them to the console, a file, or syslog as specified by the user.
 */
 
#include <QDebug>
#include <QFile>
#include <QHash>
#include <QSet>
#include <QString>
#include <QTextStream>
#include <iostream>
 
#ifdef Q_OS_UNIX
#include <syslog.h>
#endif
 
#include "cmd_line_parser.hpp"
 
namespace AppUtils {
 
    /**
     * \brief Manages application logging based on command-line arguments.
     * \ingroup UtilsLogging
     */
    class Logger {
       public:
        /**
         * \brief Initialises the logger and installs the custom message
         * handler.
         *
         * \param in_args The parsed command-line arguments.
         */
        explicit Logger(const CmdLine::CmdLineArgs& in_args) : args_(in_args) {
            instance_ = this;  // Set the static instance
 
            // Define the filtering hierarchy.
            QHash<CmdLine::LogLevel, QSet<QtMsgType>> logHierarchy;
            logHierarchy[CmdLine::LogLevel::Debug] = {
                QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg};
            logHierarchy[CmdLine::LogLevel::Info] = {QtInfoMsg, QtWarningMsg,
                                                     QtCriticalMsg, QtFatalMsg};
            logHierarchy[CmdLine::LogLevel::Warning] = {
                QtWarningMsg, QtCriticalMsg, QtFatalMsg};
            logHierarchy[CmdLine::LogLevel::Critical] = {QtCriticalMsg,
                                                         QtFatalMsg};
            logHierarchy[CmdLine::LogLevel::Fatal] = {QtFatalMsg};
            activeLevels_ = logHierarchy.value(args_.log_level_);
 
            levelPrefixes_[QtDebugMsg] = "[debug]";
            levelPrefixes_[QtInfoMsg] = "[info]";
            levelPrefixes_[QtWarningMsg] = "[warning]";
            levelPrefixes_[QtCriticalMsg] = "[critical]";
            levelPrefixes_[QtFatalMsg] = "[fatal]";
 
#ifdef Q_OS_UNIX
            if (!args_.debug_syslog_.empty()) {
                openlog(args_.debug_syslog_.c_str(), LOG_PID, LOG_USER);
            }
#endif
            if (!args_.debug_file_.empty()) {
                logFile_ = std::make_unique<QFile>(
                    QString::fromStdString(args_.debug_file_));
                if (logFile_->open(QIODevice::WriteOnly | QIODevice::Text)) {
                    logStream_ = std::make_unique<QTextStream>(logFile_.get());
                } else {
                    qWarning()
                        << "Could not open log file:" << logFile_->fileName();
                    logFile_.reset();
                }
            }
 
            // Store the old handler to restore it later.
            oldHandler_ = qInstallMessageHandler(messageHandler);
        }
 
        /**
         * \brief Restores the original message handler and cleans up logging
         *        resources, such as closing the log file.
         */
        ~Logger() {
            instance_ = nullptr;  // Clear the static instance
            qInstallMessageHandler(oldHandler_);
            if (logFile_) {
                logFile_->close();
            }
#ifdef Q_OS_UNIX
            if (!args_.debug_syslog_.empty()) {
                closelog();
            }
#endif
        }
 
        // Make Logger non-copyable and non-movable to prevent issues with
        // handler installation.
        Logger(const Logger&) = delete;
        Logger& operator=(const Logger&) = delete;
        Logger(Logger&&) = delete;
        Logger& operator=(Logger&&) = delete;
 
       private:
        /**
         * \brief The static Qt message handler that intercepts all log
         *        messages.
         *
         * This function filters messages based on the current log level and
         * routes them to the configured outputs (console, file, syslog).
         *
         * \param type The level of the message (e.g., QtDebugMsg).
         * \param context The context where the message was generated.
         * \param msg The log message.
         */
        static void messageHandler(QtMsgType type,
                                   const QMessageLogContext& context,
                                   const QString& msg) {
            if (!instance_ || !instance_->activeLevels_.contains(type)) {
                return;
            }
 
            const QString prefix =
                instance_->levelPrefixes_.value(type, "[unknown]");
            const QString formattedMsg = QString("%1 %2").arg(prefix, msg);
 
            if (instance_->args_.debug_console_) {
                std::cout << formattedMsg.toStdString() << "\n";
            }
 
#ifdef Q_OS_UNIX
            if (!instance_->args_.debug_syslog_.empty()) {
                syslog(LOG_INFO, "%s", formattedMsg.toStdString().c_str());
            }
#endif
 
            if (instance_->logStream_) {
                *instance_->logStream_ << formattedMsg << "\n";
            }
        }
 
        /// \brief Singleton instance of the logger.
        inline static Logger* instance_ = nullptr;
 
        /// \brief A reference to the parsed command-line arguments.
        const CmdLine::CmdLineArgs& args_;
 
        /// \brief The set of Qt message types to be logged.
        QSet<QtMsgType> activeLevels_;
 
        /**
         * \brief A map from message type to its string prefix (e.g.,
         *        “[debug]”).
         */
        QHash<QtMsgType, QString> levelPrefixes_;
 
        /// \brief A smart pointer to the log file.
        std::unique_ptr<QFile> logFile_;
 
        /**
         * \brief A smart pointer to the text stream for writing to the log
         *        file.
         */
        std::unique_ptr<QTextStream> logStream_;
 
        /**
         * \brief Stores the original Qt message handler to be restored on
         *        exit.
         */
        QtMessageHandler oldHandler_ = nullptr;
    };
 
}  // namespace AppUtils
 
#endif  // LOGGER_HPP