sampling_config.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 <vector>
#include <string>
#include <unordered_map>
#include <cstddef>
#include <cstdint>
 
#include <kcenon/common/interfaces/logger_interface.h>
 
namespace kcenon::logger::sampling {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
enum class sampling_strategy : std::uint8_t {
    random,         
    rate_limiting,  
    adaptive,       
    hash_based      
};
 
struct sampling_config {
    bool enabled = false;
 
    double rate = 1.0;
 
    sampling_strategy strategy = sampling_strategy::random;
 
    std::vector<log_level> always_log_levels = {
        log_level::error,
        log_level::critical
    };
 
    std::unordered_map<std::string, double> category_rates;
 
    std::unordered_map<std::string, std::unordered_map<std::string, double>> field_rates;
 
    std::vector<std::string> always_log_fields;
 
    // Rate limiting specific settings
 
    std::size_t rate_limit_per_second = 1000;
 
    std::size_t rate_limit_window_ms = 1000;
 
    // Adaptive sampling specific settings
 
    bool adaptive_enabled = false;
 
    std::size_t adaptive_threshold = 10000;
 
    double adaptive_min_rate = 0.01;
 
    // Hash-based sampling specific settings
 
    std::uint64_t hash_seed = 0;
 
    static sampling_config disabled() {
        return sampling_config{};
    }
 
    static sampling_config random_sampling(double sample_rate) {
        sampling_config config;
        config.enabled = true;
        config.rate = sample_rate;
        config.strategy = sampling_strategy::random;
        return config;
    }
 
    static sampling_config rate_limited(std::size_t max_per_second) {
        sampling_config config;
        config.enabled = true;
        config.strategy = sampling_strategy::rate_limiting;
        config.rate_limit_per_second = max_per_second;
        return config;
    }
 
    static sampling_config adaptive(std::size_t threshold, double min_rate = 0.01) {
        sampling_config config;
        config.enabled = true;
        config.strategy = sampling_strategy::adaptive;
        config.adaptive_enabled = true;
        config.adaptive_threshold = threshold;
        config.adaptive_min_rate = min_rate;
        return config;
    }
 
    static sampling_config hash_based(double sample_rate, std::uint64_t seed = 0) {
        sampling_config config;
        config.enabled = true;
        config.rate = sample_rate;
        config.strategy = sampling_strategy::hash_based;
        config.hash_seed = seed;
        return config;
    }
 
    sampling_config with_always_log(std::vector<log_level> levels) && {
        always_log_levels = std::move(levels);
        return std::move(*this);
    }
 
    sampling_config with_always_log(std::vector<log_level> levels) const & {
        sampling_config copy = *this;
        copy.always_log_levels = std::move(levels);
        return copy;
    }
};
 
struct sampling_stats {
    std::uint64_t total_count = 0;
 
    std::uint64_t sampled_count = 0;
 
    std::uint64_t dropped_count = 0;
 
    std::uint64_t bypassed_count = 0;
 
    double effective_rate = 1.0;
 
    bool is_throttling = false;
 
    [[nodiscard]] double actual_ratio() const {
        if (total_count == 0) {
            return 1.0;
        }
        return static_cast<double>(sampled_count + bypassed_count) /
               static_cast<double>(total_count);
    }
 
    void reset() {
        total_count = 0;
        sampled_count = 0;
        dropped_count = 0;
        bypassed_count = 0;
        effective_rate = 1.0;
        is_throttling = false;
    }
};
 
} // namespace kcenon::logger::sampling