linux c/c++ 后台开发基础之：c++日志模块

最新推荐文章于 2024-05-20 17:26:53 发布
最新推荐文章于 2024-05-20 17:26:53 发布
阅读量2.7k 收藏 5
点赞数
分类专栏： 模块源码实现

日志是服务端开发必不可少的模块，工作过几个公司，基本每个公司或者项目组都有自己的日志模块，有使用开源的，也有自己写的，这是自己写的一个日志模块，经过线上大并发的测试，性能良好，使用也较方便。该日志采用的是单例模式，支持自动按天分文件，按日志行数自动分文件，是多线程安全的单例模式，没有外部依赖，linux操作系统均可以使用。

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /******************************************************** 
  2. function:log class 
  3. version:1.0 
  4. date:2013.4.19 
  5. modify:2014.12.21 
  6. *********************************************************/  
  7.   
  8. #ifndef LOG_H   
  9. #define LOG_H   
  10.   
  11. #include <stdio.h>   
  12. #include <iostream>   
  13. #include <stdarg.h>   
  14. #include <pthread.h>   
  15. using namespace std;  
  16.   
  17. class Log  
  18. {  
  19.     public:  
  20.         static Log* get_instance()  
  21.         {  
  22.             static Log instance;  
  23.             return &instance;  
  24.         }  
  25.   
  26.         bool init(const char* file_name, int log_buf_size = 8192, int split_lines = 5000000);  
  27.   
  28.         void write_log(int level, const char* format, ...);  
  29.   
  30.         void flush(void);  
  31.   
  32.     private:  
  33.         Log();  
  34.         virtual ~Log();  
  35.   
  36.     private:  
  37.         pthread_mutex_t *m_mutex;  
  38.         char dir_name[128];  
  39.         char log_name[128];  
  40.         int m_split_lines;  
  41.         int m_log_buf_size;  
  42.         long long  m_count;  
  43.         int m_today;  
  44.         FILE *m_fp;  
  45.         char *m_buf;  
  46. };  
  47.   
  48. #define LOG_DEBUG(format, ...) Log::get_instance()->write_log(0, format, __VA_ARGS__)   
  49. #define LOG_INFO(format, ...) Log::get_instance()->write_log(1, format, __VA_ARGS__)   
  50. #define LOG_WARN(format, ...) Log::get_instance()->write_log(2, format, __VA_ARGS__)   
  51. #define LOG_ERROR(format, ...) Log::get_instance()->write_log(3, format, __VA_ARGS__)   
  52.   
  53. #endif   
/********************************************************
function:log class
version:1.0
date:2013.4.19
modify:2014.12.21
*********************************************************/

#ifndef LOG_H
#define LOG_H

#include <stdio.h>
#include <iostream>
#include <stdarg.h>
#include <pthread.h>
using namespace std;

class Log
{
	public:
		static Log* get_instance()
		{
			static Log instance;
			return &instance;
		}

		bool init(const char* file_name, int log_buf_size = 8192, int split_lines = 5000000);

		void write_log(int level, const char* format, ...);

		void flush(void);

	private:
		Log();
		virtual ~Log();

	private:
		pthread_mutex_t *m_mutex;
		char dir_name[128];
		char log_name[128];
		int m_split_lines;
		int m_log_buf_size;
		long long  m_count;
		int m_today;
		FILE *m_fp;
		char *m_buf;
};

#define LOG_DEBUG(format, ...) Log::get_instance()->write_log(0, format, __VA_ARGS__)
#define LOG_INFO(format, ...) Log::get_instance()->write_log(1, format, __VA_ARGS__)
#define LOG_WARN(format, ...) Log::get_instance()->write_log(2, format, __VA_ARGS__)
#define LOG_ERROR(format, ...) Log::get_instance()->write_log(3, format, __VA_ARGS__)

