DebugLog.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef DEBUGLOG
#define DEBUGLOG

#include "CoreLibraryDllGlobal.h"
#include "Platform/PlatformDefines.h"

#include <ctime>
#include <chrono>
#include <string>
#include <fstream>
#include <sstream>
#include <set>
#include <unordered_map>
#include <algorithm>
#ifdef USE_EXPLICIT_MOVE_
#include <utility>
#endif
#include <memory>
#include <functional>
#include <type_traits>
#include <stdexcept>
#define BOOST_NO_CXX11_SCOPED_ENUMS
#include <boost/filesystem.hpp>
#include <boost/throw_exception.hpp>
#include "Threads/MessageQueueThread.h"

namespace core_lib
{
namespace log
{

enum class eLogMessageLevel
{
    not_defined = 0,
    debug,
    info,
    warning,
    error,
    fatal
};

} // namespace log
} // namespace core_lib

namespace std
{

template <> struct hash<core_lib::log::eLogMessageLevel>
{
    using argument_t = core_lib::log::eLogMessageLevel;
    using result_t = std::size_t;
    using enumType_t = TYPENAME_DECL_ std::underlying_type<argument_t>::type;

    result_t operator()(const argument_t& a) const
    {
        auto                  a2 = static_cast<enumType_t>(a);
        std::hash<enumType_t> h;
        return h(a2);
    }
};

} // namespace std

namespace core_lib
{
namespace log
{

struct CORE_LIBRARY_DLL_SHARED_API DefaultLogFormat
{
    void operator()(std::ostream& os, std::time_t timeStamp, const std::string& message,
                    const std::string& logMsgLevel, const std::string& file,
                    const std::string& function, int lineNo, const std::thread::id& threadID) const;
};

enum eDefLogSize : size_t
{
    BYTES_IN_MEBIBYTE = 1024 * 1024
};

namespace dl_private
{

enum eMsgId : int
{
    MESSAGE_ID = 1
};

class CORE_LIBRARY_DLL_SHARED_API LogQueueMessage
{
public:
    LogQueueMessage() = default;
    LogQueueMessage(const std::string& message, time_t timeStamp, const std::string& file,
                    const std::string& function, int lineNo, const std::thread::id& threadID,
                    eLogMessageLevel errorLevel);
    LogQueueMessage(const LogQueueMessage&) = default;
    ~LogQueueMessage() = default;
    LogQueueMessage& operator=(const LogQueueMessage&) = default;
#ifdef USE_EXPLICIT_MOVE_

    LogQueueMessage(LogQueueMessage&& msg);
    LogQueueMessage& operator=(LogQueueMessage&& msg);
#else

    LogQueueMessage(LogQueueMessage&&) = default;
    LogQueueMessage& operator=(LogQueueMessage&&) = default;
#endif

    const std::string& Message() const;
    time_t TimeStamp() const;
    const std::string& File() const;
    const std::string& Function() const;
    int LineNo() const;
    const std::thread::id& ThreadID() const;
    eLogMessageLevel ErrorLevel() const;

private:
    std::string m_message{};
    time_t m_timeStamp{0};
    std::string m_file{};
    std::string m_function{};
    int m_lineNo{0};
    std::thread::id m_threadID{};
    eLogMessageLevel m_errorLevel{eLogMessageLevel::not_defined};
};

} // namespace dl_private

template <class Formatter> class DebugLog final
{
public:
#ifdef USE_DEFAULT_CONSTRUCTOR_
    DebugLog()
        : m_unknownLogMsgLevel("?")
    {
        InitialiseLogMessageLevelLookupMap();
    }
#else
    DebugLog()                                    = default;
#endif

    DebugLog(const std::string& softwareVersion, const std::string& logFolderPath,
             const std::string& logName, long maxLogSize = 5 * BYTES_IN_MEBIBYTE)
        :
#ifdef USE_DEFAULT_CONSTRUCTOR_
        m_unknownLogMsgLevel("?")
        ,
#endif
        m_maxLogSize(maxLogSize)
        , m_softwareVersion(softwareVersion)
        , m_logFilePath(logFolderPath)
        , m_oldLogFilePath(logFolderPath)
    {
        m_logFilePath.append(logName);
        m_logFilePath.append(".txt");

        m_oldLogFilePath.append(logName);
        m_oldLogFilePath.append("_old.txt");

#ifdef USE_DEFAULT_CONSTRUCTOR_
        InitialiseLogMessageLevelLookupMap();
#endif
        RegisterLogQueueMessageId();
        OpenOfStream(m_logFilePath, eFileOpenOptions::append_file);
    }
    DebugLog(const DebugLog&) = delete;
    DebugLog& operator=(const DebugLog&) = delete;
    DebugLog(DebugLog&&) = delete;
    DebugLog& operator=(DebugLog&&) = delete;
    ~DebugLog()
    {
        // Manually reset so we process all remaining
        // messages before closing file.
        m_logMsgQueueThread.reset();
        CloseOfStream();
    }
    void Instantiate(const std::string& softwareVersion, const std::string& logFolderPath,
                     const std::string& logName, long maxLogSize = 5 * BYTES_IN_MEBIBYTE)
    {
        m_maxLogSize = maxLogSize;

        if ((m_softwareVersion != "") || (m_logFilePath != "") || (m_oldLogFilePath != ""))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("DebugLog already instantiated"));
        }

