EventLogger.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Event Logger header file
 
Author: Alex Reynolds
*/
#ifndef EVENT_LOGGER_H
#define EVENT_LOGGER_H
 
#include <stdio.h>
#include <stdlib.h>
#include <string>
 
#include "core/clockwerkerrors.h"
 
namespace clockwerk {
 
    ///  Define some standard messages for writing to file
    const unsigned int DEFAULT_MAX_MSG = 280;
 
    /// @brief  Log level enumerations
    /// 
    /// These enumerations indicate the log level at which
    /// the event loger should log. ERROR is the lowest 
    /// bar for output, and is output in almost every case.
    /// Debug is the most restrictive and typically will be
    /// output only when set.
    enum log_level_e {
        NONE,       /// No output at all
        ERROR,      /// Output in almost all cases
        WARNING,
        INFO,
        DEBUG       /// Most restrictive level of output
    };
 
    /**
     * @brief   Class to handle event and debug logging
     * 
     * The event logger is a simple, lightweight, static class for logging events
     * as they occur. To minimize impact, the logger uses c-style file IO techniques
     * and c-strings. 
     *
     * A configurable character limit, for now set to 140 characters, is enforced
     * on logging. If you can't tweet it, you shouldn't be logging it in a simulation
     * or embedded framework.
     *
     * This logging framework derived (sort of) from the Dr. Dobbs simple logging
     * framework presented here: https:/// drdobbs.com/cpp/logging-in-c/201804215
    */
    class EventLogger {
    public:
        ///  @brief   Simple constructor for event logger
        ///  @param   fp  File pointer to write to -- set to stdout by default
        ///  @param   max_size    Max size of message, in characters. Set to 140 by default
        EventLogger(FILE *fp=stdout, unsigned int max_size=DEFAULT_MAX_MSG) :
            _fp(fp), _log_level(INFO), _max_message_size(max_size), _msg(DEFAULT_MAX_MSG, '\0') {};
 
        ///  @brief   Function to set logging level for system
        ///  @param   level   Level to set logging to
        void logLevel(log_level_e level) {_log_level = level;}
 
        ///  @brief   Function to get log level for system
        ///  @return  Log level
        log_level_e logLevel() {return _log_level;}
 
        ///  @brief   Function to write an event message
        ///  @param   level   The log level of the referenced message
        ///  @param   time    The time, written out as a string 
        ///  @param   message     The message to be written. Must be <MAX_MESSAGE_SIZE (140 char)
        ///  @param   local_msg   The local level at which the message should be written out. Allows for higher local debugging
        ///  @return  Error code corresponding to success/failure
        int logMessage(log_level_e level, const std::string &message, log_level_e local_msg=NONE);
 
        ///  @brief   Function to flush the file buffer
        ///  @note    Unless you're running real time, you probably don't need to call this
        ///  @return  Error code corresponding to success/failure
        int flushLogs();
    private:
        ///  Output stream to which output will be written
        FILE *_fp;
 
        ///  Global logging level for the event logger
        log_level_e _log_level;
 
        ///  Maximum message size, in #characters
        unsigned int _max_message_size;
 
        ///  String variable and character array to hold message 
        std::string _msg;
    };
 
}
 
#endif