#endif

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. /******************************************************** 
  2. function：log class 
  3. version:1.0 
  4. date:2013.4.19 
  5. modify:2014.12.21 
  6. *********************************************************/  
  7. #include <string.h>   
  8. #include <time.h>   
  9. #include <sys/time.h>   
  10. #include <stdarg.h>   
  11. #include "log.h"   
  12. #include <pthread.h>   
  13. using namespace std;  
  14.   
  15. Log::Log()  
  16. {  
  17.     m_count = 0;  
  18.     m_mutex = new pthread_mutex_t;  
  19.     pthread_mutex_init(m_mutex, NULL);  
  20. }  
  21.   
  22. Log::~Log()  
  23. {  
  24.     if(m_fp != NULL)  
  25.     {  
  26.         fclose(m_fp);  
  27.     }  
  28.     pthread_mutex_destroy(m_mutex);  
  29.   
  30.     if(m_mutex != NULL)  
  31.     {  
  32.         delete m_mutex;  
  33.     }  
  34. }  
  35.   
  36. bool Log::init(const char* file_name, int log_buf_size, int split_lines)  
  37. {  
  38.     m_log_buf_size = log_buf_size;  
  39.     m_buf = new char[m_log_buf_size];  
  40.     memset(m_buf, '\0', sizeof(m_buf));  
  41.     m_split_lines = split_lines;  
  42.   
  43.     time_t t = time(NULL);  
  44.     struct tm* sys_tm = localtime(&t);  
  45.     struct tm my_tm = *sys_tm;  
  46.     char *p = strrchr(file_name, '/');  
  47.     char log_full_name[256] = {0};  
  48.     if(p == NULL)  
  49.     {  
  50.         snprintf(log_full_name, 255, "%d_%02d_%02d_%s",my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, file_name);     
  51.     }  
  52.     else  
  53.     {  
  54.         strcpy(log_name, p+1);  
  55.         strncpy(dir_name, file_name, p - file_name + 1);  
  56.         snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s",dir_name, my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, log_name );   
  57.     }  
  58.   
  59.     m_today = my_tm.tm_mday;  
  60.   
  61.     m_fp = fopen(log_full_name, "a");  
  62.     if(m_fp == NULL)  
  63.     {  
  64.         return false;  
  65.     }  
  66.   
  67.     return true;  
  68. }  
  69.   
  70. void Log::write_log(int level, const char* format, ...)  
  71. {  
  72.     struct timeval now = {0,0};  
  73.     gettimeofday(&now, NULL);  
  74.     time_t t = now.tv_sec;  
  75.     struct tm* sys_tm = localtime(&t);  
  76.     struct tm my_tm = *sys_tm;  
  77.     char s[16] = {0};  
  78.     switch(level)  
  79.     {  
  80.         case 0 : strcpy(s, "[debug]:"); break;  
  81.         case 1 : strcpy(s, "[info]:"); break;  
  82.         case 2 : strcpy(s, "[warn]:"); break;  
  83.         case 3 : strcpy(s, "[erro]:"); break;  
  84.         default:  
  85.                strcpy(s, "[info]:"); break;  
  86.     }  
  87.     int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06d %s ",  
  88.             my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday,  
  89.             my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);  
  90.   
  91.     pthread_mutex_lock(m_mutex);  
  92.     m_count++;  
  93.     if(m_today != my_tm.tm_mday || m_count % m_split_lines == 0) //everyday log   
  94.     {  
  95.         char new_log[256] = {0};  
  96.         fflush(m_fp);  
  97.         fclose(m_fp);  
  98.         char tail[16] = {0};  
  99.         snprintf(tail, 16,  "%d_%02d_%02d_", my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday);  
  100.         if(m_today != my_tm.tm_mday)  
  101.         {  
  102.             snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);  
  103.             m_today = my_tm.tm_mday;  
  104.             m_count = 0;  
  105.         }  
  106.         else  
  107.         {  
  108.             snprintf(new_log, 255, "%s%s%s.%d", dir_name, tail, log_name, m_count/m_split_lines);  
  109.         }  
  110.         m_fp = fopen(new_log, "a");  
  111.     }  
  112.     pthread_mutex_unlock(m_mutex);  
  113.       
  114.     va_list valst;  
  115.     va_start(valst, format);  
  116.   
  117.     pthread_mutex_lock(m_mutex);  
  118.     int m = vsnprintf(m_buf + n, m_log_buf_size-1, format, valst);  
  119.     m_buf[n + m - 1] = '\n';  
  120.     fputs(m_buf, m_fp);  
  121.     pthread_mutex_unlock(m_mutex);  
  122.   
  123.     va_end(valst);  
  124. }  
  125.   
  126. void Log::flush(void)  
  127. {  
  128.     pthread_mutex_lock(m_mutex);  
  129.     fflush(m_fp);  
  130.     pthread_mutex_unlock(m_mutex);  
  131. }  
