033 日志

小米里的大麦2025-07-112025-07-11

日志

1. 为什么需要日志等级？

在实际生产中，程序输出的信息非常多，如果没有等级就会导致：

开发阶段找不到重点（调试信息太多）。
上线后也不好排查问题（没有区分严重错误和普通信息）。

因此，合理使用日志等级，能让我们：

快速定位错误。
过滤无用信息。
分环境（开发、测试、生产）灵活控制日志量。

2. Linux 常见日志等级

以 syslog 标准 为例（这是 Linux 内核和很多守护进程默认遵循的）：

等级名	数值（优先级）	典型含义
EMERG	0	系统不可用，比如内核崩溃（panic）
ALERT	1	必须立刻采取措施，比如磁盘坏块
CRIT	2	严重错误，可能导致程序崩溃
ERR (ERROR)	3	一般错误，需要修复
WARNING	4	警告信息，可能有潜在风险
NOTICE	5	正常但需要注意的事件
INFO	6	普通运行信息
DEBUG	7	调试信息，开发阶段最详细

数值越小，级别越高，越重要。
在生产环境中，一般只保留 WARNING 及以上等级，避免刷盘压力和磁盘占用。

然而在实际操作当中，我们大多只考虑下面几种日志等级信息：

Info：常规消息。
Warning：报警信息。
Error：比较严重了，可能需要立即处理。
Fatal：致命的。
Debug：调试信息。

无论是写到文件、控制台，还是系统日志，一个完整的日志条目 通常包含：

部分	示例	说明
时间戳（必须）	`2025-01-01 11:11:11`	发生时间
日志等级（必须）	`INFO`	该条日志的重要性
内容（必须）	`Connection established from 192.168.225.225.0`	实际信息
主机名	`server-01`	哪台机器
程序名/模块名	`nginx`	哪个程序
进程 ID	`[pid=1234]`	哪个进程
线程 ID	`[tid=5678]`	哪个线程（多线程时可选）
上下文（可选）	文件名、行号、函数名	开启调试时很重要

3. 日志的实现

下面演示之前的 有名管道通信的服务端-客户端模型 Demo 进行的日志化：

1. comm.hpp 文件

#pragma once

#include <iostream>
#include <string>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include "Log.hpp"
using namespace std;

#define FIFO_FILE "./myfifo"
#define MODE 0664

// enum
// {
//     FIFO_CREATE_ERR = 1,                    // 这是创建管道文件失败的错误码
//     FIFO_DELETE_ERR = 2,                    // 这是删除管道文件失败的错误码
//     FIFO_OPEN_ERR                           // 这是打开管道文件失败的错误码（枚举会自动赋值为3）
// };

class Init
{
public:
    Init()
    {
        int n = mkfifo(FIFO_FILE, MODE);    // 创建管道文件

        if (n == -1)
        {
            perror("mkfifo");
            exit(FIFO_CREATE_ERR);
        }
    }

    ~Init()
    {
        int m = unlink(FIFO_FILE);          // 删除管道文件
        
        if (m == -1)
        {
            perror("unlink");
            exit(FIFO_DELETE_ERR);
        }
    }
};

2. Log.hpp（主要）

#pragma once

#include <iostream>
#include <string>
#include <stdlib.h>                                      // exit, perror
#include <unistd.h>                                      // read, write, close
#include <sys/types.h>                                   // open, close, read, write, lseek
#include <sys/stat.h>                                    // mkdir
#include <fcntl.h>                                       // open, O_RDONLY, O_WRONLY, O_CREAT, O_APPEND
#include <errno.h>                                       // errno
#include <sys/time.h>                                    // gettimeofday, struct timeval
#include <ctime>                                         // localtime_r, struct tm
using namespace std;

// 管道错误码
enum FIFO_ERROR_CODE
{
    FIFO_CREATE_ERR = 1,                                 // 这是创建管道文件失败的错误码
    FIFO_DELETE_ERR = 2,                                 // 这是删除管道文件失败的错误码
    FIFO_OPEN_ERR                                        // 这是打开管道文件失败的错误码（枚举会自动赋值为3）
};

// 日志等级
enum Log_Level
{
    Fatal,                                               // 最严重级别
    Error,                                               // 严重错误
    Warning,                                             // 警告
    Debug,                                               // 调试信息
    Info                                                 // 普通信息
};

class Log
{
    int  enable = 1;                                     // 是否启用日志
    int  classification = 1;                             // 是否分类
    string log_path = "./log.txt";                       // 日志存放路径
    int  console_out = 1;                                // 是否输出到终端

    // 日志等级转换成字符串
    string level_to_string(int level)
    {
        switch (level)
        {
            case Fatal:
                return "Fatal";
            case Error:
                return "Error";
            case Warning:
                return "Warning";
            case Debug:
                return "Debug";
            case Info:
                return "Info";
            default:
                return "None";
        }
    }

