collector_registry.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 <map>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "collector_plugin.h"
#include "plugin_loader.h"
 
namespace kcenon {
namespace monitoring {
 
class collector_registry {
public:
    static auto instance() -> collector_registry&;
 
    auto register_plugin(std::unique_ptr<collector_plugin> plugin) -> bool;
 
    auto unregister_plugin(std::string_view name) -> bool;
 
    template <typename T>
    void register_factory(std::string_view name) {
        static_assert(std::is_base_of_v<collector_plugin, T>,
                      "T must derive from collector_plugin");
 
        std::lock_guard<std::mutex> lock(mutex_);
        factories_[std::string(name)] = []() -> std::unique_ptr<collector_plugin> {
            return std::make_unique<T>();
        };
    }
 
    auto get_plugin(std::string_view name) -> collector_plugin*;
 
    auto get_plugins() -> std::vector<collector_plugin*>;
 
    auto get_plugins_by_category(plugin_category category)
        -> std::vector<collector_plugin*>;
 
    auto initialize_all(const config_map& config = {}) -> size_t;
 
    void shutdown_all();
 
    auto get_registry_stats() const -> std::map<std::string, size_t>;
 
    auto has_plugin(std::string_view name) const -> bool;
 
    auto plugin_count() const -> size_t;
 
    auto load_plugin(std::string_view path) -> bool;
 
    auto unload_plugin(std::string_view name) -> bool;
 
    auto get_plugin_loader_error() const -> std::string;
 
    void clear();
 
    // Non-copyable, non-moveable
    collector_registry(const collector_registry&) = delete;
    collector_registry& operator=(const collector_registry&) = delete;
    collector_registry(collector_registry&&) = delete;
    collector_registry& operator=(collector_registry&&) = delete;
 
private:
    collector_registry() = default;
    ~collector_registry();
 
    auto instantiate_from_factory(const std::string& name) -> bool;
 
    // Plugin storage
    std::unordered_map<std::string, std::unique_ptr<collector_plugin>> plugins_;
 
    // Factory storage for lazy instantiation
    std::unordered_map<std::string, plugin_factory_fn> factories_;
 
    // Initialization tracking
    std::unordered_map<std::string, bool> initialized_;
 
    // Thread safety
    mutable std::mutex mutex_;
 
    // Shutdown flag
    bool shutdown_{false};
 
    // Dynamic plugin loader
    std::unique_ptr<dynamic_plugin_loader> plugin_loader_;
};
 
} // namespace monitoring
} // namespace kcenon