error_boundary.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
 
#include "kcenon/monitoring/core/result_types.h"
 
namespace kcenon::monitoring {
 
enum class degradation_level {
    normal = 0,
    limited = 1,
    minimal = 2,
    emergency = 3
};
 
enum class error_boundary_policy {
    fail_fast,
    isolate,
    degrade,
    fallback
};
 
struct error_boundary_metrics {
    std::atomic<size_t> total_operations{0};
    std::atomic<size_t> successful_operations{0};
    std::atomic<size_t> failed_operations{0};
    std::atomic<size_t> recovered_operations{0};
    std::atomic<size_t> recovery_attempts{0};
 
    error_boundary_metrics() = default;
 
    error_boundary_metrics(const error_boundary_metrics& other)
        : total_operations(other.total_operations.load())
        , successful_operations(other.successful_operations.load())
        , failed_operations(other.failed_operations.load())
        , recovered_operations(other.recovered_operations.load())
        , recovery_attempts(other.recovery_attempts.load()) {}
 
    error_boundary_metrics& operator=(const error_boundary_metrics& other) {
        if (this != &other) {
            total_operations = other.total_operations.load();
            successful_operations = other.successful_operations.load();
            failed_operations = other.failed_operations.load();
            recovered_operations = other.recovered_operations.load();
            recovery_attempts = other.recovery_attempts.load();
        }
        return *this;
    }
 
    double get_success_rate() const {
        size_t total = total_operations.load();
        if (total == 0) {
            return 1.0;
        }
        return static_cast<double>(successful_operations.load()) / static_cast<double>(total);
    }
};
 
struct error_boundary_config {
    std::string name;
    size_t error_threshold = 5;
    std::chrono::seconds error_window = std::chrono::seconds(60);
    bool enable_fallback_logging = true;
    degradation_level max_degradation = degradation_level::emergency;
    error_boundary_policy policy = error_boundary_policy::fail_fast;
    bool enable_automatic_recovery = false;
    std::chrono::milliseconds recovery_timeout = std::chrono::milliseconds(5000);
 
    bool validate() const {
        if (name.empty()) {
            return false;
        }
        if (error_threshold == 0) {
            return false;
        }
        return true;
    }
};
 
template<typename T>
class fallback_strategy_interface {
public:
    virtual ~fallback_strategy_interface() = default;
    virtual common::Result<T> get_fallback(const error_info& err, degradation_level level) = 0;
};
 
template<typename T>
class default_value_strategy : public fallback_strategy_interface<T> {
public:
    explicit default_value_strategy(T default_val) : default_value_(std::move(default_val)) {}
 
    common::Result<T> get_fallback(const error_info& /*err*/, degradation_level /*level*/) override {
        return common::ok(default_value_);
    }
 
private:
    T default_value_;
};
 
template<typename T>
class cached_value_strategy : public fallback_strategy_interface<T> {
public:
    explicit cached_value_strategy(std::chrono::seconds ttl = std::chrono::seconds(60))
        : ttl_(ttl), has_value_(false) {}
 
    void update_cache(const T& value) {
        std::lock_guard<std::mutex> lock(mutex_);
        cached_value_ = value;
        cache_time_ = std::chrono::steady_clock::now();
        has_value_ = true;
    }
 
    common::Result<T> get_fallback(const error_info& /*err*/, degradation_level /*level*/) override {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!has_value_) {
            return common::Result<T>::err(error_info(monitoring_error_code::operation_failed, "No cached value available").to_common_error());
        }
 
        auto now = std::chrono::steady_clock::now();
        auto age = std::chrono::duration_cast<std::chrono::seconds>(now - cache_time_);
        if (age > ttl_) {
            return common::Result<T>::err(error_info(monitoring_error_code::operation_failed, "Cached value expired").to_common_error());
        }
 
        return common::ok(cached_value_);
    }
 
private:
    std::chrono::seconds ttl_;
    T cached_value_;
    std::chrono::steady_clock::time_point cache_time_;
    bool has_value_;
    mutable std::mutex mutex_;
};
 
template<typename T>
class alternative_service_strategy : public fallback_strategy_interface<T> {
public:
    using alternative_func = std::function<common::Result<T>()>;
 
    explicit alternative_service_strategy(alternative_func func) : alternative_func_(std::move(func)) {}
 
    common::Result<T> get_fallback(const error_info& /*err*/, degradation_level /*level*/) override {
        if (alternative_func_) {
            return alternative_func_();
        }
        return common::Result<T>::err(error_info(monitoring_error_code::operation_failed, "No alternative service available").to_common_error());
    }
 
private:
    alternative_func alternative_func_;
};
 
template<typename T>
class error_boundary {
public:
    using config = error_boundary_config;
 
    error_boundary() : name_("default"), config_() {}
 
