system_resource_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 <array>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <mutex>
#include <numeric>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#ifdef __APPLE__
    #include <mach/mach.h>
    #include <mach/mach_host.h>
    #include <mach/processor_info.h>
    #include <mach/vm_map.h>
    #include <sys/sysctl.h>
    #include <sys/types.h>
#elif __linux__
    #include <sys/sysinfo.h>
    #include <unistd.h>
#elif _WIN32
    #ifndef WIN32_LEAN_AND_MEAN
    #define WIN32_LEAN_AND_MEAN
    #endif
    #ifndef NOMINMAX
    #define NOMINMAX
    #endif
    // winsock2.h must be included before windows.h to avoid redefinition errors
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <windows.h>
    #include <iphlpapi.h>
    #include <psapi.h>
    #pragma comment(lib, "ws2_32.lib")
    #pragma comment(lib, "iphlpapi.lib")
#endif
 
#include "plugin_metric_collector.h"
#include "../utils/time_series_buffer.h"
 
namespace kcenon { namespace monitoring {
 
struct system_metrics_config {
    bool collect_cpu = true;
    bool collect_memory = true;
    bool collect_disk = true;
    bool collect_network = true;
    bool collect_process = true;
    bool enable_load_history = false;
    size_t load_history_max_samples = 1000;
    std::chrono::milliseconds interval = std::chrono::seconds(10);
};
 
struct system_resources {
    struct cpu_metrics {
        double usage_percent{0.0};
        double user_percent{0.0};
        double system_percent{0.0};
        double idle_percent{0.0};
        size_t count{0};
 
        struct load_average {
            double one_min{0.0};
            double five_min{0.0};
            double fifteen_min{0.0};
        } load;
    } cpu;
 
    struct memory_metrics {
        size_t total_bytes{0};
        size_t available_bytes{0};
        size_t used_bytes{0};
        double usage_percent{0.0};
 
        struct swap_info {
            size_t total_bytes{0};
            size_t used_bytes{0};
            double usage_percent{0.0};
        } swap;
    } memory;
 
    struct disk_metrics {
        size_t total_bytes{0};
        size_t used_bytes{0};
        size_t available_bytes{0};
        double usage_percent{0.0};
 
        struct io_throughput {
            size_t read_bytes_per_sec{0};
            size_t write_bytes_per_sec{0};
            size_t read_ops_per_sec{0};
            size_t write_ops_per_sec{0};
        } io;
    } disk;
 
    struct network_metrics {
        size_t rx_bytes_per_sec{0};
        size_t tx_bytes_per_sec{0};
        size_t rx_packets_per_sec{0};
        size_t tx_packets_per_sec{0};
        size_t rx_errors{0};
        size_t tx_errors{0};
        size_t rx_dropped{0};
        size_t tx_dropped{0};
    } network;
 
    struct process_metrics {
        size_t count{0};
        size_t thread_count{0};
        size_t handle_count{0};
        size_t open_file_descriptors{0};
    } process;
 
    struct context_switch_metrics {
        uint64_t total{0};
        uint64_t per_sec{0};
        uint64_t voluntary{0};
        uint64_t nonvoluntary{0};
    } context_switches;
};
 
class system_info_collector {
  public:
    system_info_collector();
    ~system_info_collector();
 
    system_resources collect();
 
    std::chrono::seconds get_uptime() const;
 
    std::string get_hostname() const;
 
    std::string get_os_info() const;
 
  private:
    // CPU tracking for usage calculation
    struct cpu_stats {
        uint64_t user{0};
        uint64_t nice{0};
        uint64_t system{0};
        uint64_t idle{0};
        uint64_t iowait{0};
        uint64_t irq{0};
        uint64_t softirq{0};
        uint64_t steal{0};
    };
 
    mutable std::mutex stats_mutex_;
    cpu_stats last_cpu_stats_;
    std::chrono::steady_clock::time_point last_collection_time_;
 
    // Network tracking
    struct network_stats {
        uint64_t rx_bytes{0};
        uint64_t tx_bytes{0};
        uint64_t rx_packets{0};
        uint64_t tx_packets{0};
        uint64_t rx_errors{0};
        uint64_t tx_errors{0};
        uint64_t rx_dropped{0};
        uint64_t tx_dropped{0};
    };
    network_stats last_network_stats_;
 
    // Disk I/O tracking
    struct disk_stats {
        uint64_t read_bytes{0};
        uint64_t write_bytes{0};
        uint64_t read_ops{0};
        uint64_t write_ops{0};
    };
    disk_stats last_disk_stats_;
 
    // Context switch tracking
    uint64_t last_context_switches_total_{0};
 
