Thread-safe log sampler with multiple strategy support. More...

#include <log_sampler.h>

Collaboration diagram for kcenon::logger::sampling::log_sampler:

Public Member Functions
	log_sampler (const sampling_config &config=sampling_config{})
	Construct a sampler with the given configuration.

	~log_sampler ()=default
	Destructor.

	log_sampler (const log_sampler &)=delete
	Copy constructor (deleted)

log_sampler &	operator= (const log_sampler &)=delete
	Copy assignment operator (deleted)

	log_sampler (log_sampler &&other) noexcept
	Move constructor.

log_sampler &	operator= (log_sampler &&other) noexcept
	Move assignment operator.

bool	should_sample (const log_entry &entry)
	Check if a log entry should be sampled (logged)

bool	should_sample (log_level level, const std::string &message)
	Check if a log entry should be sampled (without category)

bool	should_sample (log_level level, const std::string &message, const std::optional< std::string > &category)
	Check if a log entry should be sampled with category.

void	set_config (const sampling_config &config)
	Update the sampling configuration.

sampling_config	get_config () const
	Get the current configuration.

sampling_stats	get_stats () const
	Get sampling statistics.

void	reset_stats ()
	Reset sampling statistics.

bool	is_enabled () const
	Check if sampling is enabled.

void	set_enabled (bool enabled)
	Enable or disable sampling.

double	get_effective_rate () const
	Get the current effective sampling rate.

Private Member Functions
bool	should_bypass_level (log_level level) const
	Check if a level should bypass sampling.

bool	should_bypass_field (const log_entry &entry) const
	Check if any field should bypass sampling.

double	get_field_rate (const log_entry &entry) const
	Get the sampling rate based on structured fields.

double	get_category_rate (const std::string &category) const
	Get the sampling rate for a category.

bool	random_sample (double rate)
	Perform random sampling decision.

bool	rate_limit_sample ()
	Perform rate limiting sampling decision.

bool	adaptive_sample ()
	Perform adaptive sampling decision.

bool	hash_sample (const std::string &message, double rate)
	Perform hash-based sampling decision.

void	update_adaptive_rate ()
	Update adaptive sampling rate based on current throughput.

std::uint64_t	xorshift64 ()
	Fast xorshift64 PRNG for random sampling.

Static Private Member Functions
static std::uint64_t	fnv1a_hash (const std::string &str)
	FNV-1a hash for message hashing.

Private Attributes
sampling_config	config_

std::shared_mutex	config_mutex_

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}

std::atomic< std::uint64_t >	rng_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_

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}

Detailed Description

Thread-safe log sampler with multiple strategy support.

The log_sampler class determines whether a log entry should be logged based on the configured sampling strategy. It maintains thread-safe statistics and supports runtime configuration updates.

Key features:

Thread-safe operation for high-concurrency scenarios
Multiple sampling strategies (random, rate limiting, adaptive, hash-based)
Level-based bypass for critical messages
Per-category sampling rates
Real-time statistics tracking

Note: The sampler uses fast PRNG (xorshift64) for random sampling to minimize overhead in the hot path.

Since: 3.3.0

Definition at line 71 of file log_sampler.h.

Constructor & Destructor Documentation

◆ log_sampler() [1/3]

kcenon::logger::sampling::log_sampler::log_sampler ( const sampling_config & config = sampling_config{} )

explicit

Construct a sampler with the given configuration.

Parameters

config Sampling configuration

Definition at line 16 of file log_sampler.cpp.

    : config_(config),
      rng_state_(static_cast<std::uint64_t>(
          std::chrono::steady_clock::now().time_since_epoch().count()) | 1) {
    // Initialize rate limiting window
    auto now = std::chrono::steady_clock::now();
    rate_limit_window_start_.store(now.time_since_epoch().count());
    adaptive_window_start_.store(now.time_since_epoch().count());
    effective_rate_.store(config_.rate);
}

References adaptive_window_start_, config_, effective_rate_, kcenon::logger::sampling::sampling_config::rate, and rate_limit_window_start_.

◆ ~log_sampler()

kcenon::logger::sampling::log_sampler::~log_sampler ( )

default

Destructor.

