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