kcenon::common::interfaces Namespace Reference

Classes
class	composite_health_check
	Aggregates multiple health checks into a single check. More...
class	GlobalLoggerRegistry
	Thread-safe singleton registry for managing logger instances. More...
interface	health_check
	Abstract base class for health checks. More...
class	health_check_builder
	Fluent builder for creating health checks. More...
struct	health_check_result
	Result of a health check operation. More...
class	health_dependency_graph
	Manages dependencies between health checks as a DAG. More...
class	health_monitor
	Central health monitoring system. More...
struct	health_monitor_stats
	Statistics for health monitoring. More...
struct	http_request
	Represents an HTTP request. More...
struct	http_response
	Represents an HTTP response. More...
class	IDatabase
	Standard interface for database operations. More...
interface	IExecutor
	Abstract interface for task execution systems. More...
interface	IExecutorProvider
	Interface for modules that provide executor implementations. More...
interface	IHttpClient
	Abstract interface for HTTP client implementations. More...
interface	IHttpClientProvider
	Interface for modules that provide HTTP client implementations. More...
interface	IJob
	Abstract job interface for task execution. More...
interface	ILogger
	Standard interface for logging implementations. More...
interface	ILoggerProvider
	Interface for modules that provide logger implementations. More...
interface	ILoggerRegistry
	Phase 2: Global logger registry interface. More...
interface	IMetricCollector
	Abstract interface for collecting metrics across modules. More...
interface	IMetricCollectorProvider
	Interface for modules that provide metric collector implementations. More...
interface	IMonitor
	Standard interface for monitoring implementations. More...
interface	IMonitorable
	Interface for objects that can be monitored. More...
interface	IMonitorProvider
	Interface for modules that provide monitor implementations. More...
interface	IStats
	Interface for components that expose statistics. More...
interface	IThreadPool
	Extended interface for thread pool implementations. More...
interface	IThreadPoolProvider
	Interface for modules that provide thread pool implementations. More...
interface	IUdpClient
	Abstract interface for UDP client implementations. More...
interface	IUdpClientProvider
	Interface for modules that provide UDP client implementations. More...
class	lambda_health_check
	Health check implementation using a lambda function. More...
struct	log_entry
	Standard log entry structure. More...
struct	logger_config
	Configuration for logger instances. More...
struct	metric_value
	Standard metric value structure with type information. More...
struct	metrics_snapshot
	Complete snapshot of metrics at a point in time. More...
class	null_http_client
	Null implementation for when HTTP transport is disabled. More...
class	null_metric_collector
	No-op implementation for when metrics are disabled. More...
class	null_udp_client
	Null implementation for when UDP transport is disabled. More...
class	NullLogger
	A no-op logger implementation for fallback scenarios. More...
struct	registry_event
	Represents a single audit event for registry mutations. More...
class	RegistryAuditLog
	Thread-safe audit log for registry operations. More...
class	scoped_timer
	RAII helper for automatic timing measurements. More...
struct	stats_snapshot
	Point-in-time snapshot of component statistics. More...
struct	system_metrics
	Specialized metrics for system-level monitoring. More...
struct	thread_pool_metrics
	Specialized metrics for thread pool monitoring. More...
struct	udp_endpoint
	Represents a UDP endpoint (host and port) More...
struct	udp_send_options
	Options for UDP send operations. More...
struct	udp_statistics
	Statistics for UDP client operations. More...
struct	worker_metrics
	Specialized metrics for worker thread monitoring. More...

Typedefs
using	metric_labels = std::unordered_map<std::string, std::string>
	Metric labels for dimensional data.
using	kcenon::common::interfaces::ExecutorFactory = std::function<std::shared_ptr<IExecutor>()>
	Factory function type for creating executor instances.
using	kcenon::common::interfaces::LoggerFactory = std::function<std::shared_ptr<ILogger>()>
	Factory function type for creating logger instances.
using	recovery_handler = std::function<bool()>
	Recovery handler function type.
using	MetricCollectorFactory = std::function<std::shared_ptr<IMetricCollector>()>
	Factory function type for creating metric collector instances.