◆ log_sampler() [2/3]

kcenon::logger::sampling::log_sampler::log_sampler ( const log_sampler & )

delete

Copy constructor (deleted)

Samplers contain atomic state and should not be copied

◆ log_sampler() [3/3]

kcenon::logger::sampling::log_sampler::log_sampler ( log_sampler && other )

noexcept

Move constructor.

Definition at line 27 of file log_sampler.cpp.

    : config_(std::move(other.config_)),
      total_count_(other.total_count_.load()),
      sampled_count_(other.sampled_count_.load()),
      dropped_count_(other.dropped_count_.load()),
      bypassed_count_(other.bypassed_count_.load()),
      rng_state_(other.rng_state_.load()),
      rate_limit_count_(other.rate_limit_count_.load()),
      rate_limit_window_start_(other.rate_limit_window_start_.load()),
      effective_rate_(other.effective_rate_.load()),
      adaptive_window_count_(other.adaptive_window_count_.load()),
      adaptive_window_start_(other.adaptive_window_start_.load()),
      is_throttling_(other.is_throttling_.load()) {
}

Member Function Documentation

◆ adaptive_sample()

bool kcenon::logger::sampling::log_sampler::adaptive_sample ( )

nodiscardprivate

Perform adaptive sampling decision.

Returns: true if the message should be sampled

Definition at line 364 of file log_sampler.cpp.

                                  {
    // Update adaptive rate if needed
    update_adaptive_rate();
 
    // Use effective rate for sampling
    double rate = effective_rate_.load(std::memory_order_relaxed);
    return random_sample(rate);
}

References effective_rate_, random_sample(), and update_adaptive_rate().

Referenced by should_sample(), and should_sample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fnv1a_hash()

std::uint64_t kcenon::logger::sampling::log_sampler::fnv1a_hash ( const std::string & str )

staticnodiscardprivate

FNV-1a hash for message hashing.

Parameters

str	String to hash

Returns: 64-bit hash value

Definition at line 449 of file log_sampler.cpp.

                                                        {
    constexpr std::uint64_t kFnvOffsetBasis = 14695981039346656037ULL;
    constexpr std::uint64_t kFnvPrime = 1099511628211ULL;
 
    std::uint64_t hash = kFnvOffsetBasis;
    for (char c : str) {
        hash ^= static_cast<std::uint64_t>(static_cast<unsigned char>(c));
        hash *= kFnvPrime;
    }
    return hash;
}

Referenced by hash_sample().

Here is the caller graph for this function:

◆ get_category_rate()

double kcenon::logger::sampling::log_sampler::get_category_rate ( const std::string & category ) const

nodiscardprivate

Get the sampling rate for a category.

Parameters

category Category name (empty for default rate)

Returns: Sampling rate for the category

Definition at line 296 of file log_sampler.cpp.

                                                                     {
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    auto it = config_.category_rates.find(category);
    if (it != config_.category_rates.end()) {
        return it->second;
    }
    return config_.rate;
}

References kcenon::logger::sampling::sampling_config::category_rates, config_, config_mutex_, and kcenon::logger::sampling::sampling_config::rate.

Referenced by should_sample(), and should_sample().

Here is the caller graph for this function:

◆ get_config()

sampling_config kcenon::logger::sampling::log_sampler::get_config ( ) const

nodiscard

Get the current configuration.

Returns: Copy of the current configuration

Definition at line 200 of file log_sampler.cpp.

                                              {
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    return config_;
}

References config_, and config_mutex_.

◆ get_effective_rate()

double kcenon::logger::sampling::log_sampler::get_effective_rate ( ) const

nodiscard

Get the current effective sampling rate.

Returns: Current effective rate (may differ from configured rate in adaptive mode)

Definition at line 233 of file log_sampler.cpp.

                                             {
    return effective_rate_.load(std::memory_order_relaxed);
}

References effective_rate_.

◆ get_field_rate()

double kcenon::logger::sampling::log_sampler::get_field_rate ( const log_entry & entry ) const

nodiscardprivate

Get the sampling rate based on structured fields.

Parameters

entry Log entry with fields to check

Returns: Sampling rate for the matching field value, or -1 if no match

