Configuration for log sampling behavior. More...

#include <sampling_config.h>

Collaboration diagram for kcenon::logger::sampling::sampling_config:

Public Member Functions
sampling_config	with_always_log (std::vector< log_level > levels) &&

sampling_config	with_always_log (std::vector< log_level > levels) const &
	Set log levels that bypass sampling (fluent interface, lvalue overload)

Static Public Member Functions
static sampling_config	disabled ()
	Create a default sampling configuration (disabled)

static sampling_config	random_sampling (double sample_rate)
	Create a random sampling configuration.

static sampling_config	rate_limited (std::size_t max_per_second)
	Create a rate limiting configuration.

static sampling_config	adaptive (std::size_t threshold, double min_rate=0.01)
	Create an adaptive sampling configuration.

static sampling_config	hash_based (double sample_rate, std::uint64_t seed=0)
	Create a hash-based sampling configuration.

Public Attributes
bool	enabled = false
	Enable or disable sampling.

double	rate = 1.0
	Base sampling rate (0.0 to 1.0)

sampling_strategy	strategy = sampling_strategy::random
	Sampling strategy to use.

std::vector< log_level >	always_log_levels
	Log levels that are never sampled (always logged)

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

std::size_t	rate_limit_per_second = 1000
	Maximum logs per second for rate limiting strategy.

std::size_t	rate_limit_window_ms = 1000
	Time window for rate limiting (milliseconds)

bool	adaptive_enabled = false
	Enable adaptive sampling.

std::size_t	adaptive_threshold = 10000
	Threshold (messages/second) to trigger adaptive sampling.

double	adaptive_min_rate = 0.01
	Minimum sampling rate when adaptive sampling is active.

std::uint64_t	hash_seed = 0
	Seed for hash-based sampling.

Detailed Description

Configuration for log sampling behavior.

Controls how logs are sampled to reduce volume in high-throughput scenarios. Critical levels can be configured to bypass sampling entirely.

Definition at line 76 of file sampling_config.h.

Member Function Documentation

◆ adaptive()

static sampling_config kcenon::logger::sampling::sampling_config::adaptive	(	std::size_t	threshold,
		double	min_rate = 0.01 )

inlinestatic

Create an adaptive sampling configuration.

Parameters

threshold	Messages/second threshold to trigger adaptation
min_rate	Minimum sampling rate under load

Returns: Configuration for adaptive sampling

Definition at line 239 of file sampling_config.h.

                                                                                 {
        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;
    }

References kcenon::logger::sampling::adaptive, adaptive_enabled, adaptive_min_rate, adaptive_threshold, enabled, and strategy.

Referenced by kcenon::logger::sampling::sampler_factory::create_adaptive().

Here is the caller graph for this function:

◆ disabled()

static sampling_config kcenon::logger::sampling::sampling_config::disabled ( )

inlinestatic

Create a default sampling configuration (disabled)

Returns: Default configuration with sampling disabled

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 203 of file sampling_config.h.

                                      {
        return sampling_config{};
    }

Referenced by kcenon::logger::sampling::sampler_factory::create_disabled().

Here is the caller graph for this function:

◆ hash_based()

static sampling_config kcenon::logger::sampling::sampling_config::hash_based	(	double	sample_rate,
		std::uint64_t	seed = 0 )

inlinestatic

Create a hash-based sampling configuration.

Parameters

sample_rate	Sampling rate (0.0 to 1.0)
seed	Optional seed for reproducibility

Returns: Configuration for hash-based sampling

Definition at line 255 of file sampling_config.h.

                                                                                {
        sampling_config config;
        config.enabled = true;
        config.rate = sample_rate;
        config.strategy = sampling_strategy::hash_based;
        config.hash_seed = seed;
        return config;
    }

References enabled, kcenon::logger::sampling::hash_based, hash_seed, rate, and strategy.

◆ random_sampling()

static sampling_config kcenon::logger::sampling::sampling_config::random_sampling ( double sample_rate )

inlinestatic

Create a random sampling configuration.

Parameters

