kcenon::network::utils::health_monitor Class Reference

Monitors connection health with heartbeat mechanism. More...

#include <health_monitor.h>

Inheritance diagram for kcenon::network::utils::health_monitor:

Collaboration diagram for kcenon::network::utils::health_monitor:

Public Member Functions
	health_monitor (std::chrono::seconds heartbeat_interval=std::chrono::seconds(30), size_t max_missed_heartbeats=3)
	Constructs a health monitor.
	~health_monitor () noexcept
	Destructor - stops monitoring if active.
auto	start_monitoring (std::shared_ptr< core::messaging_client > client) -> void
	Starts monitoring the given client.
auto	stop_monitoring () -> void
	Stops monitoring.
auto	get_health () const -> connection_health
	Gets current health status.
auto	set_health_callback (std::function< void(const connection_health &)> callback) -> void
	Sets callback for health status changes.
auto	is_monitoring () const noexcept -> bool
	Checks if monitoring is active.

Private Member Functions
auto	do_heartbeat () -> void
	Performs a single heartbeat check.
auto	schedule_next_heartbeat () -> void
	Schedules the next heartbeat.
auto	update_health (bool success, std::chrono::milliseconds response_time) -> void
	Updates health metrics.

Private Attributes
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_
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_

Detailed Description

Monitors connection health with heartbeat mechanism.

Thread Safety

• All public methods are thread-safe
• Health metrics are protected by mutex
• Heartbeat thread runs independently

Key Features

• Periodic heartbeat messages
• Automatic dead connection detection
• Connection quality metrics (latency, packet loss)
• Health status callbacks
• Configurable heartbeat interval

Usage Example

auto client = std::make_shared<messaging_client>("client_id");
client->start_client("localhost", 8080);
 
auto monitor = std::make_shared<health_monitor>(
    std::chrono::seconds(30)  // heartbeat every 30 seconds
);
 
monitor->set_health_callback([](const connection_health& health) {
    if (!health.is_alive) {
        std::cerr << "Connection is dead!\n";
    }
});
 
monitor->start_monitoring(client);
 
// ... later ...
auto health = monitor->get_health();
std::cout << "Missed heartbeats: " << health.missed_heartbeats << "\n";
 
monitor->stop_monitoring();

Definition at line 74 of file health_monitor.h.

Constructor & Destructor Documentation

health_monitor()

kcenon::network::utils::health_monitor::health_monitor ( std::chrono::seconds heartbeat_interval = std::chrono::seconds(30), size_t max_missed_heartbeats = 3 )

explicit

Constructs a health monitor.

Parameters

heartbeat_interval	Interval between heartbeat checks (default: 30s)
max_missed_heartbeats	Maximum missed heartbeats before marking as dead (default: 3)

Definition at line 16 of file health_monitor.cpp.

        : heartbeat_interval_(heartbeat_interval)
        , max_missed_heartbeats_(max_missed_heartbeats)
    {
        health_.last_heartbeat = std::chrono::steady_clock::now();
        NETWORK_LOG_INFO("[health_monitor] Created with interval=" +
            std::to_string(heartbeat_interval.count()) + "s, max_missed=" +
            std::to_string(max_missed_heartbeats));
    }

References health_, kcenon::network::utils::connection_health::last_heartbeat, and NETWORK_LOG_INFO.

~health_monitor()

kcenon::network::utils::health_monitor::~health_monitor ( )

noexcept

Destructor - stops monitoring if active.

Definition at line 27 of file health_monitor.cpp.

    {
        try
        {
            stop_monitoring();
        }
        catch (...)
        {
            // Destructor must not throw
        }
    }

References stop_monitoring().

Here is the call graph for this function:

Member Function Documentation

do_heartbeat()

auto kcenon::network::utils::health_monitor::do_heartbeat ( ) -> void

private

Performs a single heartbeat check.

Sends a heartbeat message and waits for response. Updates health metrics based on the result.

Definition at line 156 of file health_monitor.cpp.

    {
        if (!is_monitoring_.load() || !client_)
        {
            return;
        }
 
        auto start_time = std::chrono::steady_clock::now();
 
        // Check if client is still connected
        bool is_connected = client_->is_connected();
 
        total_heartbeats_.fetch_add(1);
 
        if (is_connected)
        {
            // Send heartbeat packet (simple ping message)
            std::vector<uint8_t> heartbeat_data = {
                0xFF, 0xFE,  // Magic bytes for heartbeat
                0x01,        // Heartbeat type
                0x00         // Padding
            };
 
            auto send_result = client_->send_packet(std::move(heartbeat_data));
 
            auto end_time = std::chrono::steady_clock::now();
            auto response_time = std::chrono::duration_cast<std::chrono::milliseconds>(
                end_time - start_time);
 
            if (!send_result.is_err())
            {
                // Heartbeat successful
                update_health(true, response_time);
                NETWORK_LOG_DEBUG("[health_monitor] Heartbeat successful, response_time=" +
                    std::to_string(response_time.count()) + "ms");
            }
            else
            {
                // Heartbeat failed
                failed_heartbeats_.fetch_add(1);
                update_health(false, response_time);
                NETWORK_LOG_WARN("[health_monitor] Heartbeat failed: " +
                    send_result.error().message);
            }
        }
        else
        {
            // Client disconnected
            failed_heartbeats_.fetch_add(1);
            update_health(false, std::chrono::milliseconds(0));
            NETWORK_LOG_WARN("[health_monitor] Client is disconnected");
        }
 
        // Schedule next heartbeat if still monitoring
        if (is_monitoring_.load())
        {
            schedule_next_heartbeat();
        }
    }

