batch_writer.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "queued_writer_base.h"
 
#include <kcenon/logger/logger_export.h>
 
#include <vector>
#include <chrono>
 
namespace kcenon::logger {
 
class LOGGER_SYSTEM_API batch_writer : public queued_writer_base<std::vector<log_entry>> {
    using base_type = queued_writer_base<std::vector<log_entry>>;
 
public:
    struct config {
        size_t max_batch_size;  // Maximum entries before auto-flush
        std::chrono::milliseconds flush_interval;  // Auto-flush interval
        bool preserve_order;  // Maintain strict ordering
        
        config()
            : max_batch_size(100)
            , flush_interval(1000)
            , preserve_order(true) {}
    };
    
    explicit batch_writer(log_writer_ptr underlying_writer,
                          const config& cfg = config{});
    
    ~batch_writer() override;
    
    common::VoidResult write(const log_entry& entry) override;
 
    common::VoidResult flush() override;
    
    std::string get_name() const override;
    
    bool is_healthy() const override;
    
    size_t get_current_batch_size() const;
    
    struct batch_stats {
        std::atomic<uint64_t> total_batches{0};
        std::atomic<uint64_t> total_entries{0};
        std::atomic<uint64_t> dropped_entries{0};
        std::atomic<uint64_t> flush_on_size{0};
        std::atomic<uint64_t> flush_on_timeout{0};
        std::atomic<uint64_t> manual_flushes{0};
        
        double average_batch_size() const {
            return total_batches > 0 ? 
                   static_cast<double>(total_entries) / total_batches : 0.0;
        }
    };
    
    const batch_stats& get_stats() const { return stats_; }
    
    void reset_stats();
    
private:
 
    common::VoidResult flush_batch_unsafe();
 
    bool should_flush_by_size() const;
 
    bool should_flush_by_time() const;
 
    // Configuration
    config config_;
 
    // Timing
    std::chrono::steady_clock::time_point last_flush_time_;
 
    // Statistics
    mutable batch_stats stats_;
};
 
std::unique_ptr<batch_writer> make_batch_writer(
    log_writer_ptr writer,
    size_t batch_size = 100,
    std::chrono::milliseconds flush_interval = std::chrono::milliseconds{1000});
 
} // namespace kcenon::logger