logging Namespace Reference

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

Namespaces
namespace	graphing
	Namespace containing all global type/structs that will be used project wide for graphing and plotting data with matplotlib. These graphing functions are built to be as feature rich as possible while still being easy to use.

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
std::string	g_szLoggingOutputPath
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

Author

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

Date

2025-01-08

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.
 
        // Store the logging output path.
        g_szLoggingOutputPath = szFilePath;
 
        // 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::ConsoleSinkConfig::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::ConsoleSinkConfig::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]);
    };