Since: 3.4.0

Definition at line 259 of file log_sampler.cpp.

                                                               {
    if (!entry.fields.has_value()) {
        return -1.0;  // No fields, use default rate
    }
 
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    const auto& field_rates = config_.field_rates;
 
    // Check each configured field
    for (const auto& [field_name, value_rates] : field_rates) {
        auto field_it = entry.fields->find(field_name);
        if (field_it == entry.fields->end()) {
            continue;
        }
 
        // Convert field value to string for lookup
        std::string value_str;
        if (std::holds_alternative<std::string>(field_it->second)) {
            value_str = std::get<std::string>(field_it->second);
        } else if (std::holds_alternative<int64_t>(field_it->second)) {
            value_str = std::to_string(std::get<int64_t>(field_it->second));
        } else if (std::holds_alternative<double>(field_it->second)) {
            value_str = std::to_string(std::get<double>(field_it->second));
        } else if (std::holds_alternative<bool>(field_it->second)) {
            value_str = std::get<bool>(field_it->second) ? "true" : "false";
        }
 
        // Look up the rate for this value
        auto rate_it = value_rates.find(value_str);
        if (rate_it != value_rates.end()) {
            return rate_it->second;
        }
    }
 
    return -1.0;  // No matching field/value rate found
}

References config_, config_mutex_, kcenon::logger::sampling::sampling_config::field_rates, and kcenon::logger::log_entry::fields.

Referenced by should_sample().

Here is the caller graph for this function:

◆ get_stats()

sampling_stats kcenon::logger::sampling::log_sampler::get_stats ( ) const

nodiscard

Get sampling statistics.

Returns: Copy of current statistics

Note: Thread-safe. Returns a snapshot of current statistics.

Definition at line 205 of file log_sampler.cpp.

                                            {
    sampling_stats stats;
    stats.total_count = total_count_.load(std::memory_order_relaxed);
    stats.sampled_count = sampled_count_.load(std::memory_order_relaxed);
    stats.dropped_count = dropped_count_.load(std::memory_order_relaxed);
    stats.bypassed_count = bypassed_count_.load(std::memory_order_relaxed);
    stats.effective_rate = effective_rate_.load(std::memory_order_relaxed);
    stats.is_throttling = is_throttling_.load(std::memory_order_relaxed);
    return stats;
}

References kcenon::logger::sampling::sampling_stats::bypassed_count, bypassed_count_, kcenon::logger::sampling::sampling_stats::dropped_count, dropped_count_, kcenon::logger::sampling::sampling_stats::effective_rate, effective_rate_, kcenon::logger::sampling::sampling_stats::is_throttling, is_throttling_, kcenon::logger::sampling::sampling_stats::sampled_count, sampled_count_, kcenon::logger::sampling::sampling_stats::total_count, and total_count_.

◆ hash_sample()

bool kcenon::logger::sampling::log_sampler::hash_sample	(	const std::string &	message,
		double	rate )

nodiscardprivate

Perform hash-based sampling decision.

Parameters

message	Message to hash
rate	Sampling rate to use

Returns: true if the message should be sampled

Definition at line 416 of file log_sampler.cpp.

                                                                   {
    if (rate >= 1.0) {
        return true;
    }
    if (rate <= 0.0) {
        return false;
    }
 
    std::uint64_t seed = 0;
    {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        seed = config_.hash_seed;
    }
 
    // Compute hash of message
    std::uint64_t hash = fnv1a_hash(message);
    hash ^= seed;
 
    // Normalize hash to [0, 1) and compare with rate
    double normalized = static_cast<double>(hash) /
                        static_cast<double>(std::numeric_limits<std::uint64_t>::max());
    return normalized < rate;
}

References config_, config_mutex_, fnv1a_hash(), and kcenon::logger::sampling::sampling_config::hash_seed.

Referenced by should_sample(), and should_sample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_enabled()

bool kcenon::logger::sampling::log_sampler::is_enabled ( ) const

nodiscard

Check if sampling is enabled.

Returns: true if sampling is currently enabled

Definition at line 223 of file log_sampler.cpp.

                                   {
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    return config_.enabled;
}