        m_softwareVersion = softwareVersion;
        m_logFilePath     = logFolderPath;
        m_oldLogFilePath  = logFolderPath;

        m_logFilePath.append(logName);
        m_logFilePath.append(".txt");

        m_oldLogFilePath.append(logName);
        m_oldLogFilePath.append("_old.txt");

        RegisterLogQueueMessageId();
        OpenOfStream(m_logFilePath, eFileOpenOptions::append_file);
    }
    void AddLogMsgLevelFilter(eLogMessageLevel logMessageLevel)
    {
        std::lock_guard<std::mutex> lock{m_mutex};

        if (!IsLogMsgLevelFilterSetNoMutex(logMessageLevel))
        {
            m_logMsgFilterSet.insert(logMessageLevel);
        }
    }
    void RemoveLogMsgLevelFilter(eLogMessageLevel logMessageLevel)
    {
        std::lock_guard<std::mutex> lock{m_mutex};

        if (IsLogMsgLevelFilterSetNoMutex(logMessageLevel))
        {
            m_logMsgFilterSet.insert(logMessageLevel);
        }
    }
    void ClearLogMsgLevelFilters()
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        m_logMsgFilterSet.clear();
    }
    void AddLogMessage(const std::string& message)
    {
        using std::chrono::system_clock;
        time_t          messageTime = system_clock::to_time_t(system_clock::now());
        std::thread::id noThread;
        m_logMsgQueueThread->Push(dl_private::LogQueueMessage(
            message, messageTime, "", "", -1, noThread, eLogMessageLevel::not_defined));
    }

    void AddLogMessage(const std::string& message, const std::string& file,
                       const std::string& function, int lineNo, eLogMessageLevel logMsgLevel)
    {
        if (!IsLogMsgLevelFilterSet(logMsgLevel))
        {
            using std::chrono::system_clock;
            time_t messageTime = system_clock::to_time_t(system_clock::now());
            m_logMsgQueueThread->Push(dl_private::LogQueueMessage(message,
                                                                  messageTime,
                                                                  file,
                                                                  function,
                                                                  lineNo,
                                                                  std::this_thread::get_id(),
                                                                  logMsgLevel));
        }
    }

private:
#ifdef USE_DEFAULT_CONSTRUCTOR_

    void InitialiseLogMessageLevelLookupMap()
    {
        m_logMsgLevelLookup.emplace(eLogMessageLevel::not_defined, "");
        m_logMsgLevelLookup.emplace(eLogMessageLevel::debug, "Debug");
        m_logMsgLevelLookup.emplace(eLogMessageLevel::info, "Info");
        m_logMsgLevelLookup.emplace(eLogMessageLevel::warning, "Warning");
        m_logMsgLevelLookup.emplace(eLogMessageLevel::error, "Error");
        m_logMsgLevelLookup.emplace(eLogMessageLevel::fatal, "Fatal");
    }