sample_rate Sampling rate (0.0 to 1.0)

Returns: Configuration for random sampling

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 212 of file sampling_config.h.

                                                               {
        sampling_config config;
        config.enabled = true;
        config.rate = sample_rate;
        config.strategy = sampling_strategy::random;
        return config;
    }

References enabled, kcenon::logger::sampling::random, rate, and strategy.

Referenced by kcenon::logger::sampling::sampler_factory::create_random().

Here is the caller graph for this function:

◆ rate_limited()

static sampling_config kcenon::logger::sampling::sampling_config::rate_limited ( std::size_t max_per_second )

inlinestatic

Create a rate limiting configuration.

Parameters

max_per_second Maximum logs per second

Returns: Configuration for rate limiting

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 225 of file sampling_config.h.

                                                                  {
        sampling_config config;
        config.enabled = true;
        config.strategy = sampling_strategy::rate_limiting;
        config.rate_limit_per_second = max_per_second;
        return config;
    }

References enabled, rate_limit_per_second, kcenon::logger::sampling::rate_limiting, and strategy.

Referenced by kcenon::logger::sampling::sampler_factory::create_rate_limited().

Here is the caller graph for this function:

◆ with_always_log() [1/2]

sampling_config kcenon::logger::sampling::sampling_config::with_always_log ( std::vector< log_level > levels ) &&

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 277 of file sampling_config.h.

                                                                    {
        always_log_levels = std::move(levels);
        return std::move(*this);
    }

References always_log_levels.

◆ with_always_log() [2/2]

sampling_config kcenon::logger::sampling::sampling_config::with_always_log ( std::vector< log_level > levels ) const &

inline

Set log levels that bypass sampling (fluent interface, lvalue overload)

Parameters

levels Log levels that should always be logged

Returns: Modified configuration for chaining

Since: 3.4.0

Definition at line 289 of file sampling_config.h.

                                                                         {
        sampling_config copy = *this;
        copy.always_log_levels = std::move(levels);
        return copy;
    }

References always_log_levels.

Member Data Documentation

◆ adaptive_enabled

bool kcenon::logger::sampling::sampling_config::adaptive_enabled = false

Enable adaptive sampling.

When true and strategy is adaptive, the sampler automatically reduces the sampling rate under high load

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 177 of file sampling_config.h.

Referenced by adaptive(), and kcenon::logger::sampling::sampler_factory::create_production().

◆ adaptive_min_rate

double kcenon::logger::sampling::sampling_config::adaptive_min_rate = 0.01

Minimum sampling rate when adaptive sampling is active.

Even under extreme load, at least this percentage of logs are kept

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 189 of file sampling_config.h.

Referenced by adaptive(), kcenon::logger::sampling::sampler_factory::create_production(), and kcenon::logger::sampling::log_sampler::update_adaptive_rate().

◆ adaptive_threshold

std::size_t kcenon::logger::sampling::sampling_config::adaptive_threshold = 10000

Threshold (messages/second) to trigger adaptive sampling.

When log rate exceeds this threshold, adaptive sampling kicks in

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 183 of file sampling_config.h.

Referenced by adaptive(), kcenon::logger::sampling::sampler_factory::create_production(), and kcenon::logger::sampling::log_sampler::update_adaptive_rate().

◆ always_log_fields

std::vector<std::string> kcenon::logger::sampling::sampling_config::always_log_fields

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 154 of file sampling_config.h.

Referenced by kcenon::logger::sampling::log_sampler::should_bypass_field().

◆ always_log_levels

std::vector<log_level> kcenon::logger::sampling::sampling_config::always_log_levels

Initial value:

= {
        log_level::error,
        log_level::critical
    }

Log levels that are never sampled (always logged)

Critical levels should bypass sampling to ensure important messages are never dropped. Default includes error and critical.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 103 of file sampling_config.h.

                                             {
        log_level::error,
        log_level::critical
    };

Referenced by kcenon::logger::sampling::sampler_factory::create_production(), kcenon::logger::sampling::log_sampler::should_bypass_level(), with_always_log(), and with_always_log().

