TnbTraceLogger.h

[詳解]

#pragma once
#include "TnbDump.h"
#include "TnbInifileAccessor.h"
#include "TnbFile.h"
#include "TnbAsyncWriter.h"
#include "TnbSingleton.h"
#include "TnbStrEx.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbLOG_DISABLE
 
 
#ifndef _TnbLOG_MULTIFILE
 #pragma message("message : TLOG系は有効になっています(SingleFileType)。")
#else
 #pragma message("message : TLOG系は有効になっています(MultiFileType)。")
#endif
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
 
 
#ifndef _TnbTraceLogger_Types
 #define _TnbTraceLogger_Types "trace"
#endif
 
#ifndef _TnbTraceLogger_LogSize
 #define _TnbTraceLogger_LogSize 64
#endif
 
#ifndef _TnbTraceLogger_FileCount
 #define _TnbTraceLogger_FileCount 5
#endif
 
#ifndef _TnbTraceLogger_Time
 #define _TnbTraceLogger_Time "normal"
#endif
 
#ifndef _TnbTraceLogger_Thread
 #define _TnbTraceLogger_Thread "on"
#endif
 
#ifndef _TnbTraceLogger_Dump
 #define _TnbTraceLogger_Dump 1
#endif
 
#ifndef _TnbTraceLogger_LogFileName
 #define _TnbTraceLogger_LogFileName ms_MakeLogfilePath
#endif
 
// 旧表記
#ifdef _TnbTraceLogger_FileMaxSize
 #undef _TnbTraceLogger_LogSize
 #define _TnbTraceLogger_LogSize _TnbTraceLogger_FileMaxSize
#endif
 
#ifdef _TnbLOG_OUTPUT_FUNC
 #undef _TnbTraceLogger_Types
 #define _TnbTraceLogger_Types "trace func"
#endif
 
 
class CTraceLogger
{
public:
 
    enum EType
    {
        Type_Absolute   = _BIT(0),  
        Type_Error      = _BIT(1),  
        Type_Trace      = _BIT(2),  
        Type_Polling    = _BIT(3),  
        Type_Function   = _BIT(4),  
    };
 
    enum EThread
    {
        Thread_Off = 0,         
        Thread_On,              
    };
 
    enum ETime
    {
        Time_Off = 0,           
        Time_Normal,            
        Time_Full,              
        Time_Tick,              
    };
 
    class CFuncer
    {
    public:
        CFuncer(LPCTSTR lpszFunctionName, ...)
        {
            CStr s;
            va_list args;   
            va_start(args, lpszFunctionName);
            s.FormatV(lpszFunctionName, args);
            m_functionName = s.FindCut('(');
            if ( s.Find('(') == INVALID_INDEX )
            {
                s += _T("()");
            }
            CTraceLogger::Write(CTraceLogger::Type_Function, CStr::Fmt(_T(">In[%s]"), s));
        }
        void Param(LPCTSTR lpszFormatText, ...)
        {
            #ifndef _WIN32_WCE
            ASSERT0(! m_functionName.IsEmpty(),
                    CAscii(m_functionName), "リザルト表示後にパラメータを表示しようとしています。");
            #endif
            CStr s;
            va_list args;   va_start(args, lpszFormatText);
            s.FormatV(lpszFormatText, args);
            CTraceLogger::Write(CTraceLogger::Type_Function, _T(">InParam ") + s);
        }
        void Result(LPCTSTR lpszFormatText, ...)
        {
            #ifndef _WIN32_WCE
            ASSERT0(! m_functionName.IsEmpty(),
                    CAscii(m_functionName), "リザルトを二回以上表示しようとしています。");
            #endif
            CStr s;
            va_list args;   va_start(args, lpszFormatText);
            s.FormatV(lpszFormatText, args);
            m_resultText.Format(_T(">Out[%s()] %s"), m_functionName, s);
            m_functionName.Empty();
        }
        ~CFuncer(void)
        {
            if ( ! m_resultText.IsEmpty() )
            {
                CTraceLogger::Write(CTraceLogger::Type_Function, m_resultText);
            }
            else if ( ! m_functionName.IsEmpty() )
            {
                CStr s;
                s.Format(_T(">Out[%s()]"), m_functionName);
                CTraceLogger::Write(CTraceLogger::Type_Function, s);
            }
            m_functionName.Empty();
        }
        LPCTSTR GetFunctionName(void) const
        {
            return m_functionName;
        }
 