#endif

    long MaxLogSize() const
    {
        return m_maxLogSize;
    }
    void RegisterLogQueueMessageId()
    {
        m_logMsgQueueThread->RegisterMessageHandler(
            dl_private::MESSAGE_ID,
            std::bind(&DebugLog<Formatter>::MessageHandler, this, std::placeholders::_1));
    }
    static int MessageDecoder(const dl_private::LogQueueMessage&)
    {
        return dl_private::MESSAGE_ID;
    }
    bool MessageHandler(dl_private::LogQueueMessage& message)
    {
        CheckLogFileSize(static_cast<long>(message.Message().size()));
        WriteMessageToLog(std::forward<dl_private::LogQueueMessage>(message));
        return true;
    }
    bool IsLogMsgLevelInLookup(eLogMessageLevel logMessageLevel) const
    {
        return m_logMsgLevelLookup.count(logMessageLevel) > 0;
    }
    const std::string& GetLogMsgLevelAsString(eLogMessageLevel logMessageLevel) const
    {
        return IsLogMsgLevelInLookup(logMessageLevel)
                   ? m_logMsgLevelLookup.find(logMessageLevel)->second
                   : m_unknownLogMsgLevel;
    }
    bool IsLogMsgLevelFilterSetNoMutex(eLogMessageLevel logMessageLevel) const
    {
        return (m_logMsgFilterSet.find(logMessageLevel) != m_logMsgFilterSet.end());
    }
    bool IsLogMsgLevelFilterSet(eLogMessageLevel logMessageLevel) const
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        return IsLogMsgLevelFilterSetNoMutex(logMessageLevel);
    }
    enum eFileOpenOptions
    {
        truncate_file,
        append_file
    };
    void OpenOfStream(const std::string& filePath, eFileOpenOptions fileOptions)
    {
        if (m_ofStream.is_open())
        {
            return;
        }

        m_ofStream.open(filePath,
                        fileOptions == eFileOpenOptions::truncate_file ? std::ofstream::trunc
                                                                       : std::ofstream::app);

        using std::chrono::system_clock;
        time_t          messageTime = system_clock::to_time_t(system_clock::now());
        std::thread::id noThread;
        WriteMessageToLog(dl_private::LogQueueMessage(
            "DEBUG LOG STARTED", messageTime, "", "", -1, noThread, eLogMessageLevel::not_defined));

        if (m_softwareVersion != "")
        {
            std::string message("Software Version ");
            message += m_softwareVersion;
            WriteMessageToLog(dl_private::LogQueueMessage(
                message, messageTime, "", "", -1, noThread, eLogMessageLevel::not_defined));
        }
    }
    void CloseOfStream()
    {
        if (!m_ofStream.is_open())
        {
            return;
        }

        using std::chrono::system_clock;
        time_t          messageTime = system_clock::to_time_t(system_clock::now());
        std::thread::id noThread;
        WriteMessageToLog(dl_private::LogQueueMessage(
            "DEBUG LOG STOPPED", messageTime, "", "", -1, noThread, eLogMessageLevel::not_defined));
        m_ofStream.close();
    }
    void CheckLogFileSize(long requiredSpace)
    {
        if (!m_ofStream.is_open())
        {
            return;
        }

        auto pos = static_cast<long>(m_ofStream.tellp());

        if ((MaxLogSize() - pos) < requiredSpace)
        {
            CloseOfStream();
            boost::filesystem::copy_file(m_logFilePath,
                                         m_oldLogFilePath,
                                         boost::filesystem::copy_option::overwrite_if_exists);
            OpenOfStream(m_logFilePath, eFileOpenOptions::truncate_file);
        }
    }
    void WriteMessageToLog(dl_private::LogQueueMessage&& logMessage)
    {
        m_logFormatter(m_ofStream,
                       logMessage.TimeStamp(),
                       logMessage.Message(),
                       GetLogMsgLevelAsString(logMessage.ErrorLevel()),
                       logMessage.File(),
                       logMessage.Function(),
                       logMessage.LineNo(),
                       logMessage.ThreadID());
        m_ofStream.flush();
    }

private:
    mutable std::mutex m_mutex;
#ifdef USE_DEFAULT_CONSTRUCTOR_

    std::string m_unknownLogMsgLevel;
    std::unordered_map<eLogMessageLevel, std::string> m_logMsgLevelLookup;
#else

    std::string m_unknownLogMsgLevel{"?"};
    std::unordered_map<eLogMessageLevel, std::string> m_logMsgLevelLookup{
        {eLogMessageLevel::not_defined, ""},
        {eLogMessageLevel::debug, "Debug"},
        {eLogMessageLevel::info, "Info"},
        {eLogMessageLevel::warning, "Warning"},
        {eLogMessageLevel::error, "Error"},
        {eLogMessageLevel::fatal, "Fatal"}};
#endif

    std::set<eLogMessageLevel> m_logMsgFilterSet{};
    Formatter m_logFormatter{};
    long m_maxLogSize{5 * BYTES_IN_MEBIBYTE};
    std::ofstream m_ofStream{};
    std::string m_softwareVersion{};
    std::string m_logFilePath{};
    std::string m_oldLogFilePath{};
    using log_msg_queue = threads::MessageQueueThread<int, dl_private::LogQueueMessage>;
    std::unique_ptr<log_msg_queue> m_logMsgQueueThread{
        new log_msg_queue(std::bind(&DebugLog<Formatter>::MessageDecoder, std::placeholders::_1),
                          threads::eOnDestroyOptions::processRemainingItems)};
};

} // namespace log
} // namespace core_lib

#endif // DEBUGLOG