TinyWebServer学习笔记-log

爱躺平的咸鱼2023-10-03 21:23

为什么服务器要有一个日志系统？

  1. 故障排查和调试： 在服务器运行期间，可能会发生各种问题和故障，例如程序崩溃、性能下降、异常请求等。日志记录了服务器的运行状态、错误信息和各种操作，这些日志可以用来快速定位和排查问题，帮助开发人员更容易地找到问题的根本原因，从而更快地修复bug和提高服务器稳定性。

  2. 性能监测： 通过日志系统可以记录服务器的性能数据，包括请求处理时间、吞吐量、内存使用情况、CPU利用率等等。这些数据有助于监控服务器的性能，发现潜在的性能瓶颈，以便进行性能优化。

  3. 安全性： 日志可以记录系统的安全事件，如登录失败尝试、异常访问等。通过分析这些日志，可以检测和防止潜在的安全威胁，提高服务器的安全性。

  4. 法律合规性： 某些行业和法规要求服务器必须记录和保留特定类型的操作日志，以便进行审计和合规性检查。缺乏合规性的日志记录可能会导致法律责任。

  5. 运营和分析： 运营团队可以通过分析日志数据来了解用户行为、产品使用情况和趋势。这有助于改进产品、优化用户体验和制定业务策略。

  6. 历史记录： 日志还可以用作历史记录，以跟踪系统的状态和操作历史。这对于了解系统的演化和历史情况非常有用。

实现过程

为了实现异步写入，利用循环数组实现阻塞队列。

复制代码 
template <class T>
class block_queue
{
public:
    block_queue(int max_size = 1000)
    {
        if (max_size <= 0)
        {
            exit(-1);
        }

        m_max_size = max_size;
        m_array = new T[max_size];
        m_size = 0;
        m_front = -1;
        m_back = -1;
    }

    void clear()
    {
        m_mutex.lock();
        m_size = 0;
        m_front = -1;
        m_back = -1;
        m_mutex.unlock();
    }

    ~block_queue()
    {
        m_mutex.lock();
        if (m_array != NULL)
            delete [] m_array;

        m_mutex.unlock();
    }
    //判断队列是否满了
    bool full() 
    {
        m_mutex.lock();
        if (m_size >= m_max_size)
        {

            m_mutex.unlock();
            return true;
        }
        m_mutex.unlock();
        return false;
    }
    //判断队列是否为空
    bool empty() 
    {
        m_mutex.lock();
        if (0 == m_size)
        {
            m_mutex.unlock();
            return true;
        }
        m_mutex.unlock();
        return false;
    }
    //返回队首元素
    bool front(T &value) 
    {
        m_mutex.lock();
        if (0 == m_size)
        {
            m_mutex.unlock();
            return false;
        }
        value = m_array[m_front];
        m_mutex.unlock();
        return true;
    }
    //返回队尾元素
    bool back(T &value) 
    {
        m_mutex.lock();
        if (0 == m_size)
        {
            m_mutex.unlock();
            return false;
        }
        value = m_array[m_back];
        m_mutex.unlock();
        return true;
    }

    int size() 
    {
        int tmp = 0;

        m_mutex.lock();
        tmp = m_size;

        m_mutex.unlock();
        return tmp;
    }

    int max_size()
    {
        int tmp = 0;

        m_mutex.lock();
        tmp = m_max_size;

        m_mutex.unlock();
        return tmp;
    }
    //往队列添加元素，需要将所有使用队列的线程先唤醒
    //当有元素push进队列,相当于生产者生产了一个元素
    //若当前没有线程等待条件变量,则唤醒无意义
    bool push(const T &item)
    {

        m_mutex.lock();
        if (m_size >= m_max_size)
        {

            m_cond.broadcast();
            m_mutex.unlock();
            return false;
        }

        m_back = (m_back + 1) % m_max_size;
        m_array[m_back] = item;

        m_size++;

        m_cond.broadcast();
        m_mutex.unlock();
        return true;
    }
    //pop时,如果当前队列没有元素,将会等待条件变量
    bool pop(T &item)
    {

        m_mutex.lock();
        while (m_size <= 0)
        {
            
            if (!m_cond.wait(m_mutex.get()))
            {
                m_mutex.unlock();
                return false;
            }
        }

        /*m_front = (m_front + 1) % m_max_size;
        item = m_array[m_front];*/
        //这里我认为应该先得到值，然后更新m_front下标
        item=m_array[m_front];
        m_front=(m_frong+1)% m_max_size;
        m_size--;
        m_mutex.unlock();
        return true;
    }

