network_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 <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
 
namespace kcenon {
namespace monitoring {
 
enum class tcp_state {
    ESTABLISHED = 1,   
    SYN_SENT = 2,      
    SYN_RECV = 3,      
    FIN_WAIT1 = 4,     
    FIN_WAIT2 = 5,     
    TIME_WAIT = 6,     
    CLOSE = 7,         
    CLOSE_WAIT = 8,    
    LAST_ACK = 9,      
    LISTEN = 10,       
    CLOSING = 11,      
    UNKNOWN = 0        
};
 
inline std::string tcp_state_to_string(tcp_state state) {
    switch (state) {
        case tcp_state::ESTABLISHED: return "ESTABLISHED";
        case tcp_state::SYN_SENT: return "SYN_SENT";
        case tcp_state::SYN_RECV: return "SYN_RECV";
        case tcp_state::FIN_WAIT1: return "FIN_WAIT1";
        case tcp_state::FIN_WAIT2: return "FIN_WAIT2";
        case tcp_state::TIME_WAIT: return "TIME_WAIT";
        case tcp_state::CLOSE: return "CLOSE";
        case tcp_state::CLOSE_WAIT: return "CLOSE_WAIT";
        case tcp_state::LAST_ACK: return "LAST_ACK";
        case tcp_state::LISTEN: return "LISTEN";
        case tcp_state::CLOSING: return "CLOSING";
        default: return "UNKNOWN";
    }
}
 
struct tcp_state_counts {
    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{0};          
    uint64_t close_wait{0};     
    uint64_t last_ack{0};       
    uint64_t listen{0};         
    uint64_t closing{0};        
    uint64_t unknown{0};        
 
    uint64_t get_count(tcp_state state) const {
        switch (state) {
            case tcp_state::ESTABLISHED: return established;
            case tcp_state::SYN_SENT: return syn_sent;
            case tcp_state::SYN_RECV: return syn_recv;
            case tcp_state::FIN_WAIT1: return fin_wait1;
            case tcp_state::FIN_WAIT2: return fin_wait2;
            case tcp_state::TIME_WAIT: return time_wait;
            case tcp_state::CLOSE: return close;
            case tcp_state::CLOSE_WAIT: return close_wait;
            case tcp_state::LAST_ACK: return last_ack;
            case tcp_state::LISTEN: return listen;
            case tcp_state::CLOSING: return closing;
            default: return unknown;
        }
    }
 
    void increment(tcp_state state) {
        switch (state) {
            case tcp_state::ESTABLISHED: ++established; break;
            case tcp_state::SYN_SENT: ++syn_sent; break;
            case tcp_state::SYN_RECV: ++syn_recv; break;
            case tcp_state::FIN_WAIT1: ++fin_wait1; break;
            case tcp_state::FIN_WAIT2: ++fin_wait2; break;
            case tcp_state::TIME_WAIT: ++time_wait; break;
            case tcp_state::CLOSE: ++close; break;
            case tcp_state::CLOSE_WAIT: ++close_wait; break;
            case tcp_state::LAST_ACK: ++last_ack; break;
            case tcp_state::LISTEN: ++listen; break;
            case tcp_state::CLOSING: ++closing; break;
            default: ++unknown; break;
        }
    }
 
    uint64_t total() const {
        return established + syn_sent + syn_recv + fin_wait1 + fin_wait2 +
               time_wait + close + close_wait + last_ack + listen + closing + unknown;
    }
};
 
struct network_metrics_config {
    bool collect_socket_buffers{true};    
    bool collect_tcp_states{true};        
    uint64_t time_wait_warning_threshold{10000};    
    uint64_t close_wait_warning_threshold{100};     
    uint64_t queue_full_threshold_bytes{65536};     
    uint64_t memory_warning_threshold_bytes{104857600};  
};
 
struct network_metrics {
    // Socket buffer metrics
    uint64_t recv_buffer_bytes{0};        
    uint64_t send_buffer_bytes{0};        
    uint64_t socket_memory_bytes{0};      
    uint64_t socket_count{0};             
    uint64_t tcp_socket_count{0};         
    uint64_t udp_socket_count{0};         
    bool socket_buffer_available{false};  
 
    // TCP state metrics
    tcp_state_counts tcp_counts;          
    uint64_t total_connections{0};        
    bool tcp_state_available{false};      
 
    std::chrono::system_clock::time_point timestamp;  
};
 
// Forward declaration
namespace platform {
class metrics_provider;
}  // namespace platform
 
class network_info_collector {
   public:
    network_info_collector();
    ~network_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    network_info_collector(const network_info_collector&) = delete;
    network_info_collector& operator=(const network_info_collector&) = delete;
    network_info_collector(network_info_collector&&) = delete;
    network_info_collector& operator=(network_info_collector&&) = delete;
 
    bool is_socket_buffer_monitoring_available() const;
 
    bool is_tcp_state_monitoring_available() const;
 
    network_metrics collect_metrics(const network_metrics_config& config);
 
   private:
    std::unique_ptr<platform::metrics_provider> provider_;
};
 
class network_metrics_collector : public collector_plugin {
   public:
    network_metrics_collector();
    ~network_metrics_collector() override = default;
 
    // Non-copyable, non-moveable due to internal state
    network_metrics_collector(const network_metrics_collector&) = delete;
    network_metrics_collector& operator=(const network_metrics_collector&) = delete;
    network_metrics_collector(network_metrics_collector&&) = delete;
    network_metrics_collector& operator=(network_metrics_collector&&) = delete;
 
    // collector_plugin implementation
    auto name() const -> std::string_view override { return "network_metrics_collector"; }
    auto collect() -> std::vector<metric> override;
    auto interval() const -> std::chrono::milliseconds override { return std::chrono::seconds(10); }
    auto is_available() const -> bool override;
    auto get_metric_types() const -> std::vector<std::string> override;
 
    auto get_metadata() const -> plugin_metadata override {
        return plugin_metadata{
            .name = name(),
            .description = "Network metrics (socket buffers, TCP states)",
            .category = plugin_category::network,
            .version = "1.0.0",
            .dependencies = {},
            .requires_platform_support = true
        };
    }
 
    auto initialize(const config_map& config) -> bool override;
 
    auto get_statistics() const -> stats_map override;
 
    network_metrics get_last_metrics() const;
 
    bool is_socket_buffer_monitoring_available() const;
 
    bool is_tcp_state_monitoring_available() const;
 
   private:
    std::unique_ptr<network_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    network_metrics_config config_;
 
    // Last metrics cache
    network_metrics last_metrics_;
 
    // Statistics
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
 
    // Helper methods
    void add_socket_buffer_metrics(std::vector<metric>& metrics,
                                   const network_metrics& data);
    void add_tcp_state_metrics(std::vector<metric>& metrics,
                               const network_metrics& data);
};
 
}  // namespace monitoring
}  // namespace kcenon