linux系统中c++写日志文件功能分享

#include "Logger.h"
#include<cstring>
#include<time.h>
#include<cstdarg>
#include<cstdlib>
#include<assert.h>
#include "FileHelper.h"
#include "Mutex.h"
namespace FrameWork {
Mutex LogMessage::mutex;
static char _defaltFolder[]="/var/tmp/";
static char _appName[MaxFilePathLen];
static char _appFolder[MaxFilePathLen];
static char _destFolder[MaxFilePathLen];
static char _destPrefix[MaxFilePathLen];
static LogLevel _destLevel;
static char _levelInfos[][16]={
 "Debug","Info","Warn","Error","Fatal"
};
const int BUFFER_SIZE = 8196;
static char _gBuffer[BUFFER_SIZE];
void combine_folder(char** destpath,char* basefolder,char* relativefolder)
{
 int lenb = strlen(basefolder);
 int lenr = strlen(relativefolder);
 char* pret = (char*)malloc((lenb+lenr+1)*sizeof(char));
 int pos=lenb-1;
 memset(pret,lenb+lenr+1);
 while(pos>0 && ( basefolder[pos]!='/'))
  pos--;
 strncpy(*destpath,basefolder,pos+1);
 if(relativefolder[0] == '' || relativefolder[0] == '/'){
  strncpy(*destpath+pos+1,relativefolder+1,lenr-1);
 }else{
  strncpy(*destpath+pos+1,relativefolder,lenr);
 }
}

static void InitPaths(const char* filename,const char* destFolder)
{
 memset(_appName,MaxFilePathLen);
 memset(_appFolder,MaxFilePathLen);
 memset(_destFolder,MaxFilePathLen);
 memset(_destPrefix,MaxFilePathLen);

 strcpy(_appName,filename);
 int len = strlen(filename),lend;
 int pos = len-1,posd,start;
 while(pos >0 && filename[pos] != PathSplitChar)
  pos--;
 strncpy(_appFolder,filename,pos+1);
 lend = strlen(destFolder);
 posd = lend-1;
 if(destFolder[lend-1] != PathSplitChar) {
  //has prefix
  while(posd >0 && destFolder[posd] != PathSplitChar)
   posd--;
 }
 if(destFolder[0] == '.' && destFolder[1] == PathSplitChar){
  strncpy(_destFolder,pos+1);
  start = 2;
 } else{
  pos = 8;
  strcpy(_destFolder,_defaltFolder);
  if(destFolder[0] != PathSplitChar){
   start = 0;
  }else{
   start = 1;
  }
 }
 strncpy(_destFolder+pos+1,destFolder+start,posd-start+1);
 strncpy(_destPrefix,pos+1);
 strncpy(_destPrefix+pos+1,lend-start);
}

void InitLogging(const char* filename,LogLevel minlevel,const char* destFolder)
{
 InitPaths(filename,destFolder);
 _destLevel = minlevel;
}

 

static string GetLocalDate(void)
{
 time_t t = time(0);
 tm *ld;
 char tmp[64] = "";
 ld=localtime(&t);
 strftime(tmp,sizeof(tmp),"%Y-%m-%d",ld);
 return string(tmp);
}
static string GetCurTime(void)
{
 time_t t = time(0);
 tm *ld;
 char tmp[64] = "";
 ld=localtime(&t);
 strftime(tmp,"%Y-%m-%d %H:%M:%S",ld);
 return string(tmp);
}

Logger::Logger(LogLevel level,char * folder,char * prefix)
 :level(level)
{
 std::string path;
 path.append(prefix);
 path.append(GetLocalDate());
 path.append(".log");
 FileHelper::CreateDir(folder);
 logPrefix.append(prefix);
 logPath = path;
 logFile.open(path.c_str(),ios::app|ios::out);
 logFile<<"Log file created at:"<<GetCurTime()<<endl;
}

Logger::~Logger() {
 logFile.close();
}

#define IMPLEMENT_LOG_FUNC1(cname,fname,lv)
void cname::fname(string msg) {
    if(level <= lv){
        WriterMutexLock lock(&mutex);
        logFile<<"["<<GetCurTime().c_str()<<"][" #lv "]"<<msg.c_str()<<endl;
        logFile.flush();
    }
}

#define PRINT_ARGS_TO_BUFFER(fmt,buf)
    {
        memset(buf,sizeof(buf));
  va_list argp;
  va_start(argp,fmt);
  vsprintf(buf,fmt,argp);
  va_end(argp);
    }

#define IMPLEMENT_LOG_FUNC2(cname,lv)
void cname::fname(const char* format,...) {
 if(level <= lv){
  WriterMutexLock lock(&mutex);
  PRINT_ARGS_TO_BUFFER(format,_gBuffer)
  logFile<<"["<<GetCurTime().c_str()<<"][" #lv "]"<<_gBuffer<<endl;
  logFile.flush();
 }
}

#define IMPLEMENT_LOG_FUNC(cname,lv)
IMPLEMENT_LOG_FUNC1(cname,lv)
IMPLEMENT_LOG_FUNC2(cname,lv)

IMPLEMENT_LOG_FUNC(Logger,Debug,DEBUG)
IMPLEMENT_LOG_FUNC(Logger,Info,INFO)
IMPLEMENT_LOG_FUNC(Logger,Warn,WARN)
IMPLEMENT_LOG_FUNC(Logger,Error,ERROR)
IMPLEMENT_LOG_FUNC(Logger,Fatal,FATAL)

Logger& Logger::GetInstance() {
 static Logger _logger(_destLevel,_destFolder,_destPrefix);
 return _logger;
}

void Logger::Log(LogLevel lv,string msg) {
 if(level <= lv){
  WriterMutexLock lock(&mutex);
  logFile<<"["<<GetCurTime().c_str()<<"]["<<_levelInfos[lv+1]<<"]"<<msg.c_str()<<endl;
  logFile.flush();
 }
}

void Logger::Log(LogLevel lv,const char* format,...) {
 if(level <= lv){
  WriterMutexLock lock(&mutex);
  PRINT_ARGS_TO_BUFFER(format,_gBuffer)
  logFile<<"["<<GetCurTime().c_str()<<"]["<<_levelInfos[lv+1]<<"]"<<_gBuffer<<endl;
  logFile.flush();
 }
}

void Logger::Log(const char* file,int line,LogLevel lv,string msg) {
 if(level <= lv){
  WriterMutexLock lock(&mutex);
  logFile<<"["<<GetCurTime().c_str()<<"]["<<_levelInfos[lv+1]<<"]["<<file<<"]["<<line<<"]"<<msg.c_str();
  logFile.flush();
 }
}

Logger* Logger::GetInstancePtr() {
 return &GetInstance();
}

void Logger::Log(const char* file,_gBuffer)
  logFile<<"["<<GetCurTime().c_str()<<"]["<<_levelInfos[lv+1]<<"]["<<file<<"]["<<line<<"]"<<_gBuffer;
  logFile.flush();
 }
}

