一个简单明了的c++ trace log 实现

最新推荐文章于 2022-06-13 19:00:00 发布
最新推荐文章于 2022-06-13 19:00:00 发布
阅读量4.4k 收藏 5
点赞数 2
分类专栏： 常用代码 文章标签： c++ trace log 跨平台 日志
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tifentan/article/details/78403967
版权

基本要求是
1.线程安全
2.支持分级过滤
3.记录时间，线程id，开始记录头等等
4.跨平台
5.支持回调处理

代码是考虑过跨平台的，主要是锁跟几个函数，有需要改动的地方应该很少，但目前还没做，因为要浪费时间测试呢，往后有需要再改改就是了。

废话不多说上代码

头文件

/*
* CREATE: tifentan
* DATE: 2017/10/30
* MODIFY: 2017/10/30
* NOTE:
*   trace.h 
* 
*
*/


#ifndef  TTF_TRACE_H_
#define TTF_TRACE_H_

#include <string>

enum TtfTraceLevel
{
	ttfTraceNone = 0x0000,    // no trace
	ttfTraceStateInfo = 0x0001,
	ttfTraceWarning = 0x0002,
	ttfTraceError = 0x0004,
	ttfTraceCritical = 0x0008,
	ttfTraceApiCall = 0x0010,
	ttfTraceModuleCall = 0x0020,

	ttfTraceInfo = 0x0040,
	ttfTraceDebugFlag = 0x007f,
	ttfTraceDebug = 0x0080,

	ttfTraceDefault = 0x00ff,

	ttfTraceMemory = 0x0100,   // memory info
	ttfTraceTimer = 0x0200,   // timing info
	ttfTraceStream = 0x0400,   // "continuous" stream of data

	// Non-verbose level used by LS_INFO of logging.h. Do not use directly.
	ttfTraceTerseInfo = 0x2000,

	ttfTraceAll = 0xffff
};

enum TtfTraceMode {
	ttfTraceModeNone,
	ttfTraceModeEnd = 0x0ffff,
};


// External Trace API
class TtfTraceCallback {
public:
	virtual void Print(TtfTraceLevel level, const char* message, int length) = 0;

protected:
	virtual ~TtfTraceCallback() {}
	TtfTraceCallback() {}
};


#define TTF_TRACE_MAX_MESSAGE_SIZE 1024
#define TTF_TRACE_MAX_FILE_SIZE 100000000 //100m

class TtfTrace {
public:
	TtfTrace();
	~TtfTrace();

	int SetFile(char* path);
	int SetCallBack(TtfTraceCallback* cb);
	int SetFilter(unsigned int filter);
	unsigned int GetFilter();

	int doTrace(const TtfTraceLevel level, 
		const char msg[TTF_TRACE_MAX_MESSAGE_SIZE],
		const TtfTraceMode module = ttfTraceModeNone,
		const int32_t id = 0);
	int doTraceEx(const TtfTraceLevel level,
		const TtfTraceMode module,
		const int32_t id,
		char* str,
		...);

	int Flush();
	int Rewind();
	unsigned int GetSize();

protected:
	int AddThreadId(char* ptr);
	int AddTime(char* ptr);
	int AddHead(char* ptr);
	int AddLevel(char* ptr, TtfTraceLevel level);
	int AddModuleAndId(char* ptr, TtfTraceMode module,int32_t id);
	int WriteToFile();

private:
	TtfTraceCallback *cb_;
	CRITICAL_SECTION crit_;
	std::string trace_file_path_;
	FILE* file_ = nullptr;
	size_t position_ = 0;
	unsigned int level_filter_ = ttfTraceDefault;
	//unsigned int prev_tick_count_ = 0;
	char* msg_ = 0;
	int msg_len_ = 0;
	size_t row_ = 0;
};

//使用这个宏就可以用了
#define DEFINE_GLOBAL_TTF_TRACE extern TtfTrace* g_ttf_trace;

