秒杀系统高并发优化实战（C++ / Drogon）：2.6 整合高性能异步日志（spdlog + 环形缓冲，替代 Log4j2+Disruptor）

template <typename T, std::size_t Capacity>
class RingBuffer {
public:
    // 满则丢（drop-newest）：返回 false 表示本次被丢弃。
    bool push(T item) {
        std::lock_guard<std::mutex> lk(mu_);
        if (count_ == Capacity) {
            ++dropped_;
            return false;
        }
        buf_[(head_ + count_) % Capacity] = std::move(item);
        ++count_;
        cv_.notify_one();
        return true;
    }

    // 阻塞直到有数据；返回本次取出的条数（0 = 已 stop 且队列已空）。
    std::size_t waitAndPopBatch(std::array<T, Capacity> &out) {
        std::unique_lock<std::mutex> lk(mu_);
        cv_.wait(lk, [this] { return count_ > 0 || stop_; });
        std::size_t n = 0;
        while (count_ > 0) {
            out[n] = std::move(buf_[head_]);
            head_ = (head_ + 1) % Capacity;
            --count_;
            ++n;
        }
        return n;
    }
    // ... requestStop() / dropped() 略
private:
    std::array<T, Capacity> buf_{};
    std::size_t head_ = 0, count_ = 0, dropped_ = 0;
    bool stop_ = false;
    mutable std::mutex mu_;
    std::condition_variable cv_;
};

void AsyncLogger::start(const std::string &file, spdlog::level::level_enum level) {
    if (running_.exchange(true)) return;  // 幂等
    try {
        std::filesystem::create_directories("logs");   // file sink 不建目录，先补上
        auto fileSink =
            std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
                file, 5 * 1024 * 1024, 3);             // 5MB × 3 轮转
        fileLogger_ = std::make_shared<spdlog::logger>("seckill", std::move(fileSink));
        fileLogger_->set_level(level);
        fileLogger_->flush_on(spdlog::level::warn);     // warn 及以上立即 flush
    } catch (const spdlog::spdlog_ex &e) {
        fileLogger_ = spdlog::stderr_color_mt("seckill_fallback");  // 降级不丢日志
        fileLogger_->error("AsyncLogger: fallback to stderr, {}", e.what());
    }
    worker_ = std::thread([this] { workerLoop(); });
}

void AsyncLogger::workerLoop() {
    std::array<LogMessage, kCapacity> batch;
    for (;;) {
        std::size_t n = buf_.waitAndPopBatch(batch);
        if (n == 0) break;                              // stop 且排空
        for (std::size_t i = 0; i < n; ++i) {
            fileLogger_->log(batch[i].level, "{}", batch[i].msg);  // "{}" 防花括号被当格式串
        }
    }
}

void AsyncLogger::log(spdlog::level::level_enum lvl, std::string msg) {
    if (!running_.load(std::memory_order_relaxed)) return;
    buf_.push(LogMessage{lvl, std::move(msg)});         // 满则丢，业务线程不阻塞
}

drogon::app().loadConfigFile("./config.json");

// 异步日志配置来自 config.json 的 custom_config.async_log 段
{
    const auto &cc = drogon::app().getCustomConfig();
    std::string logFile = "./logs/seckill.log";
    std::string logLevel = "warn";
    if (cc.isMember("async_log")) {
        const auto &al = cc["async_log"];
        if (al.isMember("file"))  logFile = al["file"].asString();
        if (al.isMember("level")) logLevel = al["level"].asString();
    }
    seckill::log::AsyncLogger::instance().start(
        logFile, spdlog::level::from_str(logLevel));
}

// src/logging/LogStream.h —— 一个轻量流式包装：析构即提交
namespace seckill::log {
class LogStream {
public:
    explicit LogStream(spdlog::level::level_enum lvl) : lvl_(lvl) {}
    ~LogStream() {
        // 析构即提交：临时对象在语句结束时析构，把拼好的字符串 push 进环形缓冲
        AsyncLogger::instance().log(lvl_, oss_.str());
    }
    LogStream(const LogStream &) = delete;            // 禁止拷贝/移动：必须是语句内临时量
    template <typename T>
    LogStream &operator<<(T &&v) { oss_ << std::forward<T>(v); return *this; }
private:
    spdlog::level::level_enum lvl_;
    std::ostringstream oss_;
};
}

// 宏：SK_ 前缀避 Drogon 自带 LOG_* 重定义；enabled() 先做级别短路
#define SK_LOG(level)                                                     \
    if (!::seckill::log::AsyncLogger::instance().enabled(level)) {        \
    } else                                                                \
        ::seckill::log::LogStream(level)
#define SK_LOG_TRACE    SK_LOG(spdlog::level::trace)
#define SK_LOG_DEBUG    SK_LOG(spdlog::level::debug)
#define SK_LOG_INFO     SK_LOG(spdlog::level::info)
#define SK_LOG_WARN     SK_LOG(spdlog::level::warn)
#define SK_LOG_ERROR    SK_LOG(spdlog::level::err)
#define SK_LOG_CRITICAL SK_LOG(spdlog::level::critical)

// 业务侧（src/service/SeckillService.cc）—— 流式、类型安全、不用 std::to_string
if (result.affectedRows() == 0) {
    tx->rollback();
    SK_LOG_WARN << "SOLD_OUT skuId=" << skuId;   // 等价于旧的 instance().log(warn, ...)，但更顺手
    cb(false, "SOLD_OUT");
    return;
}