logging Namespace Reference

Namespace containing all global type/structs that will be used project wide for logging. More...

Classes
class	LoggingFilter
	This class serves as a container class for handling log filtering of loggers. This must be used if you want each handler to have a different logging level since adding multiple handlers to the same logger will apply the loggers logging level to each handler. More...
class	MRDTConsoleSink
	A custom console sink for logging messages with specific formatting and timestamping. This class extends quill::ConsoleSink and provides the capability to format log messages using a specified pattern and time format, allowing for customizable and colorized console outputs. More...
class	MRDTRotatingFileSink
	A custom rotating file sink that formats and logs messages to a file with automatic rotation based on file size or time interval. This class extends quill::RotatingFileSink and provides the ability to format log messages using a pattern and time format, ensuring that logs are written to a rotating file system. More...
class	MRDTRoveCommSink
	A custom logger sink designed to send formatted log messages over the RoveComm protocol. This class extends quill::Sink and is tailored for use in the Autonomy system, where log messages need to be transmitted as packets over a network to a BaseStation via UDP. More...

Functions
void	InitializeLoggers (std::string szLoggingOutputPath, std::string szProgramTimeLogsDir)
	Logger Initializer - Sets Up all the logging handlers required for having the above loggers.

Variables
quill::Logger *	g_qFileLogger
quill::Logger *	g_qConsoleLogger
quill::Logger *	g_qRoveCommLogger
quill::Logger *	g_qSharedLogger
quill::LogLevel	g_eConsoleLogLevel
quill::LogLevel	g_eFileLogLevel
quill::LogLevel	g_eRoveCommLogLevel
std::string	g_szProgramStartTimeString
const std::function< void(const rovecomm::RoveCommPacket< uint8_t > &, const sockaddr_in &)>	SetLoggingLevelsCallback

Detailed Description

Namespace containing all global type/structs that will be used project wide for logging.

Logging Levels:

Author

clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date

2023-09-30

   Priority > Level     > Description
   Level 1  > TRACE_L3  > Unused
   Level 2  > TRACE_L2  > Unused
   Level 3  > TRACE_L1  > Unused
   Level 4  > DEBUG     > Details that would only be useful in a debug environment
   Level 5  > INFO      > State Changes, RoveComm Updates GPS/IMU/Autonomy, etc
   Level 6  > WARNING   > Something unexpected happened - application could potentially error soon.
   Level 7  > ERROR     > Something went wrong - application could potentially have critical error soon.
   Level 8  > CRITICAL  > Something went very wrong - application will exit after logging is sent.

   Note: At testing sessions we will have "DEBUG" Logging set as the level that is being outputted.
         However, at competition and when using "RELEASE" code we will be using "INFO" Logging. When
         a logging level is set, we only receive logging messages that are that level or higher
         priority.

   Example: When INFO is set, we only receive: INFO, WARNING, ERROR, CRITICAL
            When DEBUG is set, we only receive: DEBUG, INFO, WARNING, ERROR, CRITICAL

Author

Eli Byrd (edbgk.nosp@m.k@ms.nosp@m.t.edu)

Date

2023-08-22

Function Documentation

InitializeLoggers()

void logging::InitializeLoggers	(	std::string	szLoggingOutputPath,
		std::string	szProgramTimeLogsDir
	)

Logger Initializer - Sets Up all the logging handlers required for having the above loggers.

Parameters

szLoggingOutputPath

- A string containing the filepath to output log files to. Must be properly formatted.

Author

Eli Byrd (edbgk.nosp@m.k@ms.nosp@m.t.edu)

Date

