FesaLogger.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
//
// FesaLogger.cpp: implementation of the Logger objects
//

#include <fesa-core/Diagnostic/FesaLogger.h>
#include <fesa-core/Utilities/Lock.h>

#include <iostream>
#include <syslog.h>

namespace fesa
{

    class FesaLoggerBuffer;

    /* -------------------------------------------------------------------------
     */
    //Global data of the FesaLogger class - look at header file for comments
    const std::string FesaLogger::fwkSender = "FWK";
    const std::string FesaLogger::usrSender = "USR";
    std::map<std::string, FesaLogger *> FesaLogger::logFactoryMap_;
    Mutex FesaLogger::mutex_;
    UdpLogger* FesaLogger::pUDPLog_ = NULL;
    std::string FesaLogger::connectedHostName_ = "";
    int32_t FesaLogger::connectedPortNumber_ = -1;
    uint32_t FesaLogger::logCount_ = 0;
    TsCounter FesaLogger::logTsc_(true);
    bool FesaLogger::modeDiagnostic_ = false;
    //during start-up (any tracing will be rooted to the console output)
    bool FesaLogger::isInitPhase_ = true;
    int32_t FesaLogger::fwkTopic_ = 0xffffffff;
    FesaLogger* FesaLogger::defaultLog_ =
        FesaLogger::getLogger(defaultLogName, undefinedThreadName, undefinedClassName);
    //In case of modification, don't forget to update 'LogAction' enumeration.
    const char* FesaLogger::logActionStr_[] = { "|-|", "|START|", "|STOP|" };

    /* -------------------------------------------------------------------------
     */
    FesaLogger::FesaLogger(FesaLoggerBuffer* pBuf) :
        std::ostream(pBuf)
    {
        logBuffer_ = pBuf;
        pBuf->setFesaLogger(this); //Buffer use Logger inside sync() method
        //if FesaLogger is instantiated during start-up phase, diagnostic should be enabled.
        modeDiagnostic_ = isInitPhase_;
        customTopic_ = 0xffffffff;
        lastError_ = 0;
        errSeverity_ = none;
    }

    /* -------------------------------------------------------------------------
     * copy constructor
     */
    FesaLogger::FesaLogger(const FesaLogger& refLogger) :
        std::ostream(NULL)
    {

        //create a new instance of the FesaLogger resources
        FesaLoggerBuffer* pBuffer = new FesaLoggerBuffer();
        rdbuf(pBuffer); //set stream-buffer of the ostream base class
        logBuffer_ = pBuffer;
        pBuffer->setFesaLogger(this);
        modeDiagnostic_ = refLogger.modeDiagnostic_;
        lastError_ = 0;

        // the new FesaLogger is a copy of the refLogger
        className_ = refLogger.className_;
        logSource_ = refLogger.logSource_;
        logThread_ = refLogger.logThread_;
        logName_ = refLogger.logName_;
        logType_ = refLogger.logType_;
        customTopic_ = refLogger.customTopic_;
        errSeverity_ = refLogger.errSeverity_;
    }

