metric_factory.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 <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../utils/config_parser.h"
 
namespace kcenon::monitoring {
 
class metric_collector_plugin;
 
class collector_interface {
   public:
    collector_interface() = default;
    virtual ~collector_interface() = default;
 
    // Non-copyable, non-moveable
    collector_interface(const collector_interface&) = delete;
    collector_interface& operator=(const collector_interface&) = delete;
    collector_interface(collector_interface&&) = delete;
    collector_interface& operator=(collector_interface&&) = delete;
 
    virtual bool initialize(const config_map& config) = 0;
 
    [[nodiscard]] virtual std::string get_name() const = 0;
 
    [[nodiscard]] virtual bool is_healthy() const = 0;
 
    [[nodiscard]] virtual std::vector<std::string> get_metric_types() const = 0;
};
 
struct create_result {
    std::unique_ptr<collector_interface> collector;
    bool success{false};
    std::string error_message;
 
    explicit operator bool() const { return success; }
};
 
using collector_factory_fn = std::function<std::unique_ptr<collector_interface>()>;
 
class metric_factory {
   public:
    static metric_factory& instance() {
        static metric_factory instance;
        return instance;
    }
 
    ~metric_factory() = default;
 
    // Non-copyable, non-moveable
    metric_factory(const metric_factory&) = delete;
    metric_factory& operator=(const metric_factory&) = delete;
    metric_factory(metric_factory&&) = delete;
    metric_factory& operator=(metric_factory&&) = delete;
 
    bool register_collector(const std::string& name, collector_factory_fn factory) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (factories_.find(name) != factories_.end()) {
            return false;
        }
        factories_[name] = std::move(factory);
        return true;
    }
 
    template <typename T>
    bool register_collector(const std::string& name) {
        return register_collector(name, []() {
            return std::make_unique<T>();
        });
    }
 
    bool unregister_collector(const std::string& name) {
        std::lock_guard<std::mutex> lock(mutex_);
        return factories_.erase(name) > 0;
    }
 
    bool is_registered(const std::string& name) const {
        std::lock_guard<std::mutex> lock(mutex_);
        return factories_.find(name) != factories_.end();
    }
 
    std::vector<std::string> get_registered_collectors() const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::string> names;
        names.reserve(factories_.size());
        for (const auto& [name, _] : factories_) {
            names.push_back(name);
        }
        return names;
    }
 
    create_result create(const std::string& name, const config_map& config = {}) {
        create_result result;
 
        // Find factory
        collector_factory_fn factory;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            auto it = factories_.find(name);
            if (it == factories_.end()) {
                result.error_message = "Unknown collector: " + name;
                return result;
            }
            factory = it->second;
        }
 
        // Create collector
        try {
            result.collector = factory();
            if (!result.collector) {
                result.error_message = "Factory returned null for: " + name;
                return result;
            }
        } catch (const std::exception& e) {
            result.error_message = "Failed to create collector '" + name + "': " + e.what();
            return result;
        } catch (...) {
            result.error_message = "Unknown error creating collector: " + name;
            return result;
        }
 
        // Initialize collector
        try {
            if (!result.collector->initialize(config)) {
                result.error_message = "Initialization failed for: " + name;
                result.collector.reset();
                return result;
            }
        } catch (const std::exception& e) {
            result.error_message =
                "Exception during initialization of '" + name + "': " + e.what();
            result.collector.reset();
            return result;
        } catch (...) {
            result.error_message = "Unknown error initializing collector: " + name;
            result.collector.reset();
            return result;
        }
 
        result.success = true;
        return result;
    }
 
    std::unique_ptr<collector_interface> create_or_null(const std::string& name,
                                                         const config_map& config = {}) {
        auto result = create(name, config);
        return std::move(result.collector);
    }
 
    std::vector<std::unique_ptr<collector_interface>> create_multiple(
        const std::unordered_map<std::string, config_map>& configs) {
        std::vector<std::unique_ptr<collector_interface>> collectors;
        collectors.reserve(configs.size());
 
        for (const auto& [name, config] : configs) {
            auto result = create(name, config);
            if (result) {
                collectors.push_back(std::move(result.collector));
            }
        }
 
        return collectors;
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        factories_.clear();
    }
 
   private:
    metric_factory() = default;
 
    mutable std::mutex mutex_;
    std::unordered_map<std::string, collector_factory_fn> factories_;
};
 
#define REGISTER_COLLECTOR(CollectorType)                                   \
    namespace {                                                              \
    static const bool CollectorType##_registered = []() {                   \
        return kcenon::monitoring::metric_factory::instance()               \
            .register_collector<CollectorType>(#CollectorType);             \
    }();                                                                     \
    }
 
}  // namespace kcenon::monitoring