using	MonitorFactory = std::function<std::shared_ptr<IMonitor>()>
	Factory function type for creating monitor instances.
using	source_location = kcenon::common::source_location
using	stats_value
	Type-safe value type for statistics.
using	kcenon::common::interfaces::ThreadPoolFactory = std::function<std::shared_ptr<IThreadPool>(size_t worker_count)>
	Factory function type for creating thread pool instances.
using	http_headers = std::map<std::string, std::string>
	HTTP headers container type.
using	HttpClientFactory = std::function<std::shared_ptr<IHttpClient>()>
	Factory function type for creating HTTP client instances.
using	UdpClientFactory = std::function<std::shared_ptr<IUdpClient>()>
	Factory function type for creating UDP client instances.

Enumerations
enum class	kcenon::common::interfaces::log_level {   trace = 0 , debug = 1 , info = 2 , warning = 3 ,   warn = 3 , error = 4 , critical = 5 , fatal = 5 ,   off = 6 , trace = 0 , debug = 1 , info = 2 ,   warning = 3 , error = 4 , critical = 5 , off = 6 }
	Standard log levels. More...
enum class	health_check_type {   liveness , readiness , startup , dependency ,   custom }
	Types of health checks supported by the system. More...
enum class	metric_type { gauge , counter , histogram , summary }
	Types of metrics supported by the monitoring system. More...
enum class	health_status { healthy = 0 , degraded = 1 , unhealthy = 2 , unknown = 3 }
	Standard health status levels. More...
enum class	registry_action {   register_logger , unregister_logger , set_default_logger , register_factory ,   set_default_factory , clear_loggers , freeze_logger_registry , register_service ,   unregister_service , clear_services , freeze_service_container }
	Types of registry mutation actions. More...
enum class	kcenon::common::interfaces::log_level {   trace = 0 , debug = 1 , info = 2 , warning = 3 ,   warn = 3 , error = 4 , critical = 5 , fatal = 5 ,   off = 6 , trace = 0 , debug = 1 , info = 2 ,   warning = 3 , error = 4 , critical = 5 , off = 6 }

Functions
GlobalLoggerRegistry &	get_registry ()
	Get the global logger registry instance.
std::shared_ptr< ILogger >	get_logger ()
	Get the default logger from the global registry.
std::shared_ptr< ILogger >	get_logger (const std::string &name)
	Get a named logger from the global registry.
std::string	kcenon::common::interfaces::to_string (log_level level)
	Convert log level to string.
log_level	kcenon::common::interfaces::from_string (const std::string &str)
	Parse log level from string (case-insensitive)
std::string	to_string (health_check_type type)
	Convert health check type to string.
Result< health_check_type >	health_check_type_from_string (const std::string &str)
	Convert string to health check type.
health_monitor &	global_health_monitor ()
	Get the global health monitor instance.
std::string	to_string (metric_type type)
	Convert metric type to string.
Result< metric_type >	metric_type_from_string (const std::string &str)
	Convert string to metric type.
std::string	to_string (health_status status)
	Convert health status to string.
const char *	to_string (registry_action action)
	Convert registry_action to string representation.

Typedef Documentation

ExecutorFactory

typedef std::function< std::shared_ptr< IExecutor >()> kcenon::common::interfaces::ExecutorFactory = std::function<std::shared_ptr<IExecutor>()>

export

Factory function type for creating executor instances.

Definition at line 130 of file executor_interface.h.

http_headers

using kcenon::common::interfaces::http_headers = std::map<std::string, std::string>

HTTP headers container type.

Definition at line 31 of file http_client_interface.h.

HttpClientFactory

using kcenon::common::interfaces::HttpClientFactory = std::function<std::shared_ptr<IHttpClient>()>

Factory function type for creating HTTP client instances.

Definition at line 265 of file http_client_interface.h.

LoggerFactory

typedef std::function< std::shared_ptr< ILogger >()> kcenon::common::interfaces::LoggerFactory = std::function<std::shared_ptr<ILogger>()>

export

Factory function type for creating logger instances.

