Logger.h

Go to the documentation of this file.

 
// ###########################################################################################################################################################################################################################################################################################################################
 
#pragma once
 
// OpenTwin header
#include "OTCore/CoreAPIExport.h"
#include "OTCore/Flags.h"
#include "OTCore/OTAssert.h"
#include "OTCore/CoreTypes.h"
#include "OTCore/Serializable.h"
 
// std header
#include <string>
#include <ostream>
#include <list>
 
#define OT_LOG_TIME_FORMAT_STDSTRING "%Y-%m-%d %H:%M:%S"
 
#define OT_GLOBAL_LOGFLAG_LOGEnabled
 
#define OT_GLOBAL_LOGFLAG_LOG_IEnabled
 
#define OT_GLOBAL_LOGFLAG_LOG_DEnabled
 
#define OT_GLOBAL_LOGFLAG_LOG_WEnabled
 
#define OT_GLOBAL_LOGFLAG_LOG_EEnabled
 
#ifdef OT_GLOBAL_LOGFLAG_LOGEnabled
 
#ifdef _DEBUG
 
#define OT_LOG(___text, ___flags) ot::LogDispatcher::instance().dispatch(___text, __FUNCTION__, ___flags)
 
#else
 
#define OT_LOG(___text, ___flags) if (ot::LogDispatcher::mayLog(___flags)) { ot::LogDispatcher::instance().dispatch(___text, __FUNCTION__, ___flags); }
 
#endif
 
#ifdef OT_GLOBAL_LOGFLAG_LOG_IEnabled
 
#define OT_LOG_I(___text) OT_LOG(___text, ot::INFORMATION_LOG)
 
#define OT_LOG_IA(___text) OTAssert(0, ___text); OT_LOG(___text, ot::INFORMATION_LOG)
 
#define OT_LOG_IAS(___text) OTAssert(0, ""); OT_LOG(___text, ot::INFORMATION_LOG)
 
#else // ifdef OT_GLOBAL_LOGFLAG_LOG_IEnabled
 
#define OT_LOG_I(___text)
 
#define OT_LOG_IA(___text)
 
#define OT_LOG_IAS(___text)
 
#endif // ifdef OT_GLOBAL_LOGFLAG_LOG_IEnabled
 
#ifdef OT_GLOBAL_LOGFLAG_LOG_DEnabled
 
#define OT_LOG_D(___text) OT_LOG(___text, ot::DETAILED_LOG)
 
#define OT_LOG_DA(___text) OTAssert(0, ___text); OT_LOG(___text, ot::DETAILED_LOG)
 
#define OT_LOG_DAS(___text) OTAssert(0, ""); OT_LOG(___text, ot::DETAILED_LOG)
 
#else // ifdef OT_GLOBAL_LOGFLAG_LOG_DEnabled
 
#define OT_LOG_D(___text)
 
#define OT_LOG_DA(___text)
 
#define OT_LOG_DAS(___text)
 
#endif // ifdef OT_GLOBAL_LOGFLAG_LOG_DEnabled
 
#ifdef OT_GLOBAL_LOGFLAG_LOG_WEnabled
 
#define OT_LOG_W(___text) OT_LOG(___text, ot::WARNING_LOG)
 
#define OT_LOG_WA(___text) OTAssert(0, ___text); OT_LOG(___text, ot::WARNING_LOG)
 
#define OT_LOG_WAS(___text) OTAssert(0, ""); OT_LOG(___text, ot::WARNING_LOG)
 
#else // ifdef OT_GLOBAL_LOGFLAG_LOG_WEnabled
 
#define OT_LOG_W(___text)
 
#define OT_LOG_WA(___text)
 
#define OT_LOG_WAS(___text)
 
#endif // ifdef OT_GLOBAL_LOGFLAG_LOG_WEnabled
 
#ifdef OT_GLOBAL_LOGFLAG_LOG_EEnabled
 
#define OT_LOG_E(___text) OT_LOG(___text, ot::ERROR_LOG)
 
#define OT_LOG_EA(___text) OTAssert(0, ___text); OT_LOG(___text, ot::ERROR_LOG)
 
#define OT_LOG_EAS(___text) OTAssert(0, ""); OT_LOG(___text, ot::ERROR_LOG)
 
