C++日志Logger类

已于 2025-02-20 09:47:38 修改
阅读量277 收藏
点赞数 3
分类专栏： 笔记 文章标签： c++ linux windows
于 2025-02-17 13:22:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46591037/article/details/145675870
版权 
// Logger.hpp
#ifndef LOGGER_HPP
#define LOGGER_HPP

/**
 * @file Logger.hpp
 * @brief A flexible and thread-safe logging utility for C++ applications.
 *
 * This file defines a singleton Logger class that supports multiple log levels,
 * log file rotation by date, and customizable error callbacks. Logs can be
 * written to both the console and a file, with timestamps precise to milliseconds.
 *
 * Features:
 * - Multiple log levels: Trace, Debug, Info, Warning, Error, Fatal.
 * - Log file rotation by date (e.g., 2025-02-15.log).
 * - Thread-safe logging.
 * - Customizable error callbacks for Error and Fatal logs.
 * - Support for formatted log messages (like printf).
 *
 * Usage:
 * - Include this header file in your project.
 * - Use the provided macros (TRACE, DEBUG, INFO, WARN, ERROR, FATAL) to log messages.
 * - Set the log directory using Logger::getInstance().setLogDirectory().
 * - Configure log levels using Logger::getInstance().setLogLevelsFromString().
 *
 * Example:
 * @code
 * Logger::getInstance().setLogDirectory("logs");
 * Logger::getInstance().setLogLevelsFromString("Debug,Error");
 * DEBUG("This is a debug message: %s", "Debugging information");
 * ERROR("Failed to connect to %s", "opc.tcp://localhost:4840");
 * @endcode
 *
 * @author IT Cat
 * @date 2025-02-15
 * @version 1.0
 * @copyright ITCat
 */

#include <fstream>
#include <iostream>
#include <string>
#include <cstdarg>
#include <memory>
#include <vector>
#include <mutex>
#include <set>
#include <functional>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <unordered_map>
#include <algorithm>

#ifdef _WIN32
#include <WinSock2.h>
#include <Windows.h>
#else
#include <pthread.h>
#endif // WIN32

#include "String.hpp"

enum LogLevel
{
	Trace,   // 最详细的日志，用于跟踪程序执行流程
	Debug,   // 调试信息，用于开发阶段
	Info,    // 常规信息，用于记录程序运行状态
	Warning, // 警告信息，表示潜在问题
	Error,   // 错误信息，表示程序错误
	Fatal    // 严重错误，可能导致程序崩溃
};

class Logger
{
public:
	using LoggerErrorCallback = std::function<void(const std::string&)>;

	static Logger& getInstance()
	{
		static Logger instance;
		return instance;
	}

	// 设置日志记录的目录
	void setLogPath(const std::string& path = "./");

	// 通过字符串列表设置日志级别（如 {"F", "E"}）
	void setLogLevels(const std::vector<std::string>& levels);

	// 通过字符串设置日志级别（如 "F=1,E=1,W=1,I=1,D=1,T=1"）
	void setLogLevel(const std::string& levels = "F=1,E=1,W=1,I=1,D=1,T=1");

	// 添加日志级别
	void addLogLevel(LogLevel level);

	// 移除日志级别
	void removeLogLevel(LogLevel level);

	// 启用所有日志级别
	void enableAllLogLevels();

	// 禁用所有日志级别
	void disableAllLogLevels();

	// 设置错误日志回调函数
	void setErrorCallback(LoggerErrorCallback callback);

	void log(LogLevel level, int line, const char* function, const char* format, ...);
	void log(LogLevel level, int line, const char* function, const std::string& filename, const char* format, ...);
	void log(LogLevel level, int line, const char* function, std::ofstream& file, const char* format, ...);

	static unsigned long ProcessId();
	static std::string NumberToHex(long num);

private:
	std::ofstream m_logFile;
	std::string m_logPath;                  // 日志文件目录
	std::string m_currentDate;              // 当前日志文件的日期
	mutable std::mutex m_logMutex;
	std::set<LogLevel> m_enabledLogLevels;  // 存储启用的日志级别
	LoggerErrorCallback m_errorCallback;          // 错误日志回调函数
	std::unordered_map<std::string, LogLevel> m_logLevelMap; // 字符串到日志级别的映射
	std::unordered_map<int, std::string> m_logLevelMapRef;   // 字符串到日志级别的反映射