    private:
        CStr m_functionName;    
        CStr m_resultText;      
    };
 
 
    //-----------------
 
 
    virtual ~CTraceLogger(void)
    {
        m_Stop();
    }
 
    static void EnableOutput(bool isEnable)
    {
        CTraceLogger* P = GetInstance();
        P->m_PauseMode(! isEnable);
        if ( ! isEnable )
        {
            P->m_Stop();
        }
    }
    
    static bool Write(EType type, LPCTSTR lpszFormatText, va_list va)
    {
        CTraceLogger* P = GetInstance();
        if ( ! P->m_CanLogout(type) ){ return true; }
        CStr s;
        s.FormatV(lpszFormatText, va);
        return P->m_PostTraceInfo(type, CAscii(s), NULL);
    }
 
    static bool Write(EType type, LPCTSTR lpszFormatText, ...)
    {
        va_list args;   va_start(args, lpszFormatText);
        return Write(type, lpszFormatText, args);
    }
 
    static bool Write(EType type, const CByteVector &vb)
    {
        bool boRc = true;
        CTraceLogger* P = GetInstance();
        if ( ! P->m_CanLogout(type) ){ return true; }
        if ( P->m_outputDumpLevel > 0 )
        {
            boRc = P->m_PostTraceInfo(type, NULL, &vb);
        }
        return boRc;
    }
 
    static bool Write(EType type, size_t size, LPCVOID P)
    {
        bool r;
        if ( ! ::IsBadReadPtr(P, size) )
        {
            CByteVector b;
            b.SetElements(size, static_cast<const BYTE*>(P));
            r = Write(type, b);
        }
        else
        {
            r = Write(type, _T("アクセスできない領域をDumpしようしました。"));
        }
        return r;
    }
 
private:
 
    SINGLETON_CONSTRUCTOR(CTraceLogger)
    {
        m_outputTypes       = 0;
        m_maxLogSize        = 0;
        m_maxMultiFileCount = 0;
        m_outputThread      = Thread_On;
        m_outputTime        = Time_Normal;
        m_outputDumpLevel   = 1;
        m_offset            = 0;
        m_isInitLastTick    = false;
        m_isPause           = false;
    }
 
    static CStr ms_MakeLogfilePath(INDEX index = 0)
    {
        CStr str;
        DWORD dwRc = ::GetModuleFileName(NULL, str.GetBuffer(MAX_PATH), MAX_PATH);
        str.ReleaseBuffer();
        ASSERTLIB(dwRc != 0);
        //
        CStr strWork;
        strWork = str.Left(str.ReverseFind('.'));
        #ifdef _DEBUG
            strWork += _T(".");
            strWork += TNB::GetComputerName();
        #endif
        if ( index == 0 )
        {
            strWork += _T(".t.log");
        }
        else
        {
            strWork += CStr::Fmt(_T(".t%d.log"), index);
        }
        return strWork;
    }
 
    bool m_CanLogout(EType type)
    {
        EXCLUSIVE(&m_sync);
        if ( m_isPause )
        {
            return false;
        }
        if ( ! m_file.IsAlive() )
        {
            if ( ! m_Start() )
            {
                return false; 
            }
        }
        return (m_outputTypes & type) != 0;
    }
 
    void m_Stop()
    {
        if ( m_file.IsAlive() )
        {
            m_PostTraceInfo(Type_Absolute, "----------<<終了>>----------", NULL);
        }
        m_file.Stop();
        m_fw.Close();
    }
 
