FesaLogger.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
#ifndef __FesaLogger__H__
#define __FesaLogger__H__

#include <unistd.h>
#include <stdio.h>
#include <string>
#include <fstream>
#include <iomanip>
#include <signal.h>

#include <fesa-core/Diagnostic/TimeStampCounter.h>
#include <fesa-core/Diagnostic/UdpLogger.h>
#include <fesa-core/Utilities/Mutex.h>
#include <fesa-core/DataStore/AbstractDevice.h>

/* -------------------------------------------------------------------------
 * Names used to instantiate Error reporting loggers
 * Logging message format:
 * Sender|Type|Source|Class|Thread|Count|Time|Name|Action|<message>
 *
 * Static information (used as FesaLogger identification):
 * Sender       : which code the logging comes from (FWK, USR) - insert by macro
 * Type         : type of the logging (ERROR, TRACE)
 * Source       : logging category (MAIN, RT, SRV, EVT, NOTIF)
 * Class        : name of the concerned class (used for shared server)
 * Thread       : identification of running thread
 *
 * Dynamic information:
 * Count        : log counting, one individual counter per FesaLogger
 * Time         : time-stamping (RTSC ys) of the logged message
 * Name         : name of the event, action, ..
 * Action       : standard action (CREATE, DELETE, START, STOP, ..)
 * <message>: extra message, debug, ..
 */

/* -------------------------------------------------------------------------
 */
// to log a error (without condition)......................................
#define LOGERROR(severity) pLog->logError(fesa::FesaLogger::severity)
#define FWK_LOGERROR(severity) pLog->logError(FesaLogger::severity, FesaLogger::FWK_SENDER)

// to log a trace for a particular TOPIC ...................................
#define LOGTRACE(topic) if (pLog->isEnabledFor(topic)) *pLog
#define FWK_LOGTRACE(topic)     if (pLog->isEnabledFor(FesaLogger::topic)) *pLog

// to log a trace for a particular TOPIC and particular device .............
#define LOGTRACE_DEVICE(topic, pdev) if (pLog->isEnabledFor(topic, pdev)) *pLog
#define FWK_LOGTRACE_DEVICE(topic, pdev) if (pLog->isEnabledFor(FesaLogger::topic, pdev)) *pLog

namespace fesa
{

    // //Diagnostic State counting information
    // typedef struct
    // {
    //         unsigned long last_;
    //         unsigned long current_;
    //         unsigned long max_;
    // } DiagStateCounter;

    const std::string defaultLogName = "DLT";
    const std::string rtLogName = "RT";
    const std::string srvLogName = "SRV";
    const std::string evtLogName = "EVT";
    const std::string notifLogName = "NOTIF";
    const std::string bgrNotifLogName = "BGR_NOTIF";
    const std::string rdaLogName = "RDA";
    const std::string persLogName = "PSTCY";

    const std::string undefinedClassName = std::string("-");
    const std::string undefinedThreadName = std::string("-");
    const std::string undefinedFunctionName = std::string("-");

    class FesaLoggerBuffer;

    /* -------------------------------------------------------------------------
     */
    class FesaLogger: public std::ostream
    {

        public:
            /* Define the log sender: first part of the message header
             * FWK: message coming from Framework code
             * USR: message coming from custom code
             */
            static const std::string fwkSender;
            static const std::string usrSender;

            // enum DiagState
            // {
            //     //Define specific action to be activated on RT process during Diagnostic setting (diag
            //         initDiag = 1 << 0,
            //         startDiag = 1 << 1,
            //         stopDiag = 1 << 2,
            //         requestState = 1 << 3,
            //         updateFwkTopic = 1 << 4,
            //         updateCustomTopic = 1 << 5,
            //         updateTsPeriod = 1 << 6
            // };

            enum DIAG_FWK_TOPIC
            { // 32 bits available
                    getActionProfiling = 1 << 0,
                    setActionProfiling = 1 << 1,
                    rtActionProfiling = 1 << 2,
                    eventProfiling = 1 << 3,
                    notificationProfiling = 1 << 4,
                    getActionTracking = 1 << 5,
                    setActionTracking = 1 << 6,
                    rtActionTracking = 1 << 7,
                    eventTracking = 1 << 8,
                    notificationTracking = 1 << 9,
                    persistencyTracking = 1 << 10,
                    transactionTracking = 1 << 11,
                    subscriptionTracking = 1 << 12,
                    signalHandlerTracking = 1 << 13,
                    rdaTracking = 1 << 15,
                    startUpTracking = 1 << 31
            };

