Graceful degradation manager. More...

#include <graceful_degradation.h>

Collaboration diagram for kcenon::monitoring::graceful_degradation_manager:

Public Member Functions
	graceful_degradation_manager ()

	graceful_degradation_manager (const std::string &name)

common::VoidResult	register_service (const service_config &config)
	Register a service for management.

common::VoidResult	unregister_service (const std::string &name)
	Unregister a service.

common::VoidResult	degrade_service (const std::string &name, degradation_level level, const std::string &reason)
	Degrade a specific service.

common::VoidResult	recover_service (const std::string &name)
	Recover a specific service to normal operation.

common::VoidResult	recover_all_services ()
	Recover all services to normal operation.

degradation_level	get_service_level (const std::string &name) const
	Get current degradation level for a service.

common::VoidResult	add_degradation_plan (const degradation_plan &plan)
	Add a degradation plan.

common::VoidResult	execute_plan (const std::string &plan_name, const std::string &reason)
	Execute a degradation plan.

common::Result< bool >	is_healthy () const
	Check if the manager is healthy (more than 50% services at normal level)

graceful_degradation_metrics	get_metrics () const
	Get metrics.

const std::string &	get_name () const
	Get manager name.

std::vector< std::string >	get_service_names () const
	Get all registered service names.

Private Attributes
std::string	name_

std::mutex	mutex_

std::unordered_map< std::string, service_state >	services_

std::unordered_map< std::string, degradation_plan >	plans_

graceful_degradation_metrics	metrics_

Detailed Description

Graceful degradation manager.

Manages service degradation and recovery in a coordinated manner.

Definition at line 118 of file graceful_degradation.h.

Constructor & Destructor Documentation

◆ graceful_degradation_manager() [1/2]

kcenon::monitoring::graceful_degradation_manager::graceful_degradation_manager ( )

inline

Definition at line 120 of file graceful_degradation.h.

120: name_("default") {}

kcenon::monitoring::graceful_degradation_manager::name_

std::string name_

Definition graceful_degradation.h:331

◆ graceful_degradation_manager() [2/2]

kcenon::monitoring::graceful_degradation_manager::graceful_degradation_manager ( const std::string & name )

inlineexplicit

Definition at line 122 of file graceful_degradation.h.

122: name_(name) {}

Member Function Documentation

◆ add_degradation_plan()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::add_degradation_plan ( const degradation_plan & plan )

inline

Add a degradation plan.

Definition at line 233 of file graceful_degradation.h.

                                                                        {
        if (!plan.validate()) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration, "Invalid degradation plan").to_common_error());
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
        plans_[plan.name] = plan;
        return common::ok();
    }

References kcenon::monitoring::invalid_configuration, mutex_, kcenon::monitoring::degradation_plan::name, plans_, and kcenon::monitoring::degradation_plan::validate().

Here is the call graph for this function:

◆ degrade_service()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::degrade_service	(	const std::string &	name,
		degradation_level	level,
		const std::string &	reason )

inline

Degrade a specific service.

Definition at line 164 of file graceful_degradation.h.

                                                        {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = services_.find(name);
        if (it == services_.end()) {
            metrics_.failed_degradations++;
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::not_found),
                                  "Service not found: " + name);
        }
 
        metrics_.total_degradations++;
        it->second.current_level = level;
        it->second.last_degradation_reason = reason;
        it->second.last_state_change = std::chrono::steady_clock::now();
        metrics_.successful_degradations++;
 
        return common::ok();
    }

References kcenon::monitoring::graceful_degradation_metrics::failed_degradations, metrics_, mutex_, kcenon::monitoring::not_found, services_, kcenon::monitoring::graceful_degradation_metrics::successful_degradations, and kcenon::monitoring::graceful_degradation_metrics::total_degradations.

◆ execute_plan()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::execute_plan	(	const std::string &	plan_name,
		const std::string &	reason )

inline

Execute a degradation plan.