    bool m_Start(void)
    {
        m_Stop();
        CInifileAccessor ini(TNB::GetProcessPath() + _T("\\TnbLogger.ini"));
        CInifileAccessor::CSection sec = ini[_T("Trace")];
        m_outputTypes = Type_Trace | Type_Error | Type_Absolute;
        {
            CStr s = sec.QueryString(_T("Types"));
            if ( s.IsEmpty() )
            {
                s = _T(_TnbTraceLogger_Types);
            }
            if ( s.Find(_T("err")) >= 0 ){
                m_outputTypes = Type_Error | Type_Absolute;
            }
            if ( s.Find(_T("trace")) >= 0 ){
                m_outputTypes |= Type_Trace;
            }
            if ( s.Find(_T("poll")) >= 0 ){
                m_outputTypes |= Type_Polling;
            }
            if ( s.Find(_T("func")) >= 0 ){
                m_outputTypes |= Type_Function;
            }
            if ( s.Find(_T("off")) >= 0 ){
                m_outputTypes = 0;
            }
        }
        if ( m_outputTypes == 0 )
        {
            return true;
        }
        m_maxLogSize = sec.QueryDword(_T("LogSize"), _TnbTraceLogger_LogSize);
        if ( m_maxLogSize < 1 )
        {
            m_maxLogSize = 1;
        }
        m_maxMultiFileCount = sec.QueryDword(_T("FileCount"), _TnbTraceLogger_FileCount);
        if ( m_maxMultiFileCount < 2 )
        {
            m_maxMultiFileCount = 2;
        }
        m_maxLogSize *= 1024;
        m_outputTime = Time_Normal;
        {
            CStr s = sec.QueryString(_T("Time"));
            if ( s.IsEmpty() )
            {
                s = _T(_TnbTraceLogger_Time);
            }
            if ( s.Find(_T("off")) >= 0 ){
                m_outputTime = Time_Off;
            }
            else if ( s.Find(_T("normal")) >= 0 ){
                m_outputTime = Time_Normal;
            }
            else if ( s.Find(_T("full")) >= 0 ){
                m_outputTime = Time_Full;
            }
            else if ( s.Find(_T("tick")) >= 0 ){
                m_outputTime = Time_Tick;
            }
        }
        m_outputThread = Thread_On;
        {
            CStr s = sec.QueryString(_T("Thread"));
            if ( s.IsEmpty() )
            {
                s = _T(_TnbTraceLogger_Thread);
            }
            if ( s.Find(_T("off")) >= 0 ){
                m_outputThread = Thread_Off;
            }
            else if ( s.Find(_T("on")) >= 0 ){
                m_outputThread = Thread_On;
            }
        }
        m_outputDumpLevel = sec.QueryDword(_T("Dump"), _TnbTraceLogger_Dump);
        //
        if ( ! m_fw.Open(_TnbTraceLogger_LogFileName(0), true, true) )
        {
            return false;
        }
        m_offset = static_cast<INDEX>(m_fw.GetSize());
        #ifndef _TnbLOG_MULTIFILE
            if ( m_offset == 0 )
            {
                //新規じゃん 
                m_offset = HEADSIZE + 2;
                if ( ! m_WritePos(m_fw, m_offset) )
                {
                    return false;
                }
            }
            else
            {
                CByteVector vb;
                try
                {
                    m_fw.Seek(0);
                    vb = m_fw.ReadExactly(HEADSIZE);
                }
                catch(CTnbException& e)
                {
                    e.OnCatch();
                    return false;
                }
                catch(...)
                {
                    ASSERTLIB(false);
                    return false;
                }
                vb.Add(0);
                m_offset = atoi(reinterpret_cast<const char*>(vb.ReferBuffer()));
                m_fw.Seek(m_offset);
            }
        #endif
        if ( ! m_file.SetWriter(&m_fw) )
        {
            return false;
        }
        if ( ! m_file.Start() )
        {
            return false;
        }
        m_file.SetPriority(THREAD_PRIORITY_LOWEST/*2つ下*/);
        m_PostTraceInfo(Type_Absolute, "----------<<起動>>----------", NULL);
        return true;
    }
 