Definition at line 232 of file logger_interface.h.

metric_labels

typedef std::unordered_map< std::string, std::string > kcenon::common::interfaces::metric_labels = std::unordered_map<std::string, std::string>

Metric labels for dimensional data.

Labels allow attaching key-value pairs to metrics for filtering and grouping in monitoring systems (e.g., Prometheus, StatsD).

Example:

metric_labels labels{{"service", "api"}, {"endpoint", "/users"}};
collector->increment("http_requests_total", 1.0, labels);

Definition at line 38 of file monitoring.h.

MetricCollectorFactory

using kcenon::common::interfaces::MetricCollectorFactory = std::function<std::shared_ptr<IMetricCollector>()>

Factory function type for creating metric collector instances.

Definition at line 249 of file metric_collector_interface.h.

MonitorFactory

using kcenon::common::interfaces::MonitorFactory = std::function<std::shared_ptr<IMonitor>()>

Factory function type for creating monitor instances.

Definition at line 339 of file monitoring_interface.h.

recovery_handler

using kcenon::common::interfaces::recovery_handler = std::function<bool()>

Recovery handler function type.

A recovery handler is called when a health check fails. It should attempt to recover the failed component.

Returns

true if recovery was successful

Definition at line 56 of file health_monitor.h.

source_location

using kcenon::common::interfaces::source_location = kcenon::common::source_location

Definition at line 36 of file registry_audit_log.h.

stats_value

typedef std::variant< std::int64_t, double, std::string, bool > kcenon::common::interfaces::stats_value

Initial value:

 std::variant<
    std::int64_t,
    double,
    std::string,
    bool
>

Type-safe value type for statistics.

Supports common metric types: counters, gauges, rates, and boolean flags. Integer counters (request counts, error counts) Floating-point gauges (rates, percentages, latencies) String values (state names, labels) Boolean flags (enabled/disabled, healthy/unhealthy)

Definition at line 30 of file stats_interface.h.

ThreadPoolFactory

typedef std::function< std::shared_ptr< IThreadPool >(size_t worker_count)> kcenon::common::interfaces::ThreadPoolFactory = std::function<std::shared_ptr<IThreadPool>(size_t worker_count)>

export

Factory function type for creating thread pool instances.

Definition at line 163 of file thread_pool_interface.h.

UdpClientFactory

using kcenon::common::interfaces::UdpClientFactory = std::function<std::shared_ptr<IUdpClient>()>

Factory function type for creating UDP client instances.

Definition at line 311 of file udp_client_interface.h.

Enumeration Type Documentation

health_check_type

enum class kcenon::common::interfaces::health_check_type

strong

Types of health checks supported by the system.

Enumerator
liveness
readiness
startup
dependency
custom

Definition at line 31 of file health_check.h.

                             {
    liveness,   // Basic alive check - is the service running?
    readiness,  // Ready to accept traffic?
    startup,    // Has the service completed initialization?
    dependency, // External dependency check (database, cache, etc.)
    custom      // User-defined health check type
};

health_status

enum class kcenon::common::interfaces::health_status

strong

Standard health status levels.

Enumerator
healthy
degraded
unhealthy
unknown

Definition at line 207 of file monitoring_interface.h.

                         {
    healthy = 0,
    degraded = 1,
    unhealthy = 2,
    unknown = 3
};

log_level [1/2]

enum class kcenon::common::interfaces::log_level

exportstrong

Standard log levels.

Note

v3.0.0: Added 'warn' and 'fatal' as aliases for 'warning' and 'critical' respectively, for backward compatibility with logger_system::log_level.

Enumerator
trace
debug
info
warning
warn	Alias for warning (backward compatibility)
error
critical
fatal	Alias for critical (backward compatibility)
off
trace
debug
info
warning
error
critical
off

Definition at line 41 of file logger_interface.h.

                     {
    trace = 0,
    debug = 1,
    info = 2,
    warning = 3,
    warn = 3,       
    error = 4,
    critical = 5,
    fatal = 5,      
    off = 6
};

log_level [2/2]

enum class kcenon::common::interfaces::log_level

