C++写日志到文件

2023-08-01

利用fprintf及可变参数来实现日志功能

先封装一个lock类，用于同步写文件

#ifndef __H_AEYE_LOCKER__
#define __H_AEYE_LOCKER__
#include <pthread.h>

class Locker
{
public:
    inline Locker()
    {
        pthread_mutex_init(&mutex, NULL);
    }
    inline ~Locker()
    {
        pthread_mutex_destroy(&mutex);
    }
    inline void lock()
    {
        pthread_mutex_lock(&mutex);
    }
    inline bool tryLock()
    {
        return (pthread_mutex_trylock(&mutex) == 0);
    }
    inline void unlock()
    {
        pthread_mutex_unlock(&mutex);
    }
private:
    pthread_mutex_t mutex;
};

class RwLocker
{
public:
    inline RwLocker()
    {
        pthread_rwlock_init(&rwLocker, NULL);
    }
    inline ~RwLocker()
    {
        pthread_rwlock_destroy(&rwLocker);
    }
    inline void rLock()
    {
        pthread_rwlock_rdlock(&rwLocker);
    }
    inline void wLock()
    {
        pthread_rwlock_wrlock(&rwLocker);
    }
    inline bool tryRLock()
    {
        return (pthread_rwlock_tryrdlock(&rwLocker) == 0);
    }
    inline bool tryWLock()
    {
        return (pthread_rwlock_trywrlock(&rwLocker) == 0);
    }
    inline void unlock()
    {
        pthread_rwlock_unlock(&rwLocker);
    }

private:
    pthread_rwlock_t rwLocker;
};

#endif

对外接口，日志类头文件,这里使用了单实例类

#ifndef __H_AEYE_LOG__
#define __H_AEYE_LOG__

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "locker.h"

#define LEVEL_FATAL 0
#define LEVEL_ERROR 1
#define LEVEL_ALARM 2
#define LEVEL_PROMT 3
#define LEVEL_TRACE 4

#define LOG(LEVEL, FMT, ...) \
    do { \
        if (NULL != FMT) { \
            Logger::Log::getInstance().writeLine(LEVEL, __func__, __LINE__, FMT, ## __VA_ARGS__); \
        } \
    } while(0)

#define LOGN(FMT, ...) LOG(LEVEL_NONE, FMT, ## __VA_ARGS__)

#define LOGE(FMT, ...) LOG(LEVEL_ERROR, FMT, ## __VA_ARGS__)

#define LOGA(FMT, ...) LOG(LEVEL_ALARM, FMT, ## __VA_ARGS__)

#define LOGP(FMT, ...) LOG(LEVEL_PROMT, FMT, ## __VA_ARGS__)

#define LOGT(FMT, ...) LOG(LEVEL_TRACE, FMT, ## __VA_ARGS__)

#define NO_CONSTRUCT_FUN_MACRO(C) \
public: \
    C(const C&) = delete; \
    C& operator=(const C&) = delete;

#define INHERIT_SINGLETON_MACRO(C) \
    friend class Singleton<C>; \
    NO_CONSTRUCT_FUN_MACRO(C)


template<typename T>
class Singleton
{
public:
    static T& getInstance()
    {
        static T instance;
        return instance;
    }
    NO_CONSTRUCT_FUN_MACRO(Singleton);
protected:
    Singleton(){}
};

namespace Logger
{
class Log : public Singleton<Log>
{
    INHERIT_SINGLETON_MACRO(Log);
public:

    void setLevel(int level);

    void writeLine(int level, const char *func_name, unsigned int line, const char *fmt, ...);

private:
    FILE *m_pLogFile;
    int m_level;
    Locker m_LogLocker;
    Locker m_TimeLogLocker;

    Log(const char* logName = "./log.log");
    ~Log();
};
}

#endif

具体的实现，将内容输出到文件

#include "log.h"
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h>
#include <stdarg.h>

namespace Logger
{
Log::Log(const char* logName)
{
    m_pLogFile = NULL;
    m_level = LEVEL_PROMT;

#ifdef LOG_FILE
    m_pLogFile = fopen(logName, "w+");
#endif
}

Log::~Log()
{
    if (NULL != m_pLogFile)
    {
        fclose(m_pLogFile);
        m_pLogFile = NULL;
    }
}

static std::string tolevelstring(int level)
{
    switch(level)
    {
        case LEVEL_TRACE: return "DEBUG";
        case LEVEL_PROMT: return "INFO";
        case LEVEL_ALARM: return "WARNING";
        case LEVEL_ERROR: return "ERROR";
        case LEVEL_FATAL: return "FATAL";
        default: return "UKNOWN";
    }
}

void Log::writeLine(int level, const char *func_name, unsigned int line, const char *fmt, ...)
{
    if (level > m_level)
        return;

    va_list ap;
    va_start(ap, fmt);
    struct timespec current_time;
	struct tm format_time;
	memset(&current_time, 0, sizeof(current_time));
	clock_gettime(CLOCK_REALTIME, &current_time);
	localtime_r(&current_time.tv_sec, &format_time);
    if (NULL != m_pLogFile)
    {
        m_LogLocker.lock();
        fprintf(m_pLogFile, "[%02d-%02d-%02d %02d:%02d:%02d.%ld] [%s] [%d] ", format_time.tm_year+1900,
            format_time.tm_mon+1,
            format_time.tm_mday,
            format_time.tm_hour,
            format_time.tm_min,
            format_time.tm_sec,
            current_time.tv_nsec,
            func_name,
            line);
        vfprintf(m_pLogFile, fmt, ap);
        fprintf(m_pLogFile, "\n");
        fflush(m_pLogFile);
        m_LogLocker.unlock();
    }
    else
    {
        vprintf(fmt, ap);
        printf("\n");
    }
    va_end(ap);
}

void Log::setLevel(int level)
{
    m_level = level;
}
}

以上就是简单的日志类，当然还可以进一步实现根据日期每天创建单独的日志文件，也可以根据文件大小，写多个日志文件,编译时使用指定-DLOG_FILE

使用方法如下:

#include "log.h"

int main(int argc, char* argv[])
{
    LOG(LEVEL_ERROR, "%s", "init begin.");

    return 0;
}

makefile文件示例:

INCLUDE = ./include
SHARELIB = ./libs
STATICLIB = ./static-lib

CC:=$(compre-prefix)g++
AR:=$(compre-prefix)ar
STRIP:=$(compre-prefix)strip

SRC = ${wildcard src/*.cpp}
OBJ = ${patsubst %.cpp, %.o, $(SRC)}
#DEF = -DLOG_FILE -DLICENSE_CHECK
DEF = -DLOG_FILE

CPPFLAGS = -g -Wall -O3 -std=c++11 -D_GLIBCXX_USE_CXX11_ABI=0 $(DEF) -I./

LDFLAGS = -L$(SHARELIB) -L$(STATICLIB)\
          -Wl,-rpath=$(SHARELIB) -Wl,--allow-shlib-undefined

CLIENT_NAME = main

$(CLIENT_NAME): $(OBJ)
	$(CC) -o $@ $^ $(LDFLAGS)

#	$(STRIP) $@

$(OBJ):%.o:%.cpp
	$(CC) $(CPPFLAGS) -c $^ -o $@ 

.PHONY: all clean

all:$(CLIENT_NAME)

clean:
	rm -f *.o *.a *.log $(CLIENT_NAME)