cLogAppender.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cLogAppender_H
#define _INC_cLogAppender_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cLogLevel.h"
#include "cRefPtr.h"
#include "cString.h"
#include "cStream.h"
#include "cThreadLock.h"
 
namespace Gray
{
        class cLogEvent;
 
        typedef cStringT<LOGCHAR_t> cStringL;   
#define LOGERR(hRes) LOGSTR(cStringL::GetErrorString(hRes))             
 
        enum LOG_ATTR_TYPE_
        {
 
                LOG_ATTR_0 = 0,
 
 
                LOG_ATTR_INIT = 0x00100000,     
                LOG_ATTR_SCRIPT = 0x00200000,   
                LOG_ATTR_NET = 0x00400000,      
                LOG_ATTR_ODD = 0x01000000,      
                LOG_ATTR_DEBUG = 0x02000000,    
 
                // Bit Flags to control appenders
                LOG_ATTR_PRINT = 0x04000000,    
                LOG_ATTR_PRINTBACK = 0x08000000,        
                LOG_ATTR_TEMP = 0x10000000,     
                LOG_ATTR_INTERNAL = 0x20000000, 
                LOG_ATTR_NOCRLF = 0x40000000,   
                LOG_ATTR_FILTERED = 0x80000000, 
 
                // LOG_ATTR_QUESTION = 0x123123,        //!< This is a question that we hope will get an answer through some async callback. cLogAppendConsole
 
                LOG_ATTR_CUST_MASK = 0x000FFFFF,
                LOG_ATTR_BASE_MASK = 0xFFF00000,
                LOG_ATTR_ALL_MASK = 0xFFFFFFFF
        };
        typedef UINT32 LOG_ATTR_MASK_t; // mask of LOG_ATTR_TYPE_
 
#if 0
        typedef UINT32 LOG_FIELD_t;
        enum LOG_FIELD_MASK_
        {
                LOG_FIELD_MSG,          
                LOG_FIELD_TIME,         
                LOG_FIELD_LEVEL,        
                LOG_FIELD_CONTEXT,      
        };
#endif
 
        //***********************************************************************************
 
        class GRAYCORE_LINK cLogEventParams
        {
 
        protected:
                LOG_ATTR_MASK_t m_uAttrMask;            
                LOGLEV_TYPE m_eLogLevel;                        
 
        public:
                cLogEventParams(LOG_ATTR_MASK_t uAttrMask = LOG_ATTR_0, LOGLEV_TYPE eLogLevel = LOGLEV_TRACE)
                        : m_uAttrMask(uAttrMask)                // Level of log detail messages. IsLogMsg()
                        , m_eLogLevel(eLogLevel)                // Importance level.
                {
                }
 
                LOG_ATTR_MASK_t get_LogAttrMask() const
                {
                        return m_uAttrMask;
                }
                void put_LogAttrMask(LOG_ATTR_MASK_t uAttrMask)
                {
                        m_uAttrMask = uAttrMask;
                }
                bool IsLogAttrMask(LOG_ATTR_MASK_t uAttrMask) const
                {
                        return((m_uAttrMask & uAttrMask) ? true : false);
                }
 
                LOGLEV_TYPE get_LogLevel() const
                {
                        return m_eLogLevel;
                }
                void put_LogLevel(LOGLEV_TYPE eLogLevel)
                {
                        m_eLogLevel = eLogLevel;
                }
                bool IsLoggedLevel(LOGLEV_TYPE eLogLevel) const
                {
                        return(eLogLevel >= m_eLogLevel);
                }
 
                bool IsLogged(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel) const
                {
                        // Would this message be logged?
                        if (!IsLoggedLevel(eLogLevel))
                                return false;
                        if (uAttrMask != 0 && !IsLogAttrMask(uAttrMask))
                                return false;
                        return true;
                }
        };
 
        class GRAYCORE_LINK cLogThrottle
        {
 
        public:
                // throttle.
                float m_fLogThrottle;                           
                mutable TIMESYS_t m_TimeLogLast;        
                mutable UINT m_nQtyLogLast;                     
 