exportstrong

Enumerator
trace
debug
info
warning
warn	Alias for warning (backward compatibility)
error
critical
fatal	Alias for critical (backward compatibility)
off
trace
debug
info
warning
error
critical
off

Definition at line 51 of file logger.cppm.

                     {
    trace = 0,
    debug = 1,
    info = 2,
    warning = 3,
    error = 4,
    critical = 5,
    off = 6
};

metric_type

enum class kcenon::common::interfaces::metric_type

strong

Types of metrics supported by the monitoring system.

Enumerator
gauge
counter
histogram
summary

Definition at line 36 of file monitoring_interface.h.

                       {
    gauge,      // Instant value that can go up or down
    counter,    // Monotonic increasing value
    histogram,  // Distribution of values across buckets
    summary     // Statistical summary (min, max, mean, percentiles)
};

registry_action

enum class kcenon::common::interfaces::registry_action

strong

Types of registry mutation actions.

Enumerator
register_logger	Logger registration.
unregister_logger	Logger unregistration.
set_default_logger	Default logger set.
register_factory	Factory registration (logger)
set_default_factory	Default factory set (logger)
clear_loggers	Clear all loggers.
freeze_logger_registry	Freeze logger registry.
register_service	Service registration.
unregister_service	Service unregistration.
clear_services	Clear all services.
freeze_service_container	Freeze service container.

Definition at line 42 of file registry_audit_log.h.

                           {
    register_logger,      
    unregister_logger,    
    set_default_logger,   
    register_factory,     
    set_default_factory,  
    clear_loggers,        
    freeze_logger_registry,  
    register_service,     
    unregister_service,   
    clear_services,       
    freeze_service_container  
};

Function Documentation

from_string()

log_level kcenon::common::interfaces::from_string ( const std::string & str )

inlineexport

Parse log level from string (case-insensitive)

Supports aliases: WARN -> warning, FATAL -> critical

