Adaptive collector wrapper. More...

#include <adaptive_monitor.h>

Collaboration diagram for kcenon::monitoring::adaptive_collector:

Public Member Functions
	adaptive_collector (std::shared_ptr< kcenon::monitoring::metrics_collector > collector, const adaptive_config &config={})

common::Result< kcenon::monitoring::metrics_snapshot >	collect ()
	Collect metrics with adaptive sampling.

void	adapt (const kcenon::monitoring::system_metrics &sys_metrics)
	Adapt collection behavior based on load.

adaptation_stats	get_stats () const
	Get current adaptation statistics.

std::chrono::milliseconds	get_current_interval () const
	Get current collection interval.

void	set_config (const adaptive_config &config)
	Set adaptive configuration.

adaptive_config	get_config () const
	Get adaptive configuration.

void	set_enabled (bool enabled)
	Enable or disable adaptive behavior.

bool	is_enabled () const
	Check if adaptive behavior is enabled.

Private Member Functions
bool	should_sample () const
	Determine if current sample should be collected.

Static Private Member Functions
static load_level	calculate_load_level_with_config (double cpu_usage, double memory_usage, const adaptive_config &cfg)
	Calculate load level from metrics with provided config.

static load_level	calculate_load_level_with_hysteresis (double cpu_usage, double memory_usage, load_level current_level, const adaptive_config &cfg)
	Calculate load level with hysteresis support (ARC-005)

static double	get_threshold_for_level (load_level level, const adaptive_config &cfg)
	Get the threshold value for a given load level.

Private Attributes
std::shared_ptr< kcenon::monitoring::metrics_collector >	collector_

adaptive_config	config_

std::mutex	config_mutex_

adaptation_stats	stats_

std::atomic< bool >	enabled_ {true}

std::atomic< double >	current_sampling_rate_ {1.0}

std::mutex	stats_mutex_

Detailed Description

Adaptive collector wrapper.

Thread Safety:

Thread-safe. All public methods can be called concurrently.

config_ protected by config_mutex_
stats_ protected by stats_mutex_
Uses std::atomic for enabled_ and current_sampling_rate_
Avoids deadlock by copying config before acquiring stats_mutex_

Definition at line 156 of file adaptive_monitor.h.

Constructor & Destructor Documentation

◆ adaptive_collector()

kcenon::monitoring::adaptive_collector::adaptive_collector	(	std::shared_ptr< kcenon::monitoring::metrics_collector >	collector,
		const adaptive_config &	config = {} )

inline

Definition at line 167 of file adaptive_monitor.h.

                                        {}
    ) : collector_(collector), config_(config) {
        stats_.current_interval = config_.moderate_interval;
        stats_.last_adaptation = std::chrono::system_clock::now();
    }

Member Function Documentation

◆ adapt()

void kcenon::monitoring::adaptive_collector::adapt ( const kcenon::monitoring::system_metrics & sys_metrics )

inline

Adapt collection behavior based on load.

Thread Safety:: Thread-safe. Uses mutex for synchronization.