    explicit error_boundary(const std::string& name) : name_(name), config_() {
        config_.name = name;
    }
 
    explicit error_boundary(const std::string& name, const config& cfg)
        : name_(name), config_(cfg) {
        config_.name = name;
    }
 
    template<typename Func>
    auto execute(Func&& func) -> common::Result<T> {
        metrics_.total_operations++;
 
        try {
            auto op_result = func();
 
            if (op_result.is_ok()) {
                metrics_.successful_operations++;
                handle_success();
                return op_result;
            }
 
            metrics_.failed_operations++;
            return handle_failure(op_result.error());
 
        } catch (const std::exception& e) {
            metrics_.failed_operations++;
            error_info err(monitoring_error_code::operation_failed, e.what());
            return handle_failure(err.to_common_error());
        } catch (...) {
            metrics_.failed_operations++;
            error_info err(monitoring_error_code::operation_failed, "Unknown exception");
            return handle_failure(err.to_common_error());
        }
    }
 
    template<typename Func, typename FallbackFunc>
    auto execute(Func&& func, FallbackFunc&& fallback) -> common::Result<T> {
        metrics_.total_operations++;
 
        try {
            auto op_result = func();
 
            if (op_result.is_ok()) {
                metrics_.successful_operations++;
                handle_success();
                return op_result;
            }
 
            metrics_.failed_operations++;
            error_info err = error_info::from_common_error(op_result.error());
            return fallback(err, current_degradation_level_);
 
        } catch (const std::exception& e) {
            metrics_.failed_operations++;
            error_info err(monitoring_error_code::operation_failed, e.what());
            return fallback(err, current_degradation_level_);
        }
    }
 
    void set_error_handler(std::function<void(const error_info&, degradation_level)> handler) {
        error_handler_ = std::move(handler);
    }
 
    void set_fallback_strategy(std::shared_ptr<fallback_strategy_interface<T>> strategy) {
        fallback_strategy_ = std::move(strategy);
    }
 
    degradation_level get_degradation_level() const {
        return current_degradation_level_;
    }
 
    void force_degradation(degradation_level level) {
        if (level <= config_.max_degradation) {
            current_degradation_level_ = level;
        }
    }
 
    common::Result<bool> is_healthy() const {
        bool healthy = (current_degradation_level_ == degradation_level::normal);
        return common::ok(healthy);
    }
 
    error_boundary_metrics get_metrics() const {
        return metrics_;
    }
 
    const std::string& get_name() const {
        return name_;
    }
 
private:
    common::Result<T> handle_failure(const common::error_info& err) {
        consecutive_failures_++;
 
        // Check if we should degrade
        if (config_.policy == error_boundary_policy::degrade &&
            consecutive_failures_ >= config_.error_threshold) {
            upgrade_degradation();
        }
 
        // Call error handler if set
        if (error_handler_) {
            error_info monitoring_err = error_info::from_common_error(err);
            error_handler_(monitoring_err, current_degradation_level_);
        }
 
        // Apply policy
        switch (config_.policy) {
            case error_boundary_policy::fail_fast:
                return common::Result<T>::err(err);
 
            case error_boundary_policy::isolate:
                return common::Result<T>::err(error_info(monitoring_error_code::service_degraded, "Service isolated due to error").to_common_error());
 
            case error_boundary_policy::fallback:
                if (fallback_strategy_) {
                    error_info monitoring_err = error_info::from_common_error(err);
                    return fallback_strategy_->get_fallback(monitoring_err, current_degradation_level_);
                }
                return common::Result<T>::err(err);
 
            case error_boundary_policy::degrade:
            default:
                return common::Result<T>::err(err);
        }
    }
 
    void handle_success() {
        consecutive_failures_ = 0;
 
        // Check for recovery
        if (config_.enable_automatic_recovery &&
            current_degradation_level_ != degradation_level::normal) {
            metrics_.recovery_attempts++;
            downgrade_degradation();
        }
    }
 
    void upgrade_degradation() {
        auto current = static_cast<int>(current_degradation_level_);
        auto max_level = static_cast<int>(config_.max_degradation);
        if (current < max_level) {
            current_degradation_level_ = static_cast<degradation_level>(current + 1);
        }
    }
 
    void downgrade_degradation() {
        auto current = static_cast<int>(current_degradation_level_);
        if (current > 0) {
            current_degradation_level_ = static_cast<degradation_level>(current - 1);
        }
    }
 
    std::string name_;
    config config_;
    std::function<void(const error_info&, degradation_level)> error_handler_;
    std::shared_ptr<fallback_strategy_interface<T>> fallback_strategy_;
    mutable error_boundary_metrics metrics_;
    degradation_level current_degradation_level_ = degradation_level::normal;
    size_t consecutive_failures_ = 0;
};
 
} // namespace kcenon::monitoring