log_sampler.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 "sampling_config.h"
#include <kcenon/logger/interfaces/log_entry.h>
#include <kcenon/logger/logger_export.h>
#include <kcenon/common/interfaces/logger_interface.h>
 
#include <atomic>
#include <chrono>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <optional>
 
namespace kcenon::logger::sampling {
 
// Type alias for log_level (may already be available from sampling_config.h, but explicit here for clarity)
using log_level = common::interfaces::log_level;
 
class LOGGER_SYSTEM_API log_sampler {
public:
    explicit log_sampler(const sampling_config& config = sampling_config{});
 
    ~log_sampler() = default;
 
    log_sampler(const log_sampler&) = delete;
 
    log_sampler& operator=(const log_sampler&) = delete;
 
    log_sampler(log_sampler&& other) noexcept;
 
    log_sampler& operator=(log_sampler&& other) noexcept;
 
    [[nodiscard]] bool should_sample(const log_entry& entry);
 
    [[nodiscard]] bool should_sample(log_level level,
                                     const std::string& message);
 
    [[nodiscard]] bool should_sample(log_level level,
                                     const std::string& message,
                                     const std::optional<std::string>& category);
 
    void set_config(const sampling_config& config);
 
    [[nodiscard]] sampling_config get_config() const;
 
    [[nodiscard]] sampling_stats get_stats() const;
 
    void reset_stats();
 
    [[nodiscard]] bool is_enabled() const;
 
    void set_enabled(bool enabled);
 
    [[nodiscard]] double get_effective_rate() const;
 
private:
    [[nodiscard]] bool should_bypass_level(log_level level) const;
 
    [[nodiscard]] bool should_bypass_field(const log_entry& entry) const;
 
    [[nodiscard]] double get_field_rate(const log_entry& entry) const;
 
    [[nodiscard]] double get_category_rate(const std::string& category) const;
 
    [[nodiscard]] bool random_sample(double rate);
 
    [[nodiscard]] bool rate_limit_sample();
 
    [[nodiscard]] bool adaptive_sample();
 
    [[nodiscard]] bool hash_sample(const std::string& message, double rate);
 
    void update_adaptive_rate();
 
    [[nodiscard]] std::uint64_t xorshift64();
 
    [[nodiscard]] static std::uint64_t fnv1a_hash(const std::string& str);
 
    // Configuration
    sampling_config config_;
    mutable std::shared_mutex config_mutex_;
 
    // Statistics (atomic for lock-free access)
    std::atomic<std::uint64_t> total_count_{0};
    std::atomic<std::uint64_t> sampled_count_{0};
    std::atomic<std::uint64_t> dropped_count_{0};
    std::atomic<std::uint64_t> bypassed_count_{0};
 
    // Random sampling state
    std::atomic<std::uint64_t> rng_state_;
 
    // Rate limiting state
    std::atomic<std::uint64_t> rate_limit_count_{0};
    std::atomic<std::chrono::steady_clock::time_point::rep> rate_limit_window_start_{0};
    std::mutex rate_limit_mutex_;
 
    // Adaptive sampling state
    std::atomic<double> effective_rate_{1.0};
    std::atomic<std::uint64_t> adaptive_window_count_{0};
    std::atomic<std::chrono::steady_clock::time_point::rep> adaptive_window_start_{0};
    std::atomic<bool> is_throttling_{false};
};
 
class LOGGER_SYSTEM_API sampler_factory {
public:
    static std::unique_ptr<log_sampler> create_disabled();
 
    static std::unique_ptr<log_sampler> create_random(double rate);
 
    static std::unique_ptr<log_sampler> create_rate_limited(std::size_t max_per_second);
 
    static std::unique_ptr<log_sampler> create_adaptive(
        std::size_t threshold = 10000,
        double min_rate = 0.01);
 
    static std::unique_ptr<log_sampler> create_production(
        double base_rate = 0.1,
        std::vector<log_level> critical_levels = {
            log_level::warn,
            log_level::error,
            log_level::fatal
        });
};
 
} // namespace kcenon::logger::sampling