Definition at line 246 of file graceful_degradation.h.

                                                                                       {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = plans_.find(plan_name);
        if (it == plans_.end()) {
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::not_found),
                                  "Plan not found: " + plan_name);
        }
 
        const auto& plan = it->second;
 
        // Degrade services to maintain to target level
        for (const auto& service_name : plan.services_to_maintain) {
            auto service_it = services_.find(service_name);
            if (service_it != services_.end()) {
                metrics_.total_degradations++;
                service_it->second.current_level = plan.target_level;
                service_it->second.last_degradation_reason = reason;
                service_it->second.last_state_change = std::chrono::steady_clock::now();
                metrics_.successful_degradations++;
            }
        }
 
        // Disable (set to emergency) services to disable
        for (const auto& service_name : plan.services_to_disable) {
            auto service_it = services_.find(service_name);
            if (service_it != services_.end()) {
                metrics_.total_degradations++;
                service_it->second.current_level = degradation_level::emergency;
                service_it->second.last_degradation_reason = reason;
                service_it->second.last_state_change = std::chrono::steady_clock::now();
                metrics_.successful_degradations++;
            }
        }
 
        return common::ok();
    }

References kcenon::monitoring::emergency, metrics_, mutex_, kcenon::monitoring::not_found, plans_, services_, kcenon::monitoring::graceful_degradation_metrics::successful_degradations, and kcenon::monitoring::graceful_degradation_metrics::total_degradations.

◆ get_metrics()

graceful_degradation_metrics kcenon::monitoring::graceful_degradation_manager::get_metrics ( ) const

inline

Get metrics.

Definition at line 306 of file graceful_degradation.h.

                                                     {
        return metrics_;
    }

References metrics_.

◆ get_name()

const std::string & kcenon::monitoring::graceful_degradation_manager::get_name ( ) const

inline

Get manager name.

Definition at line 313 of file graceful_degradation.h.

                                      {
        return name_;
    }

References name_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ get_service_level()

degradation_level kcenon::monitoring::graceful_degradation_manager::get_service_level ( const std::string & name ) const

inline

Get current degradation level for a service.

Definition at line 221 of file graceful_degradation.h.

                                                                     {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = services_.find(name);
        if (it == services_.end()) {
            return degradation_level::normal;
        }
        return it->second.current_level;
    }

References mutex_, kcenon::monitoring::normal, and services_.

◆ get_service_names()

std::vector< std::string > kcenon::monitoring::graceful_degradation_manager::get_service_names ( ) const

inline

Get all registered service names.

Definition at line 320 of file graceful_degradation.h.

                                                   {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::string> names;
        names.reserve(services_.size());
        for (const auto& [name, state] : services_) {
            names.push_back(name);
        }
        return names;
    }

References mutex_, and services_.

◆ is_healthy()

common::Result< bool > kcenon::monitoring::graceful_degradation_manager::is_healthy ( ) const

inline

Check if the manager is healthy (more than 50% services at normal level)

Definition at line 286 of file graceful_degradation.h.

                                          {
        std::lock_guard<std::mutex> lock(mutex_);
        if (services_.empty()) {
            return common::ok(true);
        }
 
        size_t normal_count = 0;
        for (const auto& [name, state] : services_) {
            if (state.current_level == degradation_level::normal) {
                normal_count++;
            }
        }
 
        double healthy_ratio = static_cast<double>(normal_count) / static_cast<double>(services_.size());
        return common::ok(healthy_ratio > 0.5);
    }

References mutex_, kcenon::monitoring::normal, and services_.

◆ recover_all_services()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::recover_all_services ( )

inline

Recover all services to normal operation.

Definition at line 206 of file graceful_degradation.h.

                                            {
        std::lock_guard<std::mutex> lock(mutex_);
        for (auto& [name, state] : services_) {
            metrics_.recovery_attempts++;
            state.current_level = degradation_level::normal;
            state.last_degradation_reason.clear();
            state.last_state_change = std::chrono::steady_clock::now();
            metrics_.successful_recoveries++;
        }
        return common::ok();
    }

References metrics_, mutex_, kcenon::monitoring::normal, kcenon::monitoring::graceful_degradation_metrics::recovery_attempts, services_, and kcenon::monitoring::graceful_degradation_metrics::successful_recoveries.

◆ recover_service()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::recover_service ( const std::string & name )

inline

Recover a specific service to normal operation.