	Logger();
	~Logger();

	Logger(const Logger&) = delete;
	Logger& operator=(const Logger&) = delete;

	void openLogFile();
	void closeLogFile();
	void logToFile(const std::string& message);
	void logToFile(const std::string& message, std::ofstream& file);
	void logToConsole(const std::string& message) const;
	std::string formatString(const std::string& format, va_list args) const;
	std::string getCurrentDate() const;
	std::string getCurrentTime() const;
	void initializeLogLevelMap();
};

inline Logger::Logger()
{
	initializeLogLevelMap();

	// 默认启用所有日志级别
	enableAllLogLevels();
}

inline Logger::~Logger()
{
	closeLogFile();
}

inline void Logger::setLogPath(const std::string& path)
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_logPath = path;
	if (!m_logPath.empty() && m_logPath.back() != '/')
	{
		m_logPath += '/';
	}
	openLogFile(); // 打开新的日志文件
}

inline void Logger::setLogLevels(const std::vector<std::string>& levels)
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_enabledLogLevels.clear();

	for (const auto& levelStr : levels)
	{
		std::string upperLevelStr = levelStr;
		std::transform(upperLevelStr.begin(), upperLevelStr.end(), upperLevelStr.begin(), ::towupper);

		auto it = m_logLevelMap.find(upperLevelStr);
		if (it != m_logLevelMap.end())
		{
			m_enabledLogLevels.insert(it->second);
		}
	}
}

inline void Logger::setLogLevel(const std::string& levels)
{
	std::lock_guard<std::mutex> lockm_(m_logMutex);
	m_enabledLogLevels.clear();

	std::stringstream ss(levels);
	String levelStr;
	while (std::getline(ss, levelStr, ','))
	{
		std::transform(levelStr.begin(), levelStr.end(), levelStr.begin(), ::toupper);
		std::vector<std::string> level = levelStr.split("=");
		if (level.size() == 2)
		{
			if (level.at(1) == "1")
			{
				m_enabledLogLevels.insert(m_logLevelMap[level.at(0)]);
			}
		}
	}
}

inline void Logger::addLogLevel(LogLevel level)
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_enabledLogLevels.insert(level);
}

inline void Logger::removeLogLevel(LogLevel level)
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_enabledLogLevels.erase(level);
}

inline void Logger::enableAllLogLevels()
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	for (const auto& pair : m_logLevelMap)
	{
		m_enabledLogLevels.insert(pair.second);
	}
}

inline void Logger::disableAllLogLevels()
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_enabledLogLevels.clear();
}

inline void Logger::setErrorCallback(LoggerErrorCallback callback)
{
	std::lock_guard<std::mutex> lock(m_logMutex);
	m_errorCallback = callback;
}

inline void Logger::log(LogLevel level, int line, const char* function, const char* format, ...)
{
	std::lock_guard<std::mutex> lock(m_logMutex);

	// 格式化日志消息
	va_list va;
	va_start(va, format);
	std::string message = formatString(format, va);
	va_end(va);
	unsigned long pid = ProcessId();
	// 添加时间戳和调用位置信息
	std::string fullMessage = "[" + m_logLevelMapRef[(int)level] + "][0x" + NumberToHex(pid) + "]" + getCurrentTime() + " " + std::string(function) + ":" + std::to_string(line) + " " + message;

	// 如果是 Error 或 Fatal 日志，调用回调函数
	if ((level == LogLevel::Error || level == LogLevel::Fatal) && m_errorCallback)
	{
		m_errorCallback(fullMessage);
	}

	// 检查日志级别是否启用
	if (m_enabledLogLevels.find(level) == m_enabledLogLevels.end())
	{
		return;
	}
	std::string today = getCurrentDate();
	if (today != m_currentDate)
	{
		closeLogFile();
		m_currentDate = today;
		openLogFile();
	}

	// 输出到文件
	logToFile(fullMessage);

	// 输出到控制台
	logToConsole(fullMessage);
}