        public:
                cLogThrottle();
                ~cLogThrottle();
 
                float get_LogThrottle() const
                {
                        return m_fLogThrottle;
                }
        };
 
        // CLogFormat = what should each event line contain from cLogEvent?
 
        //***********************************************************************
 
        DECLARE_INTERFACE(ILogProcessor)
        {
                IGNORE_WARN_INTERFACE(ILogProcessor);
                virtual bool IsLogged(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel) const = 0; // fast pre-check. can call before building message.
                virtual HRESULT addEvent(cLogEvent* pEvent) = 0;
        };
 
        class cLogNexus;
 
        class GRAYCORE_LINK cLogProcessor
                : public ILogProcessor
                , public cStreamOutput  // for WriteString raw dump messages into the system.
        {
 
        public:
                virtual ~cLogProcessor()
                {
                }
                virtual const cLogNexus* get_ThisLogNexus() const
                {
                        return nullptr;
                }
                virtual bool IsLogged(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel) const override // fast pre-check.
                {
                        UNREFERENCED_PARAMETER(uAttrMask);
                        UNREFERENCED_PARAMETER(eLogLevel);
                        return true;
                }
                virtual HRESULT FlushLogs()
                {
                        return S_OK;
                }
 
                // Helpers.
                HRESULT addEventS(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel, cStringL sMsg, cStringL sContext="");
                HRESULT addEventV(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel, const LOGCHAR_t* pszFormat, va_list vargs);
 
                HRESULT _cdecl addEventF(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel, const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(uAttrMask, eLogLevel, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
 
                HRESULT _cdecl addInfoF(const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(LOG_ATTR_0, LOGLEV_INFO, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
 
                HRESULT _cdecl addDebugErrorF(const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(LOG_ATTR_DEBUG, LOGLEV_ERROR, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
                HRESULT _cdecl addDebugWarnF(const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(LOG_ATTR_DEBUG, LOGLEV_WARN, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
                HRESULT _cdecl addDebugInfoF(const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(LOG_ATTR_DEBUG, LOGLEV_INFO, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
                HRESULT _cdecl addDebugTraceF(const LOGCHAR_t* pszFormat, ...)
                {
                        va_list vargs;
                        va_start(vargs, pszFormat);
                        HRESULT hRes = addEventV(LOG_ATTR_DEBUG, LOGLEV_TRACE, pszFormat, vargs);
                        va_end(vargs);
                        return(hRes);
                }
        };
 
        class GRAYCORE_LINK cLogAppender : public IUnknown, public cLogProcessor
        {
                friend class cLogNexus;
        protected:
                virtual HRESULT WriteString(const LOGCHAR_t* pszMsg) override
                {
                        UNREFERENCED_PARAMETER(pszMsg);
                        ASSERT(0);
                        return E_NOTIMPL;
                }
 
                virtual HRESULT WriteString(const wchar_t* pszMsg) override;
 
        public:
                cLogAppender();
                virtual ~cLogAppender();
 
                bool RemoveAppenderThis();
 
                virtual HRESULT addEvent(cLogEvent* pEvent) override
                {
                        UNREFERENCED_PARAMETER(pEvent);
                        return 0;       // just pass the default string to WriteString() below;
                }
        };
 
        class GRAYCORE_LINK cLogAppendDebug : public cLogAppender, public cRefBase
        {
 
        private:
                mutable cThreadLockCount m_Lock;        // prevent multi thread mixing of messages.
        public:
                cLogAppendDebug();
                virtual ~cLogAppendDebug();
 
                static HRESULT GRAYCALL AddAppenderCheck(cLogNexus* pLogger = nullptr);
                virtual HRESULT WriteString(const LOGCHAR_t* pszMsg) override;
 
                IUNKNOWN_DISAMBIG(cRefBase);
        };
 
        class GRAYCORE_LINK cLogAppendCache : public cLogAppender, public cRefBase
        {
 
                TIMESYS_t m_nCacheHold; // How long to hold messages.
 
        };
}
 
#endif