#else // ifdef OT_GLOBAL_LOGFLAG_LOG_EEnabled
 
#define OT_LOG_E(___text)
 
#define OT_LOG_EA(___text)
 
#define OT_LOG_EAS(___text)
 
#endif // ifdef OT_GLOBAL_LOGFLAG_LOG_EEnabled
 
#else // ifdef OT_GLOBAL_LOGFLAG_LOGEnabled
 
#define OT_LOG(___text, ___flags)
 
#define OT_LOG_I(___text)
 
#define OT_LOG_IA(___text)
 
#define OT_LOG_IAS(___text)
 
#define OT_LOG_D(___text)
 
#define OT_LOG_DA(___text)
 
#define OT_LOG_DAS(___text)
 
#define OT_LOG_W(___text)
 
#define OT_LOG_WA(___text)
 
#define OT_LOG_WAS(___text)
 
#define OT_LOG_E(___text)
 
#define OT_LOG_EA(___text)
 
#define OT_LOG_EAS(___text)
 
#endif // ifdef OT_GLOBAL_LOGFLAG_LOGEnabled
 
#pragma warning (disable: 4251)
 
namespace ot {
 
    enum LogFlag {
        NO_LOG                          = 0x0000, 
        INFORMATION_LOG                 = 0x0001, 
        DETAILED_LOG                    = 0x0002, 
        WARNING_LOG                     = 0x0004, 
        ERROR_LOG                       = 0x0008, 
        INBOUND_MESSAGE_LOG             = 0x0010, 
        QUEUED_INBOUND_MESSAGE_LOG      = 0x0020, 
        ONEWAY_TLS_INBOUND_MESSAGE_LOG  = 0x0040, 
        OUTGOING_MESSAGE_LOG            = 0x0080, 
        ALL_GENERAL_LOG_FLAGS           = 0x000F, 
        ALL_INCOMING_MESSAGE_LOG_FLAGS  = 0x0070, 
        ALL_OUTGOING_MESSAGE_LOG_FLAGS  = 0x0080, 
        ALL_MESSAGE_LOG_FLAGS           = 0x00F0, 
        ALL_LOG_FLAGS                   = 0xFFFF  
    };
 
    typedef Flags<LogFlag> LogFlags;
 
    OT_CORE_API_EXPORT void addLogFlagsToJsonArray(const LogFlags& _flags, JsonArray& _flagsArray, JsonAllocator& _allocator);
 
    OT_CORE_API_EXPORT LogFlags logFlagsFromJsonArray(const ConstJsonArray& _flagsArray);
 
}
OT_ADD_FLAG_FUNCTIONS(ot::LogFlag)
 
namespace ot {
 
    class OT_CORE_API_EXPORT LogMessage : public Serializable {
    public:
        LogMessage();
        LogMessage(const std::string& _serviceName, const std::string& _functionName, const std::string& _text, const LogFlags& _flags = LogFlags(ot::INFORMATION_LOG));
        LogMessage(const LogMessage& _other);
        virtual ~LogMessage();
 
        LogMessage& operator = (const LogMessage& _other);
 
        void setServiceName(const std::string& _serviceName) { m_serviceName = _serviceName; };
        const std::string& getServiceName(void) const { return m_serviceName; };
 
        void setFunctionName(const std::string& _functionName) { m_functionName = _functionName; };
        const std::string& getFunctionName(void) const { return m_functionName; };
 
        void setText(const std::string& _text) { m_text = _text; };
        const std::string& getText(void) const { return m_text; };
 
        void setFlags(const LogFlags& _flags) { m_flags = _flags; };
        const LogFlags& getFlags(void) const { return m_flags; };
 
        void setLocalSystemTime(const std::string& _timeString) { m_localSystemTime = _timeString; };
 
        const std::string& getLocalSystemTime(void) const { return m_localSystemTime; };
 
        void setGlobalSystemTime(const std::string& _timeString) { m_globalSystemTime = _timeString; };
 
        const std::string& getGlobalSystemTime(void) const { return m_globalSystemTime; };
 
        void setCurrentTimeAsLocalSystemTime(void);
 
        void setCurrentTimeAsGlobalSystemTime(void);
 