//跨模块时使用下面两个来使用同一个trace
#define DECLARE_GLOBAL_TTF_TRACE TtfTrace* g_ttf_trace = 0;
#define INIT_GLOBAL_TTF_TRACE(trace) g_ttf_trace = trace;

//在某个文件中定义一个
#define CREATE_GLOBAL_TTF_TRACE INIT_GLOBAL_TTF_TRACE(new TtfTrace())

//使用其中之一来创建一个全局的trace file
void g_create_ttf_trace_file(char* str);
#define CREATE_GLOBAL_TTF_TRACE_FILE g_create_ttf_trace_file

//释放,跨模块时自己注意一下释放问题，一定保证在所有调用后释放,不放心自己加个全局锁吧
void g_release_ttf_trace_file();
#define RELEASE_GLOBAL_TTF_TRACE_FILE g_release_ttf_trace_file



//void g_do_ttf_trace(const TtfTraceLevel level,
//	const TtfTraceMode module,
//	const int32_t id,
//	const char* msg, ...);
#define TTF_TRACE_EX(level,module,id,msg,...) if(g_ttf_trace) \
												g_ttf_trace->doTraceEx(level,module,id,msg,##__VA_ARGS__);

#define TTF_TRACE(level,msg,...) if(g_ttf_trace) \
												g_ttf_trace->doTraceEx(level,ttfTraceModeNone,0,msg,##__VA_ARGS__);

#endif // ! TTF_TRACE_H_

实现cpp文件

#include "windows.h"
#include "ttf_trace.h"

/*
EnterCriticalSection(&crit_);
LeaveCriticalSection(&crit_);

*/


TtfTrace::TtfTrace()
	:cb_(nullptr)
{
	InitializeCriticalSection(&crit_);
	msg_ = new char[TTF_TRACE_MAX_MESSAGE_SIZE];
}

TtfTrace::~TtfTrace()
{
	if (file_) {
		fclose(file_);
	}
	if (msg_) {
		delete[] msg_;
	}
	DeleteCriticalSection(&crit_);
}

int TtfTrace::SetFile(char * path)
{
	if (path == nullptr) {
		return -1;
	}
	int ret = 0;

	EnterCriticalSection(&crit_);
	if (file_) {
		fclose(file_);
	}
	trace_file_path_.clear();
	file_ = fopen(path, "ab");
	if (file_) {
		fseek(file_, 0, SEEK_END);
		position_ = ftell(file_);
		fseek(file_, 0, SEEK_SET);
	}
	else {
		ret = -1;
	}
	trace_file_path_ = path;
	LeaveCriticalSection(&crit_);

	return ret;
}

int TtfTrace::SetCallBack(TtfTraceCallback* cb)
{
	EnterCriticalSection(&crit_);
	cb_ = cb;
	LeaveCriticalSection(&crit_);

	return 0;
}

int TtfTrace::SetFilter(unsigned int filter)
{
	EnterCriticalSection(&crit_);
	level_filter_ = filter;
	LeaveCriticalSection(&crit_);
	return 0;
}

unsigned int TtfTrace::GetFilter()
{
	return level_filter_;
}

int TtfTrace::doTrace(const TtfTraceLevel level, const char msg[TTF_TRACE_MAX_MESSAGE_SIZE], const TtfTraceMode module, const int32_t id)
{
	if((level & level_filter_) == 0){
		return 0;
	}
	int ret = 0;
	char * p = msg_;
	EnterCriticalSection(&crit_);
	if ( file_) { //能过滤且文件存在
		if (position_ > TTF_TRACE_MAX_FILE_SIZE) {
			fflush(file_);
			position_ = 0;
			fseek(file_, 0, SEEK_SET);
			row_ = 0;
		}
		if (row_ == 0) {
			msg_len_ = AddHead(msg_);
			ret = WriteToFile();
			if (ret>0) {
				row_++;
			}
		}
		p += AddTime(p);
		p += AddThreadId(p);
		p += AddLevel(p,level);
		p += AddModuleAndId(p, module, id);
		msg_len_ = p - msg_;
		int rest = TTF_TRACE_MAX_MESSAGE_SIZE - msg_len_;
		ret = snprintf(p, rest, "%s", msg_); //最后一个0 将代替成 \n
		//_snprintf 这两个处理跟返回值都不一样，考虑到跨平台，统一一个算了
		//https://msdn.microsoft.com/en-us/library/2ts7cx93.aspx
		if (ret<0 || ret >= rest) {
			ret = rest - 1;
		}
		msg_len_ += ret;
		ret = WriteToFile();
		if (ret>0) {
			row_++;
		}
	}
	LeaveCriticalSection(&crit_);
	return ret;
}

int TtfTrace::doTraceEx(const TtfTraceLevel level, const TtfTraceMode module, const int32_t id, char * str, ...)
{
	if ((level & level_filter_) == 0) {
		return 0;
	}
	int ret = 0;
	char * p = msg_;
	EnterCriticalSection(&crit_);
	if (file_) { //能过滤且文件存在
		if (position_ > TTF_TRACE_MAX_FILE_SIZE) {
			fflush(file_);
			position_ = 0;
			fseek(file_, 0, SEEK_SET);
			row_ = 0;
		}
		if (row_ == 0) {
			msg_len_ = AddHead(msg_);
			ret = WriteToFile();
			if (ret>0) {
				row_++;
			}
		}
		p += AddTime(p);
		p += AddThreadId(p);
		p += AddLevel(p, level);
		p += AddModuleAndId(p, module, id);
		msg_len_ = p - msg_;
		int rest = TTF_TRACE_MAX_MESSAGE_SIZE - msg_len_;

		va_list args;
		va_start(args, str);
		//ret = _vsnprintf(p, TTF_TRACE_MAX_MESSAGE_SIZE - 1, msg, args);
		ret = vsnprintf(p, rest, str, args);
		va_end(args);
		
		if (ret<0 || ret >= rest) {
			ret = rest - 1;
		}
		msg_len_ += ret;
		ret = WriteToFile();
		if (ret>0) {
			row_++;
		}
	}
	LeaveCriticalSection(&crit_);
	return ret;
}

int TtfTrace::Flush()
{
	EnterCriticalSection(&crit_);
	if (file_) {
		fflush(file_);
	}
	LeaveCriticalSection(&crit_);
	return 0;
}

int TtfTrace::Rewind()
{
	EnterCriticalSection(&crit_);
	if (file_) {
		position_ = 0;
		fseek(file_, 0, SEEK_SET);
	}
	LeaveCriticalSection(&crit_);
	return 0;
}

unsigned int TtfTrace::GetSize()
{
	return position_;
}

int TtfTrace::AddThreadId(char * ptr)
{
	return sprintf(ptr, "[PID:%u]|", GetCurrentThreadId());
}

int TtfTrace::AddTime(char * ptr)
{
	//uint32_t dw_current_time = timeGetTime();
	SYSTEMTIME system_time;
	GetLocalTime(&system_time);

	/*uint32_t dw_delta_time = dw_current_time - prev_tick_count_;
	if (prev_tick_count_ == 0) {
		dw_delta_time = 0;
	}
	prev_tick_count_ = dw_current_time;*/

	//if (dw_delta_time > 0x0fffffff) {
	//	// Either wraparound or data race.
	//	dw_delta_time = 0;
	//}
	//if (dw_delta_time > 99999) {
	//	dw_delta_time = 99999;
	//}
	int ret = 0;
	ret = sprintf(ptr, "[%02u:%02u:%02u:%03u]|", system_time.wHour,
		system_time.wMinute, system_time.wSecond,
		system_time.wMilliseconds);
	if (ret < 0) ret = 0;
	return ret;
}

static int Unicode2Utf8(const wchar_t * unicode, char * utf8, int nBuffSize)
{
	if (!unicode || !wcslen(unicode))
	{
		return 0;
	}
	int len;
	len = WideCharToMultiByte(CP_UTF8, 0, unicode, -1, NULL, 0, NULL, NULL);
	if (len > nBuffSize)
	{
		return 0;
	}
	WideCharToMultiByte(CP_UTF8, 0, unicode, -1, utf8, len, NULL, NULL);
	return len;
}

int TtfTrace::AddHead(char * ptr)
{
	//prev_tick_count_ = timeGetTime();

	SYSTEMTIME sys_time;
	GetLocalTime(&sys_time);

	TCHAR sz_date_str[20];
	TCHAR sz_time_str[20];
	char utf8_data[128];
	char utf8_time[128];

	// Create date string (e.g. Apr 04 2002)
	GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &sys_time, TEXT("MMM dd yyyy"),
		sz_date_str, 20);

	// Create time string (e.g. 15:32:08)
	GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &sys_time, TEXT("HH':'mm':'ss"),
		sz_time_str, 20);
	Unicode2Utf8(sz_date_str, utf8_data, 128);
	Unicode2Utf8(sz_time_str, utf8_time, 128);

	//sprintf(trace_message, "Local Date: %ls Local Time: %ls", sz_date_str,
	//  sz_time_str);
	int ret = 0;
	ret = sprintf(ptr, "Local Date: [%s] Local Time: [%s]", utf8_data,
		utf8_time);
	if (ret < 0) ret = 0;
	return ret;
}

