container_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 <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
 
namespace kcenon {
namespace monitoring {
 
struct container_metrics {
    // Container identification
    std::string container_id;    
    std::string container_name;  
    std::string image_name;      
 
    // CPU metrics
    double cpu_usage_percent{0.0};  
    uint64_t cpu_usage_ns{0};       
 
    // Memory metrics
    uint64_t memory_usage_bytes{0};    
    uint64_t memory_limit_bytes{0};    
    double memory_usage_percent{0.0};  
 
    // Network metrics (counters)
    uint64_t network_rx_bytes{0};  
    uint64_t network_tx_bytes{0};  
 
    // Block I/O metrics (counters)
    uint64_t blkio_read_bytes{0};   
    uint64_t blkio_write_bytes{0};  
 
    // Process metrics
    uint64_t pids_current{0};  
    uint64_t pids_limit{0};    
 
    // Timestamp
    std::chrono::system_clock::time_point timestamp;
};
 
struct container_info {
    std::string container_id;
    std::string container_name;
    std::string image_name;
    std::string cgroup_path;  
    bool is_running{false};
};
 
enum class cgroup_version : uint8_t {
    none = 0,  
    v1 = 1,    
    v2 = 2     
};
 
class container_info_collector {
   public:
    container_info_collector();
    ~container_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    container_info_collector(const container_info_collector&) = delete;
    container_info_collector& operator=(const container_info_collector&) = delete;
    container_info_collector(container_info_collector&&) = delete;
    container_info_collector& operator=(container_info_collector&&) = delete;
 
    cgroup_version detect_cgroup_version() const;
 
    std::vector<container_info> enumerate_containers();
 
    container_metrics collect_container_metrics(const container_info& info);
 
    bool is_containerized() const;
 
   private:
    mutable std::mutex mutex_;
    cgroup_version cached_version_{cgroup_version::none};
    bool version_detected_{false};
 
    // Previous CPU stats for calculating usage percentage
    struct cpu_stats {
        uint64_t usage_ns{0};
        std::chrono::steady_clock::time_point timestamp;
    };
    std::unordered_map<std::string, cpu_stats> prev_cpu_stats_;
 
    // Platform-specific methods
#if defined(__linux__)
    cgroup_version detect_cgroup_version_linux() const;
    std::vector<container_info> enumerate_containers_cgroup_v2();
    std::vector<container_info> enumerate_containers_cgroup_v1();
    container_metrics collect_metrics_cgroup_v2(const container_info& info);
    container_metrics collect_metrics_cgroup_v1(const container_info& info);
 
    // Helper methods for cgroup parsing
    uint64_t read_cgroup_value(const std::string& path, const std::string& key = "") const;
    std::unordered_map<std::string, uint64_t> read_cgroup_stat(const std::string& path) const;
#endif
};
 
class container_collector : public collector_plugin {
   public:
    container_collector();
    ~container_collector() override = default;
 
    // Non-copyable, non-moveable due to internal state
    container_collector(const container_collector&) = delete;
    container_collector& operator=(const container_collector&) = delete;
    container_collector(container_collector&&) = delete;
    container_collector& operator=(container_collector&&) = delete;
 
    // collector_plugin implementation
    auto name() const -> std::string_view override { return "container"; }
    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 = "Container metrics from Docker and cgroups",
            .category = plugin_category::system,
            .version = "1.0.0",
            .dependencies = {},
            .requires_platform_support = true  // Linux-specific
        };
    }
 
    auto initialize(const config_map& config) -> bool override;
    void shutdown() override {}
    auto get_statistics() const -> stats_map override;
 
    std::vector<container_metrics> get_last_metrics() const;
 
    bool is_container_environment() const;
 
   private:
    std::unique_ptr<container_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    bool collect_network_metrics_{true};
    bool collect_blkio_metrics_{true};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
    std::atomic<size_t> containers_found_{0};
    std::vector<container_metrics> last_metrics_;
 
    // Helper methods
    metric create_metric(const std::string& name, double value, const container_metrics& container,
                         const std::string& unit = "") const;
    void add_container_metrics(std::vector<metric>& metrics, const container_metrics& container);
};
 
}  // namespace monitoring
}  // namespace kcenon