/********************************************************
function：log class
version:1.0
date:2013.4.19
modify:2014.12.21
*********************************************************/
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>
#include "log.h"
#include <pthread.h>
using namespace std;

Log::Log()
{
	m_count = 0;
	m_mutex = new pthread_mutex_t;
	pthread_mutex_init(m_mutex, NULL);
}

Log::~Log()
{
	if(m_fp != NULL)
	{
		fclose(m_fp);
	}
	pthread_mutex_destroy(m_mutex);

	if(m_mutex != NULL)
	{
		delete m_mutex;
	}
}

bool Log::init(const char* file_name, int log_buf_size, int split_lines)
{
	m_log_buf_size = log_buf_size;
	m_buf = new char[m_log_buf_size];
	memset(m_buf, '\0', sizeof(m_buf));
	m_split_lines = split_lines;

	time_t t = time(NULL);
	struct tm* sys_tm = localtime(&t);
	struct tm my_tm = *sys_tm;
	char *p = strrchr(file_name, '/');
	char log_full_name[256] = {0};
	if(p == NULL)
	{
		snprintf(log_full_name, 255, "%d_%02d_%02d_%s",my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, file_name);	
	}
	else
	{
		strcpy(log_name, p+1);
		strncpy(dir_name, file_name, p - file_name + 1);
		snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s",dir_name, my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday, log_name ); 
	}

	m_today = my_tm.tm_mday;

	m_fp = fopen(log_full_name, "a");
	if(m_fp == NULL)
	{
		return false;
	}

	return true;
}

void Log::write_log(int level, const char* format, ...)
{
	struct timeval now = {0,0};
	gettimeofday(&now, NULL);
	time_t t = now.tv_sec;
	struct tm* sys_tm = localtime(&t);
	struct tm my_tm = *sys_tm;
	char s[16] = {0};
	switch(level)
	{
		case 0 : strcpy(s, "[debug]:"); break;
		case 1 : strcpy(s, "[info]:"); break;
		case 2 : strcpy(s, "[warn]:"); break;
		case 3 : strcpy(s, "[erro]:"); break;
		default:
			   strcpy(s, "[info]:"); break;
	}
	int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06d %s ",
			my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday,
			my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);

	pthread_mutex_lock(m_mutex);
	m_count++;
	if(m_today != my_tm.tm_mday || m_count % m_split_lines == 0) //everyday log
	{
		char new_log[256] = {0};
		fflush(m_fp);
		fclose(m_fp);
		char tail[16] = {0};
		snprintf(tail, 16,  "%d_%02d_%02d_", my_tm.tm_year+1900, my_tm.tm_mon+1, my_tm.tm_mday);
		if(m_today != my_tm.tm_mday)
		{
			snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
			m_today = my_tm.tm_mday;
			m_count = 0;
		}
		else
		{
			snprintf(new_log, 255, "%s%s%s.%d", dir_name, tail, log_name, m_count/m_split_lines);
		}
		m_fp = fopen(new_log, "a");
	}
	pthread_mutex_unlock(m_mutex);
	
	va_list valst;
	va_start(valst, format);

	pthread_mutex_lock(m_mutex);
	int m = vsnprintf(m_buf + n, m_log_buf_size-1, format, valst);
	m_buf[n + m - 1] = '\n';
	fputs(m_buf, m_fp);
	pthread_mutex_unlock(m_mutex);

	va_end(valst);
}

void Log::flush(void)
{
	pthread_mutex_lock(m_mutex);
	fflush(m_fp);
	pthread_mutex_unlock(m_mutex);
}


