Merge branch 'master' of ssh://115.28.86.8:29418/~admin/昆仑_1025

wxx

2024-10-30 e012082cb3c91af96619f0f982d5f2e8b4b705af

Merge branch 'master' of ssh://115.28.86.8:29418/~admin/昆仑_1025

 Server/ÂíÀöƼ/code/log/.vscode/c_cpp_properties.json

@@ -5,7 +5,7 @@
      "includePath": [
        "${workspaceFolder}/**"
      ],
      "compilerPath": "gcc",
      "compilerPath": "C:\\Users\\lenovo\\AppData\\Local\\GitHubDesktop\\bin\\g++.exe",
      "cStandard": "${default}",
      "cppStandard": "${default}",
      "intelliSenseMode": "windows-gcc-x64",

 Server/ÂíÀöƼ/code/log/.vscode/settings.json

@@ -55,5 +55,9 @@
  "C_Cpp_Runner.useLeakSanitizer": false,
  "C_Cpp_Runner.showCompilationTime": false,
  "C_Cpp_Runner.useLinkTimeOptimization": false,
  "C_Cpp_Runner.msvcSecureNoWarnings": false
  "C_Cpp_Runner.msvcSecureNoWarnings": false,
  "files.associations": {
    "iosfwd": "cpp",
    "thread": "cpp"
  }
}

 Server/ÂíÀöƼ/code/log/README.md

@@ -1,10 +1,12 @@
# å¼‚步日志系统

异步日志系统
===============
异步日志系统主要涉及了两个模块，一个是日志模块，一个是阻塞队列模块,其中加入阻塞队列模块主要是解决异步写入日志做准备.
## ç®€ä»‹

异步日志系统主要涉及两个模块：一个是日志模块，一个是阻塞队列模块，其中加入阻塞队列模块主要是解决异步写入日志的准备工作。

> * è‡ªå®šä¹‰é˜»å¡žé˜Ÿåˆ—
> * å•ä¾‹æ¨¡å¼åˆ›å»ºæ—¥å¿—
> * åŒæ­¥æ—¥å¿—
> * å¼‚步日志
> * å®žçŽ°æŒ‰å¤©ã€è¶…行分类
> * æ–‡ä»¶é™åˆ¶å¤§å° é˜²æ­¢æ—¥å¿—文件过大
> * æ–‡ä»¶é™åˆ¶å¤§å°ï¼Œé˜²æ­¢æ—¥å¿—文件过大

 Server/ÂíÀöƼ/code/log/block_queue.h

@@ -8,9 +8,12 @@

#include <iostream>
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include "../lock/locker.h"
#include <thread> // æ›¿æ¢ pthread.h

#include <chrono>
#include <ctime>

#include "locker.h"
using namespace std;

template <class T>

 Server/ÂíÀöƼ/code/log/locker.h

New file
@@ -0,0 +1,25 @@
#ifndef LOCKER_H
#define LOCKER_H

#include <mutex>
#include <stdexcept>

class locker {
public:
    locker() = default;

    ~locker() = default;

    void lock() {
        m_mutex.lock();
    }

    void unlock() {
        m_mutex.unlock();
    }

private:
    std::mutex m_mutex;
};

#endif // LOCKER_H

 Server/ÂíÀöƼ/code/log/log.cpp

@@ -1,166 +1,150 @@
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <chrono>
#include <ctime>
#include <stdarg.h>
#include "log.h"
#include <pthread.h>
#include <sstream>
#include <fstream>
#include <iostream>
#include <chrono>

using namespace std;

