health_monitor.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
 
#include <asio.hpp>
 
#include "internal/core/messaging_client.h"
 
namespace kcenon::network::utils
{
 
    struct connection_health
    {
        bool is_alive{true};                             
        std::chrono::milliseconds last_response_time{0}; 
        size_t missed_heartbeats{0};                     
        double packet_loss_rate{0.0};                    
        std::chrono::steady_clock::time_point last_heartbeat; 
    };
 
    class health_monitor : public std::enable_shared_from_this<health_monitor>
    {
    public:
        explicit health_monitor(
            std::chrono::seconds heartbeat_interval = std::chrono::seconds(30),
            size_t max_missed_heartbeats = 3);
 
        ~health_monitor() noexcept;
 
        auto start_monitoring(std::shared_ptr<core::messaging_client> client) -> void;
 
        auto stop_monitoring() -> void;
 
        [[nodiscard]] auto get_health() const -> connection_health;
 
        auto set_health_callback(
            std::function<void(const connection_health&)> callback) -> void;
 
        [[nodiscard]] auto is_monitoring() const noexcept -> bool;
 
    private:
        auto do_heartbeat() -> void;
 
        auto schedule_next_heartbeat() -> void;
 
        auto update_health(bool success, std::chrono::milliseconds response_time) -> void;
 
    private:
        std::shared_ptr<core::messaging_client> client_; 
        std::unique_ptr<asio::io_context> io_context_; 
        std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>>
            work_guard_; 
        std::unique_ptr<asio::steady_timer> heartbeat_timer_; 
        std::future<void> io_future_; 
        std::chrono::seconds heartbeat_interval_; 
        size_t max_missed_heartbeats_; 
        mutable std::mutex health_mutex_; 
        connection_health health_; 
        std::atomic<bool> is_monitoring_{false}; 
        std::atomic<size_t> total_heartbeats_{0}; 
        std::atomic<size_t> failed_heartbeats_{0}; 
        std::function<void(const connection_health&)> health_callback_; 
    };
 
} // namespace kcenon::network::utils