int TtfTrace::AddLevel(char * ptr, TtfTraceLevel level)
{
	int ret = 0;;
	switch (level) {
	case ttfTraceTerseInfo:
		// Add the appropriate amount of whitespace.
		ret = sprintf(ptr, "[]|");
		break;
	case ttfTraceStateInfo:
		ret =sprintf(ptr, "[STATEINFO]|");
		break;
	case ttfTraceWarning:
		ret = sprintf(ptr, "[WARNING]|");
		break;
	case ttfTraceError:
		ret = sprintf(ptr, "[ERROR]|");
		break;
	case ttfTraceCritical:
		ret = sprintf(ptr, "[CRITICAL]|");
		break;
	case ttfTraceInfo:
		ret = sprintf(ptr, "[INFO]|");
		break;
	case ttfTraceModuleCall:
		ret = sprintf(ptr, "[MODULECALL]|");
		break;
	case ttfTraceMemory:
		ret = sprintf(ptr, "[MEMORY]|");
		break;
	case ttfTraceTimer:
		ret = sprintf(ptr, "[TIMER]|");
		break;
	case ttfTraceStream:
		ret = sprintf(ptr, "[STREAM]|");
		break;
	case ttfTraceApiCall:
		ret = sprintf(ptr, "[APICALL]|");
		break;
	case ttfTraceDebug:
		ret = sprintf(ptr, "[DEBUG]|");
		break;
	default:
		return 0;
	}
	if (ret < 0) ret = 0;
	// All messages are 12 characters.
	return ret;
}

