TinyWebServer学习笔记-log

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

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函数将输入文件指针对应的文件中。