LogMessage::LogMessage(const char* file,LogLevel lv) {
 logger = Logger::GetInstancePtr();
 mutex.Lock();
 logger->Log(file,line,lv,"");
}

LogMessage::~LogMessage() {
 logger->stream()<<endl;
 logger->stream().flush();
 mutex.Unlock();
}

} /* namespace FrameWork */

#ifndef LOGGER_H_
#define LOGGER_H_

#include "ILogger.h"
#include "Mutex.h"
#include<fstream>
#include<string>
const int MaxFilePathLen = 1024;
const char PathSplitChar = '/';
namespace FrameWork {
enum LogLevel{
    /// <summary>
    /// 调试
    /// </summary>
    DEBUG = -1,
    /// <summary>
    /// 普通日志
    /// </summary>
    INFO = 0,
    /// <summary>
    /// 警告
    /// </summary>
    WARN,
    /// <summary>
    /// 错误
    /// </summary>
    ERROR,
    /// <summary>
    /// 崩溃
    /// </summary>
    FATAL,
    /// <summary>
    /// 超出错误级别
    /// </summary>
    OFF
};

class ILogger {
public:
 //
 virtual ~ILogger(){}
#define ABSTRACT_LOG_FUNC(name)
    virtual void name(string msg)=0;
    virtual void name(const char* fmt,...)=0;

    ABSTRACT_LOG_FUNC(Debug)
    ABSTRACT_LOG_FUNC(Info)
    ABSTRACT_LOG_FUNC(Warn)
    ABSTRACT_LOG_FUNC(Error)
    ABSTRACT_LOG_FUNC(Fatal)

#undef ABSTRACT_LOG_FUNC
#define ABSTRACT_LOG_FUNC_X(name)
    virtual void name(LogLevel lv,string msg)=0;
    virtual void name(LogLevel lv,const char* fmt,...)=0;
    virtual void name(const char* file,string msg)=0;
    virtual void name(const char* file,...)=0;
    ABSTRACT_LOG_FUNC_X(Log)

#undef LOG_FUNC_X
};

class Logger: public ILogger {
 std::string logPath;
 std::string logPrefix;
 std::fstream logFile;
 LogLevel level;
 Mutex mutex;

 Logger(LogLevel level,char * prefix);

public:
 static Logger& GetInstance();
 static Logger* GetInstancePtr();
 virtual ~Logger();
 inline fstream & stream(){return logFile;}

#define DECLARE_LOG_FUNC(name)
    virtual void name(string msg);
    virtual void name(const char* fmt,...);

#define DECLARE_LOG_FUNC_X(name)
    virtual void name(LogLevel lv,string msg);
    virtual void name(LogLevel lv,...);
    virtual void name(const char* file,string msg);
    virtual void name(const char* file,...);

    DECLARE_LOG_FUNC(Debug)
    DECLARE_LOG_FUNC(Info)
    DECLARE_LOG_FUNC(Warn)
    DECLARE_LOG_FUNC(Error)
    DECLARE_LOG_FUNC(Fatal)