References config_, config_mutex_, and kcenon::logger::sampling::sampling_config::enabled.

◆ operator=() [1/2]

log_sampler & kcenon::logger::sampling::log_sampler::operator= ( const log_sampler & )

delete

Copy assignment operator (deleted)

◆ operator=() [2/2]

log_sampler & kcenon::logger::sampling::log_sampler::operator= ( log_sampler && other )

noexcept

Move assignment operator.

Definition at line 42 of file log_sampler.cpp.

                                                                {
    if (this != &other) {
        std::unique_lock<std::shared_mutex> lock(config_mutex_);
        config_ = std::move(other.config_);
        total_count_.store(other.total_count_.load());
        sampled_count_.store(other.sampled_count_.load());
        dropped_count_.store(other.dropped_count_.load());
        bypassed_count_.store(other.bypassed_count_.load());
        rng_state_.store(other.rng_state_.load());
        rate_limit_count_.store(other.rate_limit_count_.load());
        rate_limit_window_start_.store(other.rate_limit_window_start_.load());
        effective_rate_.store(other.effective_rate_.load());
        adaptive_window_count_.store(other.adaptive_window_count_.load());
        adaptive_window_start_.store(other.adaptive_window_start_.load());
        is_throttling_.store(other.is_throttling_.load());
    }
    return *this;
}

◆ random_sample()

bool kcenon::logger::sampling::log_sampler::random_sample ( double rate )

nodiscardprivate

Perform random sampling decision.

Parameters

rate	Sampling rate to use

Returns: true if the message should be sampled (logged)

Definition at line 305 of file log_sampler.cpp.

                                           {
    if (rate >= 1.0) {
        return true;
    }
    if (rate <= 0.0) {
        return false;
    }
 
    // Generate random number and compare with threshold
    std::uint64_t random = xorshift64();
    double normalized = static_cast<double>(random) /
                        static_cast<double>(std::numeric_limits<std::uint64_t>::max());
    return normalized < rate;
}

References kcenon::logger::sampling::random, and xorshift64().

Referenced by adaptive_sample(), should_sample(), and should_sample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rate_limit_sample()

bool kcenon::logger::sampling::log_sampler::rate_limit_sample ( )

nodiscardprivate

Perform rate limiting sampling decision.

Returns: true if the message is within rate limits

Definition at line 320 of file log_sampler.cpp.

                                    {
    auto now = std::chrono::steady_clock::now();
    auto now_count = now.time_since_epoch().count();
 
    std::size_t limit_per_second = 0;
    std::size_t window_ms = 0;
    {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        limit_per_second = config_.rate_limit_per_second;
        window_ms = config_.rate_limit_window_ms;
    }
 
    // Calculate max messages per window
    std::size_t max_per_window = (limit_per_second * window_ms) / 1000;
    if (max_per_window == 0) {
        max_per_window = 1;
    }
 
    // Check if we need to reset the window
    auto window_start = std::chrono::steady_clock::time_point(
        std::chrono::steady_clock::duration(rate_limit_window_start_.load()));
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now - window_start).count();
 
    if (static_cast<std::size_t>(elapsed_ms) >= window_ms) {
        // Reset window
        std::lock_guard<std::mutex> lock(rate_limit_mutex_);
        // Double-check after acquiring lock
        window_start = std::chrono::steady_clock::time_point(
            std::chrono::steady_clock::duration(rate_limit_window_start_.load()));
        elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            now - window_start).count();
 
        if (static_cast<std::size_t>(elapsed_ms) >= window_ms) {
            rate_limit_window_start_.store(now_count);
            rate_limit_count_.store(0);
        }
    }
 
    // Check if within limit
    std::uint64_t current = rate_limit_count_.fetch_add(1, std::memory_order_relaxed);
    return current < max_per_window;
}

References config_, config_mutex_, rate_limit_count_, rate_limit_mutex_, kcenon::logger::sampling::sampling_config::rate_limit_per_second, kcenon::logger::sampling::sampling_config::rate_limit_window_ms, and rate_limit_window_start_.

Referenced by should_sample(), and should_sample().

Here is the caller graph for this function:

◆ reset_stats()