    /* -------------------------------------------------------------------------
     */
    FesaLogger::~FesaLogger()
    {

        // FesaLogger clean-up (dynamic resources)
        if (logBuffer_ != NULL)
            delete logBuffer_;
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::init(char *bname)
    {
        /* Error reporting service: uses standard syslog mechanism
         * syslog uses file configuration (required root access):
         * /etc/<syslog.conf>     : to define the ouput channel (file, console, host)
         * /etc/<sysconfig/syslog>: to set-up the syslogd daemon
         */
        openlog(bname, LOG_PID | LOG_NDELAY | LOG_CONS, LOG_USER);
    }

    bool FesaLogger::isEnabled()
    {
        return modeDiagnostic_;
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::enableConsoleOutput()
    {
        /* During the process start-up, client cannot be connected to get tracing
         * std::cout should be used instead.
         * Any tracing should be activated bypass macro tracing filtering.
         */
        isInitPhase_ = true;
        fwkTopic_ = 0xffffffff;
        std::map<std::string, FesaLogger *>::iterator itr;
        for (itr = logFactoryMap_.begin(); itr != logFactoryMap_.end(); itr++)
        {
            FesaLogger* pLogger = (FesaLogger *) ((*itr).second);
            pLogger->customTopic_ = 0xffffffff;
        }

        setDiagnosticMode(true);
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::disableConsoleOutput()
    {
        //From now tracing service is enabled, std::cout will not be used anymore.
        //Diagnostic mode is not activated yet (will be done by setDiagnosticSetting).
        setDiagnosticMode(false);
        fwkTopic_ = 0;
        std::map<std::string, FesaLogger *>::iterator itr;
        for (itr = logFactoryMap_.begin(); itr != logFactoryMap_.end(); itr++)
        {
            FesaLogger* pLogger = (FesaLogger *) ((*itr).second);
            pLogger->customTopic_ = 0;
        }
        isInitPhase_ = false;
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::reinit()
    {
        //Create a new trace logging object using new parameters and switch to it
        UdpLogger* oldTraceLog = NULL;
        if (pUDPLog_ != NULL)
            oldTraceLog = pUDPLog_;
        unsigned short lport = (unsigned short) connectedPortNumber_;

        //on that step, every TRACE FesaLogger refer the current trace channel
        // Must be in connected mode for dynamic port allocation issue

        void (*oldHandler)(int32_t) = signal(SIGPIPE, SIG_IGN);
        pUDPLog_ = new UdpLogger(connectedHostName_.c_str(), lport, /*connected mode=*/false);

        //reset tracing counter
        logCount_ = 0;

        if (oldTraceLog != NULL)
            delete oldTraceLog;
        signal(SIGPIPE, oldHandler);
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::destroy()
    {

        // FesaLogger clean-up (static resources)
        std::map<std::string, FesaLogger *>::iterator itr;
        for (itr = logFactoryMap_.begin(); itr != logFactoryMap_.end(); itr++)
        {
            delete ((FesaLogger *) ((*itr).second));
        }

        //remove Trace resources
        if (FesaLogger::pUDPLog_ != NULL)
            delete FesaLogger::pUDPLog_;

        //remove syslog resources
        closelog();
    }

    /* -------------------------------------------------------------------------
     */
    FesaLogger* FesaLogger::getLogger(const std::string& source, const std::string& thread)
    {
        return getLogger(source, thread, undefinedClassName);
    }

    /* -------------------------------------------------------------------------
     */
    FesaLogger* FesaLogger::getLogger(const std::string& source, const std::string& thread, const std::string& cname)
    {

        FesaLogger* pLogger;
        FesaLoggerBuffer* pBuffer;

        const std::string& cname_ = (cname.empty()) ? undefinedClassName : cname;
        const std::string& thread_ = (thread.empty()) ? undefinedThreadName : thread;

        // FesaLogger must be unique per source/thread. This prevent concurrent access on the same logger.
        // Force using shared-logger in case of className missing and source is not SHARED_LOGNAME.
        //        std::string loggerName = ((cname == undefinedClassName) ? defaultLogName : source);
        std::string loggerName = source + thread_ + cname_;

        // Protect critical resource by Mutex: logFactoryMap
        // The unlock is automatic so even in case of any exception
        // the unlock is done
        {
            Lock lock(mutex_);

            std::map<std::string, FesaLogger *>::iterator itr = logFactoryMap_.find(loggerName);
            if (itr != logFactoryMap_.end())
            {
//                std::cout << "get FesaLogger name: " << ""
//                                << "(source: " << source << " thread: " << thread_ << " cname: " << cname << std::endl;
                //This FesaLogger has already been defined
                pLogger = (FesaLogger *) ((*itr).second);
            }
            else
            {
//                std::cout << "instantiate FesaLogger::FesaLogger() name: " <<  loggerName
//                                << "(source: " << source << " thread: " << thread_ << " cname: " << cname << std::endl;
                pBuffer = new FesaLoggerBuffer();
                pLogger = new FesaLogger(pBuffer);

                //register the new instance
                logFactoryMap_[loggerName] = pLogger;

                pLogger->className_ = cname_;

                //store the log name which will be used as message header
                pLogger->logSource_ = source + "|";
                pLogger->logThread_ = "|" + thread_ + "|";
                pLogger->logName_ = loggerName;
                //Default logger type is TRACE
                pLogger->logType_ = FesaLogger::traceType;
                // std::cout << "NEW FesaLogger object (UDP): " << pLogger->logName
                    // _ << std::endl;
            }
            //the lock is released here
        }
        return pLogger;
    }

    /* -------------------------------------------------------------------------
     * Set Diagnostic mode for all Loggers of the process.
     */
    void FesaLogger::setDiagnosticMode(bool mode)
    {
        modeDiagnostic_ = mode;

        // clean each fesaLogger
        std::map<std::string, FesaLogger *>::iterator itr;
        for (itr = logFactoryMap_.begin(); itr != logFactoryMap_.end(); itr++)
        {
            FesaLogger* pLogger = (FesaLogger *) ((*itr).second);
            pLogger->lastError_ = 0;
        }

        // when the diagnostic is disabled the socket is closed
        if (mode == false && pUDPLog_ != NULL)
        {
            connectedHostName_.erase();
            connectedPortNumber_ = -1;
            delete pUDPLog_;
            pUDPLog_ = NULL;
        }
    }

    /* -------------------------------------------------------------------------
     * Set Diagnostic mode for all Loggers of the process.
     */
    void FesaLogger::setCustomTopic(int32_t customTopic, const std::string& cname)
    {
        //TODO : for the time being the cname is ignored
        // Set Diagnostic mode for each Logger
        std::map<std::string, FesaLogger *>::iterator itr;
        for (itr = logFactoryMap_.begin(); itr != logFactoryMap_.end(); itr++)
        {
            FesaLogger* pLogger = (FesaLogger *) ((*itr).second);
            // Update Custom topic for all the log instances of the concerned class.
            if (pLogger->className_ == cname)
            {
                pLogger->customTopic_ = customTopic;
            }
        }
    }

    /* -------------------------------------------------------------------------
     */
    void FesaLogger::send(const char* msg, LogType type)
    {

        /* Select the appropriate logger object which has been instantiate
         * depending on the FesaLogger type.
         * TRACE: log on UDP or cout during init-phase
         */
        if (pUDPLog_ == NULL)
            return;
        if ((logType_ = type) == FesaLogger::traceType)
        {
            if (!isInitPhase_)
            {
                /*UDP send could fail because of unexpected reason: network failure, ..
                 * or it could fail beacause of "acceptable reason": client does not get messages fast enough!
                 * In the latter, do nothing, just wait for normal situation back
                 */
                int32_t err = FesaLogger::pUDPLog_->sendStr(msg);
                switch (err)
                {
                //Expected cases -----------
                case 0: //Everything was ok
                case EAGAIN: //Resource temporarily unavailable
                    /*reset lastError on Diagnostic setting only:
                     UDP socket send is buffered and return OK even if client is deconnected!
                     */
                    break;
                    //Unexpected cases ---------
                    //case ENOBUFS:     //No buffer space available
                default:
                    //log critical error of UDP service
                    if (lastError_ != err)
                    {
                        //do not notify the same error again
                        std::string str("UDP send failure: ");
                        str += strerror(err);
                        syslog(errSeverity_, (char *) str.c_str());
                        lastError_ = err;
                    }
                }
            }
            else
            {
                /* During the process start-up, client cannot be connected to get tracing
                 * std::cout should be used instead (with no tracing header).
                 */
                std::string str = std::string(msg);
                std::cout << str.substr(str.rfind('|') + 1) << std::endl;
            }
        }
        else
        {
            //ERROR: log on syslogger or root on UDP if diagnostic mode is enabled.
            //During process start-up, still root error to syslogger
            if (modeDiagnostic_ && !FesaLogger::isInitPhase_)
            {
                int32_t err = FesaLogger::pUDPLog_->sendStr(msg);
                switch (err)
                {
                //Expected cases -----------
                case 0: //Everything was ok
                case EAGAIN: //Resource temporarily unavailable
                    /*reset lastError on Diagnostic setting only:
                     UDP socket send is buffered and return OK even if client is deconnected!
                     */
                    break;
                    //Unexpected cases ---------
                    //case ENOBUFS:     //No buffer space available
                default:
                    //log critical error of UDP service
                    if (lastError_ != err)
                    { //do not notify the same error again
                        std::string str("UDP send failure: ");
                        str += strerror(err);
                        syslog(errSeverity_, (char *) str.c_str());
                        lastError_ = err;
                    }
                }
            }
            else
            {
                //Diagnostic is disable, Errors go to normal error reporting channel.
                syslog(errSeverity_, (char *) msg);

                //TODO: We dont want to have console output during RUN? Not even on Critical Errors and Alarms??
                //From my point of view(Alex) putting critic errors into the std-linux logfile via syslog is not enaugh.
                //to be discussed

                //if (FesaLogger::isInitPhase_)
                //"error" or worse
                if (errSeverity_ <= FesaLogger::error || FesaLogger::isInitPhase_)
                    std::cout << msg << std::endl; //add console output during start-up
            }
        }
    }

    /* -------------------------------------------------------------------------
     */
    int32_t FesaLoggerBuffer::sync()
    {

        // sendStr() method expects null terminated buffer but
        // streambuf class does not set string terminaison.
        *pptr() = '\0';
        pbump(1);

        int32_t num = static_cast<int32_t>(pptr() - pbase());

        /* Select the appropriate logger object which has been instantiate
         * depending on the FesaLogger type.
         * TRACE: log on UDP or cout during init-phase
         */
        if (logger_->logType_ == FesaLogger::traceType)
        {

            if ((!FesaLogger::isInitPhase_) && (FesaLogger::pUDPLog_ != NULL))
            {
                /*UDP send could fail because of unexpected reason: network failure, ..
                 * or it could fail beacause of "acceptable reason": client does not get messages fast enough!
                 * In the latter, do nothing, just wait for normal situation back
                 */
                int32_t err = FesaLogger::pUDPLog_->sendStr(pbase());
                switch (err)
                {
                //Expected cases -----------
                case 0: //Everything was ok
                case EAGAIN: //Resource temporarily unavailable
                    /*reset lastError on Diagnostic setting only:
                     UDP socket send is buffered and return OK even if client is deconnected!
                     */
                    break;
                    //Unexpected cases ---------
                    //case ENOBUFS:     //No buffer space available
                default:
                    //log critical error of UDP service
                    if (logger_->lastError_ != err)
                    { //do not notify the same error again
                        std::string str("UDP send failure: ");
                        str += strerror(err);
                        syslog(logger_->errSeverity_, (char *) str.c_str());
                        logger_->lastError_ = err;
                    }
                }
            }
            else
            {
                /* During the process start-up, client cannot be connected to get tracing
                 * std::cout should be used instead (with no tracing header).
                 */
                if (pbase() != NULL)
                {
                    std::string str = std::string(pbase());
                    uint32_t position = static_cast<uint32_t>(str.rfind("|"));

                    if (position == std::string::npos)
                        std::cout << str;
                    else
                        std::cout << str.substr(position + 1);
                }
            }
        }
        else
        {
            //ERROR: log on syslogger or root on UDP if diagnostic mode is enabled.
            //During process start-up, still root error to syslogger
            if (logger_->modeDiagnostic_ && !FesaLogger::isInitPhase_ && (FesaLogger::pUDPLog_ != NULL))
            {
                int32_t err = FesaLogger::pUDPLog_->sendStr(pbase());
                switch (err)
                {
                //Expected cases -----------
                case 0: //Everything was ok
                case EAGAIN: //Resource temporarily unavailable
                    /*reset lastError on Diagnostic setting only:
                     UDP socket send is buffered and return OK even if client is deconnected!
                     */
                    break;
                    //Unexpected cases ---------
                    //case ENOBUFS:     //No buffer space available
                default:
                    //log critical error of UDP service
                    if (logger_->lastError_ != err)
                    { //do not notify the same error again
                        std::string str("UDP send failure: ");
                        str += strerror(err);
                        syslog(logger_->errSeverity_, (char *) str.c_str());
                        logger_->lastError_ = err;
                    }
                }
            }
            else
            {
                //Diagnostic is disable, Errors go to normal error reporting channel.
                syslog(logger_->errSeverity_, pbase());

                //TODO: We dont want to have console output during RUN? Not even on Critical Errors and Alarms??
                //From my point of view(Alex) putting critic errors into the std-linux logfile via syslog is not enaugh.
                //to be discussed

                //if (FesaLogger::isInitPhase_)
                //"error" or worse
                if (logger_->errSeverity_ <= FesaLogger::error || FesaLogger::isInitPhase_)
                    std::cout << pbase() << std::endl;
            }
        }

        //clear buffer: set write pointer to base pointer
        pbump(-num);
        return std::streambuf::sync();
    }

    /* -------------------------------------------------------------------------
     * FesaLogger buffer uses fixe size for performance question (no dynamic alloc).
     * In case of buffer overflow, truncated message will be sent.
     */
    int32_t FesaLoggerBuffer::overflow(int32_t c)
    {

        //buffer is full, do not bufferize character and act as null termination.
        return (int32_t) '\0';
    }

}