logger.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "utility/stringutils.h"
#include "signalslot.h"
#include "rtti/object.h"
 
// External Includes
#include <memory>
#include <mutex>
#include <string>
#include <queue>
#include <thread>
#include <fstream>
#include <nap/datetime.h>
#include <atomic>
 
#define NAP_DECLARE_LOG_LEVEL(LEVEL, NAME)                                                                                      \
    static LogLevel& NAME##Level()                                                                                              \
    {                                                                                                                           \
        static LogLevel lvl(#NAME, LEVEL);                                                                                      \
        return lvl;                                                                                                             \
    }                                                                                                                           \
                                                                                                                                \
    template<typename T>                                                                                                        \
    static void NAME(T&& msg)                                                                                                   \
    {                                                                                                                           \
        instance().log(LogMessage(NAME##Level(), std::forward<T>(msg)));                                                        \
    }                                                                                                                           \
                                                                                                                                \
    static void NAME(const rtti::Object& obj, const std::string& msg)                                                           \
    {                                                                                                                           \
        instance().log(LogMessage(NAME##Level(), utility::stringFormat("%s: %s", obj.mID.c_str(), msg.c_str())));               \
    }                                                                                                                           \
                                                                                                                                \
    template <typename... Args>                                                                                                 \
    static void NAME(const char* msg, Args&&... args)                                                                           \
    {                                                                                                                           \
        instance().log(LogMessage(NAME##Level(), utility::stringFormat(msg, std::forward<Args>(args)...)));                     \
    }                                                                                                                           \
                                                                                                                                \
    template <typename... Args>                                                                                                 \
    static void NAME(rtti::Object& obj, const char* msg, Args&&... args)                                                        \
    {                                                                                                                           \
        std::string msg_str = utility::stringFormat("%s: %s", obj.mID.c_str(), msg);                                            \
        instance().log(LogMessage(NAME##Level(), utility::stringFormat(msg_str.c_str(), std::forward<Args>(args)...)));         \
    }
 
 
namespace nap
{
    class NAPAPI LogLevel
    {
    public:
        LogLevel(const std::string& name, int level) : mName(name), mLevel(level) {}
        LogLevel(const LogLevel&) = delete;
        LogLevel& operator=(const LogLevel&) = delete;
 
        // returns the level number to indicate the level's ranking
        int level() const                               { return mLevel; }
        const std::string& name() const                 { return mName; }
 
        // comparison operators
        bool operator<(const LogLevel& other) const     { return this->mLevel < other.mLevel; }
        bool operator==(const LogLevel& other) const    { return this->mLevel == other.mLevel; }
        bool operator<=(const LogLevel& other) const    { return this->mLevel <= other.mLevel; }
        bool operator>=(const LogLevel& other) const    { return this->mLevel >= other.mLevel; }
 
    private:
        std::string mName;
        int mLevel;
    };
 
 
    class NAPAPI LogMessage
    {
    public:
        LogMessage(const LogLevel& lvl, const std::string& msg);
 
        LogMessage(const LogLevel& lvl , std::string&& msg);
 
        const LogLevel& level() const { return *mLevel; }
 
        const std::string& text() const { return mMessage; }
 
        const SystemTimeStamp& getTimestamp() const { return mTimeStamp; }
 
    private:
        const LogLevel* mLevel;
        const std::string mMessage;
        const SystemTimeStamp mTimeStamp;
    };
 
    // Shorthand for string formatter
    using LogMessageFormatter = std::function<std::string(const LogMessage& msg)>;
 
    std::string basicLogMessageFormatter(const LogMessage& msg);
 
    std::string timestampLogMessageFormatter(const LogMessage& msg);
 
    class NAPAPI LogHandler
    {
    public:
        LogHandler();
        virtual ~LogHandler() = default;
 
        virtual void commit(LogMessage msg) = 0;
 
        void setLogLevel(const LogLevel& level) { mLevel = &level; }
 
        const LogLevel& getLogLevel() const { return *mLevel; }
 
        void setFormatter(LogMessageFormatter formatter);
 
        std::string formatMessage(LogMessage& msg);
 
    private:
        const LogLevel* mLevel;
        LogMessageFormatter mFormatter = nullptr;
    };
 
    class NAPAPI Logger
    {
    public:
        static void setLevel(const LogLevel& lvl)           { instance().setCurrentLevel(lvl); }
 
        void setCurrentLevel(const LogLevel& level);
 
        static Logger& instance();
 
        // this signal is emitted every time a log message is output.
        Signal<LogMessage> log;
 
        // all log messages will be displayed
        NAP_DECLARE_LOG_LEVEL(50, fine)
 
        // messages including debug messages
        NAP_DECLARE_LOG_LEVEL(100, debug)
 
        // general information about the proceedings of the app
        NAP_DECLARE_LOG_LEVEL(200, info)
 
        // warnings about unusual situations
        NAP_DECLARE_LOG_LEVEL(300, warn)
 
        // error messages indicate that something broke, but we're not ready to die yet
        NAP_DECLARE_LOG_LEVEL(400, error)
 
        // fatal errors that seriously hinder the functionality of the app
        NAP_DECLARE_LOG_LEVEL(500, fatal)
 
        
        static const std::vector<const LogLevel*>& getLevels()
        {
            // In-line so you will remember to amend this list
            // when you add or remove a LogLevel above.
            // Must be ordered by level value.
            static std::vector<const LogLevel*> lvls = {
                    &fineLevel(),
                    &debugLevel(),
                    &infoLevel(),
                    &warnLevel(),
                    &errorLevel(),
                    &fatalLevel()
            };
            return lvls;
        }
 
        static const LogLevel* getLevel(const std::string& name);
 
        static void addFileHandler(const std::string& filename);
 
        static void logToDirectory(const std::string& directory, const std::string& prefix = "log");
 
        void addHandler(std::unique_ptr<LogHandler> handler);
 
    private:
        // The logger is a singleton
        Logger();
        Logger(Logger const&);
        void operator=(Logger const&);
 
        void initialize();
        void onLog(const LogMessage& message);
 
        Slot<LogMessage> onLogSlot = {[&](LogMessage message)   { onLog(message); }};
        const LogLevel* mLevel;
        std::vector<std::unique_ptr<LogHandler>> mHandlers{};
    };
 
 
    class ConsoleLogHandler : public LogHandler
    {
    public:
        ConsoleLogHandler() = default;
 
        void commit(LogMessage message) override;
 
    private:
        std::mutex mOutStreamMutex;
    };
 
    class FileLogHandler : public LogHandler
    {
    public:
        FileLogHandler(const std::string& mFilename);
        ~FileLogHandler();
 
        void commit(LogMessage message) override;
 
    private:
        void writeLoop();
 
        const std::string mFilename;                
        std::unique_ptr<std::thread> mWriteThread;  
        std::queue<LogMessage> mMessages;           
        std::mutex mQueueMutex;                     
        std::atomic<bool> mRunning;                 
    };
 
 
}