    bool m_WritePos(IWriter& _fw, INDEX dwPos)
    {
        if ( ! _fw.CanWrite() )
        {
            return false;
        }
        DWORD dw = ToDword(dwPos);
        char acFmt[HEADSIZE * 2];
        char acBuf[HEADSIZE * 2];
        sprintf(acFmt, "%%0%dd\r\n", HEADSIZE);
        sprintf(acBuf, acFmt, dw);
        _fw.Seek(0);
        try
        {
            _fw.Write(HEADSIZE + 2, acBuf);
        }
        catch(CTnbException& e)
        {
            e.OnCatch();
            return false;
        }
        catch(...)
        {
            ASSERTLIB(false);
            return false;
        }
        return true;
    }
 
    bool m_WriteLine(IWriter& _fw, LPCSTR lpszLine)
    {
        ASSERT( &_fw == &m_fw );
        if ( ! m_fw.CanWrite() )
        {
            return false;
        }
        //
        #ifdef _DEBUG
            ::OutputDebugString(CStr(lpszLine).Sandwich(_T("TLOG:["), _T("]\n")));
        #endif
        #ifndef _TnbLOG_MULTIFILE
            LPCSTR lpszRc = "\r\n@@\r\n";
            m_fw.Seek(m_offset);
        #else
            LPCSTR lpszRc = "\r\n";
        #endif
        size_t dwTextSize = STRLIB::GetLen(lpszLine);
        try
        {
            m_fw.Write(dwTextSize, lpszLine);
            m_fw.Write(STRLIB::GetLen(lpszRc), lpszRc);
        }
        catch(CTnbException& e)
        {
            e.OnCatch();
            return false;
        }
        catch(...)
        {
            ASSERTLIB(false);
            return false;
        }
        m_offset += dwTextSize + 2;
        #ifndef _TnbLOG_MULTIFILE
            if ( m_offset > m_maxLogSize )
            {
                m_offset = HEADSIZE + 2;
                m_fw.SetEnd();
            }
            return m_WritePos(m_fw, m_offset);
        #else
            if ( m_offset > m_maxLogSize )
            {
                // リネームするぞ
                EXCLUSIVE(&m_sync);
                m_fw.Close();
                ::DeleteFile(_TnbTraceLogger_LogFileName(m_maxMultiFileCount)); //ない場合もある
                loop_dn( i, m_maxMultiFileCount)
                {
                    CStr s1 = _TnbTraceLogger_LogFileName(i + 1);
                    CStr s2 = _TnbTraceLogger_LogFileName(i);
                    ::MoveFile(s2, s1);
                }
                if ( ! m_fw.New(_TnbTraceLogger_LogFileName(0), true) )
                {
                    return false;
                }
                m_offset = 0;
            }
            return true;
        #endif
    }
 
    class CParamWriteCmd : public CAsyncWriter::ICommand
    {
        CTraceLogger*   m_pLogger;      
    public:
        EType       type;               
        bool        hasText;            
        CAscii      strText;            
        CByteVector vbBinary;           
        SYSTEMTIME  tSysTime;           
        DWORD       dwTick;             
        DWORD       dwThreadId;         
 
        CParamWriteCmd(CTraceLogger* P)
        {
            m_pLogger = P;
        }
 