2023-08-22

    {
        // Store start time string in member variable.
        g_szProgramStartTimeString = szProgramTimeLogsDir;
 
        // Assemble filepath string.
        std::filesystem::path szFilePath;
        std::filesystem::path szFilename;
        szFilePath = szLoggingOutputPath;                  // Main location for all recordings.
        szFilePath += g_szProgramStartTimeString + "/";    // Folder for each program run.
        szFilename = "console_output";                     // Base file name.
 
        // Check if directory exists.
        if (!std::filesystem::exists(szFilePath))
        {
            // Create directory.
            if (!std::filesystem::create_directories(szFilePath))
            {
                // Submit logger message.
                std::cerr << "Unable to create the logging output directory: " << szFilePath.string() << " for console output file." << std::endl;
            }
        }
        else
        {
            // Submit logger message.
            std::cerr << "Unable to create logging output directory " << szFilePath.string() << ": it already exists." << std::endl;
        }
 
        // Construct the full output path.
        std::filesystem::path szFullOutputPath = szFilePath / szFilename;
 
        // Set Console Color Profile
        quill::ConsoleSink::Colours qColors;
        qColors.apply_default_colours();
        qColors.assign_colour_to_log_level(quill::LogLevel::TraceL3, constants::szTraceL3Color);
        qColors.assign_colour_to_log_level(quill::LogLevel::TraceL2, constants::szTraceL2Color);
        qColors.assign_colour_to_log_level(quill::LogLevel::TraceL1, constants::szTraceL1Color);
        qColors.assign_colour_to_log_level(quill::LogLevel::Debug, constants::szDebugColor);
        qColors.assign_colour_to_log_level(quill::LogLevel::Info, constants::szInfoColor);
        qColors.assign_colour_to_log_level(quill::LogLevel::Warning, constants::szWarningColor);
        qColors.assign_colour_to_log_level(quill::LogLevel::Error, constants::szErrorColor);
        qColors.assign_colour_to_log_level(quill::LogLevel::Critical, constants::szCriticalColor);
        qColors.assign_colour_to_log_level(quill::LogLevel::Backtrace, constants::szBacktraceColor);
 
        // Create Patterns
        std::string szLogFilePattern   = "%(time) %(log_level) [%(thread_id)] [%(file_name):%(line_number)] %(message)";
        std::string szCSVFilePattern   = "%(time),\t%(log_level),\t[%(thread_id)],\t[%(file_name):%(line_number)],\t\"%(message)\"";
        std::string szConsolePattern   = "%(time) %(log_level:9) [%(thread_id)] [%(file_name):%(line_number)] %(message)";
        std::string szRoveCommPattern  = "%(time) %(log_level) [%(thread_id)] [%(file_name):%(line_number)] %(message)";
        std::string szTimestampPattern = "%Y-%m-%d %H:%M:%S.%Qms";
 
        // Create Sinks
        std::shared_ptr<quill::Sink> qLogFileSink = quill::Frontend::create_or_get_sink<MRDTRotatingFileSink>(
            szFullOutputPath.replace_extension(".log"),    // Log Output Path
            []()
            {
                quill::RotatingFileSinkConfig cfg;
                cfg.set_open_mode('a');
                return cfg;               // Rotating File Sink Configs
            }(),
            szLogFilePattern,             // Log Output Pattern
            szTimestampPattern,           // Log Timestamp Pattern
            quill::Timezone::LocalTime    // Log Timezone
        );
 
        std::shared_ptr<quill::Sink> qCSVFileSink = quill::Frontend::create_or_get_sink<MRDTRotatingFileSink>(
            szFullOutputPath.replace_extension(".csv"),    // Log Output Path
            []()
            {
                quill::RotatingFileSinkConfig cfg;
                cfg.set_open_mode('a');
                return cfg;               // Rotating File Sink Configs
            }(),
            szCSVFilePattern,             // Log Output Pattern
            szTimestampPattern,           // Log Timestamp Pattern
            quill::Timezone::LocalTime    // Log Timezone
        );
 
        std::shared_ptr<quill::Sink> qConsoleSink =
            quill::Frontend::create_or_get_sink<MRDTConsoleSink>("ConsoleSink",                                // Log Name
                                                                 qColors,                                      // Log Custom Colors
                                                                 quill::ConsoleSink::ColourMode::Automatic,    // Detect is console supports colors.
                                                                 szConsolePattern,                             // Log Output Pattern
                                                                 szTimestampPattern                            // Log Timestamp Pattern
            );
 
        std::shared_ptr<quill::Sink> qMRDTRoveCommSink = quill::Frontend::create_or_get_sink<MRDTRoveCommSink>("MRDTRoveCommSink",           // Log Name
                                                                                                               szRoveCommPattern,            // Log Output Pattern
                                                                                                               szTimestampPattern,           // Log Timestamp Pattern
                                                                                                               quill::Timezone::LocalTime    // Log Timezone
        );
 
        // Configure Quill
        quill::BackendOptions qBackendConfig;
 
        // Start Quill
        quill::Backend::start(qBackendConfig);
 
        // Create Loggers
        g_qFileLogger     = quill::Frontend::create_or_get_logger("FILE_LOGGER", {qLogFileSink, qCSVFileSink});
        g_qConsoleLogger  = quill::Frontend::create_or_get_logger("CONSOLE_LOGGER", {qConsoleSink});
        g_qRoveCommLogger = quill::Frontend::create_or_get_logger("ROVECOMM_LOGGER", {qMRDTRoveCommSink});
        g_qSharedLogger   = quill::Frontend::create_or_get_logger("SHARED_LOGGER", {qLogFileSink, qCSVFileSink, qConsoleSink, qMRDTRoveCommSink});
 
        // Set Internal Logging Level Limiters
        g_eFileLogLevel     = constants::FILE_DEFAULT_LEVEL;
        g_eConsoleLogLevel  = constants::CONSOLE_DEFAULT_LEVEL;
        g_eRoveCommLogLevel = constants::ROVECOMM_DEFAULT_LEVEL;
 
        // Set Base Logging Levels
        g_qFileLogger->set_log_level(quill::LogLevel::TraceL3);
        g_qConsoleLogger->set_log_level(quill::LogLevel::TraceL3);
        g_qSharedLogger->set_log_level(quill::LogLevel::TraceL3);
        g_qRoveCommLogger->set_log_level(quill::LogLevel::Info);
 
        // Enable Backtrace
        g_qFileLogger->init_backtrace(10, quill::LogLevel::Critical);
        g_qConsoleLogger->init_backtrace(10, quill::LogLevel::Critical);
        g_qRoveCommLogger->init_backtrace(10, quill::LogLevel::Critical);
        g_qSharedLogger->init_backtrace(10, quill::LogLevel::Critical);
    }

