hardware_plugin.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 <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../../collectors/plugin_metric_collector.h"
 
namespace kcenon {
namespace monitoring {
 
// Forward declarations for internal collectors
class battery_collector;
class power_collector;
class temperature_collector;
class gpu_collector;
 
namespace plugins {
 
struct hardware_plugin_config {
    bool enable_battery = true;
 
    bool enable_power = true;
 
    bool enable_temperature = true;
 
    bool enable_gpu = false;
 
    bool battery_collect_health = true;
    bool battery_collect_thermal = true;
 
    bool power_collect_battery = true;
    bool power_collect_rapl = true;
 
    bool temperature_collect_thresholds = true;
    bool temperature_collect_warnings = true;
 
    bool gpu_collect_utilization = true;
    bool gpu_collect_memory = true;
    bool gpu_collect_temperature = true;
    bool gpu_collect_power = true;
    bool gpu_collect_clock = true;
    bool gpu_collect_fan = true;
};
 
class hardware_plugin : public metric_collector_plugin {
   public:
    static std::unique_ptr<hardware_plugin> create(const hardware_plugin_config& config = {});
 
    ~hardware_plugin() override;
 
    // Disable copy
    hardware_plugin(const hardware_plugin&) = delete;
    hardware_plugin& operator=(const hardware_plugin&) = delete;
 
    // metric_collector_plugin interface
    bool initialize(const std::unordered_map<std::string, std::string>& config) override;
    std::vector<metric> collect() override;
    std::string get_name() const override;
    std::vector<std::string> get_metric_types() const override;
    bool is_healthy() const override;
    std::unordered_map<std::string, double> get_statistics() const override;
 
    bool is_battery_available() const;
 
    bool is_power_available() const;
 
    bool is_temperature_available() const;
 
    bool is_gpu_available() const;
 
    hardware_plugin_config get_config() const;
 
   private:
    explicit hardware_plugin(const hardware_plugin_config& config);
 
    // Internal collectors
    std::unique_ptr<battery_collector> battery_collector_;
    std::unique_ptr<power_collector> power_collector_;
    std::unique_ptr<temperature_collector> temperature_collector_;
    std::unique_ptr<gpu_collector> gpu_collector_;
 
    // Configuration
    hardware_plugin_config config_;
    bool initialized_{false};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> total_collections_{0};
    std::atomic<size_t> collection_errors_{0};
 
    // Helper methods
    void initialize_collectors();
};
 
}  // namespace plugins
}  // namespace monitoring
}  // namespace kcenon