inline void Logger::log(LogLevel level, int line, const char* function, const std::string& filename, const char* format, ...)
{
	// 格式化日志消息
	va_list va;
	va_start(va, format);
	std::string message = formatString(format, va);
	va_end(va);
	unsigned long pid = ProcessId();
	// 添加时间戳和调用位置信息
	std::string fullMessage = "[" + m_logLevelMapRef[(int)level] + "][0x" + NumberToHex(pid) + "]" + getCurrentTime() + " " + std::string(function) + ":" + std::to_string(line) + " " + message;

	std::ofstream file(filename, std::ios::out | std::ios::app);
	if (!file.is_open())
	{
		throw std::runtime_error("Failed to open log file: " + filename);
	}
	// 输出到文件
	logToFile(fullMessage, file);

	// 输出到控制台
	logToConsole(fullMessage);
}

inline void Logger::log(LogLevel level, int line, const char* function, std::ofstream& file, const char* format, ...)
{
	// 格式化日志消息
	va_list va;
	va_start(va, format);
	std::string message = formatString(format, va);
	va_end(va);
	unsigned long pid = ProcessId();
	// 添加时间戳和调用位置信息
	std::string fullMessage = "[" + m_logLevelMapRef[(int)level] + "][0x" + NumberToHex(pid) + "]" + getCurrentTime() + " " + std::string(function) + ":" + std::to_string(line) + " " + message;

	// 输出到文件
	logToFile(fullMessage, file);

	// 输出到控制台
	logToConsole(fullMessage);
}

inline unsigned long Logger::ProcessId()
{
#ifdef _WIN32
	DWORD pid = GetCurrentProcessId();
#else
	pthread_t pid = pthread_self();
#endif
	return pid;
}

inline std::string Logger::NumberToHex(long num)
{
	std::stringstream ss;
	ss << std::hex << num;
	return ss.str();
}

inline void Logger::openLogFile()
{
	if (m_logPath.empty())
	{
		return;
	}
	std::string filename = m_logPath + m_currentDate + ".log";
	m_logFile.open(filename, std::ios::out | std::ios::app);
	if (!m_logFile.is_open())
	{
		throw std::runtime_error("Failed to open log file: " + filename);
	}
}
inline void Logger::closeLogFile()
{
	if (m_logFile.is_open())
	{
		m_logFile.close();
	}
}
inline void Logger::logToFile(const std::string& message)
{
	if (m_logFile.is_open())
	{
		m_logFile << message << std::endl;
	}
}

inline void Logger::logToFile(const std::string& message, std::ofstream& file)
{
	if (file.is_open())
	{
		file << message << std::endl;
	}
}

inline void Logger::logToConsole(const std::string& message) const
{
	std::cerr << message << std::endl;
}

inline std::string Logger::formatString(const std::string& format, va_list args) const
{
	// 计算需要的缓冲区大小
	va_list va;
	va_copy(va, args);
	int size = std::vsnprintf(nullptr, 0, format.c_str(), va);
	va_end(va);

	if (size < 0)
	{
		throw std::runtime_error("Failed to format log message");
	}

	// 分配缓冲区并格式化字符串
	std::vector<char> buffer(size + 1);
	std::vsnprintf(buffer.data(), buffer.size(), format.c_str(), args);

	return std::string(buffer.data());
}

inline std::string Logger::getCurrentDate() const
{
	auto now = std::chrono::system_clock::now();
	auto time = std::chrono::system_clock::to_time_t(now);
	std::tm tm = *std::localtime(&time);
	std::stringstream ss;
	ss << std::put_time(&tm, "%Y-%m-%d");
	return ss.str();
}

inline std::string Logger::getCurrentTime() const
{
	// 获取当前时间点
	auto now = std::chrono::system_clock::now();

	// 转换为时间戳（秒级）
	auto time = std::chrono::system_clock::to_time_t(now);
	std::tm tm = *std::localtime(&time);

	// 获取毫秒部分
	auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
		now.time_since_epoch()
	) % 1000;

	// 格式化输出
	std::stringstream ss;
	ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << "." << std::setfill('0') << std::setw(3) << milliseconds.count();
	return ss.str();
}