    DECLARE_LOG_FUNC_X(Log)

#undef DECLARE_LOG_FUNC_X
#undef DECLARE_LOG_FUNC

};

class LogMessage {
 Logger* logger;
 static Mutex mutex;
public:
 LogMessage(const char* file,LogLevel lv);
 ostream& stream(){return logger->stream();}
 virtual ~LogMessage();
};

void InitLogging(const char* filename,const char* destFolder);
void CloseLogging();

#define LOG(level) LogMessage(__FILE__,__LINE__,level).stream()
#define LOG_IF(severity,condition)
 !(condition) ? (void) 0 : LOG(severity)
#define LOG_ASSERT(condition) 
 LOG_IF(FATAL,!(condition)) << "Assert failed: " #condition
#define CHECK(condition) 
 LOG_IF(FATAL,!(condition))
 << "Check failed: " #condition " "

} /* namespace FrameWork */
#endif /* LOGGER_H_ */

 #include <iostream>
#include "Logger.h"
using namespace std;
using namespace FrameWork;
int main(int argc,char* argv[]) {
 InitLogging(argv[0],"./log/test");
 cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
 LOG(INFO)<<"info test";
 LOG(WARN)<<"WARN TEST %d"<<20;
 LOG(ERROR)<<"Error test %d %s"<<20<<"nihao";

 Logger::GetInstance().Error("error test common");
 Logger::GetInstance().Fatal("fatal test common %d ",100);
 Logger::GetInstance().Info("info test normal %d %s ",50,"zhongguoren");
 return 0;
}
 

 #ifndef MUTEX_H_
#define MUTEX_H_
#include <pthread.h>
#include <stdlib.h>
namespace FrameWork {
typedef pthread_mutex_t MutexType;

class Mutex {
public:
 // Create a Mutex that is not held by anybody.  This constructor is
 // typically used for Mutexes allocated on the heap or the stack.
 // See below for a recommendation for constructing global Mutex
 // objects.
 inline Mutex();

 // Destructor
 inline ~Mutex();

 inline void Lock();    // Block if needed until free then acquire exclusively
 inline void Unlock();  // Release a lock acquired via Lock()
 inline bool TryLock(); // If free,Lock() and return true,else return false
 // Note that on systems that don't support read-write locks,these may
 // be implemented as synonyms to Lock() and Unlock().  So you can use
 // these for efficiency,but don't use them anyplace where being able
 // to do shared reads is necessary to avoid deadlock.
 inline void ReaderLock();   // Block until free or shared then acquire a share
 inline void ReaderUnlock(); // Release a read share of this Mutex
 inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
 inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()

 // TODO(hamaji): Do nothing,implement correctly.
 inline void AssertHeld() {}
private:
 MutexType mutex_;
 // We want to make sure that the compiler sets is_safe_ to true only
 // when we tell it to,and never makes assumptions is_safe_ is
 // always true.  volatile is the most reliable way to do that.
 volatile bool is_safe_;

 inline void SetIsSafe() { is_safe_ = true; }

 // Catch the error of writing Mutex when intending MutexLock.
 Mutex(Mutex* /*ignored*/) {}
 // Disallow "evil" constructors
 Mutex(const Mutex&);
 void operator=(const Mutex&);
};
#define SAFE_PTHREAD(fncall)  do {   /* run fncall if is_safe_ is true */ 
 if (is_safe_ && fncall(&mutex_) != 0) abort();                          
 } while (0)

 Mutex::Mutex()             {
  SetIsSafe();
  if (is_safe_ && pthread_mutex_init(&mutex_,NULL) != 0) abort();
 }
 Mutex::~Mutex()            { SAFE_PTHREAD(pthread_mutex_destroy); }
 void Mutex::Lock()         { SAFE_PTHREAD(pthread_mutex_lock); }
 void Mutex::Unlock()       { SAFE_PTHREAD(pthread_mutex_unlock); }
 bool Mutex::TryLock()      { return is_safe_ ?
  pthread_mutex_trylock(&mutex_) == 0 : true; }
 void Mutex::ReaderLock()   { Lock(); }
 void Mutex::ReaderUnlock() { Unlock(); }
 class MutexLock {
 public:
  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
  ~MutexLock() { mu_->Unlock(); }
 private:
  Mutex * const mu_;
  // Disallow "evil" constructors
  MutexLock(const MutexLock&);
  void operator=(const MutexLock&);
 };

 // ReaderMutexLock and WriterMutexLock do the same,for rwlocks
 class ReaderMutexLock {
 public:
  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
 private:
  Mutex * const mu_;
  // Disallow "evil" constructors
  ReaderMutexLock(const ReaderMutexLock&);
  void operator=(const ReaderMutexLock&);
 };

 class WriterMutexLock {
 public:
  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
  ~WriterMutexLock() { mu_->WriterUnlock(); }
 private:
  Mutex * const mu_;
  // Disallow "evil" constructors
  WriterMutexLock(const WriterMutexLock&);
  void operator=(const WriterMutexLock&);
 };
} /* namespace FrameWork */
#endif /* MUTEX_H_ */