int TtfTrace::AddModuleAndId(char * ptr, TtfTraceMode module, int32_t id)
{
	const unsigned long int id_engine = id >> 16;
	const unsigned long int id_channel = id & 0xffff;
	return 0;
}

int TtfTrace::WriteToFile()
{
	//if (file_ == nullptr) return 0;
	msg_[msg_len_] = '\n';
	int totol = msg_len_ + 1;
	int ret = fwrite(msg_,1, totol,file_);
	if (ret == totol) {
		position_ += ret;
	}else { //write error
		OutputDebugStringA("Trace error write..................\n");
		ret = 0;
	}
	
	return ret;
}

DECLARE_GLOBAL_TTF_TRACE

void g_create_ttf_trace_file(char * str)
{
	CREATE_GLOBAL_TTF_TRACE
	g_ttf_trace->SetFile(str);
}

void g_release_ttf_trace_file()
{
	if (g_ttf_trace) {
		delete g_ttf_trace;
		g_ttf_trace = 0;
	}		
}

//void g_do_ttf_trace(const TtfTraceLevel level, const TtfTraceMode module, const int32_t id, const char * msg, ...)
//{
//	if (g_ttf_trace) {
//		
//	}
//}

最后写个简单的使用例子：

#include "ttf_trace.h"
DEFINE_GLOBAL_TTF_TRACE
void main(){
CREATE_GLOBAL_TTF_TRACE_FILE("test.log");

	TTF_TRACE_EX(ttfTraceInfo, ttfTraceModeNone,0,"what the fuck");
	TTF_TRACE(ttfTraceDebug,"cao nids%d",1);
	TTF_TRACE(ttfTraceDebug, "cao nids%d", 2);
	TTF_TRACE(ttfTraceDebug, "cao nids%d", 3);
	TTF_TRACE(ttfTraceDebug, "cao nids%d", 3);
	TTF_TRACE(ttfTraceDebug, "cao nids%d", 4);

	RELEASE_GLOBAL_TTF_TRACE_FILE();
}