Definition at line 186 of file graceful_degradation.h.

                                                            {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = services_.find(name);
        if (it == services_.end()) {
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::not_found),
                                  "Service not found: " + name);
        }
 
        metrics_.recovery_attempts++;
        it->second.current_level = degradation_level::normal;
        it->second.last_degradation_reason.clear();
        it->second.last_state_change = std::chrono::steady_clock::now();
        metrics_.successful_recoveries++;
 
        return common::ok();
    }

References metrics_, mutex_, kcenon::monitoring::normal, kcenon::monitoring::not_found, kcenon::monitoring::graceful_degradation_metrics::recovery_attempts, services_, and kcenon::monitoring::graceful_degradation_metrics::successful_recoveries.

◆ register_service()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::register_service ( const service_config & config )

inline

Register a service for management.

Definition at line 127 of file graceful_degradation.h.

                                                                    {
        if (!config.validate()) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration, "Invalid service configuration").to_common_error());
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
        if (services_.find(config.name) != services_.end()) {
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::already_exists),
                                  "Service already registered: " + config.name);
        }
 
        service_state state;
        state.config = config;
        state.current_level = degradation_level::normal;
        state.last_state_change = std::chrono::steady_clock::now();
        services_[config.name] = state;
 
        return common::ok();
    }

References kcenon::monitoring::already_exists, kcenon::monitoring::service_state::config, kcenon::monitoring::service_state::current_level, kcenon::monitoring::invalid_configuration, kcenon::monitoring::service_state::last_state_change, mutex_, kcenon::monitoring::service_config::name, kcenon::monitoring::normal, services_, and kcenon::monitoring::service_config::validate().

Here is the call graph for this function:

◆ unregister_service()

common::VoidResult kcenon::monitoring::graceful_degradation_manager::unregister_service ( const std::string & name )

inline

Unregister a service.

Definition at line 150 of file graceful_degradation.h.

                                                               {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = services_.find(name);
        if (it == services_.end()) {
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::not_found),
                                  "Service not found: " + name);
        }
        services_.erase(it);
        return common::ok();
    }

References mutex_, kcenon::monitoring::not_found, and services_.

Member Data Documentation

◆ metrics_

graceful_degradation_metrics kcenon::monitoring::graceful_degradation_manager::metrics_

mutableprivate

Definition at line 335 of file graceful_degradation.h.

Referenced by degrade_service(), execute_plan(), get_metrics(), recover_all_services(), and recover_service().

◆ mutex_

std::mutex kcenon::monitoring::graceful_degradation_manager::mutex_

mutableprivate

Definition at line 332 of file graceful_degradation.h.

Referenced by add_degradation_plan(), degrade_service(), execute_plan(), get_service_level(), get_service_names(), is_healthy(), recover_all_services(), recover_service(), register_service(), and unregister_service().

◆ name_

std::string kcenon::monitoring::graceful_degradation_manager::name_

private

Definition at line 331 of file graceful_degradation.h.

Referenced by get_name().

◆ plans_

std::unordered_map<std::string, degradation_plan> kcenon::monitoring::graceful_degradation_manager::plans_

private

Definition at line 334 of file graceful_degradation.h.

Referenced by add_degradation_plan(), and execute_plan().

◆ services_

std::unordered_map<std::string, service_state> kcenon::monitoring::graceful_degradation_manager::services_

private

Definition at line 333 of file graceful_degradation.h.

Referenced by degrade_service(), execute_plan(), get_service_level(), get_service_names(), is_healthy(), recover_all_services(), recover_service(), register_service(), and unregister_service().

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

include/kcenon/monitoring/reliability/graceful_degradation.h

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ graceful_degradation_manager() [1/2]

◆ graceful_degradation_manager() [2/2]

Member Function Documentation

◆ add_degradation_plan()

◆ degrade_service()

◆ execute_plan()

◆ get_metrics()

◆ get_name()

◆ get_service_level()

◆ get_service_names()

◆ is_healthy()

◆ recover_all_services()

◆ recover_service()

◆ register_service()

◆ unregister_service()

Member Data Documentation

◆ metrics_

◆ mutex_

◆ name_

◆ plans_

◆ services_