        virtual bool Exec(IWriter& fw)
        {
            if ( ! m_pLogger->m_isInitLastTick )
            {
                m_pLogger->m_isInitLastTick = true;
                m_pLogger->m_lastTick = dwTick;
            }
            DWORD dwTickDiff = dwTick - m_pLogger->m_lastTick;
            CAscii strThread;
            if ( m_pLogger->m_outputThread != Thread_Off )
            {
                strThread.Format("[%08X] ", dwThreadId);
            }
            CAscii strLine;
            switch ( m_pLogger->m_outputTime )
            {
            case Time_Off:  //出力しない
                break;
            case Time_Normal:   //YY/MM/DD-HH:MM:SS.SSS
            default:
                #ifndef _WIN32_WCE
                    strLine.Format("%02d/%02d/%02d-%02d:%02d:%02d.%03d",
                            tSysTime.wYear%100,
                            tSysTime.wMonth,
                            tSysTime.wDay,
                            tSysTime.wHour,
                            tSysTime.wMinute,
                            tSysTime.wSecond,
                            tSysTime.wMilliseconds
                    );
                #else
                    strLine.Format("%02d/%02d-%02d:%02d:%02d",
                            tSysTime.wMonth,
                            tSysTime.wDay,
                            tSysTime.wHour,
                            tSysTime.wMinute,
                            tSysTime.wSecond
                    );
                #endif
                break;
            case Time_Full: //YY/MM/DD-HH:MM:SS.SSS(TTTTTTTT)
                strLine.Format("%02d/%02d/%02d-%02d:%02d:%02d.%03d(%8d)",
                        tSysTime.wYear%100,
                        tSysTime.wMonth,
                        tSysTime.wDay,
                        tSysTime.wHour,
                        tSysTime.wMinute,
                        tSysTime.wSecond,
                        tSysTime.wMilliseconds,
                        dwTickDiff
                );
                break;
            case Time_Tick: //TTTTTTTT
                strLine.Format("(%8d)", dwTickDiff);
                break;
            }
            m_pLogger->m_lastTick = dwTick;
            //
            if ( type == Type_Error )
            {
                strLine += "*Err* ";
            }
            else
            {
                strLine += " ";
            }
            //
            if ( hasText )
            {
                strLine += strText;
                m_pLogger->m_WriteLine(fw, strThread + strLine);
            }
            else if ( (m_pLogger->m_outputDumpLevel) > 0 )
            {
                CAscii s;
                s.Format(" Bin(size=%d)", vbBinary.GetSize());
                strLine += s;
                m_pLogger->m_WriteLine(fw, strThread + strLine);
                //
                size_t l = vbBinary.GetSize();
                if ( (m_pLogger->m_outputDumpLevel) == 1 && l > 16 )
                {
                    l = 16;
                }
                CStrVector vs = DumpData(l, vbBinary.ReferBuffer());
                loop ( i, vs.GetSize() )
                {
                    m_pLogger->m_WriteLine(fw, CAscii(vs[i]));
                }
            }
            return true;
        }
    };
 
    bool m_PostTraceInfo(EType type, LPCSTR lpszText, const CByteVector* pvb)
    {
        if ( m_isPause ) { return true; }
        //
        CParamWriteCmd* P = new CParamWriteCmd(this);
        P->dwTick       = ::GetTickCount();
        P->dwThreadId   = ::GetCurrentThreadId();
        P->type         = type;
        if ( lpszText != NULL )
        {
            P->hasText = true;
            P->strText = lpszText;
        }
        else if ( pvb != NULL )
        {
            P->hasText = false;
            P->vbBinary = *pvb;
        }
        else
        {
            delete P;   //メモリ開放。
            return false;
        }
        ::GetLocalTime(&(P->tSysTime));
        return m_file.Command(P);
    }
 
    void m_PauseMode(bool isPause)
    {
        m_isPause = isPause;
    }
 
    enum { HEADSIZE = 12 };                 //ヘッダの桁数
    bool            m_isPause;              
    DWORD           m_outputTypes;          
    DWORD           m_maxLogSize;           
    DWORD           m_maxMultiFileCount;    
    EThread         m_outputThread;         
    ETime           m_outputTime;           
    int             m_outputDumpLevel;      
    bool            m_isInitLastTick;       
    DWORD           m_lastTick;             
    CFileWriter     m_fw;                   
    CAsyncWriter    m_file;                 
    INDEX           m_offset;               
    CSyncSection    m_sync;                 
    friend class CTraceLogger::CParamWriteCmd;
};
 
 
#define TFUNC                   CTraceLogger::CFuncer _TnbFunc_
#define TFUNC_PARAM             _TnbFunc_.Param
#define TFUNC_RESULT            _TnbFunc_.Result
 
 
 
#endif // _TnbDOXYGEN
 
 
 
