AutonomyLogging.h

Go to the documentation of this file.

 
#include <quill/Backend.h>
#include <quill/Frontend.h>
#include <quill/LogMacros.h>
#include <quill/Logger.h>
 
#include "quill/backend/PatternFormatter.h"
#include "quill/core/Attributes.h"
#include "quill/core/Common.h"
#include "quill/core/Filesystem.h"
 
#include "quill/sinks/ConsoleSink.h"
#include "quill/sinks/RotatingFileSink.h"
 
#include <RoveComm/RoveComm.h>
#include <RoveComm/RoveCommManifest.h>
#include <atomic>
#include <shared_mutex>
 
 
#include "./AutonomyConstants.h"
#include "./util/TimeOperations.hpp"
 
#ifndef AUTONOMY_LOGGING_H
#define AUTONOMY_LOGGING_H
 
 
namespace logging
{
    // Declare namespace external variables and objects.
 
    extern quill::Logger* g_qFileLogger;
    extern quill::Logger* g_qConsoleLogger;
    extern quill::Logger* g_qSharedLogger;
    extern quill::Logger* g_qRoveCommLogger;
 
    extern quill::LogLevel g_eConsoleLogLevel;
    extern quill::LogLevel g_eFileLogLevel;
    extern quill::LogLevel g_eRoveCommLogLevel;
 
    extern std::string g_szProgramStartTimeString;
 
    // Declare namespace methods.
 
    void InitializeLoggers(std::string szLoggingOutputPath, std::string szProgramTimeLogsDir = timeops::GetTimestamp());
 
    // Declare namespace callbacks.
 
    const std::function<void(const rovecomm::RoveCommPacket<uint8_t>&, const sockaddr_in&)> SetLoggingLevelsCallback =
        [](const rovecomm::RoveCommPacket<uint8_t>& stPacket, const sockaddr_in& stdAddr)
    {
        // Not using this.
        (void) stdAddr;
 
        // Convert Minimum Permitted Console Level to Integer Value
        const int nMinConsoleLevel  = static_cast<int>(constants::CONSOLE_MIN_LEVEL);
        const int nMinFileLevel     = static_cast<int>(constants::FILE_MIN_LEVEL);
        const int nMinRoveCommLevel = static_cast<int>(constants::ROVECOMM_MIN_LEVEL);
 
        // Convert Requested Console Level to Integer Value
        const int nRequestedConsoleLevel  = stPacket.vData[0];
        const int nRequestedFileLevel     = stPacket.vData[1];
        const int nRequestedRoveCommLevel = stPacket.vData[2];
 
        // Determine if change is allowed
        bool bConsoleLevelChangePermitted  = nRequestedConsoleLevel >= nMinConsoleLevel;
        bool bFileLevelChangePermitted     = nRequestedFileLevel >= nMinFileLevel;
        bool bRoveCommLevelChangePermitted = nRequestedRoveCommLevel >= nMinRoveCommLevel;
 
        // Convert RoveComm Enumeration to Quill Enumeration and store to logging globals if permitted
        logging::g_eConsoleLogLevel  = bConsoleLevelChangePermitted ? static_cast<quill::LogLevel>(stPacket.vData[0]) : logging::g_eConsoleLogLevel;
        logging::g_eFileLogLevel     = bFileLevelChangePermitted ? static_cast<quill::LogLevel>(stPacket.vData[1]) : logging::g_eFileLogLevel;
        logging::g_eRoveCommLogLevel = bRoveCommLevelChangePermitted ? static_cast<quill::LogLevel>(stPacket.vData[2]) : logging::g_eRoveCommLogLevel;
 
        // Submit logger message.
        LOG_INFO(logging::g_qSharedLogger, "Incoming SETLOGGINGLEVELS: [Console: {}, File: {}, RoveComm: {}]", stPacket.vData[0], stPacket.vData[1], stPacket.vData[2]);
    };
 
    // Define namespace file filters.
 
 
    class LoggingFilter : public quill::Filter
    {
        private:
            // Declare private member variables.
            quill::LogLevel m_eMinLogLevel;
 
        public:
 
            LoggingFilter(const std::string szFilterBaseType, const quill::LogLevel eMinLogLevel) : quill::Filter(szFilterBaseType)
            {
                // Set member variables.
                m_eMinLogLevel = eMinLogLevel;
            };
 
 
            QUILL_NODISCARD bool filter(const quill::MacroMetadata* qLogMetadata,
                                        uint64_t unLogTimestamp,
                                        std::string_view szThreadID,
                                        std::string_view szThreadName,
                                        std::string_view szLoggerName,
                                        quill::LogLevel qLogLevel,
                                        std::string_view szLogMessage,
                                        std::string_view szLogStatement) noexcept override
            {
                // Not using these.
                (void) qLogMetadata;
                (void) unLogTimestamp;
                (void) szThreadID;
                (void) szThreadName;
                (void) szLoggerName;
                (void) szLogMessage;
                (void) szLogStatement;
 
                // Log only m_eMinLogLevel or higher to stdout.
                return qLogLevel >= m_eMinLogLevel;
            }
    };
 
