C++下按应用启动时间间隔读写日志的实现方案咨询

嘿，我来帮你搞定这个日志需求！你想要的是基于应用启动时长的时间戳，还得能按时间间隔回放日志对吧？easyloggingpp确实没直接提供这个功能，但咱们有两种思路：要么扩展它，要么自己写个轻量的实现——毕竟你的需求不算复杂，完全可控。

一、实现带启动时间间隔的日志写入 #

方案1：扩展easyloggingpp自定义时间戳 #

easyloggingpp支持自定义日志格式化器，我们可以利用这个特性，替换默认的系统时间戳为应用启动后的秒数。

#include <easylogging++.h>
#include <chrono>
#include <thread>

// 存储应用启动的初始时间点（程序启动时初始化）
static const std::chrono::steady_clock::time_point app_start_time = std::chrono::steady_clock::now();

// 自定义日志格式化函数：替换时间戳为启动后的秒数
void customLogFormatter(el::LogMessage* msg) {
    // 计算当前距离启动的秒数
    auto elapsed_seconds = std::chrono::duration_cast<std::chrono::seconds>(
        std::chrono::steady_clock::now() - app_start_time
    ).count();
    // 替换默认时间格式为我们的间隔秒数
    msg->setTime(std::to_string(elapsed_seconds) + ":");
    // 调用默认格式化逻辑完成剩余部分
    el::base::DefaultLogFormatter::format(msg);
}

int main(int argc, char* argv[]) {
    // 注册自定义格式化器
    el::Helpers::installCustomFormatter(customLogFormatter);
    START_EASYLOGGINGPP(argc, argv);

    LOG(INFO) << "此日志消息在应用启动后1秒到达";
    std::this_thread::sleep_for(std::chrono::seconds(4));
    LOG(INFO) << "此日志消息在应用启动后5秒到达";

    return 0;
}

方案2：自己实现轻量日志类（更灵活） #

如果不想依赖第三方库，自己写个小日志类也很简单，完全掌控日志格式和行为：

#include <iostream>
#include <fstream>
#include <chrono>
#include <mutex>
#include <string>
#include <thread>

class IntervalLogger {
private:
    std::ofstream log_file;
    const std::chrono::steady_clock::time_point start_time;
    std::mutex log_mutex; // 多线程环境下保证日志写入线程安全

public:
    // 构造函数：打开日志文件，记录启动时间
    IntervalLogger(const std::string& filename) 
        : start_time(std::chrono::steady_clock::now()) {
        log_file.open(filename, std::ios::out | std::ios::app);
        if (!log_file.is_open()) {
            std::cerr << "无法打开日志文件: " << filename << std::endl;
        }
    }

    // 析构函数：关闭日志文件
    ~IntervalLogger() {
        if (log_file.is_open()) {
            log_file.close();
        }
    }

    // 写入日志：自动添加启动时间间隔戳
    void log(const std::string& message) {
        std::lock_guard<std::mutex> lock(log_mutex);
        if (!log_file.is_open()) return;

        auto elapsed_seconds = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::steady_clock::now() - start_time
        ).count();
        log_file << elapsed_seconds << ": " << message << std::endl;
        log_file.flush(); // 确保日志立即写入文件
    }
};

// 使用示例
int main() {
    IntervalLogger logger("app.log");
    logger.log("此日志消息在应用启动后1秒到达");
    std::this_thread::sleep_for(std::chrono::seconds(4));
    logger.log("此日志消息在应用启动后5秒到达");
    return 0;
}

二、实现按时间间隔读取/回放日志 #

不管用哪种写入方式，日志文件的格式都是[秒数]: [消息]，我们只需要解析这个格式，就能实现按时间点读取或实时回放。

方式1：实时回放日志（模拟启动后时间点触发） #

这种方式会模拟应用启动的节奏，到对应时间点自动打印日志：

#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
#include <vector>
#include <sstream>
#include <utility>

// 解析日志文件，存储<时间戳, 消息>的配对
std::vector<std::pair<long long, std::string>> parseLogFile(const std::string& filename) {
    std::vector<std::pair<long long, std::string>> log_entries;
    std::ifstream log_file(filename);
    std::string line;

    while (std::getline(log_file, line)) {
        size_t colon_pos = line.find(':');
        if (colon_pos != std::string::npos) {
            // 解析时间戳（秒数）
            long long elapsed = std::stoll(line.substr(0, colon_pos));
            // 提取消息内容（跳过": "）
            std::string message = line.substr(colon_pos + 2);
            log_entries.emplace_back(elapsed, message);
        }
    }
    return log_entries;
}

// 实时回放日志：按照日志记录的时间间隔，模拟启动后逐步打印
void replayLog(const std::vector<std::pair<long long, std::string>>& log_entries) {
    auto replay_start_time = std::chrono::steady_clock::now();
    size_t current_idx = 0;

    while (current_idx < log_entries.size()) {
        // 计算当前回放的"启动时长"
        auto current_elapsed = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::steady_clock::now() - replay_start_time
        ).count();

        // 如果到达当前日志的时间点，打印消息
        if (current_elapsed >= log_entries[current_idx].first) {
            std::cout << "回放: " << log_entries[current_idx].first << ": " << log_entries[current_idx].second << std::endl;
            current_idx++;
        }
        // 短时间休眠避免忙等
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 使用示例
int main() {
    auto logs = parseLogFile("app.log");
    std::cout << "开始回放日志..." << std::endl;
    replayLog(logs);
    return 0;
}

方式2：离线查找指定时间点的日志 #

如果只是想查询某个时间点的日志，可以直接遍历解析后的日志条目：

// 查找指定时间间隔对应的所有日志消息
std::vector<std::string> findLogsAtInterval(const std::vector<std::pair<long long, std::string>>& log_entries, long long target_elapsed) {
    std::vector<std::string> results;
    for (const auto& entry : log_entries) {
        if (entry.first == target_elapsed) {
            results.push_back(entry.second);
        }
    }
    return results;
}

// 使用示例
int main() {
    auto logs = parseLogFile("app.log");
    auto messages = findLogsAtInterval(logs, 5);
    
    std::cout << "启动后5秒的日志消息:" << std::endl;
    for (const auto& msg : messages) {
        std::cout << "- " << msg << std::endl;
    }
    return 0;
}

总结 #

• 如果想继续用easyloggingpp，自定义格式化器就能轻松替换时间戳，读取日志只需要自己解析固定格式的日志文件即可。
• 如果追求轻量和完全可控，自己写个小日志类+解析模块是最灵活的，代码量也不大，还能根据需求随时扩展（比如支持毫秒级时间戳、多线程安全等）。

内容的提问来源于stack exchange，提问作者Mahmudur Rahman