collector_base.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 <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
 
namespace kcenon {
namespace monitoring {
 
using config_map = std::unordered_map<std::string, std::string>;
 
using stats_map = std::unordered_map<std::string, double>;
 
template <typename Derived>
class collector_base {
   public:
    collector_base() = default;
    virtual ~collector_base() = default;
 
    // Non-copyable, non-moveable
    collector_base(const collector_base&) = delete;
    collector_base& operator=(const collector_base&) = delete;
    collector_base(collector_base&&) = delete;
    collector_base& operator=(collector_base&&) = delete;
 
    bool initialize(const config_map& config) {
        // Parse common configuration
        if (auto it = config.find("enabled"); it != config.end()) {
            enabled_ = (it->second == "true" || it->second == "1");
        }
 
        // Delegate to derived class for specific initialization
        return derived().do_initialize(config);
    }
 
    std::vector<metric> collect() {
        if (!enabled_) {
            return {};
        }
 
        try {
            auto metrics = derived().do_collect();
            ++collection_count_;
            return metrics;
        } catch (...) {
            ++collection_errors_;
            return {};
        }
    }
 
    std::string get_name() const {
        return Derived::collector_name;
    }
 
    std::vector<std::string> get_metric_types() const {
        return derived().do_get_metric_types();
    }
 
    bool is_healthy() const {
        if (!enabled_) {
            return true;  // Disabled collectors are considered healthy
        }
        return derived().is_available();
    }
 
    stats_map get_statistics() const {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        stats_map stats;
 
        // Common statistics
        stats["enabled"] = enabled_ ? 1.0 : 0.0;
        stats["collection_count"] = static_cast<double>(collection_count_.load());
        stats["collection_errors"] = static_cast<double>(collection_errors_.load());
 
        // Let derived class add specific statistics
        derived().do_add_statistics(stats);
 
        return stats;
    }
 
    bool is_enabled() const { return enabled_; }
 
    size_t get_collection_count() const { return collection_count_.load(); }
 
    size_t get_collection_errors() const { return collection_errors_.load(); }
 
   protected:
    metric create_base_metric(const std::string& name, double value,
                              const std::unordered_map<std::string, std::string>& tags = {},
                              const std::string& /* unit */ = "") const {
        metric m;
        m.name = name;
        m.value = value;
        m.timestamp = std::chrono::system_clock::now();
        m.tags = tags;
        m.tags["collector"] = Derived::collector_name;
        return m;
    }
 
    // Configuration
    bool enabled_{true};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
 
   private:
    Derived& derived() { return static_cast<Derived&>(*this); }
    const Derived& derived() const { return static_cast<const Derived&>(*this); }
};
 
}  // namespace monitoring
}  // namespace kcenon