retry_policy.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 <algorithm>
#include <chrono>
#include <cmath>
#include <functional>
#include <string>
#include <thread>
 
#include "kcenon/monitoring/core/result_types.h"
 
namespace kcenon::monitoring {
 
enum class retry_strategy {
    fixed_delay,
    exponential_backoff,
    linear_backoff,
    fibonacci_backoff
};
 
struct retry_metrics {
    size_t total_executions = 0;
    size_t successful_executions = 0;
    size_t failed_executions = 0;
    size_t total_retries = 0;
 
    void reset() {
        total_executions = 0;
        successful_executions = 0;
        failed_executions = 0;
        total_retries = 0;
    }
};
 
struct retry_config {
    size_t max_attempts = 3;
    retry_strategy strategy = retry_strategy::exponential_backoff;
    std::chrono::milliseconds initial_delay = std::chrono::milliseconds(1000);
    std::chrono::milliseconds max_delay = std::chrono::milliseconds(30000);
    double backoff_multiplier = 2.0;
    std::function<bool(const error_info&)> should_retry = nullptr;
 
    bool validate() const {
        if (max_attempts == 0) {
            return false;
        }
        if (backoff_multiplier < 1.0) {
            return false;
        }
        return true;
    }
};
 
inline retry_config create_exponential_backoff_config(
    size_t max_attempts = 3,
    std::chrono::milliseconds initial_delay = std::chrono::milliseconds(1000)) {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::exponential_backoff;
    config.initial_delay = initial_delay;
    config.backoff_multiplier = 2.0;
    return config;
}
 
inline retry_config create_fixed_delay_config(
    size_t max_attempts = 3,
    std::chrono::milliseconds delay = std::chrono::milliseconds(1000)) {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::fixed_delay;
    config.initial_delay = delay;
    return config;
}
 
inline retry_config create_fibonacci_backoff_config(
    size_t max_attempts = 3,
    std::chrono::milliseconds initial_delay = std::chrono::milliseconds(1000)) {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::fibonacci_backoff;
    config.initial_delay = initial_delay;
    return config;
}
 
template<typename T>
class retry_executor {
public:
    using config = retry_config;
 
    retry_executor() : name_("default"), config_() {}
 
    explicit retry_executor(const std::string& name)
        : name_(name), config_() {}
 
    explicit retry_executor(const std::string& name, const config& cfg)
        : name_(name), config_(cfg) {}
 
    template<typename Func>
    common::Result<T> execute(Func&& func) {
        metrics_.total_executions++;
 
        common::Result<T> last_result = common::Result<T>::err(error_info(monitoring_error_code::operation_failed, "No attempts made").to_common_error());
 
        for (size_t attempt = 0; attempt < config_.max_attempts; ++attempt) {
            if (attempt > 0) {
                metrics_.total_retries++;
                auto delay = calculate_delay(attempt);
                std::this_thread::sleep_for(delay);
            }
 
            last_result = func();
 
            if (last_result.is_ok()) {
                metrics_.successful_executions++;
                return last_result;
            }
 
            if (config_.should_retry) {
                auto err_info = error_info::from_common_error(last_result.error());
                if (!config_.should_retry(err_info)) {
                    metrics_.failed_executions++;
                    return last_result;
                }
            }
        }
 
        metrics_.failed_executions++;
        return last_result;
    }
 
    retry_metrics get_metrics() const {
        return metrics_;
    }
 
    void reset_metrics() {
        metrics_.reset();
    }
 
    const std::string& get_name() const {
        return name_;
    }
 
private:
    std::chrono::milliseconds calculate_delay(size_t attempt) const {
        std::chrono::milliseconds delay;
 
        switch (config_.strategy) {
            case retry_strategy::fixed_delay:
                delay = config_.initial_delay;
                break;
 
            case retry_strategy::exponential_backoff: {
                auto multiplier = std::pow(config_.backoff_multiplier, static_cast<double>(attempt - 1));
                auto delay_ms = static_cast<long long>(config_.initial_delay.count() * multiplier);
                delay = std::chrono::milliseconds(delay_ms);
                break;
            }
 
            case retry_strategy::linear_backoff:
                delay = config_.initial_delay * attempt;
                break;
 
            case retry_strategy::fibonacci_backoff: {
                delay = config_.initial_delay * fibonacci(attempt);
                break;
            }
 
            default:
                delay = config_.initial_delay;
                break;
        }
 
        return std::min(delay, config_.max_delay);
    }
 
    static size_t fibonacci(size_t n) {
        if (n <= 1) return 1;
 
        size_t prev = 1;
        size_t curr = 1;
 
        for (size_t i = 2; i <= n; ++i) {
            size_t next = prev + curr;
            prev = curr;
            curr = next;
        }
 
        return curr;
    }
 
    std::string name_;
    config config_;
    mutable retry_metrics metrics_;
};
 
class retry_policy {
public:
    using config = retry_config;
 
    retry_policy() : config_() {}
    explicit retry_policy(const config& cfg) : config_(cfg) {}
 
    template<typename Func>
    auto execute(Func&& func) -> decltype(func()) {
        return func();
    }
 
private:
    config config_;
};
 
} // namespace kcenon::monitoring