            /* Define the type of logger:
             * ERROR for Error and warning reporting
             * TRACE for Trace and debugging
             * Different type allow to use appropriate communication channel (syslog Logging, udp logging, ..)
             */
            enum LogType
            {
                errorType = 0,
                traceType = 1
            };

            /* Define the type of logger:
             * ERROR for Error and warning reporting
             * TRACE for Trace and debugging
             * Different type allow to use appropriate communication channel (syslog Logging, udp logging, ..)
             */
            enum LogSeverity
            {
                //absolute value used beacause of rda redefinition conflict (to be fixed from RDA)
                //all these LogSeverity are from the syslog() standard!!
                fatal = 0, //LOG_EMERG     -system crashed
                alert = 1,              //LOG_ALERT: urgently to do some actions.Only use in worst case !! Since the log messages is spreaded to all open consoles of the system
                critical = 2,   //LOG_CRIT: critical error, from syslog() standard
                error = 3,              //LOG_ERR: error, from syslog() standard
                warning = 4,    //LOG_WARNING: warning from syslog() standard
                notice = 5,     //LOG_NOTICE: important Message
                none = 6,               //LOG_INFO: for Trace logging. Normal message
                debug = 7
            };

            //Define action for USR traces to be displayed in the profiler
            //In case of modification, don't forget to update 'logActionStr' string-table.
            enum LogAction
            {
                undefined = 0,  //"|-|"
                    start = 1,  //"|START|"
                    stop = 2    //"|STOP|"
            };

            //set ERROR header without condition for general purpose ........................
            inline FesaLogger & logError(LogSeverity severity, const std::string& sender);

            //set TRACE header for topic-conditionned logging ...............................
            inline bool isEnabledFor(int32_t topic, const std::string& name, LogAction action);

            //FWK interface
            inline bool isEnabledFor(DIAG_FWK_TOPIC topic);

            //set TRACE header for topic-conditionned logging upon particular device ........
            inline bool isEnabledFor(int32_t topic, AbstractDevice* pdev, const std::string& name, LogAction action);

            static bool isEnabled();

            FesaLogger(const FesaLogger&);

            ~FesaLogger();

            static void init(char *bname);
            static void enableConsoleOutput();
            static void disableConsoleOutput();
            static void reinit();
            static void destroy();

            /* Instantiate or just retrieve a logger object (logger-name = source+thread)
             * source: domain of the logging (MAIN, RT, SRV, .. look at definition above)
             * thread: prevents concurrent logger access and allow visualization of the
             * different layer in the diagnostic scope (Framework instrumentation only).
             */
            // this signature is used for the Framework instrumentation
            static FesaLogger* getLogger(const std::string& source, const std::string& thread, const std::string& cname);

            // this signature is used for the Framework instrumentation
            static FesaLogger* getLogger(const std::string& source, const std::string& thread);

            // returns a unique instance
            static FesaLogger* getDefaultLogger();

            // Set Diagnostic mode for all Loggers of the process.
            static void setDiagnosticMode(bool mode);

            // Set custom topic for all the log instances belonging to that class.
            static void setCustomTopic(int32_t customTopic, const std::string& cname);

            //send the message using the appropriate channel
            void send(const char* msg, LogType type);

            // public attributes used by the framework
            static int32_t fwkTopic_; // Topics' state of the Framework Modediagnostic
            int32_t customTopic_; // Custom' state of the Framework diagnostic

            //process goes to diagnostic mode if logging channel has been set (enableDiagnosticMode = true)
            static bool modeDiagnostic_;

            //Message couting (allow to detect messages loss)
            static uint32_t logCount_;

            //TSC counter for Logging time-stamping
            static TsCounter logTsc_;

            /* Diagnostic is done for one class only even in SharedServer process.
             * In order to limit the CPU overload during logging process, configuration
             * of the current class diagnostic is stored into the FesaLogger.
             * These Global data are set by the Diagnostic setting property.
             */
            //used for one interface at a time, can be static.
            static std::string connectedHostName_;
            static int32_t connectedPortNumber_;

            std::string className_;
            std::string logSource_;
            std::string logThread_;
            std::string logName_;


        private:

