sliding_histogram.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/network/detail/metrics/histogram.h"
 
#include <chrono>
#include <deque>
#include <memory>
#include <mutex>
 
namespace kcenon::network::metrics {
 
struct sliding_histogram_config
{
    histogram_config hist_config;                               
    std::chrono::seconds window_duration{60};                   
    size_t bucket_count{6};                                     
 
    static auto default_config() -> sliding_histogram_config
    {
        return sliding_histogram_config{histogram_config::default_latency_config(),
                                        std::chrono::seconds{60}, 6};
    }
};
 
class sliding_histogram
{
public:
    explicit sliding_histogram(sliding_histogram_config cfg = sliding_histogram_config::default_config());
 
    ~sliding_histogram() = default;
 
    // Non-copyable
    sliding_histogram(const sliding_histogram&) = delete;
    auto operator=(const sliding_histogram&) -> sliding_histogram& = delete;
 
    // Movable
    sliding_histogram(sliding_histogram&& other) noexcept;
    auto operator=(sliding_histogram&& other) noexcept -> sliding_histogram&;
 
    void record(double value);
 
    [[nodiscard]] auto count() const -> uint64_t;
 
    [[nodiscard]] auto sum() const -> double;
 
    [[nodiscard]] auto mean() const -> double;
 
    [[nodiscard]] auto percentile(double p) const -> double;
 
    [[nodiscard]] auto p50() const -> double { return percentile(0.50); }
 
    [[nodiscard]] auto p95() const -> double { return percentile(0.95); }
 
    [[nodiscard]] auto p99() const -> double { return percentile(0.99); }
 
    [[nodiscard]] auto p999() const -> double { return percentile(0.999); }
 
    [[nodiscard]] auto snapshot(const std::map<std::string, std::string>& labels = {}) const
        -> histogram_snapshot;
 
    [[nodiscard]] auto window_duration() const -> std::chrono::seconds
    {
        return config_.window_duration;
    }
 
    void reset();
 
private:
    struct time_bucket
    {
        histogram hist;
        std::chrono::steady_clock::time_point start_time;
 
        explicit time_bucket(const histogram_config& cfg)
            : hist(cfg), start_time(std::chrono::steady_clock::now())
        {
        }
    };
 
    sliding_histogram_config config_;
    std::chrono::milliseconds bucket_duration_;
    std::deque<std::unique_ptr<time_bucket>> buckets_;
    mutable std::mutex mutex_;
 
    void expire_old_buckets();
 
    auto get_current_bucket() -> time_bucket&;
 
    [[nodiscard]] auto aggregate() const -> histogram_snapshot;
};
 
} // namespace kcenon::network::metrics