    // Platform-specific collection methods
    void collect_cpu_stats(system_resources& resources);
    void collect_memory_stats(system_resources& resources);
    void collect_disk_stats(system_resources& resources);
    void collect_network_stats(system_resources& resources);
    void collect_process_stats(system_resources& resources);
 
#ifdef __APPLE__
    void collect_macos_cpu_stats(system_resources& resources);
    void collect_macos_memory_stats(system_resources& resources);
#elif __linux__
    void collect_linux_cpu_stats(system_resources& resources);
    void collect_linux_memory_stats(system_resources& resources);
    cpu_stats parse_proc_stat();
#elif _WIN32
    void collect_windows_cpu_stats(system_resources& resources);
    void collect_windows_memory_stats(system_resources& resources);
#endif
};
 
class system_resource_collector : public metric_collector_plugin {
  public:
    system_resource_collector();
 
    explicit system_resource_collector(const system_metrics_config& config);
 
    ~system_resource_collector() override = default;
 
    // metric_collector_plugin implementation
    bool initialize(const std::unordered_map<std::string, std::string>& config) override;
    std::vector<metric> collect() override;
    std::string get_name() const override { return "system_resource_collector"; }
    std::vector<std::string> get_metric_types() const override;
    bool is_healthy() const override;
    std::unordered_map<std::string, double> get_statistics() const override;
 
    system_metrics_config get_config() const;
 
    void set_config(const system_metrics_config& config);
 
    system_resources get_last_resources() const;
 
    template <typename Duration>
    std::vector<load_average_sample> get_load_history(Duration duration) const {
        if (load_history_) {
            return load_history_->get_samples(duration);
        }
        return {};
    }
 
    template <typename Duration>
    load_average_statistics get_load_statistics(Duration duration) const {
        if (load_history_) {
            return load_history_->get_statistics(duration);
        }
        return {};
    }
 
    std::vector<load_average_sample> get_all_load_history() const;
 
    load_average_statistics get_all_load_statistics() const;
 
    void configure_load_history(size_t max_samples);
 
    bool is_load_history_enabled() const;
 
  private:
    // Collector implementation
    std::unique_ptr<system_info_collector> collector_;
 
    // Configuration
    bool collect_cpu_metrics_{true};
    bool collect_memory_metrics_{true};
    bool collect_disk_metrics_{true};
    bool collect_network_metrics_{true};
    bool collect_process_metrics_{true};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
    std::atomic<int64_t> init_time_ns_{0};  // Store as nanoseconds for atomic access
    std::shared_ptr<system_resources> last_resources_;  // Use shared_ptr to avoid large struct copy
 
    // Load average history tracking
    std::unique_ptr<load_average_history> load_history_;
    bool enable_load_history_{true};
 
    // Helper methods
    metric create_metric(const std::string& name, double value, const std::string& unit = "",
                         const std::unordered_map<std::string, std::string>& labels = {}) const;
    void add_cpu_metrics(std::vector<metric>& metrics, const system_resources& resources);
    void add_memory_metrics(std::vector<metric>& metrics, const system_resources& resources);
    void add_disk_metrics(std::vector<metric>& metrics, const system_resources& resources);
    void add_network_metrics(std::vector<metric>& metrics, const system_resources& resources);
    void add_process_metrics(std::vector<metric>& metrics, const system_resources& resources);
};
 
class resource_threshold_monitor {
  public:
    struct thresholds {
        double cpu_usage_warn{75.0};
        double cpu_usage_critical{90.0};
        double memory_usage_warn{80.0};
        double memory_usage_critical{95.0};
        double disk_usage_warn{85.0};
        double disk_usage_critical{95.0};
        double swap_usage_warn{50.0};
        double swap_usage_critical{80.0};
    };
 
    struct alert {
        enum class severity { info, warning, critical };
 
        std::string resource;
        severity level;
        double current_value;
        double threshold;
        std::string message;
        std::chrono::steady_clock::time_point timestamp;
    };
 
    explicit resource_threshold_monitor(const thresholds& config);
 
    std::vector<alert> check_thresholds(const system_resources& resources);
 
    void update_thresholds(const thresholds& config);
 
    thresholds get_thresholds() const;
 
    std::vector<alert> get_alert_history(size_t max_count = 100) const;
 
    void clear_history();
 
  private:
    mutable std::mutex config_mutex_;
    thresholds config_;
 
    mutable std::mutex history_mutex_;
    std::vector<alert> alert_history_;
    const size_t max_history_size_{1000};
 
    void check_cpu_usage(std::vector<alert>& alerts, const system_resources& resources);
    void check_memory_usage(std::vector<alert>& alerts, const system_resources& resources);
    void check_disk_usage(std::vector<alert>& alerts, const system_resources& resources);
    void check_swap_usage(std::vector<alert>& alerts, const system_resources& resources);
    void add_alert(std::vector<alert>& alerts, const std::string& resource,
                   alert::severity level, double value, double threshold, const std::string& message);
};
 
} } // namespace kcenon::monitoring