            friend class FesaLoggerBuffer;

            FesaLogger(FesaLoggerBuffer* pBuf);

            /* For the Trace logging, topic filtering is done by the source
             * We just need to define one logging channel and maintain it globally.
             */
            static UdpLogger* pUDPLog_;

            /* Name of the FesaLogger object which is used as message header
             * Must be unique per concurrent thread. Format: <source>|<thread>, exp: "EVT|RTLayer1"
             */
            //Maintain the logging severity (FATAL, ERROR, WARNING)
            LogSeverity errSeverity_;

            //Maintain the logger type (ERROR or TRACE)
            LogType logType_;

            //Save the last Error (client connection lost in particular) in order
            //to not fill the syslogger with the same message.
            int32_t lastError_;

            //flag used to root logging to standard 'cout <<' during the process start-up
            static bool isInitPhase_; //init-phase=true ==> logging means 'std::cout'

            static FesaLogger* errLog_; //shared Logger used for Error reporting


            //Define action for USR traces to be displayed in the profiler
            //In case of modification, don't forget to update 'LogAction' enumeration.
            static const char* logActionStr_[];

            // Map to register logger objects
            static std::map<std::string, FesaLogger *> logFactoryMap_;
            // Maintains a reference to the default one to avoid
            // map lookup for retrieving the default logger instance
            static FesaLogger* defaultLog_;

            // Mutex used to protect the logFactoryMap
            static Mutex mutex_;

            //Buffer and stream object for each logger instance
            FesaLoggerBuffer* logBuffer_;
    };

    /* -------------------------------------------------------------------------
     */
    class FesaLoggerBuffer: public std::streambuf
    {
        public:
            FesaLoggerBuffer()
            {
                setp(buffer_, buffer_ + (bufferSize_ - 1));
            }

            void setFesaLogger(FesaLogger* pLogger)
            {
                logger_ = pLogger;
            }
            ;

        protected:
            virtual int32_t sync();
            virtual int32_t overflow(int32_t);

        private:
            /* For perfomance aspect, the ouput message should be limited to the
             * network MTU: 1480 bytes for Ethernet.
             */
            static const int32_t bufferSize_ = 1479; //reserve 1 char for string termination
            char buffer_[bufferSize_];
            //FesaLogger owner of that buffer
            FesaLogger* logger_;
    };

    inline FesaLogger* FesaLogger::getDefaultLogger()
    {
        return defaultLog_;
    }

#define SET_TRACE_HEADER(sender)        \
        logType_ = traceType;                   \
        errSeverity_ = none;                            \
        *this << sender << "|TRACE|" << logSource_ << className_ << logThread_ << logCount_++ << "|" << std::setprecision(20) << logTsc_.getValue(YS_UNIT) << "|"

    inline FesaLogger & FesaLogger::logError(LogSeverity severity, const std::string& sender = FesaLogger::usrSender)
    {
        logType_ = errorType;
        errSeverity_ = severity;
        *this << sender << "|ERROR|";
        return *this;
    }

    inline bool FesaLogger::isEnabledFor(int32_t topic, const std::string& name = undefinedFunctionName, LogAction action =
                    undefined)
    {

        if (modeDiagnostic_ && (topic & customTopic_))
        {
            //function name and action attributes can be defined for USR profiling traces purpose,
            //otherwise "-" string will be automatically set in the trace header.
            SET_TRACE_HEADER("USR") << name << logActionStr_[action];
            return true;
        }
        return false;
    }

    inline bool FesaLogger::isEnabledFor(DIAG_FWK_TOPIC topic)
    {

        if (modeDiagnostic_ && (topic & fwkTopic_))
        {
            //explicit (name,action) attributes to be added with FWK trace
            SET_TRACE_HEADER("FWK");
            return true;
        }
        return false;
    }

    inline bool FesaLogger::isEnabledFor(int32_t topic, AbstractDevice* pdev, const std::string& name =
                    undefinedFunctionName, LogAction action = undefined)
    {
        if (modeDiagnostic_ && (topic & customTopic_) && pdev->isLoggable_)
        {
            //function name and action attributes can be defined for USR profiling traces purpose,
            //otherwise "-" string will be automatically set in the trace header.
            SET_TRACE_HEADER("USR") << name << logActionStr_[action];
            return true;
        }
        return false;
    }

}

#endif // __FesaLogger__H__