CodeTempla
390 lines
9.2 KiB
C++
390 lines
9.2 KiB
C++
#ifndef LOGGER__H_
|
|
#define LOGGER__H_
|
|
|
|
#ifdef _WIN32
|
|
|
|
#pragma once
|
|
|
|
//#pragma warning(disable:4710)
|
|
#pragma warning(disable:4996)
|
|
|
|
#include <io.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/timeb.h>
|
|
|
|
#else
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
#include <pthread.h>
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
|
|
#endif // _WIN32
|
|
|
|
|
|
|
|
class HLoggerExtension
|
|
{
|
|
public:
|
|
HLoggerExtension() {}
|
|
virtual ~HLoggerExtension() {}
|
|
|
|
protected:
|
|
virtual void OnWrite(const char * pszText, unsigned nLength) = 0;
|
|
|
|
friend class HLogger;
|
|
};
|
|
|
|
///////////////////////////////////////
|
|
|
|
class HLogger
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
MD_MAX_STRING = 1024, // max one-line log length
|
|
MD_MAX_PATH = 1024, // max path name length
|
|
MD_MAX_DATE = 16, // max date string length
|
|
MIN_LIMIT_SIZE = 4096
|
|
};
|
|
|
|
enum Options
|
|
{
|
|
dayWrite = 0x0001, // add day : default
|
|
timeWrite = 0x0002, // add time : default
|
|
autoNewLine = 0x0004, // ...
|
|
onlyLevel = 0x0008,
|
|
consoleWrite = 0x0010
|
|
};
|
|
|
|
HLogger();
|
|
virtual ~HLogger();
|
|
|
|
bool Create(unsigned nLevel, bool bContinue, const char * szPathName = NULL, bool bIsBinary = false);
|
|
// nLevel : max write level
|
|
// bContinue : true is contiue writing to exist log file.
|
|
// szPathName : NULL ==> log name is date. ex) 20030201.log
|
|
// szPathName : Directory ==> log name is date. ex) Create("log/") = log/20030201.log
|
|
// szPathName : full path name or file name ==> equal.
|
|
|
|
void Release(); // for log file close.
|
|
|
|
inline int GetLevel();
|
|
inline void SetLevel(unsigned nLevel);
|
|
inline int GetOption();
|
|
inline void SetOption(int flagOption);
|
|
inline void SetFileSplitSize(off_t nFileSize);
|
|
inline off_t GetFileSplitSize();
|
|
inline off_t GetFileLimitSize();
|
|
inline void SetFileLimitSize(off_t nFileSize);
|
|
inline void SetExtension(HLoggerExtension * pExtension); // auto delete instance
|
|
|
|
void Write(int nLevel, const char * pszLog);
|
|
void Dump(int nLevel, const char * pszLog, size_t nSize, bool bWithHex);
|
|
void Format(int nLevel, const char * fmt, ...);
|
|
void Trace(const char * szSrcFileName, const unsigned nSrcLine, int nLevel, const char *fmt, ...);
|
|
|
|
protected:
|
|
inline char * GetLogStringBuffer();
|
|
inline void SetLogStringBuffer(const char * pszLog);
|
|
|
|
bool OpenFile(unsigned nLevel, const char * szPathName);
|
|
void CloseFile();
|
|
|
|
void GetDateTime(char *szDate, char *szTime);
|
|
void WriteLog(const bool bIsTrace);
|
|
|
|
virtual inline void OnWrite(const char * pszText, unsigned nLength);
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
inline void Lock();
|
|
inline void Unlock();
|
|
#endif
|
|
|
|
public:
|
|
// Two pair fuctions for source file name and line
|
|
// Must be called pair.
|
|
void SetSrcInfoWithLock(const char * szSrcFileName, const unsigned nSrcLine);
|
|
void TraceWithUnlock(int nLevel);
|
|
|
|
friend void __Logger_Format(int nLevel, const char *fmt, ...);
|
|
friend void __Logger_SetSrcInfoWithLock(const char * szSrcFileName, const unsigned nSrcLine);
|
|
friend void __Logger_TraceWithUnlock(int nLevel, const char *fmt, ...);
|
|
|
|
public:
|
|
int m_nLogLength;
|
|
|
|
private:
|
|
char * m_szWriteString;
|
|
char * m_szLogString;
|
|
char * m_szTmpString;
|
|
|
|
int m_fhLog;
|
|
int m_nLevel;
|
|
int m_flagOption;
|
|
bool m_bIsContinue;
|
|
bool m_bIsBinary;
|
|
off_t m_nFileSplitSize; // bytes
|
|
off_t m_nFileLimitSize; // bytes
|
|
char m_szPathName[MD_MAX_PATH];
|
|
char m_szLogFileName[MD_MAX_PATH];
|
|
unsigned m_nLogFileNameExt;
|
|
bool m_bIsFileNameChange;
|
|
char m_szPrevDate[MD_MAX_DATE];
|
|
char m_szSrcFileName[MD_MAX_PATH];
|
|
unsigned m_nSrcLine;
|
|
|
|
int m_nWriteLength;
|
|
|
|
#ifdef _WIN32
|
|
struct _timeb m_tTimeb;
|
|
#else
|
|
struct timeb m_tTimeb;
|
|
#endif
|
|
|
|
char m_szMiliSec[8];
|
|
char m_szTracePathName[MD_MAX_PATH];
|
|
int m_nTracePathLength;
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
#ifdef _WIN32
|
|
CRITICAL_SECTION m_csInstance;
|
|
#else
|
|
pthread_mutex_t m_mutex;
|
|
#endif // _WIN32
|
|
#endif // SINGLE_THREADED_MODEL
|
|
|
|
HLoggerExtension * m_pExtension;
|
|
};
|
|
|
|
inline int HLogger::GetLevel()
|
|
{
|
|
return m_nLevel;
|
|
}
|
|
inline void HLogger::SetLevel(unsigned nLevel)
|
|
{
|
|
m_nLevel = nLevel;
|
|
}
|
|
inline int HLogger::GetOption()
|
|
{
|
|
return m_flagOption;
|
|
}
|
|
inline void HLogger::SetOption(int flagOption)
|
|
{
|
|
m_flagOption = flagOption;
|
|
}
|
|
inline void HLogger::SetFileSplitSize(off_t nFileSize)
|
|
{
|
|
m_nFileSplitSize = nFileSize;
|
|
}
|
|
inline off_t HLogger::GetFileSplitSize()
|
|
{
|
|
return m_nFileSplitSize;
|
|
}
|
|
inline off_t HLogger::GetFileLimitSize()
|
|
{
|
|
return m_nFileLimitSize;
|
|
}
|
|
inline void HLogger::SetFileLimitSize(off_t nFileSize)
|
|
{
|
|
if (nFileSize < MIN_LIMIT_SIZE)
|
|
m_nFileLimitSize = MIN_LIMIT_SIZE;
|
|
else
|
|
m_nFileLimitSize = nFileSize;
|
|
}
|
|
inline char * HLogger::GetLogStringBuffer()
|
|
{
|
|
return m_szLogString;
|
|
}
|
|
inline void HLogger::SetLogStringBuffer(const char * pszLog)
|
|
{
|
|
m_szLogString = (char *)pszLog;
|
|
}
|
|
inline void HLogger::OnWrite(const char * pszText, unsigned nLength)
|
|
{
|
|
write(m_fhLog, pszText, nLength);
|
|
}
|
|
inline void HLogger::SetExtension(HLoggerExtension * pExtension)
|
|
{
|
|
if (m_pExtension)
|
|
delete m_pExtension;
|
|
|
|
m_pExtension = pExtension;
|
|
}
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
inline void HLogger::Lock()
|
|
{
|
|
#ifdef _WIN32
|
|
EnterCriticalSection(&m_csInstance);
|
|
#else
|
|
pthread_mutex_lock(&m_mutex);
|
|
#endif
|
|
}
|
|
inline void HLogger::Unlock()
|
|
{
|
|
#ifdef _WIN32
|
|
LeaveCriticalSection(&m_csInstance);
|
|
#else
|
|
pthread_mutex_unlock(&m_mutex);
|
|
#endif
|
|
}
|
|
#endif // SINGLE_THREADED_MODEL
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
extern HLogger * g_pLogFile__Logger;
|
|
|
|
|
|
extern inline int __Logger_GetLevel()
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return 0;
|
|
|
|
return g_pLogFile__Logger->GetLevel();
|
|
}
|
|
|
|
extern inline void __Logger_SetLevel(unsigned nLevel)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->SetLevel(nLevel);
|
|
}
|
|
|
|
extern inline int __Logger_GetOption()
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return 0;
|
|
|
|
return g_pLogFile__Logger->GetOption();
|
|
}
|
|
|
|
extern inline void __Logger_SetOption(int flagOption)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->SetOption(flagOption);
|
|
}
|
|
|
|
extern inline void __Logger_SetExtension(HLoggerExtension * pExtension)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->SetExtension(pExtension);
|
|
}
|
|
|
|
extern inline void __Logger_Write(int nLevel, const char * pszLog)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->Write(nLevel, pszLog);
|
|
}
|
|
|
|
extern inline void __Logger_Dump(int nLevel, const char * pszLog, size_t nSize, bool bWithHex)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->Dump(nLevel, pszLog, nSize, bWithHex);
|
|
}
|
|
|
|
extern inline void __Logger_Format(int nLevel, const char * fmt, ...)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
if (nLevel > g_pLogFile__Logger->GetLevel() ||
|
|
((g_pLogFile__Logger->GetOption() & HLogger::onlyLevel) == HLogger::onlyLevel && g_pLogFile__Logger->GetLevel() != nLevel))
|
|
return;
|
|
|
|
va_list vaList;
|
|
va_start(vaList, fmt);
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
g_pLogFile__Logger->Lock();
|
|
#endif
|
|
|
|
|
|
#ifdef _WIN32
|
|
g_pLogFile__Logger->m_nLogLength = _vsnprintf(g_pLogFile__Logger->GetLogStringBuffer(), HLogger::MD_MAX_STRING - 1, fmt, vaList);
|
|
#else
|
|
g_pLogFile__Logger->m_nLogLength = vsnprintf(g_pLogFile__Logger->GetLogStringBuffer(), HLogger::MD_MAX_STRING - 1, fmt, vaList);
|
|
#endif
|
|
if (g_pLogFile__Logger->m_nLogLength < 0 || g_pLogFile__Logger->m_nLogLength >= HLogger::MD_MAX_STRING)
|
|
{
|
|
g_pLogFile__Logger->m_nLogLength = HLogger::MD_MAX_STRING;
|
|
g_pLogFile__Logger->GetLogStringBuffer()[HLogger::MD_MAX_STRING - 1] = '\0';
|
|
}
|
|
|
|
va_end(vaList);
|
|
|
|
g_pLogFile__Logger->WriteLog(false);
|
|
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
g_pLogFile__Logger->Unlock();
|
|
#endif
|
|
}
|
|
|
|
extern inline void __Logger_SetSrcInfoWithLock(const char * szSrcFileName, const unsigned nSrcLine)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
g_pLogFile__Logger->SetSrcInfoWithLock(szSrcFileName, nSrcLine);
|
|
}
|
|
|
|
extern inline void __Logger_TraceWithUnlock(int nLevel, const char *fmt, ...)
|
|
{
|
|
if (g_pLogFile__Logger == NULL)
|
|
return;
|
|
|
|
if (nLevel > g_pLogFile__Logger->GetLevel() ||
|
|
((g_pLogFile__Logger->GetLevel() & HLogger::onlyLevel) == HLogger::onlyLevel && g_pLogFile__Logger->GetLevel() != nLevel))
|
|
{
|
|
#ifndef SINGLE_THREADED_MODEL
|
|
g_pLogFile__Logger->Unlock();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
va_list vaList;
|
|
va_start(vaList, fmt);
|
|
|
|
#ifdef _WIN32
|
|
g_pLogFile__Logger->m_nLogLength = _vsnprintf(g_pLogFile__Logger->GetLogStringBuffer(), HLogger::MD_MAX_STRING - 1, fmt, vaList);
|
|
#else
|
|
g_pLogFile__Logger->m_nLogLength = vsnprintf(g_pLogFile__Logger->GetLogStringBuffer(), HLogger::MD_MAX_STRING - 1, fmt, vaList);
|
|
#endif
|
|
if (g_pLogFile__Logger->m_nLogLength < 0 || g_pLogFile__Logger->m_nLogLength >= HLogger::MD_MAX_STRING)
|
|
{
|
|
g_pLogFile__Logger->m_nLogLength = HLogger::MD_MAX_STRING;
|
|
g_pLogFile__Logger->GetLogStringBuffer()[HLogger::MD_MAX_STRING - 1] = '\0';
|
|
}
|
|
|
|
va_end(vaList);
|
|
|
|
g_pLogFile__Logger->TraceWithUnlock(nLevel);
|
|
}
|
|
|
|
|
|
#define HLOG_OPEN(LEVEL, CONTINUE, FILENAME) { if (g_pLogFile__Logger == NULL) { g_pLogFile__Logger = new HLogger; if (g_pLogFile__Logger->Create(LEVEL, CONTINUE, FILENAME) == false) g_pLogFile__Logger = NULL; } }
|
|
#define HLOG_CLOSE() { if (g_pLogFile__Logger) { delete g_pLogFile__Logger; g_pLogFile__Logger = NULL; } }
|
|
#define HLOG_GETLEVEL __Logger_GetLevel
|
|
#define HLOG_SETLEVEL __Logger_SetLevel
|
|
#define HLOG_GETOPTION __Logger_GetOption
|
|
#define HLOG_SETOPTION __Logger_SetOption
|
|
#define HLOG_SETEXTENSION __Logger_SetExtension
|
|
|
|
#define HLOG __Logger_Write
|
|
#define HLOGD __Logger_Dump
|
|
#define HLOGF __Logger_Format
|
|
#define PSTRACE __Logger_SetSrcInfoWithLock(__FILE__, __LINE__),__Logger_TraceWithUnlock
|
|
|
|
#endif // LOGGER__H_
|