    // 获取当前计算机的时间，返回格式：YYYY-MM-DD HH:MM:SS.UUUUUU （含微秒）
    string get_current_time()
    {
        struct timeval tv;                               // timeval：包含秒和微秒
        gettimeofday(&tv, nullptr);                      // 系统调用：获取当前时间（精确到微秒）

        struct tm t;                                     // tm：分解时间，转格式（年、月、日、时、分、秒）
        localtime_r(&tv.tv_sec, &t);                     // 把秒转换成年月日时分秒（本地时区）

        char buffer[64];                                 // 定义字符数组作为格式化输出的缓冲区

        snprintf(buffer, sizeof(buffer),
                "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
                t.tm_year + 1900,                        // 年：tm_year 从 1900 开始计数
                t.tm_mon + 1,                            // 月：tm_mon 从 0 开始，0 表示 1 月
                t.tm_mday,                               // 日
                t.tm_hour,                               // 时
                t.tm_min,                                // 分
                t.tm_sec,                                // 秒
                tv.tv_usec);                             // 微秒部分，取自 gettimeofday

        return string(buffer);                           // 转换成 string 返回
    }

public:
    Log() = default;                                     // 使用默认构造
    Log(int enable, int classification, string log_path, int console_out)
        : enable(enable),
        classification(classification),
        log_path(log_path),
        console_out(console_out)
    {

    }
    
    // 重载函数调用运算符
    void operator()(int level, const string& content)
    {
        if (enable == 0)
        {
            return;                                      // 日志未启用
        }

        string level_str = "[" + level_to_string(level) + "] ";
        string log_message;

        if (classification == 1)
        {
            log_message = level_str + "[" + get_current_time() + "] " + content + "\n";
        }
        else if (classification == 0)
        {
            log_message = "[" + get_current_time() + "] " + content + "\n";
        }
        else
        {
            printf("传入的分类参数错误！\n");              // 分类未启用
            return;
        }

        if (console_out == 1)
        {
            cout << log_message;
        }

        log_to_file(level, log_message);
    }

private:
    // 文件路径的后缀处理函数：当按照日志等级分类存储并且文件路径是 "./log.txt" 这种有文件扩展名时的处理方法
    string Suffix_processing(int level, string log_path)
    {
        string Path;
        if (log_path.back() == '/')                      // 如果是一个目录的路径，比如 "./log/"，则最终文件名为 "log_等级名.txt"
        {
            Path = log_path + "log_" + level_to_string(level) + ".txt";
        }
        else                                             // 如果是一个文件路径，比如 "./log.txt"，则最终文件名为 "log_等级名.txt"
        {
            size_t pos = log_path.find_last_of('.');     // 从后往前找到第一个 '.' 的位置，即最后一次出现的 '.' 的位置
            if (pos != string::npos)
            {
                string left = log_path.substr(0, pos);   // 去掉后缀，即我所需要的有效的前部分路径
                string right = log_path.substr(pos);     // 保留后缀，即有效的文件扩展名
                Path = left + "_" + level_to_string(level) + right;         // 组合成新的文件名
            }
            else                                         // 如果没有文件扩展名（比如 "./log"），则直接在文件名后面加上 "_等级名.txt"
            {
                Path = log_path + "_" + level_to_string(level) + ".txt";
            }
        }

        return Path;
    }

    // 核心写文件函数
    void log_to_file(int level, const string& log_content)
    {
        string Path;

        if (classification == 1)
        {
            Path = Suffix_processing(level, log_path);   // 按照日志等级分类存储
        }
        else if (classification == 0)
        {
            Path = log_path;                             // 不分类直接使用传入的 log_path
        }

        // 追加写入，文件不存在则创建，权限 0644
        int fd = open(Path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
        if (fd < 0)
        {
            perror("");
            exit(FIFO_OPEN_ERR);
        }

        write(fd, log_content.c_str(), log_content.size());
        close(fd);
    }
};

3. Client.cc 文件

#include "comm.hpp"

int main()
{
    Log log(1, 1, "./log.txt", 1);
    
    int fd = open(FIFO_FILE, O_WRONLY);             // 以只写方式打开管道文件
    if(fd < 0)
    {
        perror("open");
        log(Error, "open FIFO_FILE failed");        // 使用日志记录错误
        exit(FIFO_OPEN_ERR);
    }

    string str;                                     // 定义消息字符串
    while(true)
    {
        cout << "请输入要发送的消息：";
        getline(cin, str);                          // 读取用户输入的消息（一整行）

        write(fd, str.c_str(), str.size());         // 向管道文件写入消息，str.c_str()是 string 转换为 C 风格字符串 的方法
        log(Info, "发送的消息: " + str);             // 记录发送内容
    }
    
    close(fd);                                      // 关闭管道文件
    return 0;
}

4. Server.cc 文件

#include "comm.hpp"

int main()
{
    Log log(1, 0, "./log.txt", 1);

    int fd = open(FIFO_FILE, O_RDONLY);                 // 以只读方式打开管道
    if(fd < 0)
    {
        perror("open");
        log(Error, "打开文件失败！");
        exit(FIFO_OPEN_ERR);
    }

    while(true)
    {
        char buf[1024] = {0};
        int x = read(fd, buf, sizeof(buf));             // 读取管道数据，x 为读取的字节数
        if(x > 0)
        {
            buf[x] = 0;                                 // 将完整的字节流转换为字符串，并添加结束符‘\0’
            cout << "客户端说:" << buf << endl;
            log(Debug, "收到消息: " + (string)buf);      // 记录接收内容
        }
    }

    close(fd);                                          // 关闭管道

    return 0;
}