void kcenon::logger::sampling::log_sampler::reset_stats ( )

Reset sampling statistics.

Note: Thread-safe. Does not affect the configuration.

Definition at line 216 of file log_sampler.cpp.

                              {
    total_count_.store(0, std::memory_order_relaxed);
    sampled_count_.store(0, std::memory_order_relaxed);
    dropped_count_.store(0, std::memory_order_relaxed);
    bypassed_count_.store(0, std::memory_order_relaxed);
}

References bypassed_count_, dropped_count_, sampled_count_, and total_count_.

◆ set_config()

void kcenon::logger::sampling::log_sampler::set_config ( const sampling_config & config )

Update the sampling configuration.

Parameters

config New configuration to apply

Note: Thread-safe. Takes effect for subsequent sampling decisions.

Definition at line 194 of file log_sampler.cpp.

                                                          {
    std::unique_lock<std::shared_mutex> lock(config_mutex_);
    config_ = config;
    effective_rate_.store(config.rate);
}

References config_, config_mutex_, effective_rate_, and kcenon::logger::sampling::sampling_config::rate.

◆ set_enabled()

void kcenon::logger::sampling::log_sampler::set_enabled ( bool enabled )

Enable or disable sampling.

Parameters

enabled true to enable, false to disable

Definition at line 228 of file log_sampler.cpp.

                                          {
    std::unique_lock<std::shared_mutex> lock(config_mutex_);
    config_.enabled = enabled;
}

References config_, config_mutex_, and kcenon::logger::sampling::sampling_config::enabled.

◆ should_bypass_field()

bool kcenon::logger::sampling::log_sampler::should_bypass_field ( const log_entry & entry ) const

nodiscardprivate

Check if any field should bypass sampling.

Parameters

entry Log entry to check

Returns: true if any configured bypass field is present

Since: 3.4.0

Definition at line 243 of file log_sampler.cpp.

                                                                  {
    if (!entry.fields.has_value()) {
        return false;
    }
 
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    const auto& bypass_fields = config_.always_log_fields;
 
    for (const auto& field_name : bypass_fields) {
        if (entry.fields->find(field_name) != entry.fields->end()) {
            return true;  // Found a bypass field
        }
    }
    return false;
}

References kcenon::logger::sampling::sampling_config::always_log_fields, config_, config_mutex_, and kcenon::logger::log_entry::fields.

Referenced by should_sample().

Here is the caller graph for this function:

◆ should_bypass_level()

bool kcenon::logger::sampling::log_sampler::should_bypass_level ( log_level level ) const

nodiscardprivate

Check if a level should bypass sampling.

Parameters

level Log level to check

Returns: true if the level should always be logged

Definition at line 237 of file log_sampler.cpp.

                                                           {
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    const auto& levels = config_.always_log_levels;
    return std::find(levels.begin(), levels.end(), level) != levels.end();
}

References kcenon::logger::sampling::sampling_config::always_log_levels, config_, and config_mutex_.

Referenced by should_sample(), and should_sample().

Here is the caller graph for this function:

◆ should_sample() [1/3]

bool kcenon::logger::sampling::log_sampler::should_sample ( const log_entry & entry )

nodiscard

Check if a log entry should be sampled (logged)

Parameters

entry The log entry to check

Returns: true if the entry should be logged, false if it should be dropped

This is the main entry point for sampling decisions. It considers:

Whether sampling is enabled
Whether the log level bypasses sampling
Category-specific sampling rates
The configured sampling strategy

Note: Thread-safe. Can be called from multiple threads concurrently.

