platform_metrics_collector.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 <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
#include "collector_base.h"
 
namespace kcenon {
namespace monitoring {
 
// =============================================================================
// Metrics structures
// =============================================================================
 
struct platform_info {
    std::string name;        
    std::string version;     
    std::string architecture;
    bool available{false};   
};
 
struct platform_uptime {
    int64_t uptime_seconds{0};   
    int64_t idle_seconds{0};     
    int64_t boot_timestamp{0};   
    bool available{false};       
};
 
struct platform_context_switches {
    uint64_t total_switches{0};       
    uint64_t voluntary_switches{0};   
    uint64_t involuntary_switches{0}; 
    double switches_per_second{0.0};  
    bool available{false};            
};
 
struct platform_tcp_info {
    uint64_t established{0};   
    uint64_t syn_sent{0};      
    uint64_t syn_recv{0};      
    uint64_t fin_wait1{0};     
    uint64_t fin_wait2{0};     
    uint64_t time_wait{0};     
    uint64_t close_wait{0};    
    uint64_t listen{0};        
    uint64_t total{0};         
    bool available{false};     
};
 
struct platform_socket_info {
    uint64_t rx_buffer_size{0};  
    uint64_t tx_buffer_size{0};  
    uint64_t rx_buffer_used{0};  
    uint64_t tx_buffer_used{0};  
    bool available{false};       
};
 
struct platform_interrupt_info {
    uint64_t total_interrupts{0}; 
    bool available{false};        
};
 
struct platform_metrics_config {
    bool collect_uptime{true};            
    bool collect_context_switches{true};  
    bool collect_tcp_states{true};        
    bool collect_socket_buffers{true};    
    bool collect_interrupts{true};        
};
 
struct platform_metrics {
    platform_info info;
    platform_uptime uptime;
    platform_context_switches context_switches;
    platform_tcp_info tcp;
    platform_socket_info socket;
    platform_interrupt_info interrupts;
    std::chrono::system_clock::time_point timestamp;
};
 
// =============================================================================
// Forward declarations
// =============================================================================
 
namespace platform {
class metrics_provider;
}
 
// =============================================================================
// Platform info collector
// =============================================================================
 
class platform_info_collector {
   public:
    platform_info_collector();
    ~platform_info_collector();
 
    platform_info_collector(const platform_info_collector&) = delete;
    platform_info_collector& operator=(const platform_info_collector&) = delete;
    platform_info_collector(platform_info_collector&&) = delete;
    platform_info_collector& operator=(platform_info_collector&&) = delete;
 
    bool is_platform_available() const;
 
    platform_info get_platform_info() const;
 
    platform_uptime get_uptime() const;
 
    platform_context_switches get_context_switches() const;
 
    platform_tcp_info get_tcp_states() const;
 
    platform_socket_info get_socket_buffers() const;
 
    platform_interrupt_info get_interrupt_stats() const;
 
   private:
    std::unique_ptr<platform::metrics_provider> provider_;
};
 
// =============================================================================
// Main collector
// =============================================================================
 
class platform_metrics_collector : public collector_plugin {
   public:
    platform_metrics_collector();
    explicit platform_metrics_collector(platform_metrics_config config);
    ~platform_metrics_collector() override = default;
 
    platform_metrics_collector(const platform_metrics_collector&) = delete;
    platform_metrics_collector& operator=(const platform_metrics_collector&) = delete;
    platform_metrics_collector(platform_metrics_collector&&) = delete;
    platform_metrics_collector& operator=(platform_metrics_collector&&) = delete;
 
    // collector_plugin interface implementation
    auto name() const -> std::string_view override { return "platform_metrics_collector"; }
 
    auto collect() -> std::vector<metric> override;
 
    auto interval() const -> std::chrono::milliseconds override { return collection_interval_; }
 
    auto is_available() const -> bool override;
 
    bool is_healthy() const { return is_available(); }
 
    auto get_metric_types() const -> std::vector<std::string> override;
 
    bool initialize(const config_map& config) override;
 
    auto get_statistics() const -> stats_map override;
 
    // Accessors
    platform_metrics get_last_metrics() const;
 
    platform_info get_platform_info() const;
 
    std::string get_platform_name() const;
 
    bool is_platform_available() const;
 
   private:
    std::unique_ptr<platform_info_collector> collector_;
 
    platform_metrics_config config_;
    platform_metrics last_metrics_;
 
    // Cached platform info (doesn't change during runtime)
    platform_info cached_platform_info_;
    bool platform_info_cached_{false};
 
    // Collection interval
    std::chrono::milliseconds collection_interval_{std::chrono::seconds(10)};
    mutable std::mutex metrics_mutex_;
 
    // Helper methods
    void collect_platform_info_metrics(std::vector<metric>& metrics);
    void collect_uptime_metrics(std::vector<metric>& metrics);
    void collect_context_switch_metrics(std::vector<metric>& metrics);
    void collect_tcp_metrics(std::vector<metric>& metrics);
    void collect_socket_metrics(std::vector<metric>& metrics);
    void collect_interrupt_metrics(std::vector<metric>& metrics);
};
 
}  // namespace monitoring
}  // namespace kcenon