thread_local_buffer.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <vector>
#include <string>
#include <chrono>
#include <memory>
#include <functional>
 
namespace kcenon { namespace monitoring {
 
// Forward declaration
class central_collector;
 
struct metric_sample {
    std::string operation_name;
    std::chrono::nanoseconds duration;
    bool success;
    std::chrono::steady_clock::time_point timestamp;
 
    metric_sample() = default;
    metric_sample(const std::string& name,
                  std::chrono::nanoseconds dur,
                  bool succ)
        : operation_name(name)
        , duration(dur)
        , success(succ)
        , timestamp(std::chrono::steady_clock::now())
    {}
};
 
class thread_local_buffer {
public:
    static constexpr size_t DEFAULT_CAPACITY = 256;
 
    explicit thread_local_buffer(size_t capacity = DEFAULT_CAPACITY,
                                 std::shared_ptr<central_collector> collector = nullptr);
 
    ~thread_local_buffer();
 
    // Non-copyable, non-movable (thread-local resource)
    thread_local_buffer(const thread_local_buffer&) = delete;
    thread_local_buffer& operator=(const thread_local_buffer&) = delete;
    thread_local_buffer(thread_local_buffer&&) = delete;
    thread_local_buffer& operator=(thread_local_buffer&&) = delete;
 
    bool record(const metric_sample& sample);
 
    bool record_auto_flush(const metric_sample& sample);
 
    size_t flush();
 
    size_t size() const { return write_index_; }
 
    bool is_full() const { return write_index_ >= capacity_; }
 
    size_t capacity() const { return capacity_; }
 
    void set_collector(std::shared_ptr<central_collector> collector) {
        collector_ = collector;
    }
 
    struct stats {
        size_t total_records{0};    
        size_t total_flushes{0};    
        size_t auto_flushes{0};     
    };
 
    const stats& get_stats() const { return stats_; }
 
private:
    std::vector<metric_sample> buffer_;  // Pre-allocated ring buffer
    size_t capacity_;
    size_t write_index_{0};  // Single-writer, no atomic needed
    std::shared_ptr<central_collector> collector_;
    stats stats_;
};
 
}} // namespace kcenon::monitoring