Here is the caller graph for this function:

Variable Documentation

SetLoggingLevelsCallback

const std::function<void(const rovecomm::RoveCommPacket<uint8_t>&, const sockaddr_in&)> logging::SetLoggingLevelsCallback

Initial value:

=
        [](const rovecomm::RoveCommPacket<uint8_t>& stPacket, const sockaddr_in& stdAddr)
    {
        
        (void) stdAddr;
 
        
        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);
 
        
        const int nRequestedConsoleLevel  = stPacket.vData[0];
        const int nRequestedFileLevel     = stPacket.vData[1];
        const int nRequestedRoveCommLevel = stPacket.vData[2];
 
        
        bool bConsoleLevelChangePermitted  = nRequestedConsoleLevel >= nMinConsoleLevel;
        bool bFileLevelChangePermitted     = nRequestedFileLevel >= nMinFileLevel;
        bool bRoveCommLevelChangePermitted = nRequestedRoveCommLevel >= nMinRoveCommLevel;
 
        
        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;
 
        
        LOG_INFO(logging::g_qSharedLogger, "Incoming SETLOGGINGLEVELS: [Console: {}, File: {}, RoveComm: {}]", stPacket.vData[0], stPacket.vData[1], stPacket.vData[2]);
    }

    {
        // 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]);
    };