再上个notepad++上看到的log文件效果：
这里写图片描述

露蛇
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LOG文件c++实现，多线程写入
03-22
LOG文件c++实现，多线程写入
trace、log 和 metric
最新发布
星瀚
12-19 586
分布式跟踪可以帮助追踪请求的传播路径，日志提供详细的事件记录，而指标则提供了对系统性能的实时度量。例如，通过在分布式跟踪中识别延迟的组件、在日志中查找错误消息，以及使用指标监控系统的资源利用率，可以更全面地了解应用程序的健康状况。在一个全面的监控方案中，通常会使用 trace、log 和 metric 这三个关键的监控数据类型，以全面了解应用程序的性能、行为和健康状态。- 用途： 日志提供了详细的事件记录，用于分析错误、异常情况，以及了解应用程序的运行状态。
【C++学习笔记】 五、VS下非MFC 自写TRACE()
没有手牌的博客
02-01 467
文章目录1.TRACE.h2. cpp文件 1.TRACE.h 我们大多数开发都需要一边输出数据，一边开出界面。 很多时候窗口应用开出就关闭了控制台，有些环境需要自行配置两者同时显示。 断点操作查看数据是必须的，但是有的时候还是想念printf，cout，OutputDebugString这些简易输出某些数据。 下面直接介绍打印数据到VS2019的输出窗口 TRACE是MFC 中用于打印的输出,...
c++语法（一）
Trace
02-12 459
一、 进入C++ 首先介绍一个显示消息的简单C++程序，利用cout生成字符输出。源代码中对注释//忽略。C++对大小写敏感。文件的扩展名为cpp 例：myfirst.cpp 其中endl代表换行。 该程序包含以下元素： 1） 注释，由前缀//标识 2） 预处理器编译指令#include。可以通过手册或在线帮助查看函数描述确定使用头文件。 3） 函数头：int main（）
可观测性的三大支柱：Metrics、Trace、Log
观测云的博客
06-13 5656
Opentelemetry 协议，是 CNCF (Cloud Native Computing Foundation -云原生计算基金会) 定义的最新一代可观测规范，该规范定义了可观测性的三大支柱：Metrics、Trace、Log (指标、链路、日志)，三者之间的关联数据分析成为了各大厂商的必争之地。...
C++中TRACE宏的使用
因为刚好遇见你.
11-08 8202
TRACE 宏类似C语言中的Printf函数，用于程序运行过程中，适当输出想要的调试信息。 注意点：TRACE宏只有在调试状态下才有所输出，所以只对Debug 版本的工程产生作用，而在Release 版本的工程中，TRACE宏将被忽略。而Printf 函数则无限制条件，任何情况均可以进行输出。
关于C++中的assert，ASSERT，TRACE和VERIFY
dvlinker的技术专栏
07-30 1553
assert 接收一个表达式，如果这个表达式为TRUE，则无动作，否则中断当前程序执行。在的debug版状态下出现。在release版本中不计算传入的表达式。 TRACE 接收跟printf一样的参数。在debug版的调试状态下出现，在debug窗口中输出信息。在release版本中不计算传入的表达式。 ASSERT 它接收一个表达式，如果这个表达式为TR
c++跟踪实例
qq_58665528的博客
02-23 647
在实际开发过程中，我们常常通过一个跟踪实例来跟踪我们的代码，以便于不依靠调试器就能发现代码的错误 先来看初始Trace类 class Trace { public: static bool traceIsActive; //标志跟踪是关闭还是启动 Trace(const std::string& name); ~Trace(); void debug(const std::string& msg); private: std::string theFunc.
C++下的简单Logtrace的编写
liangls1982的专栏
04-06 1336
<br />#include <afx.h><br />#include <shellapi.h><br />class LOG<br />{<br />public:<br /> LOG();<br /> virtual ~LOG();<br />public:<br /> static CString  GetLogFile(); <br /> static short  SetLogFile(LPCTSTR strPath); <br /> static short  ViewLogFile();  
C++中TRACE宏及assert()函数的使用
执着于我的执着
04-12 1214
C++中TRACE宏的使用     TRACE宏对于VC下程序调试来说是很有用的东西，有着类似printf的功能；该宏仅仅在程序的DEBUG版本中出现，当RELEASE的时候该宏就完全消失了，从而帮助你调试也在RELEASE的时候减少代码量。 使用非常简单，格式如下： TRACE("DDDDDDDDDDD"); TRACE("wewe%d",333)
LogTrace源码
07-06
自己写的一个在C++项目中log日志输出的lib源码，大家可以自己修改着用。
TraceTool C++ 12.4 (带中文例子）
12-12
TraceTool C++ 12.4 (带中文例子） 其中有修改了一些代码以支持中文，若有错误之处，请使用原版。
traceroute在windows下的c++实现源代码
01-30
traceroute socket windows c++ 源代码原理 详细解析traceroute的工作原理和实现细节
c++ 打印log 日志到文件
03-20
1:可以删除旧的log日志 2：可以设置每个日志的大小 3：c++ 代码简单
c++使用spdlog整合读取配置文件使用
04-21
使用c++语言使用spdlog日志功能，创建新的message类进行包装，读取外部配置文件进行快速使用，好处可以不用每次都得make程序，只需要修改配置文件就可以直接运行程序
c++日志类log代码小使用简单跨平台
09-01
一个.h文件，封装了日志类,c++跨平台，在很多项目中使用过，使用超级简单。
C++实现最小二乘法一元回归和多项式拟合
03-23
在进行曲线拟合时用的最多的是最小二乘法，其中以一元函数（线性）和多元函数（多项式）居多，下面这个类专门用于进行多项式拟合，可以根据用户输入的阶次进行多项式拟合，算法来自于网上，和GSL的拟合算法对比过，...
简单实用的环形缓冲器
tifentan的专栏
08-25 576
简单实用的环形缓冲器近来处理音频rawdata时需要一个FIFO的内存缓冲，自己写了一个基于环形结构的缓冲器。 可处理任意大小输入，输出 数据不够时可强制获取剩余数据 代码简单明了 bug可能有，暂时没发现。/* * CREATE: tifentan * DATE: 2017/8/23 * MODIFY: 2017/8/23 * NOTE: * * */#ifndef __CIRCLEBUFFER_
简单给出一个c++多态的实现
05-25
1. 定义一个基类（父类），其中至少包含一个虚函数，该虚函数在派生类（子类）中得到重写。 ```c++ class Shape { public: virtual int getArea() { return 0; } }; ``` 2. 定义派生类（子类），并在其中重写虚...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值