#ifdef _TnbDOXYGEN
 
 
 
void TFUNC(LPCTSTR lpszFormatText, ...);
 
void TFUNC_PARAM(LPCTSTR lpszFormatText, ...);
 
void TFUNC_RESULT(LPCTSTR lpszFormatText, ...);
 
 
 
#endif //_TnbDOXYGEN
 
 
 
inline void TLOG_AB(LPCTSTR lpszFormatText, ...)
{
    va_list args; va_start(args, lpszFormatText);
    CTraceLogger::Write(CTraceLogger::Type_Absolute, lpszFormatText, args);
}
 
inline void TLOG_ERR(LPCTSTR lpszFormatText, ...)
{
    va_list args; va_start(args, lpszFormatText);
    CTraceLogger::Write(CTraceLogger::Type_Error, lpszFormatText, args);
}
 
inline void TLOG_ERRDUMP(size_t size, LPCVOID P)
{
    CTraceLogger::Write(CTraceLogger::Type_Error, size, P);
}
 
inline void TLOG_ERRDUMPV(const CByteVector& vb)
{
    CTraceLogger::Write(CTraceLogger::Type_Error, vb);
}
 
inline void TLOG(LPCTSTR lpszFormatText, ...)
{
    va_list args; va_start(args, lpszFormatText);
    CTraceLogger::Write(CTraceLogger::Type_Trace, lpszFormatText, args);
}
 
inline void TLOG_DUMP(size_t size, LPCVOID P)
{
    CTraceLogger::Write(CTraceLogger::Type_Trace, size, P);
}
 
inline void TLOG_DUMPV(const CByteVector& vb)
{
    CTraceLogger::Write(CTraceLogger::Type_Trace, vb);
}
 
inline void TLOG_POL(LPCTSTR lpszFormatText, ...)
{
    va_list args; va_start(args, lpszFormatText);
    CTraceLogger::Write(CTraceLogger::Type_Polling, lpszFormatText, args);
}
 
inline DWORD TLASTERROR(LPCTSTR lpszFunctionName)
{
    DWORD e = ::GetLastError();
    if ( e != ERROR_SUCCESS )
    {
        CSimpleStr s;
        SystemErrorToMessageText(s, e);
        LPCTSTR lpszErr = s;
        TLOG( _T("API[%s()]失敗 ErrorCode = 0x%08x(%s)"), lpszFunctionName, e, lpszErr);
    }
    ::SetLastError(e);
    return e;
}
 
#ifdef _DEBUG
#ifdef _GetLastError
#undef _GetLastError
#define _GetLastError(XX) TLASTERROR(_T(XX))
#endif
#endif
 
#ifdef _DEBUG
    #define TLINE() CTraceLogger::Write(CTraceLogger::Type_Absolute, _T("** %s(%d):"), _T(__FILE__), __LINE__)
#else
    #define TLINE()
#endif
 
 
 
#else //_TnbLOG_DISABLE
 
    // TLOG無効用宣言
    #define TFUNC           __noop
    #define TFUNC_PARAM     __noop
    #define TFUNC_RESULT    __noop
    #define TLOG_POL        __noop
    #define TLOG            __noop
    #define TLOG_DUMP       __noop
    #define TLOG_DUMPV      __noop
    #define TLOG_ERR        __noop
    #define TLOG_ERRDUMP    __noop
    #define TLOG_ERRDUMPV   __noop
    #define TLOG_AB         __noop
    #define TLASTERROR      __noop
    #define TLINE()
 
#endif //_TnbLOG_DISABLE
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
// 旧バージョンに対応
#define TFUNC_(XX)              TFUNC XX
#define TFUNC_PARAM_(XX)        TFUNC_PARAM XX
#define TFUNC_RESULT_(XX)       TFUNC_RESULT XX
#define TLOG_AB_(XX)            TLOG_AB XX
#define TLOG_ERR_(XX)           TLOG_ERR XX
#define TLOG_(XX)               TLOG XX
#define TLOG_POL_(XX)           TPOL XX
 
#endif
 
 
 
}; // TNB