kcenon::monitoring::metric_factory Class Reference

Unified factory for metric collector instantiation. More...

#include <metric_factory.h>

Collaboration diagram for kcenon::monitoring::metric_factory:

Public Member Functions
	~metric_factory ()=default
	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)
	Register a collector factory function.
template<typename T >
bool	register_collector (const std::string &name)
	Register a collector type using template.
bool	unregister_collector (const std::string &name)
	Unregister a collector.
bool	is_registered (const std::string &name) const
	Check if a collector is registered.
std::vector< std::string >	get_registered_collectors () const
	Get list of registered collector names.
create_result	create (const std::string &name, const config_map &config={})
	Create a collector instance.
std::unique_ptr< collector_interface >	create_or_null (const std::string &name, const config_map &config={})
	Create a collector and return raw pointer (for compatibility)
std::vector< std::unique_ptr< collector_interface > >	create_multiple (const std::unordered_map< std::string, config_map > &configs)
	Create multiple collectors from configuration.
void	clear ()
	Clear all registered collectors.

Static Public Member Functions
static metric_factory &	instance ()
	Get the singleton instance.

Private Member Functions
	metric_factory ()=default

Private Attributes
std::mutex	mutex_
std::unordered_map< std::string, collector_factory_fn >	factories_

Detailed Description

Unified factory for metric collector instantiation.

This singleton factory provides centralized creation and configuration of metric collectors. Features include:

• Type-safe collector registration
• Centralized configuration validation
• Consistent error handling
• Support for custom collectors

Thread-safe for all operations.

Definition at line 118 of file metric_factory.h.

Constructor & Destructor Documentation

~metric_factory()

kcenon::monitoring::metric_factory::~metric_factory ( )

default

metric_factory() [1/3]

kcenon::monitoring::metric_factory::metric_factory ( const metric_factory & )

delete

metric_factory() [2/3]

kcenon::monitoring::metric_factory::metric_factory ( metric_factory && )

delete

metric_factory() [3/3]

kcenon::monitoring::metric_factory::metric_factory ( )

privatedefault

Member Function Documentation

clear()

void kcenon::monitoring::metric_factory::clear ( )

inline

Clear all registered collectors.

Definition at line 292 of file metric_factory.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
        factories_.clear();
    }

References factories_, and mutex_.

create()

create_result kcenon::monitoring::metric_factory::create ( const std::string & name, const config_map & config = {} )

inline

Create a collector instance.

Parameters

name	The collector name
config	Configuration options

Returns

create_result containing the collector or error information

Definition at line 205 of file metric_factory.h.

                                                                           {}) {
        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;
    }

Referenced by create_multiple().

Here is the caller graph for this function:

create_multiple()

std::vector< std::unique_ptr< collector_interface > > kcenon::monitoring::metric_factory::create_multiple ( const std::unordered_map< std::string, config_map > & configs )

inline

Create multiple collectors from configuration.

Parameters

configs

Map of collector name to configuration

Returns

Vector of created collectors (only successfully created ones)

Definition at line 274 of file metric_factory.h.

                                                                {
        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;
    }

References kcenon::monitoring::create_result::collector, and create().

Here is the call graph for this function:

create_or_null()

std::unique_ptr< collector_interface > kcenon::monitoring::metric_factory::create_or_null ( const std::string & name, const config_map & config = {} )

inline

Create a collector and return raw pointer (for compatibility)

Parameters

name	The collector name
config	Configuration options

Returns

Unique pointer to collector, or nullptr on failure

Definition at line 263 of file metric_factory.h.

                                                                                    {}) {
        auto result = create(name, config);
        return std::move(result.collector);
    }

get_registered_collectors()

std::vector< std::string > kcenon::monitoring::metric_factory::get_registered_collectors ( ) const

inline

Get list of registered collector names.

Returns

Vector of registered collector names

Definition at line 189 of file metric_factory.h.

                                                           {
        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;
    }

References factories_, and mutex_.

instance()

static metric_factory & kcenon::monitoring::metric_factory::instance ( )

inlinestatic

Get the singleton instance.

Returns

Reference to the global factory instance

Definition at line 124 of file metric_factory.h.

                                      {
        static metric_factory instance;
        return instance;
    }

References instance().

Referenced by instance(), main(), kcenon::monitoring::register_crtp_collector(), kcenon::monitoring::register_plugin_collector(), and kcenon::monitoring::register_standalone_collector().

Here is the call graph for this function:

Here is the caller graph for this function:

is_registered()

bool kcenon::monitoring::metric_factory::is_registered ( const std::string & name ) const

inline

Check if a collector is registered.

Parameters

name	The collector name to check

Returns

true if collector is registered

Definition at line 180 of file metric_factory.h.

                                                    {
        std::lock_guard<std::mutex> lock(mutex_);
        return factories_.find(name) != factories_.end();
    }

References factories_, and mutex_.

operator=() [1/2]

metric_factory & kcenon::monitoring::metric_factory::operator= ( const metric_factory & )

delete

operator=() [2/2]

metric_factory & kcenon::monitoring::metric_factory::operator= ( metric_factory && )

delete

register_collector() [1/2]

template<typename T >

bool kcenon::monitoring::metric_factory::register_collector ( const std::string & name )

inline

Register a collector type using template.

Template Parameters

T	The collector type (must derive from collector_interface)

Parameters

name	The collector name (identifier)

Returns

true if registration successful

Definition at line 159 of file metric_factory.h.

                                                   {
        return register_collector(name, []() {
            return std::make_unique<T>();
        });
    }

References register_collector().

Here is the call graph for this function:

register_collector() [2/2]

bool kcenon::monitoring::metric_factory::register_collector ( const std::string & name, collector_factory_fn factory )

inline

Register a collector factory function.

Parameters

name	The collector name (identifier)
factory	Factory function that creates the collector

Returns

true if registration successful, false if name already exists

Definition at line 143 of file metric_factory.h.

                                                                                 {
        std::lock_guard<std::mutex> lock(mutex_);
        if (factories_.find(name) != factories_.end()) {
            return false;
        }
        factories_[name] = std::move(factory);
        return true;
    }

References factories_, and mutex_.

Referenced by register_collector(), kcenon::monitoring::register_crtp_collector(), kcenon::monitoring::register_plugin_collector(), and kcenon::monitoring::register_standalone_collector().

Here is the caller graph for this function:

unregister_collector()

bool kcenon::monitoring::metric_factory::unregister_collector ( const std::string & name )

inline

Unregister a collector.

Parameters

name	The collector name to unregister

Returns

true if collector was registered and removed

Definition at line 170 of file metric_factory.h.

                                                     {
        std::lock_guard<std::mutex> lock(mutex_);
        return factories_.erase(name) > 0;
    }

References factories_, and mutex_.

Member Data Documentation

factories_

std::unordered_map<std::string, collector_factory_fn> kcenon::monitoring::metric_factory::factories_

private

Definition at line 301 of file metric_factory.h.

Referenced by clear(), get_registered_collectors(), is_registered(), register_collector(), and unregister_collector().

mutex_

std::mutex kcenon::monitoring::metric_factory::mutex_

mutableprivate

Definition at line 300 of file metric_factory.h.

Referenced by clear(), get_registered_collectors(), is_registered(), register_collector(), and unregister_collector().

---

The documentation for this class was generated from the following file:

• include/kcenon/monitoring/factory/metric_factory.h