buffered_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 "decorator_writer_base.h"
#include "../interfaces/log_entry.h"
 
#include <kcenon/logger/logger_export.h>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <mutex>
#include <vector>
 
namespace kcenon::logger {
 
class LOGGER_SYSTEM_API buffered_writer : public decorator_writer_base {
public:
    static constexpr size_t DEFAULT_BUFFER_SIZE = 100;
 
    static constexpr std::chrono::milliseconds DEFAULT_FLUSH_INTERVAL{5000};
 
    explicit buffered_writer(
        std::unique_ptr<log_writer_interface> wrapped,
        size_t max_entries = DEFAULT_BUFFER_SIZE,
        std::chrono::milliseconds flush_interval = DEFAULT_FLUSH_INTERVAL);
 
    ~buffered_writer() override;
 
    // Non-copyable
    buffered_writer(const buffered_writer&) = delete;
    buffered_writer& operator=(const buffered_writer&) = delete;
 
    // Non-movable (mutex is not movable)
    buffered_writer(buffered_writer&&) = delete;
    buffered_writer& operator=(buffered_writer&&) = delete;
 
    common::VoidResult write(const log_entry& entry) override;
 
    common::VoidResult flush() override;
 
    size_t get_buffer_count() const;
 
    size_t get_max_entries() const noexcept;
 
    std::chrono::milliseconds get_flush_interval() const noexcept;
 
    struct stats {
        std::atomic<uint64_t> total_entries_written{0};
        std::atomic<uint64_t> total_flushes{0};
        std::atomic<uint64_t> flush_on_full{0};
        std::atomic<uint64_t> flush_on_interval{0};
        std::atomic<uint64_t> manual_flushes{0};
    };
 
    const stats& get_stats() const noexcept;
 
    void reset_stats();
 
private:
    common::VoidResult flush_buffer_unsafe();
 
    bool should_flush_by_time() const;
 
    static log_entry copy_entry(const log_entry& entry);
 
    size_t max_entries_;
    std::chrono::milliseconds flush_interval_;
 
    mutable std::mutex mutex_;
    std::vector<log_entry> buffer_;
    std::chrono::steady_clock::time_point last_flush_time_;
 
    mutable stats stats_;
};
 
std::unique_ptr<buffered_writer> make_buffered_writer(
    std::unique_ptr<log_writer_interface> writer,
    size_t max_entries = buffered_writer::DEFAULT_BUFFER_SIZE,
    std::chrono::milliseconds flush_interval = buffered_writer::DEFAULT_FLUSH_INTERVAL);
 
}  // namespace kcenon::logger