Definition at line 334 of file logger_interface.h.

                                                   {
    std::string upper(str.size(), '\0');
    std::transform(str.begin(), str.end(), upper.begin(),
                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
 
    // Handle aliases first
    if (upper == "WARN") {
        return log_level::warning;
    }
    if (upper == "FATAL") {
        return log_level::critical;
    }
 
    // Use generic template for standard values
    auto result = enum_from_string<log_level>(str);
    return result.is_ok() ? result.value() : log_level::info;  // default
}

References critical, kcenon::common::enum_from_string(), info, and warning.

Here is the call graph for this function:

get_logger() [1/2]

std::shared_ptr< ILogger > kcenon::common::interfaces::get_logger ( )

inline

Get the default logger from the global registry.

Convenience function to get the default logger. Returns NullLogger if no default logger is registered.

Returns

Default logger or NullLogger

Definition at line 752 of file global_logger_registry.h.

                                           {
    return GlobalLoggerRegistry::instance().get_default_logger();
}

References kcenon::common::interfaces::GlobalLoggerRegistry::get_default_logger(), and kcenon::common::interfaces::GlobalLoggerRegistry::instance().

Referenced by kcenon::common::logging::flush(), kcenon::common::logging::flush(), kcenon::common::logging::is_enabled(), kcenon::common::logging::is_enabled(), kcenon::common::logging::log(), and kcenon::common::logging::log().

Here is the call graph for this function:

Here is the caller graph for this function:

get_logger() [2/2]

std::shared_ptr< ILogger > kcenon::common::interfaces::get_logger ( const std::string & name )

inline

Get a named logger from the global registry.

Convenience function to get a named logger. Returns NullLogger if the specified logger is not registered.

Parameters

name	Logger name

Returns

Named logger or NullLogger

Definition at line 765 of file global_logger_registry.h.

                                                                {
    return GlobalLoggerRegistry::instance().get_logger(name);
}

References kcenon::common::interfaces::GlobalLoggerRegistry::get_logger(), and kcenon::common::interfaces::GlobalLoggerRegistry::instance().

Here is the call graph for this function:

get_registry()

GlobalLoggerRegistry & kcenon::common::interfaces::get_registry ( )

inline

Get the global logger registry instance.

Convenience function to access the GlobalLoggerRegistry singleton.

Returns

Reference to the GlobalLoggerRegistry

Definition at line 740 of file global_logger_registry.h.

                                            {
    return GlobalLoggerRegistry::instance();
}

References kcenon::common::interfaces::GlobalLoggerRegistry::instance().

Here is the call graph for this function:

global_health_monitor()

health_monitor & kcenon::common::interfaces::global_health_monitor ( )

inline

Get the global health monitor instance.

Returns

Reference to the global health monitor singleton

This function provides access to a global health monitor instance for application-wide health monitoring.

Example usage:

auto& monitor = global_health_monitor();
monitor.register_check("database", db_check);

Definition at line 403 of file health_monitor.h.

                                               {
    static health_monitor instance;
    return instance;
}

health_check_type_from_string()

Result< health_check_type > kcenon::common::interfaces::health_check_type_from_string ( const std::string & str )

inline

Convert string to health check type.

Definition at line 72 of file health_check.h.

                                                                                     {
    return enum_from_string<health_check_type>(str);
}

References kcenon::common::enum_from_string().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

metric_type_from_string()

Result< metric_type > kcenon::common::interfaces::metric_type_from_string ( const std::string & str )

inline

Convert string to metric type.

Definition at line 71 of file monitoring_interface.h.

                                                                         {
    return enum_from_string<metric_type>(str);
}

References kcenon::common::enum_from_string().

Here is the call graph for this function:

to_string() [1/5]

std::string kcenon::common::interfaces::to_string ( health_check_type type )

inline

Convert health check type to string.

Definition at line 65 of file health_check.h.

                                                   {
    return enum_to_string(type);
}

References kcenon::common::enum_to_string().

Here is the call graph for this function:

to_string() [2/5]

std::string kcenon::common::interfaces::to_string ( health_status status )

inline

Convert health status to string.

Definition at line 366 of file monitoring_interface.h.

                                                 {
    return enum_to_string(status);
}

References kcenon::common::enum_to_string().

Here is the call graph for this function:

to_string() [3/5]

std::string kcenon::common::interfaces::to_string ( log_level level )

inlineexport

Convert log level to string.

Definition at line 325 of file logger_interface.h.

                                            {
    return enum_to_string(level);
}

References kcenon::common::enum_to_string().

Referenced by kcenon::common::interfaces::health_monitor::get_health_report(), kcenon::common::interfaces::health_monitor::get_overall_status_string(), kcenon::common::logging::ConsoleLogger::log(), kcenon::common::logging::ConsoleLogger::log(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

to_string() [4/5]

std::string kcenon::common::interfaces::to_string ( metric_type type )

inline

Convert metric type to string.

Definition at line 64 of file monitoring_interface.h.

                                             {
    return enum_to_string(type);
}

References kcenon::common::enum_to_string().

Here is the call graph for this function:

to_string() [5/5]

const char * kcenon::common::interfaces::to_string ( registry_action action )

inline

Convert registry_action to string representation.

Parameters

action

The action to convert

Returns

Human-readable string

Definition at line 61 of file registry_audit_log.h.

                                                     {
    switch (action) {
        case registry_action::register_logger: return "register_logger";
        case registry_action::unregister_logger: return "unregister_logger";
        case registry_action::set_default_logger: return "set_default_logger";
        case registry_action::register_factory: return "register_factory";
        case registry_action::set_default_factory: return "set_default_factory";
        case registry_action::clear_loggers: return "clear_loggers";
        case registry_action::freeze_logger_registry: return "freeze_logger_registry";
        case registry_action::register_service: return "register_service";
        case registry_action::unregister_service: return "unregister_service";
        case registry_action::clear_services: return "clear_services";
        case registry_action::freeze_service_container: return "freeze_service_container";
        default: return "unknown";
    }
}

References clear_loggers, clear_services, freeze_logger_registry, freeze_service_container, register_factory, register_logger, register_service, set_default_factory, set_default_logger, unregister_logger, and unregister_service.