        void setUserName(const std::string& _userName) { m_userName = _userName; };
        const std::string& getUserName(void) const { return m_userName; };
 
        void setProjectName(const std::string& _projectName) { m_projectName = _projectName; };
        const std::string& getProjectName(void) const { return m_projectName; };
 
        virtual void addToJsonObject(JsonValue& _object, JsonAllocator& _allocator) const override;
 
        virtual void setFromJsonObject(const ConstJsonObject& _object) override;
 
    private:
        friend OT_CORE_API_EXPORT std::ostream& operator << (std::ostream& _stream, const LogMessage& _msg);
 
        std::string m_serviceName;          
        std::string m_functionName;         
        std::string m_text;                 
        LogFlags    m_flags;                
        std::string m_localSystemTime;      
        std::string m_globalSystemTime;     
        std::string m_userName;             
        std::string m_projectName;          
    };
 
    OT_CORE_API_EXPORT std::ostream& operator << (std::ostream& _stream, const LogMessage& _msg);
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    class OT_CORE_API_EXPORT AbstractLogNotifier {
    public:
        AbstractLogNotifier() : m_deleteLater(false) {};
        virtual ~AbstractLogNotifier() {};
 
        void setDeleteLogNotifierLater(bool _deleteLater = true) { m_deleteLater = _deleteLater; };
 
        bool getDeleteLogNotifierLater(void) const { return m_deleteLater; };
 
        virtual void log(const LogMessage& _message) = 0;
 
    private:
        bool m_deleteLater; 
    };
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    class OT_CORE_API_EXPORT LogNotifierStdCout : public AbstractLogNotifier {
    public:
        virtual ~LogNotifierStdCout() {};
 
        virtual void log(const LogMessage& _message) override;
    };
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    class OT_CORE_API_EXPORT LogNotifierFileWriter : public AbstractLogNotifier {
        OT_DECL_NODEFAULT(LogNotifierFileWriter)
        OT_DECL_NOCOPY(LogNotifierFileWriter)
    public:
        LogNotifierFileWriter(const std::string& _serviceName);
        virtual ~LogNotifierFileWriter();
 
        virtual void log(const LogMessage& _message) override;
 
    private:
        std::ofstream* m_stream;
    };
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    // ######################################################################################################################################################
 
    class OT_CORE_API_EXPORT LogDispatcher {
    public:
        static LogDispatcher& instance(void);
        static LogDispatcher& initialize(const std::string& _serviceName, bool _addCoutReceiver = false);
        static inline bool mayLog(LogFlag _flags) { return ((_flags & LogDispatcher::instance().m_logFlags.data()) == _flags); };
        static void addFileWriter(void);
 
        // #################################################################################
 
        // Setter/Getter
 
        void setLogFlag(LogFlag _flag, bool _active = true) { m_logFlags.setFlag(_flag, _active); };
        void setLogFlags(LogFlags _flags) { m_logFlags = _flags; };
        LogFlags logFlags(void) const { return m_logFlags; };
 
        void setServiceName(const std::string& _name) { m_serviceName = _name; };
        const std::string& serviceName(void) const { return m_serviceName; };
 
        void setUserName(const std::string& _name) { m_userName = _name; };
        const std::string& getUserName(void) const { return m_userName; };
 
        void setProjectName(const std::string& _name) { m_projectName = _name; };
        const std::string& getProjectName(void) const { return m_projectName; };
 
        void addReceiver(AbstractLogNotifier* _receiver);
 
        // #################################################################################
 
        void dispatch(const std::string& _text, const std::string& _functionName = std::string(), const LogFlags& _logFlags = LogFlags(ot::INFORMATION_LOG));
 
        void dispatch(const LogMessage& _message);
 
    private:
        void applyEnvFlag(const std::string& _str);
 
        LogFlags                        m_logFlags;         
        std::string                     m_serviceName;      
 
        std::list<AbstractLogNotifier*> m_messageReceiver;  
 
        std::string                     m_userName;
        std::string                     m_projectName;
 
        LogDispatcher();
        virtual ~LogDispatcher();
 
        LogDispatcher(LogDispatcher&) = delete;
        LogDispatcher& operator = (LogDispatcher&) = delete;
    };
 
}