    // Define namespace custom sinks
 
 
    class MRDTConsoleSink : public quill::ConsoleSink
    {
        public:
 
            MRDTConsoleSink(const quill::ConsoleSink::Colours& qColors,                                          // Custom Colors Import
                            const quill::ConsoleSink::ColourMode& qColorMode,
                            const std::string& szFormatPattern,                                                  // Custom Format Pattern
                            const std::string& szTimeFormat,                                                     // Custom Time Format
                            quill::Timezone qTimestampTimezone = quill::Timezone::LocalTime,                     // Timezone
                            const std::string& szStream        = "stdout"                                        // Stream
                            ) :
                quill::ConsoleSink(qColors, qColorMode, szStream),                                               // Pass Parameters into quill::ConsoleSink
                qFormatter(quill::PatternFormatterOptions(szFormatPattern, szTimeFormat, qTimestampTimezone))    // Pass Parameters into qFormatter type
            {}
 
            void write_log(const quill::MacroMetadata* qLogMetadata,
                           uint64_t unLogTimestamp,
                           std::string_view szThreadID,
                           std::string_view szThreadName,
                           const std::string& szProcessID,
                           std::string_view szLoggerName,
                           quill::LogLevel qLogLevel,
                           std::string_view szLogLevelDescription,
                           std::string_view szLogLevelShortCode,
                           const std::vector<std::pair<std::string, std::string>>* vNamedArgs,
                           std::string_view szLogMessage,
                           std::string_view) override;
 
        private:
            quill::PatternFormatter qFormatter;
    };
 
 
    class MRDTRotatingFileSink : public quill::RotatingFileSink
    {
        public:
 
            MRDTRotatingFileSink(const quill::fs::path& qFilename,                                               // File Path
                                 const quill::RotatingFileSinkConfig& qConfig,                                   // Rotating File Sink Config
                                 const std::string& szFormatPattern,                                             // Custom Format Pattern
                                 const std::string& szTimeFormat,                                                // Custom Time Format
                                 quill::Timezone qTimestampTimezone          = quill::Timezone::LocalTime,       // Timezone
                                 quill::FileEventNotifier qFileEventNotifier = quill::FileEventNotifier{}        // Event Notifier (Default: None)
                                 ) :
                quill::RotatingFileSink(qFilename, qConfig, qFileEventNotifier),                                 // Pass Parameters into quill::RotatingFileSink
                qFormatter(quill::PatternFormatterOptions(szFormatPattern, szTimeFormat, qTimestampTimezone))    // Pass Parameters into qFormatter type
            {}
 
            void write_log(const quill::MacroMetadata* qLogMetadata,
                           uint64_t unLogTimestamp,
                           std::string_view szThreadID,
                           std::string_view szThreadName,
                           const std::string& szProcessID,
                           std::string_view szLoggerName,
                           quill::LogLevel qLogLevel,
                           std::string_view szLogLevelDescription,
                           std::string_view szLogLevelShortCode,
                           const std::vector<std::pair<std::string, std::string>>* vNamedArgs,
                           std::string_view szLogMessage,
                           std::string_view) override;
 
        private:
            quill::PatternFormatter qFormatter;
    };
 
 
    class MRDTRoveCommSink : public quill::Sink
    {
        private:
            quill::PatternFormatter qFormatter;
 
 
            std::vector<char> StringToVector(const std::string& szString)
            {
                std::vector<char> result;
                int length = std::min(static_cast<int>(szString.length()), 255);
                result.reserve(length);
 
                for (int i = 0; i < length; ++i)
                {
                    result.push_back(szString[i]);
                }
 
                return result;
            }
 
        public:
 
            MRDTRoveCommSink(std::string const& szFormatPattern, std::string const& szTimeFormat, quill::Timezone qTimestampTimezone) :
                qFormatter(quill::PatternFormatterOptions(szFormatPattern, szTimeFormat, qTimestampTimezone))
            {}
 
 
            ~MRDTRoveCommSink() override = default;
 
            void write_log(const quill::MacroMetadata* qLogMetadata,
                           uint64_t unLogTimestamp,
                           std::string_view szThreadID,
                           std::string_view szThreadName,
                           const std::string& szProcessID,
                           std::string_view szLoggerName,
                           quill::LogLevel qLogLevel,
                           std::string_view szLogLevelDescription,
                           std::string_view szLogLevelShortCode,
                           const std::vector<std::pair<std::string, std::string>>* vNamedArgs,
                           std::string_view szLogMessage,
                           std::string_view) override;
 
 
            void flush_sink() noexcept override {}
    };
 
}    // namespace logging
#endif    // AUTONOMY_LOGGING_H