[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include "log.h"   
  2. void *f(void* args)  
  3. {  
  4.     for(int i = 0;i < 100000; i++)  
  5.     {  
  6.             Log::get_instance()->write_log(1, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  7.             Log::get_instance()->write_log(2, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  8.             Log::get_instance()->write_log(3, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  9.   
  10.             LOG_INFO("%d", 123456789);  
  11.             LOG_ERROR("%d", 123456789);  
  12.             LOG_DEBUG("%d", 123456789);  
  13.             LOG_WARN("%d", 123456789);  
  14.   
  15.     }  
  16. }  
  17.   
  18. int main()  
  19. {  
  20.     Log::get_instance()->init("./mylog.log", 100, 2000000);  
  21.     int i = 0;  
  22.     Log::get_instance()->write_log(1, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  23.     Log::get_instance()->write_log(2, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  24.     Log::get_instance()->write_log(3, "d=%d,c=%c,s=%s,f=%f", i,'a',"log", 1.000);  
  25.   
  26.     LOG_INFO("%d", 123456789);  
  27.     LOG_ERROR("%d", 123456789);  
  28.     LOG_DEBUG("%d", 123456789);  
  29.     LOG_WARN("%d", 123456789);  
  30.   
  31.     pthread_t id;  
  32.     for(int i = 0; i < 10; i++)  
  33.     {  
  34.         pthread_create(&id, NULL, f, NULL);  
  35.         pthread_join(id,NULL);  
  36.     }  
  37.   
  38.     for(;;)  
  39.     {  
  40.         sleep(5);  
  41.         Log::get_instance()->flush();  
  42.     }  
  43.   
  44.     return 0;  
  45. }  
李生龙
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux&window C++ 写日志
07-22
window 和linux 下载 记录日志。 window 和linux 下载 记录日志。
c++日志库(windows、linux)
08-04
自己写的一个小小的日志库，功能比较简单，单一。主要用到__FILE_、__FUNCTION__、__FILE__等宏定义。日志主要记录文件、行数、函数名、日志信息。日志的格式最终保存为json格式，方便查看。
[Linux][C\C++] 一个简单的日志系统
yll7702的博客
01-18 793
【代码】[Linux][C语言] 一个简单的日志系统
c++实现轻量和高效的日志系统
最新发布
itnkcong的博客
05-20 536
1、支持多线程日志输出，输出效率足够高，每秒达到10000+行日志的输出（程序超出这个需求，可能要考虑是不是日志打印太多了）；3、日志自动清理，超过一定天数的日志应自动删除（当然可以通过额外的定时脚本达到这个目的），避免长期运行后积累的日志过多，过大；3、日志格式容易不规范，关键信息可能会缺失，比如严重程度、日志的准确时间、输出日志的线程、函数名称、文件行号等等；2、日志文件自动切分，应避免单个日志文件过大，切分方式可以是按天、小时、分钟、文件大小超出限制等；
linux c/c++ 后台开发常用组件之：c++日志模块
刘日新的博客
05-06 679
版权声明：本文为博主原创文章，未经博主允许不得转载。 日志是服务端开发必不可少的模块，工作过几个公司，基本每个公司或者项目组都有自己的日志模块，有使用开源的，也有自己写的，这是自己写的一个日志模块，经过线上大并发的测试，性能良好，使用也较方便。该日志采用的是单例模式，支持自动按天分文件，按日志行数自动分文件，是多线程安全的单例模式，没有外部依赖，linux操作系统均可以使用。在日志安全级别高
C++日志系统源代码（linux）
11-13
此源码从一个开源项目nox中提取。其中有一份使用说明，包含了接口使用以及代码结构分析；此模块的接口使用方便，通过调用可以轻松管理应用中不同模块发出的日志消息、向socket中发送日志消息的功能。最后，要强调一点，这个模块依赖boost库
linux日志模块
weixin_33713707的博客
07-26 144
日志的记录功能有特定的守护程序syslog来提供，若软件套件需要写入到syslogd的管理的登录文件中，则该软件套件需要支持syslogd的登录文件的写入模式。 日志的信息主要是放在目录/var/log的目录下，syslog的配置文件为/etc/syslog.conf，该配置文件设置了auth,authpriv、cron、daemon、kern、lpr、mail、news...
基于Linux的日志模块
09-05
基于Linux的一个记录客户写入情况的日志模块。 其中附有详细的ReadMe说明和代码注释。 关键字：Linux，日志模块，共享存储，多线程。-Linux-based clients to write a case record log module. One of the ReadMe with detailed instructions and code comments. Keywords: Linux, the log module, shared memory, multi-threading.
fwrGUIline.rar_Linux/Unix编程_C/C++_
08-10
在IT行业中，Linux/Unix编程和C/C++是两个至关重要的领域，特别是在系统级开发和嵌入式系统中。标题中的“fwrGUIline.rar”可能是指一个关于图形用户界面（GUI）线程或者进程的设计，而“Linux/Unix编程_C/C++”则...
HX711-master.zip_Linux/Unix编程_C/C++__Linux/Unix编程_C/C++_
08-09
《HX711驱动在Linux/Unix环境下的C/C++编程实践》 在嵌入式系统开发中，数据采集和处理是至关重要的环节，而HX711是一款专为高精度重量传感器设计的数字模数转换器（ADC），广泛应用于称重应用。本资料主要探讨如何...
零声学院 第9代 Linux CC++后台架构开发 成长体系课程 - v1.21
08-03
【零声学院第九代Linux C/C++后台架构开发成长体系课程】是一门全面涵盖后台开发技术的高级课程，旨在帮助学员深入理解Linux环境下的后台架构设计与开发。课程内容丰富，涉及多个专题，包括算法与设计、后台组件编程...
linux系统中c++写日志文件功能分享
09-04
主要介绍了linux系统中c++写日志文件功能，简化了glog，只保留了写日志文件的功能，只是改写了linux版本,需要的朋友可以参考下
日志模块(c/c++),简单、快捷，就一头文件就实现了日志模块无缝接入
08-12
一个C/C++日志记录模块，它是对开源log4c进行的封装和修正的基础上，将所有的代码都集成到一个.h头文件中。带来的革命性突破是日志模块的使用是那么的方便和简单：只要使用一个.h头文件即可无缝的将日志模块嵌入到你的工程中去，不需要再添加额外的的.c/.cpp或是链接lib/dll等，整个日志模块就是一个头文件。日志输出格式方面，提供了C语言传统的字符printf格式输出，同时也为C++提供了ostream方式的流式输出..
c++线程安全的日志模块(非常好用)
03-02
c++ 线程安全 日志模块,可以直接应用到项目中，详细介绍可以阅读我的博客文章http://blog.csdn.net/ltm5180/article/details/20287045或者发邮件给我讨论(ltm5180@126.com)
linux下的日志处理
08-07
linux下实现的日志功能，功能比较强大，看了代码就懂了
linux下读写日志文件
10-22
从执行体程序库中的CLLogger类可知，通过缓存要写入文件中的数据，能够提高读写磁盘的性能。编写一个文件操作的封装类，调用该类的写操作接口时，数据要首先写到缓存，然后再根据策略写到文件中。调用该类的读操作接口时，该类能根据策略缓存读出的数据读写缓存要保持一致性
C语言程序设计大作业：选课系统 基于QT的纯C++控制台项目.zip
11-20
通过这个项目，学生不仅可以巩固C语言和C++的基本功，还能掌握QT库的使用，提升对GUI编程的理解，为将来从事更复杂的应用程序开发打下坚实基础。同时，此项目也提供了一个实际应用场景，让学生能够看到理论知识如何...
Linux中的日志管理模块
weixin_42731856的博客
07-27 1022
###系统日志的管理### 1. rsyslog ##此服务是用来采集日志的，它不生产日志，只是起到采集作用 2.rsyslog的管理 /var/log/messages ##服务信息的日志 /var/log/secure...
Unix/Linux C/C++编程：从基础到高级特性
此外，Linux作为一个开源操作系统，其内核的灵活性和模块化特性使得C/C++程序员能够深入理解并参与到系统底层的开发中。 学习Unix/Linux下的C/C++编程，不仅是掌握编程语言本身，更是理解和掌握操作系统原理、系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值