health_monitor.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/external_client.h>
#include <entropic/mcp/reconnect_policy.h>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <map>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
namespace entropic {
 
struct HealthEvent {
    std::string server_name;   
    std::string old_status;    
    std::string new_status;    
    std::vector<std::string> added_tools;   
    std::vector<std::string> removed_tools; 
};
 
class HealthMonitor {
public:
    using StatusCallback = std::function<void(const HealthEvent&)>;
 
    HealthMonitor(ReconnectPolicy policy,
                  uint32_t health_check_interval_ms = 0);
 
    ~HealthMonitor();
 
    void watch(const std::string& name, ExternalMCPClient* client);
 
    void unwatch(const std::string& name);
 
    void set_status_callback(StatusCallback cb);
 
    void start();
 
    void stop();
 
    void process_events();
 
private:
    ReconnectPolicy policy_;                     
    uint32_t health_check_interval_ms_;          
    StatusCallback status_callback_;             
 
    struct WatchEntry {
        ExternalMCPClient* client;               
        std::string status;                      
        uint32_t reconnect_attempt;              
        std::chrono::steady_clock::time_point next_action; 
    };
 
    std::map<std::string, WatchEntry> watched_;  
    std::mutex watched_mutex_;                   
 
    std::vector<HealthEvent> event_queue_;        
    std::mutex event_mutex_;                     
 
    std::thread monitor_thread_;                 
    std::atomic<bool> running_{false};           
    std::condition_variable wake_cv_;            
    std::mutex wake_mutex_;                      
 
    void monitor_loop();
 
    void check_server(const std::string& name, WatchEntry& entry);
 
    void attempt_reconnect(const std::string& name,
                           WatchEntry& entry);
 
    void on_reconnect_success(const std::string& name,
                              WatchEntry& entry);
 
    void post_event(const std::string& name,
                    const std::string& old_status,
                    const std::string& new_status);
};
 
} // namespace entropic