    //增加了超时处理
    bool pop(T &item, int ms_timeout)
    {
        struct timespec t = {0, 0};
        struct timeval now = {0, 0};
        gettimeofday(&now, NULL);
        m_mutex.lock();
        if (m_size <= 0)
        {
            t.tv_sec = now.tv_sec + ms_timeout / 1000;
            t.tv_nsec = (ms_timeout % 1000) * 1000;
            if (!m_cond.timewait(m_mutex.get(), t))
            {
                m_mutex.unlock();
                return false;
            }
        }

        if (m_size <= 0)
        {
            m_mutex.unlock();
            return false;
        }

        m_front = (m_front + 1) % m_max_size;
        item = m_array[m_front];
        m_size--;
        m_mutex.unlock();
        return true;
    }

private:
    locker m_mutex;        //互斥锁
    cond m_cond;           //条件变量

    T *m_array;            //存放日志的数组
    int m_size;            //已经用的空间
    int m_max_size;        //最大容量
    int m_front;           //数组头的下标
    int m_back;            //数组尾的下标
};

解释下timespec结构体和timeval结构体，timespec结构体，分为秒和微秒两个部分，timeval结构体now，分为秒和纳秒两个部分。在这个自定义队列中，当队列为空时，从队列中获取元素的线程将会被挂起；当队列是满时，往队列里添加元素的线程将会挂起。

复制代码 
class Log
{
public:
    //C++11以后,使用局部变量懒汉不用加锁
    static Log *get_instance()
    {
        static Log instance;
        return &instance;
    }

    static void *flush_log_thread(void *args)
    {
        Log::get_instance()->async_write_log();
    }
    //可选择的参数有日志文件、日志缓冲区大小、最大行数以及最长日志条队列
    bool init(const char *file_name, int close_log, int log_buf_size = 8192, int split_lines = 5000000, int max_queue_size = 0);

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

    void flush(void);

private:
    Log();
    virtual ~Log();
    void *async_write_log()
    {
        string single_log;
        //从阻塞队列中取出一个日志string，写入文件
        while (m_log_queue->pop(single_log))
        {
            m_mutex.lock();
            fputs(single_log.c_str(), m_fp);
            m_mutex.unlock();
        }
    }

private:
    char dir_name[128];                 //路径名
    char log_name[128];                 //log文件名
    int m_split_lines;                  //日志最大行数
    int m_log_buf_size;                 //日志缓冲区大小
    long long m_count;                  //日志行数记录
    int m_today;                        //因为按天分类,记录当前时间是那一天
    FILE *m_fp;                         //打开log的文件指针
    char *m_buf;                        //缓冲区
    block_queue<string> *m_log_queue;   //阻塞队列
    bool m_is_async;                    //是否同步标志位
    locker m_mutex;                     //互斥锁
    int m_close_log;                    //关闭日志
};

#define LOG_DEBUG(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(0, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_INFO(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(1, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_WARN(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(2, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_ERROR(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(3, format, ##__VA_ARGS__); Log::get_instance()->flush();}

本项目中，使用单例模式创建日志系统，记录服务器的运行状态、错误信息和访问数据。能够按天分类，超行分类。可以选择同步和异步写入两种方式。

同步打开对应的文件写入日志；异步则采取生产者-消费者模型封装为阻塞队列，创建一个写线程，工作线程将要写的日志push进队列，写线程从队列中读取内容，写入日志。

在这个项目的日志系统中，如果设置了阻塞队列的长度，则代表选择了异步写入日志；如果没有设置，则代表同步写入日志。

为什么要日志分级？

  1. 信息过滤： 在大型应用程序中，产生的日志可能非常庞大。通过分级，可以根据需要选择性地查看日志。例如，开发人员可能只对错误和警告感兴趣，而不关心调试信息。

  2. 故障排查： 当应用程序出现故障或错误时，日志分级可以帮助开发人员快速定位问题。错误日志可以提供关于发生了什么错误的详细信息，而调试日志则可以提供更多上下文，帮助解决问题。

  3. 性能监测： 分级日志还可以用于监测应用程序的性能。通过记录某些操作的耗时信息，开发人员可以识别性能瓶颈，并进行优化。

  4. 审核和合规性： 在某些情况下，应用程序需要记录特定事件或行为，以满足合规性要求或进行审核。通过使用不同级别的日志，可以轻松地识别和检索这些信息。

  5. 容易维护： 通过使用分级日志，开发人员可以更容易地维护应用程序的日志记录。不同级别的日志通常被写入不同的文件或存储位置，这使得查找和清理日志变得更加简单。