Definition at line 61 of file log_sampler.cpp.

                                                      {
    // Increment total count
    total_count_.fetch_add(1, std::memory_order_relaxed);
 
    // Check if sampling is enabled
    bool enabled = false;
    sampling_strategy strategy = sampling_strategy::random;
    double rate = 1.0;
    {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        enabled = config_.enabled;
        strategy = config_.strategy;
        rate = config_.rate;
    }
 
    if (!enabled) {
        sampled_count_.fetch_add(1, std::memory_order_relaxed);
        return true;  // Pass through when disabled
    }
 
    // Check if level bypasses sampling
    if (should_bypass_level(entry.level)) {
        bypassed_count_.fetch_add(1, std::memory_order_relaxed);
        return true;
    }
 
    // Check if any field bypasses sampling (Phase 3.4)
    if (should_bypass_field(entry)) {
        bypassed_count_.fetch_add(1, std::memory_order_relaxed);
        return true;
    }
 
    // Try to get field-specific rate first (Phase 3.4)
    double effective = get_field_rate(entry);
    if (effective < 0) {
        // No field-specific rate found, try category
        effective = rate;
        if (entry.category.has_value()) {
            effective = get_category_rate(entry.category->to_string());
        }
    }
 
    // Apply the configured strategy
    bool sampled = false;
    switch (strategy) {
        case sampling_strategy::random:
            sampled = random_sample(effective);
            break;
        case sampling_strategy::rate_limiting:
            sampled = rate_limit_sample();
            break;
        case sampling_strategy::adaptive:
            sampled = adaptive_sample();
            break;
        case sampling_strategy::hash_based:
            sampled = hash_sample(entry.message.to_string(), effective);
            break;
    }
 
    if (sampled) {
        sampled_count_.fetch_add(1, std::memory_order_relaxed);
    } else {
        dropped_count_.fetch_add(1, std::memory_order_relaxed);
    }
 
    return sampled;
}

References kcenon::logger::sampling::adaptive, adaptive_sample(), bypassed_count_, kcenon::logger::log_entry::category, config_, config_mutex_, dropped_count_, kcenon::logger::sampling::sampling_config::enabled, get_category_rate(), get_field_rate(), kcenon::logger::sampling::hash_based, hash_sample(), kcenon::logger::log_entry::level, kcenon::logger::log_entry::message, kcenon::logger::sampling::random, random_sample(), kcenon::logger::sampling::sampling_config::rate, rate_limit_sample(), kcenon::logger::sampling::rate_limiting, sampled_count_, should_bypass_field(), should_bypass_level(), kcenon::logger::sampling::sampling_config::strategy, kcenon::logger::small_string< SSO_SIZE >::to_string(), and total_count_.

Referenced by should_sample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ should_sample() [2/3]

bool kcenon::logger::sampling::log_sampler::should_sample	(	log_level	level,
		const std::string &	message )

nodiscard

Check if a log entry should be sampled (without category)

Parameters

level	Log level
message	Log message (used for hash-based sampling)

Returns: true if the entry should be logged

Definition at line 129 of file log_sampler.cpp.

                                                          {
    return should_sample(level, message, std::nullopt);
}

References should_sample().

Here is the call graph for this function:

◆ should_sample() [3/3]

bool kcenon::logger::sampling::log_sampler::should_sample	(	log_level	level,
		const std::string &	message,
		const std::optional< std::string > &	category )

nodiscard

Check if a log entry should be sampled with category.

Parameters

level	Log level
message	Log message
category	Optional category for category-specific rates

Returns: true if the entry should be logged

Definition at line 134 of file log_sampler.cpp.

                                                                        {
    // Increment total count
    total_count_.fetch_add(1, std::memory_order_relaxed);
 
    // Check if sampling is enabled
    bool enabled = false;
    sampling_strategy strategy = sampling_strategy::random;
    double rate = 1.0;
    {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        enabled = config_.enabled;
        strategy = config_.strategy;
        rate = config_.rate;
    }
 
    if (!enabled) {
        sampled_count_.fetch_add(1, std::memory_order_relaxed);
        return true;  // Pass through when disabled
    }
 
    // Check if level bypasses sampling
    if (should_bypass_level(level)) {
        bypassed_count_.fetch_add(1, std::memory_order_relaxed);
        return true;
    }
 
    // Get category-specific rate if applicable
    double effective = rate;
    if (category.has_value()) {
        effective = get_category_rate(category.value());
    }
 
    // Apply the configured strategy
    bool sampled = false;
    switch (strategy) {
        case sampling_strategy::random:
            sampled = random_sample(effective);
            break;
        case sampling_strategy::rate_limiting:
            sampled = rate_limit_sample();
            break;
        case sampling_strategy::adaptive:
            sampled = adaptive_sample();
            break;
        case sampling_strategy::hash_based:
            sampled = hash_sample(message, effective);
            break;
    }
 
    if (sampled) {
        sampled_count_.fetch_add(1, std::memory_order_relaxed);
    } else {
        dropped_count_.fetch_add(1, std::memory_order_relaxed);
    }
 
    return sampled;
}

