smart_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 smart_disk_metrics {
    // Disk identification
    std::string device_path;       
    std::string model_name;        
    std::string serial_number;     
    std::string firmware_version;  
 
    // Health status
    bool smart_supported{false};  
    bool smart_enabled{false};    
    bool health_ok{true};         
 
    // SMART attributes
    double temperature_celsius{0.0};   
    uint64_t reallocated_sectors{0};   
    uint64_t power_on_hours{0};        
    uint64_t power_cycle_count{0};     
    uint64_t pending_sectors{0};       
    uint64_t uncorrectable_errors{0};  
    uint64_t read_error_rate{0};       
    uint64_t write_error_rate{0};      
 
    // Timestamp
    std::chrono::system_clock::time_point timestamp;
};
 
struct disk_info {
    std::string device_path;      
    std::string device_type;      
    bool smart_available{false};  
};
 
class smart_info_collector {
   public:
    smart_info_collector();
    ~smart_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    smart_info_collector(const smart_info_collector&) = delete;
    smart_info_collector& operator=(const smart_info_collector&) = delete;
    smart_info_collector(smart_info_collector&&) = delete;
    smart_info_collector& operator=(smart_info_collector&&) = delete;
 
    bool is_smartctl_available() const;
 
    std::vector<disk_info> enumerate_disks();
 
    smart_disk_metrics collect_smart_metrics(const disk_info& info);
 
   private:
    mutable std::mutex mutex_;
    mutable bool smartctl_checked_{false};
    mutable bool smartctl_available_{false};
 
    // Helper methods
    std::string execute_command(const std::string& command) const;
    smart_disk_metrics parse_smartctl_json(const std::string& json_output,
                                           const disk_info& info) const;
};
 
class smart_collector : public collector_plugin {
   public:
    smart_collector();
    ~smart_collector() = default;
 
    // Non-copyable, non-moveable due to internal state
    smart_collector(const smart_collector&) = delete;
    smart_collector& operator=(const smart_collector&) = delete;
    smart_collector(smart_collector&&) = delete;
    smart_collector& operator=(smart_collector&&) = delete;
 
    // collector_plugin interface implementation
    auto name() const -> std::string_view override { return "smart_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;
 
    std::vector<smart_disk_metrics> get_last_metrics() const;
 
    bool is_smart_available() const;
 
   private:
    std::unique_ptr<smart_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    bool collect_temperature_{true};
    bool collect_error_rates_{true};
    std::chrono::milliseconds collection_interval_{std::chrono::seconds(300)};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
    std::atomic<size_t> disks_found_{0};
    std::vector<smart_disk_metrics> last_metrics_;
 
    // Helper methods
    metric create_metric(const std::string& name, double value, const smart_disk_metrics& disk,
                         const std::string& unit = "") const;
    void add_disk_metrics(std::vector<metric>& metrics, const smart_disk_metrics& disk);
};
 
}  // namespace monitoring
}  // namespace kcenon