inline void Logger::initializeLogLevelMap()
{
	// 初始化日志级别映射
	m_logLevelMap = {
		{"T", LogLevel::Trace},
		{"D", LogLevel::Debug},
		{"I", LogLevel::Info},
		{"W", LogLevel::Warning},
		{"E", LogLevel::Error},
		{"F", LogLevel::Fatal}
	};
	for (std::unordered_map<std::string, LogLevel>::iterator it = m_logLevelMap.begin(); it != m_logLevelMap.end(); it++)
	{
		m_logLevelMapRef[(int)it->second] = it->first;
	}
}

// 日志宏定义
#define LOG(level, format, ...) \
    Logger::getInstance().log(level, __LINE__, __FUNCTION__, format, ##__VA_ARGS__)

#define TRACE(format, ...) LOG(LogLevel::Trace, format, ##__VA_ARGS__)
#define DEBUG(format, ...) LOG(LogLevel::Debug, format, ##__VA_ARGS__)
#define INFO(format, ...)  LOG(LogLevel::Info, format, ##__VA_ARGS__)
#define WARN(format, ...)  LOG(LogLevel::Warning, format, ##__VA_ARGS__)
#define ERROR(format, ...) LOG(LogLevel::Error, format, ##__VA_ARGS__)
#define FATAL(format, ...) LOG(LogLevel::Fatal, format, ##__VA_ARGS__)

#define LogFile(level, file, format, ...) Logger::getInstance().log(level, __LINE__, __FUNCTION__, file, format, ##__VA_ARGS__)
#define LogToFile(level, file, format, ...) Logger::getInstance().log(level, __LINE__, __FUNCTION__, file, format, ##__VA_ARGS__)

#endif // LOGGER_HPP

// String.hpp
#pragma once

#include <string>
#include <vector>
#include <regex>

class String :public std::string
{
public:
	String() :std::string("") { }
	String(const String& str) :std::string(str) { }
	String(const std::string& str) :std::string(str) { }
	String(const char* str) :std::string(str) { }
	std::vector<std::string> split(const std::string& delimiter);
};

inline std::vector<std::string> String::split(const std::string& delimiter)
{
	std::vector<std::string> tokens;
	std::regex reg(delimiter);
	std::sregex_token_iterator iter(this->begin(), this->end(), reg, -1);
	std::sregex_token_iterator end;
	while (iter != end)
	{
		tokens.push_back(*iter++);
	}
	return tokens;
}
c++ 自定义Logger 日志类
weixin_43763292的博客
02-12 1546
使用qt界面，接收日志，，通过接收 logReceived 信号，获取日志信息显示。这里QtConcurrent::run 可以方便接收信息，触发异步信号，不阻塞界面。不然界面会卡死，更新UI只能在一个线程中。默认保存到文件，并支持回调函数，比如显示到界面。
C++ 日志类
04-21
很好使用的日志类
C++日志类
Syee001的专栏
07-26 395
//Log.h头文件 /* 简单日志类 */ #ifndef LOGGER_H_ #define LOGGER_H_ #include #include #include using namespace std; //日志级别枚举 typedef enum LogLevel { 信息 = 0, //什么都不记录 错误, //只记录严重错误 警告,
C++的日志类
linshixina的专栏
02-24 1301
前一个项目中，当时遇到日志的问题，因为时间紧迫，用了开源社区的glog。但本人对开源的东西又或者说不是自己写的东西的总有点不放心，也可以说是心理有点疾病吧。于是今天就趁着闲下来，自己写了个C++的日志类，机制是仿照自己之前写的C#log类。        日志类所要解决的问题：        1. 自检查目录以及文件的存在性，如果不存在，则创建        2. 多线程冲突问题
C++ 日志类，
zhihu008的专栏
05-10 5172
C++ 日志类，期待您的意见        前一个项目中，当时遇到日志的问题，因为时间紧迫，用了开源社区的glog。但本人对开源的东西又或者说不是自己写的东西的总有点不放心，也可以说是心理有点疾病吧。于是今天就趁着闲下来，自己写了个C++的日志类，机制是仿照自己之前写的C#log类。        日志类所要解决的问题：        1. 自检查目录以及文件的存在性，如果不存在
C++通用日志系统Logger
03-25
日志系统是成熟软件中的一个重要组成部分，其记录软件的使用和运行行为，方便事后进行故障分析、数据统计等。...模块设计过程中参考了Log4j等软件，并结合C++特性，具有高度可拓展、使用灵活、高性能等优点。
cpp11logger——线程安全的日志类（使用C++11特性）
02-18
《C++11线程安全日志类的设计与实现》 在现代软件开发中，日志记录是一项必不可少的任务，它能够帮助开发者追踪程序运行过程中的错误、调试问题以及监控系统状态。C++11标准引入了许多新特性，使得编写线程安全的...
C++轻量级日志类Logger的使用
11-10
Logger是轻量级日志类，提供写日志功能，支持多线程，支持可变形参数操作，支持写日志级别的设置。 博客地址： http://blog.youkuaiyun.com/sunflover454/article/details/49758801
Windows C++日志工具类及使用示例
最新发布
09-01
windows系统下，使用C++编写的日志类。 资源保护3个文件： MyLog.h是日志类的头文件 MyLog.cpp是日志类的实现文件 main.cpp是日志接口的测试文件 日志文件模式：每天一个日志文件，每月一个日志文件，只有一个日志...
简单的c++日志类
07-06
该模块中简单给出了三种不同的日志记录格式，并且定义了三种log宏，方便快捷调用写入日志文件，是调试c++程序的利器
超简单的C++日志类
09-26
非常适合新手阅读, 代码量极少, 实现了日志最基本的需求, 有等级控制, 文件控制, 性能足够一般小型项目调试使用, 线程安全, 全局单例, 并有定义了几个宏, 可直接用宏, 使用方式类似于 printf, 支持不定参数
专门用来写日志的类（C++）
03-06
1、本资源使用C++实现写日志的类 2、该日志类使用了内核变量Mutex，所以能保证进程间不会出现日志混乱的现象。 3、输出地日志内容丰富，包括进程名称，进程id，源代码文件名，log在代码文件中的行数，时间等等。 4、你可以自定义log输出format，正如printf函数那样输出log 5、使用方法非常简单，在进程的入口调用一下BEGINLOG（）；在进程的出口调用一下ENDLOG；在程序中间随意的调用LOG（）；
c++写日志操作
qwangq的专栏
12-22 770
#ifndef COMMAND_DEFINE_H #define COMMAND_DEFINE_H //日志级别的提示信息 static const char * KEYINFOPREFIX = " Key: \n"; static const char * ERRORPREFIX = " Error: \n"; static const char * WARNINGPREFIX = "
一个简单实用的C++日志类
liaogaobo2008的博客
09-14 613
        最近做c++开发，需要对软件状态做一个日志记录，发现开源的实现很多，但感觉太大了，动不动就几十个Cpp文件。我的东西还要跑在嵌入式设备上呢？不就写个日志吗，“”噼噼啪啪“”，一个下午就搞定！ 在此做一个简单记录吧，供自己日后参考！    Log.H头文件 #pragma once #include &lt;fstream&gt; #include &lt;iostream&g...
一个简单的c++写日志类
huang714的专栏
11-06 491
在开发当中有的直接调试很方便，有的就不太好调试，所以我经常使用写日志以及输出Debug信息来进行开发。尽管我比较喜欢使用以输出Debug的信息的方式来跟踪程序。因为直接一句话： OutputDebugString("你想输出的信息\r\n"); 就可以在非调试模式下直接在DebugView上面显示输出信息了。 但是除了这种方式之外有时侯我也会使用写日志的方式来输出调试信息，虽然写文件很简单，但还是记录一下吧。方便自己同时也可能方便需要的人吧。 首先是main()函数定义： .
一个经典的C++日志类
dragon_feeling的专栏
05-04 4163
转自：http://www.zaoxue.com/article/tech-73193.htm 可按日期生成多个日志， 还可分年月日频率生成文件名 ===================================================================== /*Log File Library(WIN98/NT/2000) Compile
掌握C++轻量级日志类Logger的高级用法
使用Logger类可以极大地简化日志记录的过程，同时保持代码的整洁和模块化。 Logger类的一个核心特性是支持多线程环境下的安全日志写入。在多线程程序中，多个线程几乎同时写入同一日志文件的情况经常发生，Logger类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT灰猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值