◆ category_rates

std::unordered_map<std::string, double> kcenon::logger::sampling::sampling_config::category_rates

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 120 of file sampling_config.h.

Referenced by kcenon::logger::sampling::log_sampler::get_category_rate().

◆ enabled

bool kcenon::logger::sampling::sampling_config::enabled = false

Enable or disable sampling.

When false, all logs are passed through without sampling

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 81 of file sampling_config.h.

Referenced by adaptive(), kcenon::logger::sampling::sampler_factory::create_production(), hash_based(), kcenon::logger::sampling::log_sampler::is_enabled(), random_sampling(), rate_limited(), kcenon::logger::sampling::log_sampler::set_enabled(), kcenon::logger::sampling::log_sampler::should_sample(), and kcenon::logger::sampling::log_sampler::should_sample().

◆ field_rates

std::unordered_map<std::string, std::unordered_map<std::string, double> > kcenon::logger::sampling::sampling_config::field_rates

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 140 of file sampling_config.h.

Referenced by kcenon::logger::sampling::log_sampler::get_field_rate().

◆ hash_seed

std::uint64_t kcenon::logger::sampling::sampling_config::hash_seed = 0

Seed for hash-based sampling.

Used to make hash-based sampling reproducible

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 197 of file sampling_config.h.

Referenced by hash_based(), and kcenon::logger::sampling::log_sampler::hash_sample().

◆ rate

double kcenon::logger::sampling::sampling_config::rate = 1.0

Base sampling rate (0.0 to 1.0)

Probability that a log message will be sampled (kept).

1.0 = keep all logs (no sampling)
0.1 = keep 10% of logs
0.0 = drop all logs (not recommended)

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 90 of file sampling_config.h.

Referenced by kcenon::logger::sampling::sampler_factory::create_production(), kcenon::logger::sampling::log_sampler::get_category_rate(), hash_based(), kcenon::logger::sampling::log_sampler::log_sampler(), random_sampling(), kcenon::logger::sampling::log_sampler::set_config(), kcenon::logger::sampling::log_sampler::should_sample(), kcenon::logger::sampling::log_sampler::should_sample(), and kcenon::logger::sampling::log_sampler::update_adaptive_rate().

◆ rate_limit_per_second

std::size_t kcenon::logger::sampling::sampling_config::rate_limit_per_second = 1000

Maximum logs per second for rate limiting strategy.

Used when strategy is rate_limiting

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 162 of file sampling_config.h.

Referenced by kcenon::logger::sampling::log_sampler::rate_limit_sample(), and rate_limited().

◆ rate_limit_window_ms

std::size_t kcenon::logger::sampling::sampling_config::rate_limit_window_ms = 1000

Time window for rate limiting (milliseconds)

The window over which rate limiting is applied

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 168 of file sampling_config.h.

Referenced by kcenon::logger::sampling::log_sampler::rate_limit_sample().

◆ strategy

sampling_strategy kcenon::logger::sampling::sampling_config::strategy = sampling_strategy::random

Sampling strategy to use.

Determines the algorithm for selecting which logs to keep

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/sampling/sampling_config.h.

Definition at line 96 of file sampling_config.h.

Referenced by adaptive(), kcenon::logger::sampling::sampler_factory::create_production(), hash_based(), random_sampling(), rate_limited(), kcenon::logger::sampling::log_sampler::should_sample(), and kcenon::logger::sampling::log_sampler::should_sample().

The documentation for this struct was generated from the following file:

include/kcenon/logger/sampling/sampling_config.h

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ adaptive()

◆ disabled()

◆ hash_based()

◆ random_sampling()

◆ rate_limited()

◆ with_always_log() [1/2]

◆ with_always_log() [2/2]

Member Data Documentation

◆ adaptive_enabled

◆ adaptive_min_rate

◆ adaptive_threshold

◆ always_log_fields

◆ always_log_levels

◆ category_rates

◆ enabled

◆ field_rates

◆ hash_seed

◆ rate

◆ rate_limit_per_second

◆ rate_limit_window_ms

◆ strategy