References kcenon::logger::sampling::adaptive, adaptive_sample(), bypassed_count_, config_, config_mutex_, dropped_count_, kcenon::logger::sampling::sampling_config::enabled, get_category_rate(), kcenon::logger::sampling::hash_based, hash_sample(), kcenon::logger::sampling::random, random_sample(), kcenon::logger::sampling::sampling_config::rate, rate_limit_sample(), kcenon::logger::sampling::rate_limiting, sampled_count_, should_bypass_level(), kcenon::logger::sampling::sampling_config::strategy, and total_count_.

Here is the call graph for this function:

◆ update_adaptive_rate()

void kcenon::logger::sampling::log_sampler::update_adaptive_rate ( )

private

Update adaptive sampling rate based on current throughput.

Definition at line 373 of file log_sampler.cpp.

                                       {
    auto now = std::chrono::steady_clock::now();
    auto now_count = now.time_since_epoch().count();
 
    std::size_t threshold = 0;
    double min_rate = 0.01;
    double base_rate = 1.0;
    {
        std::shared_lock<std::shared_mutex> lock(config_mutex_);
        threshold = config_.adaptive_threshold;
        min_rate = config_.adaptive_min_rate;
        base_rate = config_.rate;
    }
 
    // Increment window count
    adaptive_window_count_.fetch_add(1, std::memory_order_relaxed);
 
    // Check if we need to recalculate rate (every second)
    auto window_start = std::chrono::steady_clock::time_point(
        std::chrono::steady_clock::duration(adaptive_window_start_.load()));
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now - window_start).count();
 
    if (elapsed_ms >= 1000) {
        // Calculate messages per second
        std::uint64_t count = adaptive_window_count_.exchange(0);
        adaptive_window_start_.store(now_count);
 
        if (count > threshold) {
            // Calculate new rate based on how much we're over threshold
            double ratio = static_cast<double>(threshold) / static_cast<double>(count);
            double new_rate = base_rate * ratio;
            new_rate = std::max(new_rate, min_rate);
            effective_rate_.store(new_rate);
            is_throttling_.store(true);
        } else {
            // Reset to base rate
            effective_rate_.store(base_rate);
            is_throttling_.store(false);
        }
    }
}

References kcenon::logger::sampling::sampling_config::adaptive_min_rate, kcenon::logger::sampling::sampling_config::adaptive_threshold, adaptive_window_count_, adaptive_window_start_, config_, config_mutex_, effective_rate_, is_throttling_, and kcenon::logger::sampling::sampling_config::rate.

Referenced by adaptive_sample().

Here is the caller graph for this function:

◆ xorshift64()

std::uint64_t kcenon::logger::sampling::log_sampler::xorshift64 ( )

nodiscardprivate

Fast xorshift64 PRNG for random sampling.

Returns: Random number in range [0, UINT64_MAX]

Definition at line 440 of file log_sampler.cpp.

                                    {
    std::uint64_t x = rng_state_.load(std::memory_order_relaxed);
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    rng_state_.store(x, std::memory_order_relaxed);
    return x;
}

References rng_state_.

Referenced by random_sample().

Here is the caller graph for this function:

Member Data Documentation

◆ adaptive_window_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::adaptive_window_count_ {0}

private

Definition at line 283 of file log_sampler.h.

283{0};

Referenced by update_adaptive_rate().

◆ adaptive_window_start_

std::atomic<std::chrono::steady_clock::time_point::rep> kcenon::logger::sampling::log_sampler::adaptive_window_start_ {0}

private

Definition at line 284 of file log_sampler.h.

284{0};

Referenced by log_sampler(), and update_adaptive_rate().

◆ bypassed_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::bypassed_count_ {0}

private

Definition at line 271 of file log_sampler.h.

271{0};

Referenced by get_stats(), reset_stats(), should_sample(), and should_sample().

