vm_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 {
 
enum class vm_type {
    none = 0,       
    kvm = 1,        
    hyperv = 2,     
    vmware = 3,     
    virtualbox = 4, 
    xen = 5,        
    docker = 6,     
    other = 7       
};
 
inline std::string vm_type_to_string(vm_type type) {
    switch (type) {
        case vm_type::none: return "NONE";
        case vm_type::kvm: return "KVM";
        case vm_type::hyperv: return "HYPER-V";
        case vm_type::vmware: return "VMWARE";
        case vm_type::virtualbox: return "VIRTUALBOX";
        case vm_type::xen: return "XEN";
        case vm_type::docker: return "DOCKER";
        case vm_type::other: return "OTHER";
        default: return "UNKNOWN";
    }
}
 
struct vm_metrics {
    bool is_virtualized{false};      
    vm_type type{vm_type::none};     
    double guest_cpu_steal_time{0.0}; 
    std::string hypervisor_vendor;   
    
    // Additional possibilities:
    // - host_physical_cpu_count (if exposed)
    // - ballooned_memory (if relevant)
};
 
class vm_info_collector {
   public:
    vm_info_collector();
    ~vm_info_collector();
 
    // Mac-specific / Platform-specific detection
    vm_metrics collect_metrics();
 
   private:
    // Caching static info since VM type doesn't change at runtime usually
    bool info_cached_{false};
    vm_metrics cached_metrics_;
    
    void detect_vm_environment();
    double get_steal_time();
};
 
class vm_collector : public collector_plugin {
   public:
    vm_collector();
    ~vm_collector() = default;
 
    // Non-copyable, non-moveable
    vm_collector(const vm_collector&) = delete;
    vm_collector& operator=(const vm_collector&) = delete;
    vm_collector(vm_collector&&) = delete;
    vm_collector& operator=(vm_collector&&) = delete;
 
    // collector_plugin interface implementation
    auto name() const -> std::string_view override { return "vm_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;
    auto get_metric_types() const -> std::vector<std::string> override;
 
    bool initialize(const std::unordered_map<std::string, std::string>& config) override;
 
 
    std::unordered_map<std::string, double> get_statistics() const override;
 
   private:
    std::unique_ptr<vm_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    std::chrono::milliseconds collection_interval_{std::chrono::seconds(30)};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
 
    // Helper methods
    metric create_metric(const std::string& name, double value,
                         const std::unordered_map<std::string, std::string>& tags = {},
                         const std::string& unit = "") const;
};
 
}  // namespace monitoring
}  // namespace kcenon