builtin_collectors.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 "collector_adapters.h"
#include "../plugins/collector_registry.h"
 
// Include all collector headers
#include "../collectors/battery_collector.h"
#include "../collectors/interrupt_collector.h"
#include "../collectors/network_metrics_collector.h"
#include "../collectors/platform_metrics_collector.h"
#include "../collectors/process_metrics_collector.h"
#include "../collectors/security_collector.h"
#include "../collectors/smart_collector.h"
#include "../collectors/system_resource_collector.h"
#include "../collectors/uptime_collector.h"
#include "../collectors/vm_collector.h"
 
namespace kcenon::monitoring {
 
inline bool register_builtin_collectors() {
    bool all_success = true;
    auto& registry = collector_registry::instance();
 
    // Register plugin-based collectors with collector_registry for runtime plugin management
    // (Only collectors that implement collector_plugin interface)
    registry.register_factory<battery_collector>("battery_collector");
    registry.register_factory<uptime_collector>("uptime_collector");
    registry.register_factory<interrupt_collector>("interrupt_collector");
    registry.register_factory<network_metrics_collector>("network_metrics_collector");
    registry.register_factory<platform_metrics_collector>("platform_metrics_collector");
    registry.register_factory<process_metrics_collector>("process_metrics_collector");
    registry.register_factory<security_collector>("security_collector");
    registry.register_factory<smart_collector>("smart_collector");
    registry.register_factory<vm_collector>("vm_collector");
 
    // Also register all collectors with metric_factory for backward compatibility
    all_success &= register_plugin_collector<battery_collector>("battery_collector");
    all_success &= register_plugin_collector<uptime_collector>("uptime_collector");
    all_success &= register_plugin_collector<interrupt_collector>("interrupt_collector");
    all_success &= register_plugin_collector<network_metrics_collector>("network_metrics_collector");
    all_success &= register_plugin_collector<platform_metrics_collector>("platform_metrics_collector");
    all_success &= register_plugin_collector<process_metrics_collector>("process_metrics_collector");
    all_success &= register_plugin_collector<security_collector>("security_collector");
    all_success &= register_plugin_collector<smart_collector>("smart_collector");
    all_success &= register_plugin_collector<vm_collector>("vm_collector");
    all_success &= register_standalone_collector<system_resource_collector>("system_resource_collector");
 
    return all_success;
}
 
inline std::vector<std::string> get_builtin_collector_names() {
    return {"battery_collector",
            "uptime_collector",
            "interrupt_collector",
            "network_metrics_collector",
            "platform_metrics_collector",
            "process_metrics_collector",
            "security_collector",
            "smart_collector",
            "vm_collector",
            "system_resource_collector"};
}
 
}  // namespace kcenon::monitoring