日志系统¶

[可读性很好的时间][日志等级][进程pid][打印对应日志的文件名][行号] - 消息内容，支持可变参数
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc][16] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc][17] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc][18] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc][20] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc][21] - hello world
[2024-08-04 12:27:03] [WARNING] [202938] [main.cc][23] - hello world

// 日志等级
enum class LogLevel
{
    // 默认从1开始
    DEBUG = 1,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

class LogStrategy
{
public:
    // 使用默认析构函数
    virtual ~LogStrategy() = default;
    // 定义抽象虚函数
    virtual void printLog(const std::string &message) = 0;
};

class ConsoleLogStrategy : public LogStrategy
{
public:
    ConsoleLogStrategy() = default;

    virtual void printLog(const std::string &message) override
    {
        // 先申请锁
        MutexGuard guard(_lock);
        std::cout << message << std::endl;
    }

    ~ConsoleLogStrategy() = default;

private:
    Mutex _lock;
};

// 默认的目录路径和文件路径
const std::string d_dir_path = "./log/";
const std::string d_file_path = "log.txt";

// 具体策略类——文件输出
class FileLogStrategy : public LogStrategy
{
public:
    FileLogStrategy(const std::string &dir_path = d_dir_path, const std::string &file_path = d_file_path)
        : _dir_path(dir_path), _file_path(file_path)
    {
        // 先申请锁
        MutexGuard guard(_lock);

        // 判断目录是否存在
        if (std::filesystem::exists(_dir_path))
            return; // 存在直接返回
        else
        {
            try
            {
                // 创建目录
                std::filesystem::create_directories(_dir_path);
            }
            catch (const std::filesystem::filesystem_error &e)
            {
                std::cerr << e.what() << '\n';
            }
        }
    }

    virtual void printLog(const std::string &message) override
    {
        // 先申请锁
        MutexGuard guard(_lock);

        // 打开文件并追加写入
        const std::string path = _dir_path + _file_path;
        std::fstream out(path, std::ios::app);
        out << message << "\n";

        // 关闭文件
        out.close();
    }

    ~FileLogStrategy()
    {
    }

private:
    std::string _dir_path;
    std::string _file_path;

    Mutex _lock;
};

class LogHandler
{
public:
    // 默认使用ConsoleLogStrategy类初始化
    LogHandler()
        : _log(std::make_shared<ConsoleLogStrategy>())
    {
    }
    ~LogHandler()
    {
    }

private:
    std::shared_ptr<LogStrategy> _log;
};

class LogHandler
{
public:
    // ...

    class LogMessage
    {
    public:
        LogMessage(LogLevel level, const std::string &filename, int lineno)
            : _time(getCurrentTime()), _level(level), _pid(getpid()), _filename(filename), _lineno(lineno)
        {
        }

    private:
        std::string _time;     // 时间
        LogLevel _level;       // 日志等级
        pid_t _pid;            // 进程pid
        std::string _filename; // 文件名
        int _lineno;           // 行号
    };

    // ...
};

// 将枚举值转换为对应的字符串
std::string level2string(LogLevel level)
{
    switch (level)
    {
    case LogLevel::DEBUG:
        return "DEBUG";
    case LogLevel::INFO:
        return "INFO";
    case LogLevel::WARNING:
        return "WARNING";
    case LogLevel::ERROR:
        return "WARNING";
    case LogLevel::FATAL:
        return "FATAL";
    default:
        return "";
    }
    return "";
}

class LogMessage
{
public:
    LogMessage(LogLevel level, const std::string &filename, int lineno)
        : _time(getCurrentTime()), _level(level), _pid(getpid()), _filename(filename), _lineno(lineno)
    {
        std::stringstream ss;
        ss << "[" << _time << "] "
           << "[" << level2string(_level) << "] "
           << "[" << _pid << "] "
           << "[" << _filename << "] "
           << "[" << _lineno << "] - ";

        _message = ss.str();
    }

private:
    // ...
    std::string _message;  // 记录结果
};

LogMessage对象 << 自定义信息;

// 重载流插入函数
template <class T>
LogMessage &operator<<(const T &content)
{
    std::stringstream ss;
    ss << stream;
    _message += ss.str();

    return *this;
}

class LogHandler
{
public:
    // ...

    class LogMessage
    {
    public:
        LogMessage(/* ... */, LogHandler &loghandler)
            : // ...
            , _loghandler(loghandler)
        {
            //...
        }

        // ...

    private:
        // ...
        LogHandler &_loghandler;
    };

private:
    std::shared_ptr<LogStrategy> _log;
};

~LogMessage()
{
    // 如果父类引用不为空指针，就可以实现日志输出到指定为止
    if (_loghandler._log)
        _loghandler._log->printLog(_message);
}

LogHandler对象(日志等级) << 自定义信息

LogMessage operator()(LogLevel level, const std::string filename, int lineno)
{
    return LogMessage(level, filename, lineno, *this);
}

LogHandler对象(日志等级) << 自定义信息;

LOG(日志等级) << 自定义信息;

// 创建LogHandler对象
LogHandler loghandler;

#define LOG(LEVEL) loghandler(LEVEL, __FILE__, __LINE__)

#define ENABLECONSOLELOG() loghandler.enableConsoleLog()
#define ENABLEFILELOG() loghandler.enableFileLog()

#include "log.hpp"

using namespace LogSystemModule;

int main()
{
    ENABLECONSOLELOG();

    LOG(LogLevel::DEBUG) << "hello console";
    LOG(LogLevel::DEBUG) << "hello console";
    LOG(LogLevel::DEBUG) << "hello console";
    LOG(LogLevel::DEBUG) << "hello console";

    ENABLEFILELOG();
    LOG(LogLevel::DEBUG) << "hello file";
    LOG(LogLevel::DEBUG) << "hello file";
    LOG(LogLevel::DEBUG) << "hello file";
    LOG(LogLevel::DEBUG) << "hello file";
    return 0;
}