常见的日志级别包括：

  • DEBUG（调试）： 用于记录详细的调试信息，通常只在开发和测试阶段启用。

  • INFO（信息）： 用于记录应用程序的重要事件和状态信息，例如启动、关闭、用户登录等。

  • WARNING（警告）： 用于记录可能需要关注但不一定是错误的事件，例如配置警告或不寻常的操作。

  • ERROR（错误）： 用于记录应用程序的错误事件，例如异常、未处理的异常、无法连接到数据库等。

  • CRITICAL（关键）： 用于记录严重错误，可能导致应用程序无法正常运行的情况，例如关键服务崩溃。

本项目中，包括DEBUG,INFO,WARN,ERROR四个级别。

复制代码 
#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__)

在init函数中完成路径名，文件名等私有数据成员的设置。

复制代码 
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);
}

这段代码判断file_name是是否包含'\'，如果不包含，也就是没有包含路径信息，那么就用当前日期和file_name来构建日志文件名。p为空则代表file_name不包含路径信息，只包含文件名，那么生成最终文件名:年_月_日_文件名。如果p不为空，那么找到最后一个路径分隔符，计算出文件名所在文件夹的长度，并将路径复制到dir_name中，文件名复制到log_name中，最终构建的路径是文件路径+时间+文件名。也就是根据是否包含路径信息，生成不同格式的日志文件名。

接下来是分级和分片函数：

复制代码 
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;
    }
    //写入一个log，对m_count++, m_split_lines最大行数
    m_mutex.lock();
    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.%lld", dir_name, tail, log_name, m_count / m_split_lines);
        }
        m_fp = fopen(new_log, "a");
    }
 
    m_mutex.unlock();

    va_list valst;
    va_start(valst, format);

    string log_str;
    m_mutex.lock();

    //写入的具体时间内容格式
    int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %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);
    
    int m = vsnprintf(m_buf + n, m_log_buf_size - n - 1, format, valst);
    m_buf[n + m] = '\n';
    m_buf[n + m + 1] = '\0';
    log_str = m_buf;

    m_mutex.unlock();

    if (m_is_async && !m_log_queue->full())
    {
        m_log_queue->push(log_str);
    }
    else
    {
        m_mutex.lock();
        fputs(log_str.c_str(), m_fp);
        m_mutex.unlock();
    }

    va_end(valst);
}

思路如下：

1、获得今天的日期时间，如果日志的日期不是今天则创建新的日志文件，然后向新的文件写入。

2、如果是今天的日期时间，但是超过了文件的最大行，那么就进行分片，在文件结尾加入分片的ID，比如***_log_file1,***_log_file2这样。然后写入文件。

3、如果是今天的日期，并且没有超过最大文件行，就写入对应的文件。

准备好要写入的文件后，格式化时间和内容，放到缓冲数组中，然后判断日志系统是异步写入还是同步写入，如果是异步则将需要写的日志内容加入到阻塞队列中，否则直接调用fputs函数将输入文件指针对应的文件中。

相关推荐
大筒木老辈子34 分钟前
Linux笔记---协议定制与序列化/反序列化
网络·笔记
草莓熊Lotso42 分钟前
【C++】递归与迭代：两种编程范式的对比与实践
c语言·开发语言·c++·经验分享·笔记·其他
我爱挣钱我也要早睡！4 小时前
Java 复习笔记
java·开发语言·笔记
知识分享小能手6 小时前
React学习教程，从入门到精通， React 属性（Props）语法知识点与案例详解(14）
前端·javascript·vue.js·学习·react.js·vue·react
汇能感知8 小时前
摄像头模块在运动相机中的特殊应用
经验分享·笔记·科技
阿巴Jun9 小时前
【数学】线性代数知识点总结
笔记·线性代数·矩阵
茯苓gao9 小时前
STM32G4 速度环开环，电流环闭环 IF模式建模
笔记·stm32·单片机·嵌入式硬件·学习
是誰萆微了承諾9 小时前
【golang学习笔记 gin 】1.2 redis 的使用
笔记·学习·golang
DKPT10 小时前
Java内存区域与内存溢出
java·开发语言·jvm·笔记·学习
aaaweiaaaaaa10 小时前
HTML和CSS学习
前端·css·学习·html
热门推荐
01UV安装并设置国内源022025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！032025年数学建模国赛C题超详细解题思路04A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程05不再让Windows更新！&Edge游戏助手卸载及关闭自动更新06KGG转MP3工具|非KGM文件|解密音频07UV 工具安装与国内镜像源配置指南08突破百度网盘的下载限速，两种方法教会你【超详细】09Linux下V2Ray安装配置指南10教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员