circuit_breaker.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "circuit_breaker_config.h"
#include "circuit_state.h"
#include "failure_window.h"
#include "../interfaces/stats.h"
 
#include <atomic>
#include <chrono>
#include <exception>
#include <memory>
#include <mutex>
 
namespace kcenon::common::resilience {
 
class circuit_breaker : public interfaces::IStats {
public:
    using clock_type = std::chrono::steady_clock;
    using time_point = clock_type::time_point;
 
    explicit circuit_breaker(circuit_breaker_config config = {})
        : config_(std::move(config))
        , state_(circuit_state::CLOSED)
        , failure_window_(config_.failure_window)
        , consecutive_successes_(0)
        , half_open_requests_(0)
        , last_state_change_(clock_type::now())
    {
    }
 
    [[nodiscard]] auto allow_request() -> bool
    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        switch (state_) {
        case circuit_state::CLOSED:
            return true;
 
        case circuit_state::OPEN:
            // Check if timeout has elapsed to attempt recovery
            if (should_attempt_reset()) {
                transition_to_half_open();
                // First request in HALF_OPEN counts toward the limit
                ++half_open_requests_;
                return true;
            }
            return false;
 
        case circuit_state::HALF_OPEN:
            // Allow limited requests for testing
            if (half_open_requests_ < config_.half_open_max_requests) {
                ++half_open_requests_;
                return true;
            }
            return false;
        }
 
        return false; // Unreachable, but satisfies compiler
    }
 
    auto record_success() -> void
    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (state_ == circuit_state::HALF_OPEN) {
            ++consecutive_successes_;
            if (consecutive_successes_ >= config_.success_threshold) {
                transition_to_closed();
            }
        }
    }
 
    auto record_failure(const std::exception* e = nullptr) -> void
    {
        (void)e; // Reserved for future metrics/logging integration
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        failure_window_.record_failure();
 
        if (state_ == circuit_state::HALF_OPEN) {
            // Any failure in half-open immediately reopens circuit
            transition_to_open();
        } else if (state_ == circuit_state::CLOSED) {
            // Check if failure threshold exceeded
            if (failure_window_.get_failure_count() >= config_.failure_threshold) {
                transition_to_open();
            }
        }
    }
 
    [[nodiscard]] auto get_state() const -> circuit_state
    {
        return state_.load(std::memory_order_acquire);
    }
 
    class guard {
    public:
        explicit guard(circuit_breaker& breaker)
            : breaker_(breaker)
            , committed_(false)
        {
        }
 
        ~guard()
        {
            if (!committed_) {
                breaker_.record_failure();
            }
        }
 
        // Non-copyable, non-movable
        guard(const guard&) = delete;
        guard& operator=(const guard&) = delete;
        guard(guard&&) = delete;
        guard& operator=(guard&&) = delete;
 
        auto record_success() -> void
        {
            committed_ = true;
            breaker_.record_success();
        }
 
    private:
        circuit_breaker& breaker_;
        bool committed_;
    };
 
    [[nodiscard]] auto make_guard() -> guard { return guard(*this); }
 
    // IStats interface implementation
 
    [[nodiscard]] auto get_stats() const -> std::unordered_map<std::string, interfaces::stats_value> override
    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        const auto current_state = state_.load(std::memory_order_acquire);
        const auto failure_count = failure_window_.get_failure_count();
 
        return {
            {"current_state", to_string(current_state)},
            {"failure_count", static_cast<std::int64_t>(failure_count)},
            {"consecutive_successes", static_cast<std::int64_t>(consecutive_successes_)},
            {"half_open_requests", static_cast<std::int64_t>(half_open_requests_)},
            {"failure_threshold", static_cast<std::int64_t>(config_.failure_threshold)},
            {"is_open", current_state == circuit_state::OPEN}
        };
    }
 
    [[nodiscard]] auto to_json() const -> std::string override
    {
        const auto snapshot = get_snapshot();
        return snapshot.to_json();
    }
 
    [[nodiscard]] auto name() const -> std::string_view override
    {
        return "circuit_breaker";
    }
 
private:
    [[nodiscard]] auto should_attempt_reset() const -> bool
    {
        const auto now = clock_type::now();
        const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            now - last_state_change_);
        return elapsed >= config_.timeout;
    }
 
    auto transition_to_closed() -> void
    {
        state_.store(circuit_state::CLOSED, std::memory_order_release);
        failure_window_.reset();
        consecutive_successes_ = 0;
        half_open_requests_ = 0;
        last_state_change_ = clock_type::now();
    }
 
    auto transition_to_open() -> void
    {
        state_.store(circuit_state::OPEN, std::memory_order_release);
        consecutive_successes_ = 0;
        half_open_requests_ = 0;
        last_state_change_ = clock_type::now();
    }
 
    auto transition_to_half_open() -> void
    {
        state_.store(circuit_state::HALF_OPEN, std::memory_order_release);
        consecutive_successes_ = 0;
        half_open_requests_ = 0;
        last_state_change_ = clock_type::now();
    }
 
    circuit_breaker_config config_;
    std::atomic<circuit_state> state_;
    failure_window failure_window_;
    std::size_t consecutive_successes_;
    std::size_t half_open_requests_;
    time_point last_state_change_;
    mutable std::mutex mutex_;
};
 
} // namespace kcenon::common::resilience