References NETWORK_LOG_DEBUG, and NETWORK_LOG_WARN.

get_health()

auto kcenon::network::utils::health_monitor::get_health ( ) const -> connection_health

nodiscard

Gets current health status.

Returns

Current connection health metrics

Definition at line 139 of file health_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(health_mutex_);
        return health_;
    }

References health_, and health_mutex_.

is_monitoring()

auto kcenon::network::utils::health_monitor::is_monitoring ( ) const -> bool

nodiscardnoexcept

Checks if monitoring is active.

Returns

true if monitoring, false otherwise

Definition at line 151 of file health_monitor.cpp.

    {
        return is_monitoring_.load();
    }

References is_monitoring_.

schedule_next_heartbeat()

auto kcenon::network::utils::health_monitor::schedule_next_heartbeat ( ) -> void

private

Schedules the next heartbeat.

Definition at line 216 of file health_monitor.cpp.

    {
        if (!heartbeat_timer_ || !is_monitoring_.load())
        {
            return;
        }
 
        heartbeat_timer_->expires_after(heartbeat_interval_);
 
        auto self = shared_from_this();
        heartbeat_timer_->async_wait(
            [this, self](const std::error_code& ec)
            {
                if (!ec && is_monitoring_.load())
                {
                    do_heartbeat();
                }
            }
        );
    }

set_health_callback()

auto kcenon::network::utils::health_monitor::set_health_callback

(

std::function< void(const connection_health &)>

callback

)

-> void

Sets callback for health status changes.

Parameters

callback

Function called when health status changes

The callback receives the current health metrics.

Definition at line 145 of file health_monitor.cpp.

    {
        health_callback_ = std::move(callback);
    }

start_monitoring()

auto kcenon::network::utils::health_monitor::start_monitoring

(

std::shared_ptr< core::messaging_client >

client

)

-> void

Starts monitoring the given client.

Parameters

client

Client to monitor

Begins periodic heartbeat checks. If client doesn't respond within the timeout, increments missed_heartbeats counter.

Definition at line 39 of file health_monitor.cpp.

    {
        if (is_monitoring_.load())
        {
            NETWORK_LOG_WARN("[health_monitor] Already monitoring");
            return;
        }
 
        if (!client)
        {
            NETWORK_LOG_ERROR("[health_monitor] Cannot monitor null client");
            return;
        }
 
        client_ = client;
 
        // Create io_context and work guard
        io_context_ = std::make_unique<asio::io_context>();
        work_guard_ = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(
            asio::make_work_guard(*io_context_)
        );
 
        // Create heartbeat timer
        heartbeat_timer_ = std::make_unique<asio::steady_timer>(*io_context_);
 
        is_monitoring_.store(true);
 
        // Reset metrics
        total_heartbeats_.store(0);
        failed_heartbeats_.store(0);
        {
            std::lock_guard<std::mutex> lock(health_mutex_);
            health_.is_alive = true;
            health_.missed_heartbeats = 0;
            health_.packet_loss_rate = 0.0;
            health_.last_heartbeat = std::chrono::steady_clock::now();
        }
 
        // Submit io_context::run() to thread pool
        io_future_ = integration::thread_integration_manager::instance().submit_task(
            [this]()
            {
                try
                {
                    io_context_->run();
                }
                catch (const std::exception& e)
                {
                    NETWORK_LOG_ERROR("[health_monitor] Exception in io_context run: " +
                        std::string(e.what()));
                }
            }
        );
 
        // Schedule first heartbeat
        schedule_next_heartbeat();
 
        NETWORK_LOG_INFO("[health_monitor] Started monitoring");
    }

References kcenon::network::integration::thread_integration_manager::instance(), NETWORK_LOG_ERROR, NETWORK_LOG_INFO, NETWORK_LOG_WARN, and kcenon::network::integration::thread_integration_manager::submit_task().

Here is the call graph for this function:

stop_monitoring()

auto kcenon::network::utils::health_monitor::stop_monitoring

(

)

-> void

Stops monitoring.

Cancels the heartbeat timer and stops the monitoring thread.

Definition at line 100 of file health_monitor.cpp.

    {
        if (!is_monitoring_.exchange(false))
        {
            return;
        }
 
        // Cancel timer
        if (heartbeat_timer_)
        {
            heartbeat_timer_->cancel();
        }
 
        // Release work guard
        if (work_guard_)
        {
            work_guard_.reset();
        }
 
        // Stop io_context
        if (io_context_)
        {
            io_context_->stop();
        }
 
        // Wait for io_context task to complete
        if (io_future_.valid())
        {
            io_future_.wait();
        }
 
        // Release resources
        heartbeat_timer_.reset();
        io_context_.reset();
        client_.reset();
 
        NETWORK_LOG_INFO("[health_monitor] Stopped monitoring");
    }

