ms_logging.hpp

/*
##############################################################################
# File: ms_logging.hpp                                                       #
# Mascot Parser toolkit                                                      #
# Encapsulates general purpose objects which act as conduits for receiving   #
# and processing logging events                                              #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 2015-2016 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Source: parser/inc/ms_logging.hpp $
#    $Author: dcreasy@matrixscience.com $ 
#      $Date: 2020-02-17 11:11:01 +0000 $ 
#  $Revision: 568c8a55fee82c07355ed0cee4a6cbf220d9a6fe | MSPARSER_REL_2_8_1-0-gea32989045 $
##############################################################################
*/

#ifndef MS_LOGGING_HPP
#define MS_LOGGING_HPP


// Includes from the standard template library
#include <string>
#include <vector>
#include <list>

namespace msparser_internal {
    class ms_loggingmonitor_impl;
}

namespace matrix_science {
    class ms_logger;        
    


    class MS_MASCOTRESFILE_API ms_loggingmonitor 
    {
    public:

        enum Level_e {
            LVL_NONE     = 0,   
            LVL_ERROR    = 1,   
            LVL_WARNING  = 2,   
            LVL_INFO     = 4,   
            LVL_DEBUG1   = 8,   
            LVL_DEBUG2   = 16,  
            LVL_DEBUG3   = 32   
        }; // enum LogLevel_e


        enum Source_e {
            SRC_APPLICATION  = 1,     
            SRC_MASCOTSERVER = 2,     
            SRC_MSPARSER     = 3,     
            SRC_MDRO         = 4,     
            SRC_MSQUANTLIB   = 5,     
            SRC_PURIFIERAPI  = 6,     
            SRC_PURIFIERAPP  = 7,     
            SRC_DENOVOLIB    = 8,     
            SRC_VENDORSTART  = 100,   
            SRC_ALL          = 0xFFFF 
        }; // enum LogSource_e

    private:        
        msparser_internal::ms_loggingmonitor_impl *pImpl_;
        static ms_loggingmonitor defaultLoggingMonitor;

    public:
        ms_loggingmonitor();

        virtual ~ms_loggingmonitor();

        virtual int addLogEventsHandler(ms_logger& logger);

        virtual bool removeLogEventsHandler(const int uid);

        virtual ms_logger * getLogEventsHandler(const int uid);

        virtual int getNumLogEventsHandlers() const;

        virtual void logMessage(Level_e eSeverity,
            Source_e eSource,
            long lMsgId,
            const std::string & text,
            const char * srcFileName,
            const int srcFileLineNum,
            long lContextId=0) const;

        virtual long getLogMask(unsigned source = SRC_ALL);

        virtual void setLogMask(long newVal, unsigned source = SRC_ALL);

        static matrix_science::ms_loggingmonitor & getDefaultMonitor();
        static void setDefaultMonitor(ms_loggingmonitor & loggingMonitor);

        static std::string messageSourceAsText(Source_e eSource);

        static std::string severityAsText(Level_e eSeverity);

    }; // class ms_loggingmonitor


    class MS_MASCOTRESFILE_API ms_logger {
    public:

        enum LogOutputColumns_e {
            COL_ASC_TIME         = 0x0001, 
            COL_ISO8601_TIME     = 0x0002, 
            COL_IP_ADDRESS       = 0x0004, 
            COL_MSG_NUM_DEC      = 0x0008, 
            COL_MSG_NUM_HEX      = 0x0010, 
            COL_SEVERITY_NUM     = 0x0020, 
            COL_SEVERITY_TXT     = 0x0040, 
            COL_MSG_SOURCE_TXT   = 0x0080, 
            COL_SRC_FILE         = 0x0100, 
            COL_SRC_LINENUM      = 0x0200, 
            COL_THREAD_ID        = 0x0400, 
            COL_MSG              = 0x0800, 

            COL_TSV              = 0x1000, 
            COL_QUOTES           = 0x2000, 
            COL_HEADERS          = 0x4000, 

            COL_LOGGER_DEFAULTS = COL_ISO8601_TIME | COL_MSG_NUM_HEX | COL_SEVERITY_TXT | COL_MSG_SOURCE_TXT | COL_SRC_FILE | COL_SRC_LINENUM | COL_MSG | COL_HEADERS 
        };

        ms_logger(const unsigned int colsToOutput = COL_MSG);

        virtual ~ms_logger() {}

        virtual void onLogMessage(ms_loggingmonitor::Level_e eSeverity,
            ms_loggingmonitor::Source_e eSource,
            long lMsgId,
            const std::string & text,
            const char * srcFileName,
            const int srcFileLineNum,
            long lContextId=0)=0;

        virtual unsigned int getColsToOutput() const;

        virtual void setColsToOutput(const unsigned int colsToOutput);

        std::string formatMessage(ms_loggingmonitor::Level_e eSeverity,
                                  ms_loggingmonitor::Source_e eSource,
                                  long lMsgId,
                                  const std::string & text,
                                  const char * srcFileName,
                                  const int srcFileLineNum,
                                  long lContextId) const;

        std::string getHeaderLine() const;

    protected:
        unsigned int colsToOutput_;
    }; // class ms_logger

    class MS_MASCOTRESFILE_API ms_stdout_logger : public ms_logger {
    public:
        ms_stdout_logger(unsigned int colsToOutput = ms_logger::COL_LOGGER_DEFAULTS);
        virtual ~ms_stdout_logger();

        virtual void onLogMessage(ms_loggingmonitor::Level_e eSeverity,
            ms_loggingmonitor::Source_e eSource,
            long lMsgId,
            const std::string & text,
            const char * srcFileName,
            const int srcFileLineNum,
            long lContextId=0);

    }; // class ms_stdout_logger

    class MS_MASCOTRESFILE_API ms_file_logger : public ms_logger {
    public:
        ms_file_logger(const std::string logFileName, unsigned int colsToOutput = ms_logger::COL_LOGGER_DEFAULTS);

        virtual ~ms_file_logger();

        std::string getLogFilename();

        virtual void onLogMessage(ms_loggingmonitor::Level_e eSeverity,
            ms_loggingmonitor::Source_e eSource,
            long lMsgId,
            const std::string & text,
            const char * srcFileName,
            const int srcFileLineNum,
            long lContextId=0);

    private:
        std::string logfilename_;

    }; // class ms_file_logger

    class MS_MASCOTRESFILE_API ms_buffer_logger : public ms_logger {
    public:
        ms_buffer_logger(unsigned int colsToOutput = ms_logger::COL_LOGGER_DEFAULTS);

        virtual ~ms_buffer_logger();

        std::vector<std::string> flush();

        virtual void onLogMessage(ms_loggingmonitor::Level_e eSeverity,
            ms_loggingmonitor::Source_e eSource,
            long lMsgId,
            const std::string & text,
            const char * srcFileName,
            const int srcFileLineNum,
            long lContextId=0);

    private:
        std::list<std::string> messages_;
        std::list<std::string>::size_type numMessages_;

    }; // class ms_file_logger
 // end of error_handling_group
} // namespace matrix_science

#endif // MS_LOGGING_HPP

/*------------------------------- End of File -------------------------------*/