Definition at line 192 of file adaptive_monitor.h.

                                                                  {
        // Copy config under lock to avoid holding both locks
        adaptive_config local_config;
        {
            std::lock_guard<std::mutex> config_lock(config_mutex_);
            local_config = config_;
        }
 
        std::lock_guard<std::mutex> lock(stats_mutex_);
 
        bool is_first_adaptation = (stats_.total_adaptations == 0);
 
        // Initialize averages on first adaptation
        if (is_first_adaptation) {
            stats_.average_cpu_usage = sys_metrics.cpu_usage_percent;
            stats_.average_memory_usage = sys_metrics.memory_usage_percent;
        } else {
            // Update average metrics using exponential smoothing
            stats_.average_cpu_usage =
                local_config.smoothing_factor * sys_metrics.cpu_usage_percent +
                (1.0 - local_config.smoothing_factor) * stats_.average_cpu_usage;
 
            stats_.average_memory_usage =
                local_config.smoothing_factor * sys_metrics.memory_usage_percent +
                (1.0 - local_config.smoothing_factor) * stats_.average_memory_usage;
        }
 
        // Determine load level with hysteresis support
        auto new_level = calculate_load_level_with_hysteresis(
            stats_.average_cpu_usage,
            stats_.average_memory_usage,
            stats_.current_load_level,
            local_config
        );
 
        // Adapt if load level changed
        if (new_level != stats_.current_load_level) {
            auto now = std::chrono::system_clock::now();
 
            // Check cooldown period (ARC-005)
            // Skip cooldown check for first adaptation to allow initial level setting
            if (local_config.enable_cooldown && !is_first_adaptation) {
                auto time_since_last_change = std::chrono::duration_cast<std::chrono::milliseconds>(
                    now - stats_.last_level_change
                );
                if (time_since_last_change < local_config.cooldown_period) {
                    stats_.cooldown_prevented_changes++;
                    return;  // Skip this adaptation due to cooldown
                }
            }
 
            if (new_level > stats_.current_load_level) {
                stats_.downscale_count++;
            } else {
                stats_.upscale_count++;
            }
 
            stats_.current_load_level = new_level;
            stats_.current_interval = local_config.get_interval_for_load(new_level);
            current_sampling_rate_ = local_config.get_sampling_rate_for_load(new_level);
            stats_.current_sampling_rate = current_sampling_rate_;
            stats_.total_adaptations++;
            stats_.last_adaptation = now;
            stats_.last_level_change = now;
        }
    }

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_load_level_with_config()

static load_level kcenon::monitoring::adaptive_collector::calculate_load_level_with_config	(	double	cpu_usage,
		double	memory_usage,
		const adaptive_config &	cfg )

inlinestaticprivate

Calculate load level from metrics with provided config.

Note: Thread-safe as it only uses the provided config copy

Definition at line 324 of file adaptive_monitor.h.

      {
        // Consider memory pressure in load calculation
        double effective_load = cpu_usage;
 
        // Memory pressure should escalate load level
        if (memory_usage > cfg.memory_critical_threshold) {
            // Critical memory -> at least high load
            effective_load = std::max(effective_load, cfg.high_threshold + 1.0);
        } else if (memory_usage > cfg.memory_warning_threshold) {
            // Warning memory -> at least moderate load
            effective_load = std::max(effective_load, cfg.moderate_threshold + 1.0);
        }
 
        // Apply strategy-specific adjustments BEFORE determining level
        switch (cfg.strategy) {
            case adaptation_strategy::conservative:
                effective_load *= 0.8;  // Be more conservative
                break;
            case adaptation_strategy::aggressive:
                effective_load *= 1.2;  // Be more aggressive
                break;
            case adaptation_strategy::balanced:
            default:
                break;
        }
 
        // Determine load level
        if (effective_load >= cfg.high_threshold) {
            return load_level::critical;
        } else if (effective_load >= cfg.moderate_threshold) {
            return load_level::high;
        } else if (effective_load >= cfg.low_threshold) {
            return load_level::moderate;
        } else if (effective_load >= cfg.idle_threshold) {
            return load_level::low;
        } else {
            return load_level::idle;
        }
    }

Referenced by calculate_load_level_with_hysteresis().

Here is the caller graph for this function:

◆ calculate_load_level_with_hysteresis()

static load_level kcenon::monitoring::adaptive_collector::calculate_load_level_with_hysteresis	(	double	cpu_usage,
		double	memory_usage,
		load_level	current_level,
		const adaptive_config &	cfg )

inlinestaticprivate

Calculate load level with hysteresis support (ARC-005)

Hysteresis prevents oscillation at threshold boundaries by requiring the metric to cross a margin before changing levels.

Parameters

cpu_usage	Current CPU usage percentage
memory_usage	Current memory usage percentage
current_level	Current load level
cfg	Adaptive configuration

Returns: New load level (may be same as current if within hysteresis margin)