References NETWORK_LOG_INFO.

Referenced by ~health_monitor().

Here is the caller graph for this function:

update_health()

auto kcenon::network::utils::health_monitor::update_health ( bool success, std::chrono::milliseconds response_time ) -> void

private

Updates health metrics.

Parameters

success	Whether heartbeat was successful
response_time	Response time in milliseconds

Definition at line 237 of file health_monitor.cpp.

    {
        std::lock_guard<std::mutex> lock(health_mutex_);
 
        health_.last_heartbeat = std::chrono::steady_clock::now();
        health_.last_response_time = response_time;
 
        if (success)
        {
            // Reset missed heartbeats on success
            health_.missed_heartbeats = 0;
            health_.is_alive = true;
        }
        else
        {
            // Increment missed heartbeats
            health_.missed_heartbeats++;
 
            // Mark as dead if exceeded threshold
            if (health_.missed_heartbeats >= max_missed_heartbeats_)
            {
                health_.is_alive = false;
                NETWORK_LOG_ERROR("[health_monitor] Connection marked as DEAD (missed " +
                    std::to_string(health_.missed_heartbeats) + " heartbeats)");
            }
        }
 
        // Calculate packet loss rate
        auto total = total_heartbeats_.load();
        auto failed = failed_heartbeats_.load();
        if (total > 0)
        {
            health_.packet_loss_rate = static_cast<double>(failed) / static_cast<double>(total);
        }
 
        // Report metrics to monitoring system (optional)
        try
        {
            auto& monitor_mgr = integration::monitoring_integration_manager::instance();
            auto monitor = monitor_mgr.get_monitoring();
            if (monitor && client_)
            {
                // Use client pointer address as connection identifier
                std::ostringstream oss;
                oss << "client_" << static_cast<const void*>(client_.get());
 
                monitor->report_health(
                    oss.str(),
                    health_.is_alive,
                    static_cast<double>(health_.last_response_time.count()),
                    health_.missed_heartbeats,
                    health_.packet_loss_rate
                );
            }
        }
        catch (...)
        {
            // Monitoring failure is not critical, continue normal operation
        }
 
        // Invoke health callback if set
        if (health_callback_)
        {
            health_callback_(health_);
        }
    }

References kcenon::network::integration::monitoring_integration_manager::instance(), and NETWORK_LOG_ERROR.

Here is the call graph for this function:

Member Data Documentation

client_

std::shared_ptr<core::messaging_client> kcenon::network::utils::health_monitor::client_

private

Monitored client

Definition at line 150 of file health_monitor.h.

failed_heartbeats_

std::atomic<size_t> kcenon::network::utils::health_monitor::failed_heartbeats_ {0}

private

Failed heartbeats

Definition at line 166 of file health_monitor.h.

{0}; 

health_

connection_health kcenon::network::utils::health_monitor::health_

private

Current health metrics

Definition at line 162 of file health_monitor.h.

Referenced by get_health(), and health_monitor().

health_callback_

std::function<void(const connection_health&)> kcenon::network::utils::health_monitor::health_callback_

private

Health callback

Definition at line 168 of file health_monitor.h.

health_mutex_

std::mutex kcenon::network::utils::health_monitor::health_mutex_

mutableprivate

Protects health metrics

Definition at line 161 of file health_monitor.h.

Referenced by get_health().

heartbeat_interval_

std::chrono::seconds kcenon::network::utils::health_monitor::heartbeat_interval_

private

Heartbeat interval

Definition at line 158 of file health_monitor.h.

heartbeat_timer_

std::unique_ptr<asio::steady_timer> kcenon::network::utils::health_monitor::heartbeat_timer_

private

Heartbeat timer

Definition at line 155 of file health_monitor.h.

io_context_

std::unique_ptr<asio::io_context> kcenon::network::utils::health_monitor::io_context_

private

IO context for timer

Definition at line 152 of file health_monitor.h.

io_future_

std::future<void> kcenon::network::utils::health_monitor::io_future_

private

Future for io_context execution

Definition at line 156 of file health_monitor.h.

is_monitoring_

std::atomic<bool> kcenon::network::utils::health_monitor::is_monitoring_ {false}

private

Monitoring active flag

Definition at line 164 of file health_monitor.h.

{false}; 

Referenced by is_monitoring().

max_missed_heartbeats_

size_t kcenon::network::utils::health_monitor::max_missed_heartbeats_

private

Max missed heartbeats before dead

Definition at line 159 of file health_monitor.h.

total_heartbeats_

std::atomic<size_t> kcenon::network::utils::health_monitor::total_heartbeats_ {0}

private

Total heartbeats sent

Definition at line 165 of file health_monitor.h.

{0}; 

work_guard_

std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type> > kcenon::network::utils::health_monitor::work_guard_

private

Work guard to keep io_context running

Definition at line 154 of file health_monitor.h.

---

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

• src/internal/utils/health_monitor.h
• src/internal/utils/health_monitor.cpp