log4cplus使用

头文件

#pragma once
#include <string>
#include <log4cplus/logger.h>
#include <log4cplus/fileappender.h>
#include <log4cplus/layout.h>
#include <log4cplus/consoleappender.h>
#include <log4cplus/loggingmacros.h>

using namespace log4cplus;

const unsigned int RTC_LOG_FILE_SIZE = 1024 * 1024 * 3;
const unsigned int RTC_LOG_FILE_BACKUP_NUM = 5;

const std::string RTC_LOG_Logger("RTCLogger");
const std::string RTC_LOG_APPENDER_NAME("RTCAppender");
const std::string RTC_PC_LOGINSTANCE("RTCMediaService.log");
//const std::string RTC_LOG_APPENDER_PATTERN("%d{%m/%d/%y/%H:%M:%S:%Q}[%-6t][%-5p]:%2m [%l]%n"); //日志格式设置
const std::string RTC_LOG_APPENDER_PATTERN("%d{%m/%d/%y/%H:%M:%S:%Q}[%-5t][%-5p]:%2m %n"); //日志格式设置


namespace RTC_COMMEN_LOG
{
#define RTC_MEDIASERVICE_VERSION "v6.19.0.04"

	//void Debug(const char* pFormat, ...)
	//{
	//	LOG4CPLUS_DEBUG(Logger::getInstance("RTC_LOG_Logger"), "[" << __FUNCTION__ << "]" << pFormat);
	//}
	//Logger::getInstance("RTC_LOG_Logger")
#define TRACE_GET_INSTANCE Logger::getInstance(RTC_LOG_Logger)

#define TRACE(p)    LOG4CPLUS_TRACE(TRACE_GET_INSTANCE,p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")
#define DEBUG(p)    LOG4CPLUS_DEBUG(TRACE_GET_INSTANCE, p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")
#define INFO(p)     LOG4CPLUS_INFO(TRACE_GET_INSTANCE, p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")
#define WARN(p)     LOG4CPLUS_WARN(TRACE_GET_INSTANCE, p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")
#define ERROR(p)    LOG4CPLUS_ERROR(TRACE_GET_INSTANCE, p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")
#define FATAL(p)    LOG4CPLUS_FATAL(TRACE_GET_INSTANCE, p<<"[" << __FUNCTION__ <<":"<<__LINE__<< "]")


#define RTC_MEDIASERVICE_BUILD_INFO RTC_MEDIASERVICE_VERSION <<"  "<<__DATE__"<<"<<__TIME__

#define LOG_RTC_MS_SEPERATOR "************************************ Welcome to use RTC MediaService("\
		<< RTC_MEDIASERVICE_BUILD_INFO <<\
		"), enjoy it!  ************************************"


#define TRACE_FUNC() \
    RTC_COMMEN_LOG::FunctionEntryTrace FUNC_ENTRY_TRACE(__FUNCTION__)


///
//函数入口、出口的类
class FunctionEntryTrace 
{
public:
	inline FunctionEntryTrace(const char* funcName)
		: funcName_(funcName)
	{
		LOG4CPLUS_INFO(TRACE_GET_INSTANCE,"{" << funcName_ << "} ENTER ");
	}

	inline ~FunctionEntryTrace()
	{
		LOG4CPLUS_INFO(TRACE_GET_INSTANCE, "{" << funcName_ << "} LEAVE ");
	}

private:
	const std::string funcName_;
};


/*
todo:
1.日志实例如何释放
2.多线程测试;
3.日志存放目录
*/

class RtcCommenLog
{
public:
	//RtcCommenLog();
	//virtual ~RtcCommenLog();
	void initializeLogInstance();
	static RtcCommenLog* getInstance();  //获取单例
	static void releaseInstance();	     //释放单例
public:

private:
	RtcCommenLog() {};
	RtcCommenLog(const RtcCommenLog&) {};
	RtcCommenLog& operator=(const RtcCommenLog&) {};
	virtual ~RtcCommenLog() {};
private:
	static RtcCommenLog * mLogInstance;
};

}

cpp

#include "RtcCommenLog.h"
#include <mutex>


using namespace RTC_COMMEN_LOG;

std::mutex mute;

RtcCommenLog*  RtcCommenLog::mLogInstance = nullptr;   //单实例

void RtcCommenLog::initializeLogInstance()
{
	log4cplus::initialize();
	SharedAppenderPtr _append(new RollingFileAppender(RTC_PC_LOGINSTANCE, RTC_LOG_FILE_SIZE, RTC_LOG_FILE_BACKUP_NUM));
	_append->setName(RTC_LOG_APPENDER_NAME);
	//std::string pattern = "%d{%m/%d/%y/%H:%M:%S:%Q}[%-6t][%-5p]:%m [%l]%n";
	_append->setLayout(std::unique_ptr<log4cplus::Layout>(new log4cplus::PatternLayout(RTC_LOG_APPENDER_PATTERN)));
	Logger _logger = Logger::getInstance(RTC_LOG_Logger);
	_logger.addAppender(_append);
	_logger.setLogLevel(ALL_LOG_LEVEL);
	LOG4CPLUS_INFO(_logger, LOG_RTC_MS_SEPERATOR);
}

RtcCommenLog * RtcCommenLog::getInstance()
{
	if (mLogInstance == nullptr)   //双重锁定
	{
		mute.lock();
		if (mLogInstance == nullptr)
		{
			mLogInstance = new RtcCommenLog();
			if (mLogInstance == nullptr)
			{
				mute.unlock();
				return nullptr;
			}
		}
		mute.unlock();
	}
	return mLogInstance;
}