Definition at line 380 of file adaptive_monitor.h.

      {
        // First calculate what the level would be without hysteresis
        load_level raw_level = calculate_load_level_with_config(cpu_usage, memory_usage, cfg);
 
        // If hysteresis is disabled, return raw level
        if (!cfg.enable_hysteresis) {
            return raw_level;
        }
 
        // If no change, return current level
        if (raw_level == current_level) {
            return current_level;
        }
 
        // Calculate effective load (same logic as calculate_load_level_with_config)
        double effective_load = cpu_usage;
        if (memory_usage > cfg.memory_critical_threshold) {
            effective_load = std::max(effective_load, cfg.high_threshold + 1.0);
        } else if (memory_usage > cfg.memory_warning_threshold) {
            effective_load = std::max(effective_load, cfg.moderate_threshold + 1.0);
        }
 
        switch (cfg.strategy) {
            case adaptation_strategy::conservative:
                effective_load *= 0.8;
                break;
            case adaptation_strategy::aggressive:
                effective_load *= 1.2;
                break;
            case adaptation_strategy::balanced:
            default:
                break;
        }
 
        // Get threshold for current level
        double current_threshold = get_threshold_for_level(current_level, cfg);
        double margin = cfg.hysteresis_margin;
 
        // For upward transitions (higher load), require crossing threshold + margin
        // For downward transitions (lower load), require crossing threshold - margin
        if (raw_level > current_level) {
            // Moving to higher load level - need to exceed threshold by margin
            double next_threshold = get_threshold_for_level(
                static_cast<load_level>(static_cast<int>(current_level) + 1), cfg);
            if (effective_load < next_threshold + margin) {
                return current_level;  // Stay at current level (hysteresis)
            }
        } else {
            // Moving to lower load level - need to drop below threshold by margin
            if (effective_load > current_threshold - margin) {
                return current_level;  // Stay at current level (hysteresis)
            }
        }
 
        return raw_level;
    }

Referenced by adapt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect()

common::Result< kcenon::monitoring::metrics_snapshot > kcenon::monitoring::adaptive_collector::collect ( )

inline

Collect metrics with adaptive sampling.

Definition at line 178 of file adaptive_monitor.h.

                                                             {
        if (!should_sample()) {
            stats_.samples_dropped++;
            return common::Result<kcenon::monitoring::metrics_snapshot>::err(error_info(kcenon::monitoring::monitoring_error_code::operation_cancelled, "Sample dropped due to adaptive sampling").to_common_error());
        }
 
        stats_.samples_collected++;
        return collector_->collect();
    }

References kcenon::monitoring::metrics_collector::collect(), collector_, kcenon::monitoring::operation_cancelled, kcenon::monitoring::adaptation_stats::samples_collected, kcenon::monitoring::adaptation_stats::samples_dropped, should_sample(), and stats_.

Referenced by TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_config()

adaptive_config kcenon::monitoring::adaptive_collector::get_config ( ) const

inline

Get adaptive configuration.

Thread Safety:: Thread-safe. Uses mutex for synchronization.

Definition at line 288 of file adaptive_monitor.h.

                                       {
        std::lock_guard<std::mutex> lock(config_mutex_);
        return config_;
    }

References config_, and config_mutex_.

◆ get_current_interval()

std::chrono::milliseconds kcenon::monitoring::adaptive_collector::get_current_interval ( ) const

inline

Get current collection interval.

Definition at line 270 of file adaptive_monitor.h.

                                                       {
        std::lock_guard lock(stats_mutex_);
        return stats_.current_interval;
    }

References kcenon::monitoring::adaptation_stats::current_interval, stats_, and stats_mutex_.

◆ get_stats()

adaptation_stats kcenon::monitoring::adaptive_collector::get_stats ( ) const

inline

Get current adaptation statistics.

Definition at line 262 of file adaptive_monitor.h.

                                       {
        std::lock_guard lock(stats_mutex_);
        return stats_;
    }

References stats_, and stats_mutex_.

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ get_threshold_for_level()

static double kcenon::monitoring::adaptive_collector::get_threshold_for_level	(	load_level	level,
		const adaptive_config &	cfg )

inlinestaticprivate

Get the threshold value for a given load level.

Definition at line 445 of file adaptive_monitor.h.

                                                                                        {
        switch (level) {
            case load_level::idle: return 0.0;
            case load_level::low: return cfg.idle_threshold;
            case load_level::moderate: return cfg.low_threshold;
            case load_level::high: return cfg.moderate_threshold;
            case load_level::critical: return cfg.high_threshold;
        }
        return cfg.moderate_threshold;
    }