◆ config_

sampling_config kcenon::logger::sampling::log_sampler::config_

private

Definition at line 264 of file log_sampler.h.

Referenced by get_category_rate(), get_config(), get_field_rate(), hash_sample(), is_enabled(), log_sampler(), rate_limit_sample(), set_config(), set_enabled(), should_bypass_field(), should_bypass_level(), should_sample(), should_sample(), and update_adaptive_rate().

◆ config_mutex_

std::shared_mutex kcenon::logger::sampling::log_sampler::config_mutex_

mutableprivate

Definition at line 265 of file log_sampler.h.

Referenced by get_category_rate(), get_config(), get_field_rate(), hash_sample(), is_enabled(), rate_limit_sample(), set_config(), set_enabled(), should_bypass_field(), should_bypass_level(), should_sample(), should_sample(), and update_adaptive_rate().

◆ dropped_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::dropped_count_ {0}

private

Definition at line 270 of file log_sampler.h.

270{0};

Referenced by get_stats(), reset_stats(), should_sample(), and should_sample().

◆ effective_rate_

std::atomic<double> kcenon::logger::sampling::log_sampler::effective_rate_ {1.0}

private

Definition at line 282 of file log_sampler.h.

282{1.0};

Referenced by adaptive_sample(), get_effective_rate(), get_stats(), log_sampler(), set_config(), and update_adaptive_rate().

◆ is_throttling_

std::atomic<bool> kcenon::logger::sampling::log_sampler::is_throttling_ {false}

private

Definition at line 285 of file log_sampler.h.

285{false};

Referenced by get_stats(), and update_adaptive_rate().

◆ rate_limit_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::rate_limit_count_ {0}

private

Definition at line 277 of file log_sampler.h.

277{0};

Referenced by rate_limit_sample().

◆ rate_limit_mutex_

std::mutex kcenon::logger::sampling::log_sampler::rate_limit_mutex_

private

Definition at line 279 of file log_sampler.h.

Referenced by rate_limit_sample().

◆ rate_limit_window_start_

std::atomic<std::chrono::steady_clock::time_point::rep> kcenon::logger::sampling::log_sampler::rate_limit_window_start_ {0}

private

Definition at line 278 of file log_sampler.h.

278{0};

Referenced by log_sampler(), and rate_limit_sample().

◆ rng_state_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::rng_state_

private

Definition at line 274 of file log_sampler.h.

Referenced by xorshift64().

◆ sampled_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::sampled_count_ {0}

private

Definition at line 269 of file log_sampler.h.

269{0};

Referenced by get_stats(), reset_stats(), should_sample(), and should_sample().

◆ total_count_

std::atomic<std::uint64_t> kcenon::logger::sampling::log_sampler::total_count_ {0}

private

Definition at line 268 of file log_sampler.h.

268{0};

Referenced by get_stats(), reset_stats(), should_sample(), and should_sample().

The documentation for this class was generated from the following files:

include/kcenon/logger/sampling/log_sampler.h
src/sampling/log_sampler.cpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ log_sampler() [1/3]

◆ ~log_sampler()

◆ log_sampler() [2/3]

◆ log_sampler() [3/3]

Member Function Documentation

◆ adaptive_sample()

◆ fnv1a_hash()

◆ get_category_rate()

◆ get_config()

◆ get_effective_rate()

◆ get_field_rate()

◆ get_stats()

◆ hash_sample()

◆ is_enabled()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ random_sample()

◆ rate_limit_sample()

◆ reset_stats()

◆ set_config()

◆ set_enabled()

◆ should_bypass_field()

◆ should_bypass_level()

◆ should_sample() [1/3]

◆ should_sample() [2/3]

◆ should_sample() [3/3]

◆ update_adaptive_rate()

◆ xorshift64()

Member Data Documentation

◆ adaptive_window_count_

◆ adaptive_window_start_

◆ bypassed_count_

◆ config_

◆ config_mutex_

◆ dropped_count_

◆ effective_rate_

◆ is_throttling_

◆ rate_limit_count_

◆ rate_limit_mutex_

◆ rate_limit_window_start_

◆ rng_state_

◆ sampled_count_

◆ total_count_