Log::Log()
{
    m_count = 0;
    m_is_async = false;
// æž„造函数
Log::Log() {
    m_count = 0; // åˆå§‹åŒ–日志行数
    m_is_async = false; // åˆå§‹åŒ–为同步
}

Log::~Log()
{
    if (m_fp != NULL)
    {
        fclose(m_fp);
// æžæž„函数
Log::~Log() {
    if (m_fp.is_open()) {
        m_fp.close(); // å…³é—­æ—¥å¿—文件
    }
}

bool Log::init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size)
{
    if (max_queue_size >= 1)
    {
        m_is_async = true;
        m_log_queue = new block_queue<string>(max_queue_size);
        pthread_t tid;
        pthread_create(&tid, NULL, flush_log_thread, NULL);
// æŽ¥æ”¶åŽŸå§‹æ—¥å¿—并解析
void Log::receiveLog(const std::string &raw_log) {
    ParsedLog parsed_log = parseLog(raw_log);
    write_log(levelToInt(parsed_log.level), "%s [%s] %s", parsed_log.timestamp.c_str(), parsed_log.device_id.c_str(), parsed_log.content.c_str());
}

// è§£æžæ—¥å¿—字符串
ParsedLog Log::parseLog(const std::string &log) {
    ParsedLog parsed_log;
    std::istringstream iss(log);
    std::string level;

    // è¯»å–时间戳、设备ID和日志级别
    iss >> parsed_log.timestamp >> parsed_log.device_id >> level;
    std::getline(iss, parsed_log.content);
    parsed_log.level = level; // è®¾ç½®è§£æžåŽçš„级别

    return parsed_log;
}

// åˆå§‹åŒ–日志系统
bool Log::init(const std::string &file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size) {
    if (max_queue_size >= 1) {
        m_is_async = true; // å¯ç”¨å¼‚步写入
        m_log_queue = new block_queue<string>(max_queue_size); // åˆ›å»ºé˜»å¡žé˜Ÿåˆ—
        std::thread(&Log::flush_log_thread, this).detach(); // åˆ›å»ºåˆ·æ–°æ—¥å¿—线程
    }

    m_close_log = close_log;
    m_log_buf_size = log_buf_size;
    m_buf = new char[m_log_buf_size];
    memset(m_buf, '\0', m_log_buf_size);
    m_split_lines = split_lines;
    m_close_log = close_log; // è®¾ç½®å…³é—­æ—¥å¿—标志
    m_log_buf_size = log_buf_size; // è®¾ç½®ç¼“冲区大小
    m_buf = new char[m_log_buf_size]; // åˆ†é…ç¼“冲区
    memset(m_buf, '\0', m_log_buf_size); // æ¸…空缓冲区
    m_split_lines = split_lines; // è®¾ç½®æœ€å¤§è¡Œæ•°

    time_t t = time(NULL);
    struct tm *sys_tm = localtime(&t);
    const char *p = strrchr(file_name, '/');
    char log_full_name[256] = {0};
    std::string log_full_name;

    if (p == NULL)
    {
        snprintf(log_full_name, 255, "%d_%02d_%02d_%s", sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_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, sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday, log_name);
    // æ ¹æ®æ–‡ä»¶è·¯å¾„和当前日期生成完整日志文件名
    if (file_name.find('/') == std::string::npos) {
        log_full_name = to_string(sys_tm->tm_year + 1900) + "_" + to_string(sys_tm->tm_mon + 1) + "_" + to_string(sys_tm->tm_mday) + "_" + file_name;
    } else {
        std::string log_name = file_name.substr(file_name.find_last_of('/') + 1);
        std::string dir_name = file_name.substr(0, file_name.find_last_of('/') + 1);

        log_full_name = dir_name + to_string(sys_tm->tm_year + 1900) + "_" + to_string(sys_tm->tm_mon + 1) + "_" + to_string(sys_tm->tm_mday) + "_" + log_name;
    }

    m_today = sys_tm->tm_mday;
    m_fp = fopen(log_full_name, "a");
    if (m_fp == NULL)
    {
        return false;
    m_today = sys_tm->tm_mday; // è®°å½•ä»Šå¤©çš„日期
    m_fp.open(log_full_name, std::ios::out | std::ios::app); // æ‰“开日志文件
    if (!m_fp.is_open()) {
        return false; // æ‰“开失败
    }

    return true;
    return true; // åˆå§‹åŒ–成功
}

void Log::write_log(int level, const char *format, ...)
{
    struct timeval now;
    gettimeofday(&now, NULL);
    time_t t = now.tv_sec;
    struct tm *sys_tm = localtime(&t);
    char s[16] = {0};
#include <chrono>

    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;
void Log::write_log(int level, const char *format, ...) {
    auto now = std::chrono::system_clock::now();
    auto now_time_t = std::chrono::system_clock::to_time_t(now);
    struct tm *sys_tm = localtime(&now_time_t);
    
    std::string s;

    // æ ¹æ®æ—¥å¿—级别设置前缀
    switch (level) {
        case DEBUG: s = "[debug]: "; break;
        case INFO: s = "[info]: "; break;
        case WARN: s = "[warn]: "; break;
        case ERROR: s = "[error]: "; break;
        default: s = "[info]: "; break;
    }

    m_mutex.lock();
    m_count++;
    m_mutex.lock(); // é”å®šäº’斥体
    m_count++; // å¢žåŠ æ—¥å¿—计数

    if (m_today != sys_tm->tm_mday || m_count % m_split_lines == 0)
    {
        char new_log[256] = {0};
        fflush(m_fp);
        fclose(m_fp);
        char tail[16] = {0};
        snprintf(tail, 16, "%d_%02d_%02d_", sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday);
        
        if (m_today != sys_tm->tm_mday)
        {
            snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);
            m_today = sys_tm->tm_mday;
            m_count = 0;
    // æ£€æŸ¥æ˜¯å¦éœ€è¦è½®æ¢æ—¥å¿—
    if (m_today != sys_tm->tm_mday || m_count % m_split_lines == 0) {
        // ... (日志轮换代码)
    }

    // å†™å…¥æ—¥å¿—内容
    va_list valist;
    va_start(valist, format);
    vsnprintf(m_buf, m_log_buf_size, format, valist); // å†™å…¥æ—¥å¿—内容

    m_fp << s << m_buf << std::endl; // ä½¿ç”¨ofstream写入文件

    m_mutex.unlock(); // è§£é”äº’斥体

    // å¼‚步写入日志
    if (m_is_async && !m_log_queue->full()) {
        m_log_queue->push(m_buf); // å°†æ—¥å¿—推入队列
    }
}

// åˆ·æ–°æ—¥å¿—文件
void Log::flush(void) {
    m_mutex.lock(); // é”å®šäº’斥体
    m_fp.flush(); // åˆ·æ–°æ–‡ä»¶
    m_mutex.unlock(); // è§£é”äº’斥体
}

// åˆ·æ–°æ—¥å¿—线程
void Log::flush_log_thread() {
    while (m_is_async) {
        // ä»Žé˜Ÿåˆ—中获取日志并写入
        string log;
        if (m_log_queue->pop(log)) {
            write_log(INFO, "%s", log.c_str());
        }
        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");
    }

    // åœ¨å†™å…¥ä¹‹å‰æ£€æŸ¥æ—¥å¿—文件大小
    if (check_log_size())
    {
        rotate_logs(); // å¦‚果超过最大文件大小，进行日志轮换
    }

    va_list valst;
    va_start(valst, format);

    string log_str;
    int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %s ",
                     sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday,
                     sys_tm->tm_hour, sys_tm->tm_min, sys_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);
}

void Log::flush(void)
{
    m_mutex.lock();
    fflush(m_fp);
    m_mutex.unlock();
}

// æ·»åŠ çš„文件大小检查函数
bool Log::check_log_size()
{
    if (m_fp)
    {
        fseek(m_fp, 0, SEEK_END);
        long file_size = ftell(m_fp);
        return file_size >= max_size; // è¿”回文件是否超出限制
    }
    return false;
}

void Log::rotate_logs()
{
    fclose(m_fp); // å…³é—­å½“前日志文件
    char new_log[256] = {0};
    snprintf(new_log, sizeof(new_log), "%s/%s.%lld", dir_name, log_name, m_count / m_split_lines);
    m_fp = fopen(new_log, "a"); // æ‰“开新的日志文件
    m_count = 0; // é‡ç½®æ—¥å¿—计数
// æ—¥å¿—级别转换为整数
int Log::levelToInt(const std::string &level) {
    if (level == "[debug]:") return DEBUG;
    if (level == "[info]:") return INFO;
    if (level == "[warn]:") return WARN;
    if (level == "[error]:") return ERROR;
    return INFO; // é»˜è®¤è¿”回INFO
}

 Server/ÂíÀöƼ/code/log/log.h

@@ -5,93 +5,92 @@
#include <iostream>
#include <string>
#include <stdarg.h>
#include <pthread.h>
#include <thread> 
#include "block_queue.h"
#include "locker.h" // ç¡®ä¿ locker.h è¢«åŒ…含
#include <fstream>

using namespace std;

// æ—¥å¿—级别枚举
enum LogLevel {
    DEBUG = 0,
    INFO,
    WARN,
    ERROR
};

// å­˜å‚¨è§£æžæ—¥å¿—文件的结构体
struct ParsedLog {
    std::string timestamp; // æ—¶é—´æˆ³
    std::string device_id; // è®¾å¤‡ID
    std::string level;     // æ—¥å¿—级别
    std::string content;   // æ—¥å¿—内容
};

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();
    }
    // åˆ·æ–°æ—¥å¿—线程
    void flush_log_thread(); // ä¿®æ”¹ä¸ºéžé™æ€æˆå‘˜å‡½æ•°

    // å¯é€‰æ‹©çš„参数有日志文件、日志缓冲区大小、最大行数以及最长日志条队列
    bool init(const char *file_name, int close_log, int log_buf_size = 8192, int split_lines = 5000000, int max_queue_size = 0);
    // åˆå§‹åŒ–日志系统，参数包括文件名、是否关闭日志、缓冲区大小、最大行数和最大队列大小
    bool Log::init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);

    
    // å†™å…¥æ—¥å¿—
    void write_log(int level, const char *format, ...);
    
    // åˆ·æ–°æ—¥å¿—文件
    void flush(void);

    //接收原始的要公共类
    void receiveLog(const std::string& raw_log); // æŽ¥æ”¶åŽŸå§‹æ—¥å¿—

private:
    Log();
    virtual ~Log();
    Log(); // æž„造函数
    virtual ~Log(); // æžæž„函数

    void async_write_log(); // å¼‚步写入日志
    bool check_log_size(); // æ£€æŸ¥æ—¥å¿—文件大小
    void rotate_logs(); // è½®æ¢æ—¥å¿—文件
    
    void *async_write_log()
    {
        string single_log;
        // ä»Žé˜»å¡žé˜Ÿåˆ—中取出一个日志string，写入文件
        while (m_log_queue->pop(single_log))
        {
            m_mutex.lock();
            if (check_log_size()) // æ£€æŸ¥æ–‡ä»¶å¤§å°
            {
                rotate_logs(); // è½®æ¢æ—¥å¿—
            }
            fputs(single_log.c_str(), m_fp);
            m_mutex.unlock();
        }
    }
    ParsedLog parseLog(const std::string& log); // è§£æžæ—¥å¿—
    bool init(const std::string &file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size);
    void queryLogs(const std::string &device_id); // æŸ¥è¯¢æ—¥å¿—

    // æ£€æŸ¥æ—¥å¿—文件大小
    bool check_log_size()
    {
        if (m_fp)
        {
            fseek(m_fp, 0, SEEK_END);
            long file_size = ftell(m_fp);
            return file_size >= max_size; // è¿”回文件是否超出限制
        }
        return false;
    }

    // è½®æ¢æ—¥å¿—文件
    void rotate_logs()
    {
        fclose(m_fp); // å…³é—­å½“前日志文件
        char new_log[256] = {0};
        snprintf(new_log, sizeof(new_log), "%s/%s.%lld", dir_name, log_name, m_count / m_split_lines);
        m_fp = fopen(new_log, "a"); // æ‰“开新的日志文件
        m_count = 0; // é‡ç½®æ—¥å¿—计数
    }
    const char* log_level_to_string(int level); // å°†æ—¥å¿—级别转换为字符串
    int levelToInt(const std::string &level);

private:
    char dir_name[128]; // è·¯å¾„名
    char log_name[128]; // log文件名
    char dir_name[128]; // æ—¥å¿—文件目录
    char log_name[128]; // æ—¥å¿—文件名
    int m_split_lines;  // æ—¥å¿—最大行数
    int m_log_buf_size; // æ—¥å¿—缓冲区大小
    long long m_count;  // æ—¥å¿—行数记录
    int m_today;        // å› ä¸ºæŒ‰å¤©åˆ†ç±»,记录当前时间是那一天
    FILE *m_fp;         // æ‰“å¼€log的文件指针
    char *m_buf;
    int m_today;        // è®°å½•å½“前时间
    std::ofstream m_fp; // å°† FILE * m_fp æ›´æ”¹ä¸º std::ofstream m_fp
    char *m_buf;        // æ—¥å¿—缓冲区
    block_queue<string> *m_log_queue; // é˜»å¡žé˜Ÿåˆ—
    bool m_is_async;                  // æ˜¯å¦åŒæ­¥æ ‡å¿—位
    locker m_mutex;
    int m_close_log; // å…³é—­æ—¥å¿—
    bool m_is_async;                  // æ˜¯å¦å¼‚步标志位
    locker m_mutex;                   // äº’斥锁
    int m_close_log; // å…³é—­æ—¥å¿—的标志
    long max_size = 10 * 1024 * 1024; // 10MB
    //测试文件里面的
    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();}
// å®å®šä¹‰ç”¨äºŽä¸åŒçº§åˆ«çš„日志记录
#define LOG_DEBUG(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(DEBUG, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_INFO(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(INFO, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_WARN(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(WARN, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_ERROR(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(ERROR, format, ##__VA_ARGS__); Log::get_instance()->flush();}

#endif

 Server/ÂíÀöƼ/code/log/test_log.cpp

New file
@@ -0,0 +1,25 @@
#include <iostream>
#include "log.h"

int main() {
    // åˆå§‹åŒ–日志系统
    if (!Log::get_instance()->init("test_log.txt", 0, 8192, 5000000, 1000)) {
        std::cerr << "Failed to initialize log system." << std::endl;
        return 1;
    }

    // æµ‹è¯•å†™å…¥ä¸åŒçº§åˆ«çš„日志
    Log::get_instance()->write_log(DEBUG, "This is a debug message.");
    Log::get_instance()->write_log(INFO, "This is an info message.");
    Log::get_instance()->write_log(WARN, "This is a warning message.");
    Log::get_instance()->write_log(ERROR, "This is an error message.");

    // æ¨¡æ‹ŸæŽ¥æ”¶åŽŸå§‹æ—¥å¿—
    Log::get_instance()->receiveLog("[info]: Device123 Operation successful.");

    // åˆ·æ–°æ—¥å¿—
    Log::get_instance()->flush();

    std::cout << "Logs written successfully." << std::endl;
    return 0;
}