References kcenon::monitoring::critical, kcenon::monitoring::high, kcenon::monitoring::adaptive_config::high_threshold, kcenon::monitoring::idle, kcenon::monitoring::adaptive_config::idle_threshold, kcenon::monitoring::low, kcenon::monitoring::adaptive_config::low_threshold, kcenon::monitoring::moderate, and kcenon::monitoring::adaptive_config::moderate_threshold.

Referenced by calculate_load_level_with_hysteresis().

Here is the caller graph for this function:

◆ is_enabled()

bool kcenon::monitoring::adaptive_collector::is_enabled ( ) const

inline

Check if adaptive behavior is enabled.

Definition at line 303 of file adaptive_monitor.h.

                            {
        return enabled_;
    }

References enabled_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ set_config()

void kcenon::monitoring::adaptive_collector::set_config ( const adaptive_config & config )

inline

Set adaptive configuration.

Thread Safety:: Thread-safe. Uses mutex for synchronization.

Definition at line 279 of file adaptive_monitor.h.

                                                   {
        std::lock_guard<std::mutex> lock(config_mutex_);
        config_ = config;
    }

References config_, and config_mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ set_enabled()

void kcenon::monitoring::adaptive_collector::set_enabled ( bool enabled )

inline

Enable or disable adaptive behavior.

Definition at line 296 of file adaptive_monitor.h.

                                   {
        enabled_ = enabled;
    }

References enabled_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ should_sample()

bool kcenon::monitoring::adaptive_collector::should_sample ( ) const

inlineprivate

Determine if current sample should be collected.

Definition at line 311 of file adaptive_monitor.h.

                               {
        if (!enabled_) return true;
 
        // Use random sampling based on current rate
        static thread_local std::mt19937 gen(std::random_device{}());
        std::uniform_real_distribution<> dis(0.0, 1.0);
        return dis(gen) < current_sampling_rate_.load();
    }

References current_sampling_rate_, and enabled_.

Referenced by collect().

Here is the caller graph for this function:

Member Data Documentation

◆ collector_

std::shared_ptr<kcenon::monitoring::metrics_collector> kcenon::monitoring::adaptive_collector::collector_

private

Definition at line 158 of file adaptive_monitor.h.

Referenced by collect().

◆ config_

adaptive_config kcenon::monitoring::adaptive_collector::config_

private

Definition at line 159 of file adaptive_monitor.h.

Referenced by adapt(), get_config(), and set_config().

◆ config_mutex_

std::mutex kcenon::monitoring::adaptive_collector::config_mutex_

mutableprivate

Definition at line 160 of file adaptive_monitor.h.

Referenced by adapt(), get_config(), and set_config().

◆ current_sampling_rate_

std::atomic<double> kcenon::monitoring::adaptive_collector::current_sampling_rate_ {1.0}

private

Definition at line 163 of file adaptive_monitor.h.

163{1.0};

Referenced by adapt(), and should_sample().

◆ enabled_

std::atomic<bool> kcenon::monitoring::adaptive_collector::enabled_ {true}

private

Definition at line 162 of file adaptive_monitor.h.

162{true};

Referenced by is_enabled(), set_enabled(), and should_sample().

◆ stats_

adaptation_stats kcenon::monitoring::adaptive_collector::stats_

private

Definition at line 161 of file adaptive_monitor.h.

Referenced by adapt(), collect(), get_current_interval(), and get_stats().

◆ stats_mutex_

std::mutex kcenon::monitoring::adaptive_collector::stats_mutex_

mutableprivate

Definition at line 164 of file adaptive_monitor.h.

Referenced by adapt(), get_current_interval(), and get_stats().

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

include/kcenon/monitoring/adaptive/adaptive_monitor.h

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ adaptive_collector()

Member Function Documentation

◆ adapt()

◆ calculate_load_level_with_config()

◆ calculate_load_level_with_hysteresis()

◆ collect()

◆ get_config()

◆ get_current_interval()

◆ get_stats()

◆ get_threshold_for_level()

◆ is_enabled()

◆ set_config()

◆ set_enabled()

◆ should_sample()

Member Data Documentation

◆ collector_

◆ config_

◆ config_mutex_

◆ current_sampling_rate_

◆ enabled_

◆ stats_

◆ stats_mutex_