void RtcCommenLog::releaseInstance()
{
	TRACE_FUNC();
	if (mLogInstance != nullptr)
	{

		log4cplus::Logger::shutdown();
		delete mLogInstance;
		mLogInstance = NULL;
	}
	else
	{
		DEBUG("LogInstance == nullptr");
	}
}

main

#include "RtcCommenLog.h"
#include <log4cplus/logger.h>
#include <log4cplus/fileappender.h>
#include <log4cplus/layout.h>
#include <log4cplus/consoleappender.h>
#include <log4cplus/loggingmacros.h>
#include <iostream>
#include <thread>  
#include "slog.h"
using namespace std;
using namespace log4cplus;

using namespace log4cplus::helpers;
int LOOP_COUNT = 20;
//using namespace RTC_COMMEN_LOG;
std::mutex mut;
void testdebug()
{
	//TRACE_FUNC();
	mut.lock();
	DEBUG("this is testdebug " << LOOP_COUNT--);
	mut.unlock();
}
void testinfo()
{
	TRACE_FUNC();
	INFO("this is testinfo " << LOOP_COUNT);
	testdebug();
}

void testwarn()
{
	TRACE_FUNC();
	WARN("this is testwarn " << LOOP_COUNT);
	testinfo();
}

void testERROR()
{
	TRACE_FUNC();
	ERROR("this is testERROR " << LOOP_COUNT);
	testwarn();
}

void testFATAL()
{
	TRACE_FUNC();
	FATAL("this is testFATAL " << LOOP_COUNT);
	testERROR();
}
int main()
{
	RTC_COMMEN_LOG::RtcCommenLog * rtcLog = RTC_COMMEN_LOG::RtcCommenLog::getInstance();
	rtcLog->initializeLogInstance();
	testFATAL();

	std::vector<std::thread> vc;
	for (int i = 0; i < 10; ++i) {
		vc.push_back(std::thread(testdebug));
	}
	for (int i = 0; i < 10 ;i ++)
	{
		vc[i].join();
	}
	return 0;
}


int main3()
{
	SharedAppenderPtr _append(new RollingFileAppender("Test.log", 1024 * 1024 * 3 , 5));
	_append->setName("zhoulilitest");
	std::string pattern = "%d{%m/%d/%y/%H:%M:%S:%Q}[%-6t][%-5p]:%m [%l]%n";
	//std::string pattern = "%d{%m/%d/%y/%H:%M:%S:%Q}[%t][%p]:%m [%l]%n";
	_append->setLayout(std::unique_ptr<log4cplus::Layout>(new log4cplus::PatternLayout(pattern)));
	Logger _logger = Logger::getInstance("test1111");
	_logger.addAppender(_append);
	_logger.setLogLevel(ALL_LOG_LEVEL);
	int i = 10086;
	LOG4CPLUS_DEBUG(_logger, "[" << __FUNCTION__ << "]" << " first blood: " << i);
	LOG4CPLUS_WARN(_logger, "[" << __FUNCTION__ << "]" << " second blood");

	for (int i = 0; i < LOOP_COUNT; ++i) {

		

	}
	return 0;
}


//输出到文件
int main2()
{
	SharedAppenderPtr _append(new FileAppender("Test.log"));
	_append->setName("zhoulilitest");
	std::string pattern = "%d{%m/%d/%y/%H:%M:%S:%Q}[%-6t][%-5p]:%m [%l]%n";
	//std::string pattern = "%d{%m/%d/%y/%H:%M:%S:%Q}[%t][%p]:%m [%l]%n";
	_append->setLayout(std::unique_ptr<log4cplus::Layout>(new log4cplus::PatternLayout(pattern)));
	Logger _logger = Logger::getInstance("test1111");
	_logger.addAppender(_append);
	_logger.setLogLevel(ALL_LOG_LEVEL);
	int i = 10086;
	LOG4CPLUS_DEBUG(_logger, "["<<__FUNCTION__<<"]" <<" first blood: "<< i);
	LOG4CPLUS_WARN(_logger, "[" << __FUNCTION__ << "]" << " second blood");
	return 0;
}



//控制台输出 模式 + cout模式
int main1()
{
	SharedAppenderPtr _append(new ConsoleAppender());
	std::string pattern = "%d{%m/%d/%y  %H:%M:%S}  - %m [%l]%n";	
	_append->setLayout(std::unique_ptr<log4cplus::Layout>(new log4cplus::PatternLayout(pattern)));
	Logger _logger = Logger::getInstance("test");
	_logger.addAppender(_append);
	_logger.setLogLevel(ALL_LOG_LEVEL);

	LOG4CPLUS_DEBUG(_logger, "This is the  FIRST log message...");
	LOG4CPLUS_WARN(_logger, "This is the  SECOND log message...");
	LOG4CPLUS_WARN(_logger, "Thisis" << "justat" << "est.");


	LOG4CPLUS_DEBUG(_logger, "Thisisabool:" << true);

	LOG4CPLUS_INFO(_logger, "Thisisachar:" << 'x');

	LOG4CPLUS_WARN(_logger, "Thisisaint:" << 1000);

	LOG4CPLUS_ERROR(_logger, "Thisisalong(hex):" << std::hex << 100000000);

	return 0;
}