Namespaces
namespace	adapters

namespace	collectors

namespace	concepts

namespace	core

namespace	detail

namespace	exporters

namespace	hot_path

namespace	interfaces

namespace	metrics

namespace	platform

namespace	plugins

namespace	stats

namespace	utils

Classes
class	absent_trigger
	Trigger when no data is received for a period. More...

struct	adaptation_stats
	Adaptation statistics. More...

class	adaptive_collector
	Adaptive collector wrapper. More...

struct	adaptive_config
	Adaptive configuration parameters. More...

class	adaptive_monitor
	Adaptive monitoring controller. More...

class	adaptive_scope
	Adaptive monitoring scope. More...

class	aggregation_processor
	Processes metric streams and generates aggregated statistics. More...

struct	aggregation_result
	Result of time series aggregation. More...

struct	aggregation_rule
	Configuration for metric aggregation. More...

struct	alert
	Core alert data structure. More...

class	alert_aggregator
	Groups and deduplicates alerts. More...

struct	alert_aggregator_config
	Configuration for alert aggregation. More...

struct	alert_annotations
	Additional metadata for alert context. More...

class	alert_deduplicator
	Deduplicates alerts based on fingerprint. More...

class	alert_formatter
	Formats alerts for notification payloads. More...

struct	alert_group
	Group of related alerts for batch notification. More...

class	alert_inhibitor
	Manages alert inhibition rules. More...

struct	alert_labels
	Key-value labels for alert identification and routing. More...

class	alert_manager
	Central coordinator for the alert pipeline. More...

struct	alert_manager_config
	Configuration for the alert manager. More...

struct	alert_manager_metrics
	Metrics for alert manager operations. More...

class	alert_notifier
	Base class for alert notification handlers. More...

class	alert_pipeline
	Configurable alert processing pipeline. More...

class	alert_rule
	Defines conditions and behavior for alert triggering. More...

struct	alert_rule_config
	Configuration for an alert rule. More...

class	alert_rule_group
	A group of related alert rules. More...

struct	alert_silence
	Silence configuration to suppress alerts. More...

class	alert_template
	Template engine for alert messages. More...

class	alert_trigger
	Base class for alert trigger conditions. More...

class	alternative_service_strategy
	Alternative service fallback strategy. More...

class	anomaly_trigger
	Trigger based on statistical anomaly detection. More...

class	battery_collector
	Battery status monitoring collector implementing collector_plugin interface. More...

struct	battery_info
	Information about a battery source. More...

class	battery_info_collector
	Battery data collector using platform abstraction layer. More...

struct	battery_reading
	A single battery reading. More...

class	buffered_notifier
	Buffers alerts and sends in batches. More...

class	cached_value_strategy
	Cached value fallback strategy. More...

class	callback_notifier
	Notifier that invokes a callback function. More...

class	central_collector
	Central collector for aggregating metrics from thread-local buffers. More...

class	circuit_breaker_registry
	Circuit breaker registry. More...

class	cloud_storage_backend
	Cloud storage backend (stub implementation) More...

class	collection_config
	Configuration for metric collection. More...

class	collector_base
	CRTP base class for metric collectors. More...

class	collector_interface
	Base interface for type-erased collectors. More...

class	collector_plugin
	Pure virtual interface for metric collector plugins. More...

class	collector_registry
	Thread-safe registry for managing collector plugins. More...

struct	compact_metric_value
	Memory-efficient metric value storage. More...

class	component_lifecycle_event
	Event for component lifecycle changes. More...

class	composite_health_check
	Composite health check that aggregates multiple sub-checks. More...

class	composite_trigger
	Combines multiple triggers with logical operations. More...

class	config_parser
	Unified configuration parsing utility. More...

class	configuration_change_event
	Event fired when configuration changes. More...

class	console_color_notifier

class	container_collector

struct	container_info

class	container_info_collector

struct	container_metrics

struct	context_metadata
	Context metadata for thread-specific information. More...

class	context_switch_info_collector
	Context switch data collector using platform abstraction layer. More...

struct	context_switch_metrics
	Aggregated context switch metrics for system and process. More...

class	cooldown_tracker
	Tracks cooldown periods for alert notifications. More...

struct	cpu_interrupt_info
	Per-CPU interrupt statistics. More...

struct	cpu_throttle_config
	Configuration for CPU throttling. More...

class	cpu_throttler
	Throttles operations based on CPU usage. More...

struct	create_result
	Result of collector creation. More...

class	crtp_collector_adapter
	Adapter for CRTP-based collectors (collector_base<T>) More...

class	data_consistency_manager
	Data consistency manager coordinating transaction managers and validators. More...

class	database_storage_backend
	Database storage backend (stub implementation) More...

class	default_value_strategy
	Default value fallback strategy. More...

class	degradable_service
	Degradable service wrapper. More...

struct	degradation_plan
	Degradation plan for coordinated service degradation. More...

class	delta_trigger
	Trigger based on change from previous value. More...

struct	disk_info

class	distributed_tracer
	Distributed tracer for managing spans and traces. More...

class	dynamic_plugin_loader
	Concrete implementation of plugin_loader using OS dynamic loading APIs. More...

class	error_boundary
	Error boundary implementation for resilient operations. More...

struct	error_boundary_config
	Error boundary configuration. More...

struct	error_boundary_metrics
	Error boundary metrics with atomic counters. More...

class	error_boundary_registry
	Error boundary registry for managing multiple boundaries. More...

struct	error_info
	Extended error information with context. More...

class	event_base
	Base class for all events in the system. More...

class	event_bus
	Thread-safe event bus implementation. More...

struct	event_bus_config
	Configuration for event bus. More...

class	event_envelope
	Container for events with metadata. More...

class	event_handler
	Type-safe event handler wrapper. More...

class	event_handler_wrapper
	Wrapper for event handlers with metadata. More...

class	fallback_strategy_interface
	Base interface for fallback strategies. More...

struct	fault_tolerance_config
	Fault tolerance configuration. More...

class	fault_tolerance_manager
	Fault tolerance manager template class. More...

struct	fault_tolerance_metrics
	Fault tolerance metrics. More...

class	fault_tolerance_registry
	Fault tolerance manager registry. More...

class	fd_info_collector
	File descriptor data collector using platform abstraction layer. More...

struct	fd_metrics
	File descriptor usage metrics. More...

class	file_notifier
	Writes alerts to a file. More...

class	file_storage_backend
	File storage backend for metrics snapshots. More...

struct	filesystem_inode_info
	Inode usage information for a single filesystem. More...

class	functional_health_check
	Health check implementation backed by a std::function. More...

class	gpu_collector
	GPU metrics monitoring collector implementing collector_plugin interface. More...

struct	gpu_device_info
	Information about a GPU device. More...

class	gpu_info_collector
	GPU data collector using platform abstraction layer. More...

struct	gpu_reading
	A single GPU metrics reading. More...

class	graceful_degradation_manager
	Graceful degradation manager. More...

struct	graceful_degradation_metrics
	Graceful degradation metrics. More...

struct	grpc_request
	gRPC request configuration More...

struct	grpc_response
	gRPC response data More...

struct	grpc_statistics
	Statistics for gRPC transport operations. More...

class	grpc_transport
	Abstract gRPC transport interface. More...

struct	handler_error_info
	Information about handler execution errors. More...

class	health_check
	Abstract base class for health checks. More...

class	health_check_builder
	Fluent builder for creating functional_health_check instances. More...

class	health_check_event
	Event for health check results. More...

struct	health_check_result
	Result of a health check operation. More...

class	health_dependency_graph
	Directed acyclic graph for health check dependencies. More...

class	health_monitor
	Health monitor with dependency management, auto-recovery, and statistics. More...

struct	health_monitor_config
	Configuration for the health_monitor. More...

struct	health_monitor_stats
	Accumulated statistics for health monitoring operations. More...

struct	histogram_bucket
	Bucket for histogram metrics. More...

struct	histogram_data
	Histogram data with buckets. More...

struct	http_request
	HTTP request configuration. More...

struct	http_response
	HTTP response data. More...

class	http_transport
	Abstract HTTP transport interface. More...

struct	inhibition_rule
	Rule for inhibiting alerts based on other alerts. More...

class	inode_info_collector
	Inode data collector using platform abstraction layer. More...

struct	inode_metrics
	Aggregated inode usage metrics for all filesystems. More...

class	interface_aggregated_collector
	Interface for collectors that aggregate metrics from multiple sources. More...

class	interface_event_bus
	Pure virtual interface for event bus implementation. More...

class	interface_event_publisher
	Interface for components that publish events. More...

class	interface_event_subscriber
	Interface for components that subscribe to events. More...

class	interface_metric_collector
	Pure virtual interface for metric collectors. More...

class	interface_metric_source
	Interface for components that provide metrics. More...

class	interface_monitoring_observer
	Pure virtual interface for monitoring event observers. More...

class	interface_observable
	Interface for components that can be observed. More...

class	interrupt_collector
	Hardware and software interrupt statistics monitoring collector. More...

class	interrupt_info_collector
	Interrupt data collector using platform abstraction layer. More...

struct	interrupt_metrics
	Aggregated interrupt statistics for the system. More...

class	jaeger_exporter
	Jaeger trace exporter implementation. More...

struct	jaeger_span_data
	Jaeger-specific span representation. More...

class	json_alert_formatter
	Formats alerts as JSON. More...

class	kv_memory_storage_backend
	In-memory key-value storage backend (legacy interface) More...

class	kv_storage_backend
	Basic key-value storage interface - stub. More...

class	leaky_bucket_limiter
	Leaky bucket rate limiter implementation. More...

class	load_average_history
	Specialized buffer for tracking load average history. More...

struct	load_average_sample
	Sample containing all three load averages. More...

struct	load_average_statistics
	Statistics for load average history. More...

class	lockfree_queue
	Thread-safe lock-free MPMC (Multiple Producer Multiple Consumer) queue. More...

struct	lockfree_queue_config
	Configuration for lock-free queue. More...

struct	lockfree_queue_statistics
	Statistics for lock-free queue operations. More...

class	log_notifier
	Simple notifier that logs alerts. More...

class	logger_to_monitoring_adapter
	Logger system adapter using dependency injection (Phase 2.3.3) More...

class	logging_metric_event
	Event containing logging system metrics. More...

class	memory_pool
	Thread-safe fixed-size block memory allocator. More...

struct	memory_pool_config
	Configuration for memory pool. More...

struct	memory_pool_statistics
	Statistics for memory pool operations. More...

class	memory_quota_manager
	Manages memory quota with tracking and throttling. More...

class	memory_storage_backend
	In-memory snapshot storage backend. More...

struct	metric
	Basic metric structure for interface compatibility. More...

struct	metric_batch
	Batch of metrics for efficient processing. More...

class	metric_collection_event
	Event containing collected metrics batch. More...

class	metric_collector_plugin

class	metric_event
	Event fired when a metric is collected. More...

struct	metric_export_config
	Configuration for metric exporters. More...

class	metric_exporter_factory
	Factory for creating metric exporters. More...

class	metric_exporter_interface
	Abstract interface for metric exporters. More...

class	metric_factory
	Unified factory for metric collector instantiation. More...

class	metric_filter
	Filter configuration for metric collection. More...

struct	metric_metadata
	Compact metadata for metrics. More...

struct	metric_sample
	Sample data structure for metric recording. More...

struct	metric_stats
	Statistics about metric collection. More...

class	metric_storage
	Thread-safe metric storage with ring buffer buffering. More...

struct	metric_storage_config
	Configuration for metric storage. More...

struct	metric_storage_stats
	Statistics for metric storage performance. More...

struct	metric_value
	Represents a single metric value with metadata. More...

class	metrics_analyzer
	Abstract interface for metrics analysis. More...

class	metrics_collector
	Abstract base class for metric collectors. More...

struct	metrics_snapshot
	Complete snapshot of metrics at a point in time. More...

class	monitorable_component
	Base class providing default monitorable implementation. More...

class	monitorable_interface
	Interface for components that can be monitored. More...

class	monitoring_aggregator
	Utility class to aggregate metrics from multiple monitorable components. More...

struct	monitoring_config
	Configuration for the monitoring system. More...

struct	monitoring_data
	Container for monitoring metrics from a component. More...

class	monitoring_interface
	Abstract interface for monitoring operations. More...

class	moving_window_aggregator
	Time-windowed value collection. More...

class	multi_notifier
	Sends alerts to multiple notifiers. More...

class	network_info_collector
	Internal network data collector using platform abstraction layer. More...

struct	network_metrics
	Aggregated network metrics from all sources. More...

class	network_metrics_collector
	Unified network metrics collector implementing collector_plugin interface. More...

struct	network_metrics_config
	Configuration for network metrics collector. More...

class	online_statistics
	Welford's algorithm for computing streaming statistics. More...

class	opentelemetry_compatibility_layer
	Main OpenTelemetry compatibility layer. More...

class	opentelemetry_exporter_config
	Configuration for OpenTelemetry exporters. More...

class	opentelemetry_metrics_adapter
	Adapter for converting monitoring system metrics to OpenTelemetry format. More...

class	opentelemetry_tracer_adapter
	Adapter for converting monitoring system traces to OpenTelemetry format. More...

struct	otel_attribute
	OpenTelemetry attribute representation. More...

struct	otel_metric_data
	OpenTelemetry metric data representation. More...

struct	otel_resource
	OpenTelemetry resource representation. More...

struct	otel_span_context
	OpenTelemetry span context. More...

struct	otel_span_data
	OpenTelemetry span data representation. More...

class	otlp_exporter
	OpenTelemetry Protocol (OTLP) trace exporter implementation. More...

struct	otlp_exporter_stats
	Statistics for OTLP exporter. More...

struct	otlp_grpc_config
	Configuration for OTLP gRPC exporter. More...

class	otlp_grpc_exporter
	OTLP gRPC trace exporter. More...

class	otlp_metrics_exporter
	OpenTelemetry Protocol (OTLP) metrics exporter implementation. More...

class	otlp_span_converter
	Converts internal spans to OTLP wire format. More...

class	performance_alert_event
	Event for performance-related alerts. More...

class	performance_benchmark
	Performance benchmark utility. More...

struct	performance_metrics
	Performance metrics for a specific operation. More...

class	performance_monitor
	Performance monitor combining profiling and system monitoring. More...

class	performance_monitor_adapter
	Adapter that wraps performance_monitor to implement IMonitor interface. More...

struct	performance_profile
	Lightweight performance profile for aggregated metrics. More...

class	performance_profiler
	Performance profiler for code sections. More...

class	pipeline_stage
	Base class for pipeline processing stages. More...

struct	platform_context_switches
	Platform context switch statistics. More...

struct	platform_info
	Platform identification information. More...

class	platform_info_collector
	Platform data collector using platform abstraction layer. More...

struct	platform_interrupt_info
	Platform interrupt statistics. More...

struct	platform_metrics
	Combined platform-level metrics. More...

class	platform_metrics_collector
	Unified platform-agnostic metrics collector. More...

struct	platform_metrics_config
	Configuration for platform metrics collection. More...

struct	platform_socket_info
	Platform socket buffer statistics. More...

struct	platform_tcp_info
	Platform TCP connection state information. More...

struct	platform_uptime
	Platform uptime information. More...

class	plugin_collector_adapter
	Adapter for plugin-based collectors (metric_collector_plugin) More...

struct	plugin_collector_config

class	plugin_factory

class	plugin_loader
	Abstract interface for plugin loading. More...

struct	plugin_metadata
	Metadata describing a collector plugin. More...

class	plugin_metric_collector

class	power_collector
	Power consumption monitoring collector implementing collector_plugin interface. More...

class	power_info_collector
	Power data collector using platform abstraction layer. More...

struct	power_reading
	A single power reading from a source. More...

struct	power_source_info
	Information about a power source. More...

struct	process_context_switch_info
	Context switch information for the current process. More...

struct	process_metrics
	Combined process-level metrics. More...

class	process_metrics_collector
	Unified process-level metrics collector. More...

struct	process_metrics_config
	Configuration for selective metric collection. More...

class	prometheus_exporter
	Prometheus metric exporter implementation. More...

struct	prometheus_metric_data
	Prometheus-specific metric representation. More...

class	quantile_estimator
	P² algorithm for streaming quantile estimation. More...

class	range_trigger
	Trigger based on value being within or outside a range. More...

struct	rate_limit_config
	Configuration for rate limiting. More...

class	rate_limiter
	Base interface for rate limiters. More...

class	rate_of_change_trigger
	Trigger based on rate of change of values. More...

class	resource_manager
	Coordinates multiple resource management components. More...

struct	resource_metrics
	Metrics for resource usage tracking. More...

struct	resource_quota
	Configuration for resource quotas. More...

class	resource_threshold_monitor

struct	retry_config
	Retry configuration. More...

class	retry_executor
	Retry executor template class. More...

class	retry_executor_registry
	Retry executor registry. More...

struct	retry_metrics
	Retry metrics. More...

class	retry_policy
	Basic retry policy implementation (backward compatibility) More...

class	ring_buffer
	Lock-free ring buffer with atomic operations. More...

struct	ring_buffer_config
	Configuration for ring buffer behavior. More...

struct	ring_buffer_stats
	Statistics for ring buffer performance monitoring. More...

class	routing_notifier
	Routes alerts to different notifiers based on criteria. More...

class	rule_builder
	Builds alert_rule from rule_definition. More...

struct	rule_definition
	Structured definition for alert rule configuration. More...

class	rule_registry
	Dynamic registry for alert rules with hot-reload support. More...

class	safe_event_dispatcher
	Event dispatcher with exception handling and error recovery. More...

class	scoped_span
	Scoped span for RAII-style span management. More...

class	scoped_timer
	Scoped performance timer. More...

class	security_collector
	Security event monitoring collector. More...

struct	security_event
	Individual security event information. More...

struct	security_event_counts
	Counts of security events by type. More...

class	security_info_collector
	Security event data collector using platform abstraction layer. More...

struct	security_metrics
	Aggregated security event metrics. More...

struct	service_config
	Service configuration for graceful degradation. More...

struct	service_state
	Service state tracking. More...

class	simd_aggregator
	SIMD-accelerated statistical aggregator. More...

struct	simd_aggregator_statistics
	Statistics for SIMD aggregator operations. More...

struct	simd_capabilities
	SIMD capabilities detection. More...

struct	simd_config
	Configuration for SIMD aggregator. More...

class	simple_http_client
	Simple HTTP client using basic socket operations. More...

class	smart_collector

struct	smart_disk_metrics

class	smart_info_collector

class	snapshot_storage_backend
	Base interface for snapshot storage backends. More...

class	span_builder
	Span builder for creating new spans. More...

class	standalone_collector_adapter
	Adapter for standalone collectors (like vm_collector) More...

class	state_change_event
	Event fired when system state changes. More...

class	state_validator
	State validator for validating system state. More...

struct	statistical_summary
	Statistical summary result. More...

class	statistics_notifier

class	statsd_exporter
	StatsD metric exporter implementation. More...

struct	statsd_metric_data
	StatsD-specific metric representation. More...

class	storage_backend
	Abstract interface for metrics storage. More...

class	storage_backend_factory
	Factory for creating storage backends. More...

struct	storage_config
	Storage configuration. More...

struct	stream_aggregation_result
	Result of an aggregation operation. More...

class	stream_aggregator
	Full-featured streaming aggregation. More...

struct	stream_aggregator_config
	Configuration for stream aggregator. More...

struct	streaming_statistics
	Statistical summary from streaming computation. More...

class	stub_grpc_transport
	Stub gRPC transport for testing. More...

class	stub_http_transport
	Stub HTTP transport for testing. More...

class	stub_udp_transport
	Stub UDP transport for testing. More...

class	subscription_token
	Token for managing event subscriptions. More...

struct	summary_data
	Summary statistics for metrics. More...

class	system_event
	Generic system event for monitoring components. More...

class	system_info_collector

struct	system_metrics
	System resource metrics. More...

struct	system_metrics_config

class	system_monitor
	System resource monitor. More...

class	system_resource_collector

class	system_resource_event
	Event containing system resource metrics. More...

struct	system_resources

struct	tagged_metric
	Represents a metric value with associated tags. More...

struct	tcp_state_counts
	Counts of connections in each TCP state. More...

class	temperature_collector
	Hardware temperature monitoring collector implementing collector_plugin interface. More...

class	temperature_info_collector
	Temperature data collector using platform abstraction layer. More...

struct	temperature_reading
	A single temperature reading from a sensor. More...

struct	temperature_sensor_info
	Information about a temperature sensor. More...

class	text_alert_formatter
	Formats alerts as human-readable text. More...

class	thread_context
	Thread-local context management for request tracking. More...

struct	thread_context_data
	Enhanced thread context data for comprehensive request and trace tracking. More...

class	thread_local_buffer
	Thread-local buffer for lock-free metric collection. More...

class	thread_pool_metric_event
	Event containing thread pool metrics. More...

class	thread_to_monitoring_adapter

class	threshold_trigger
	Trigger based on comparing value against a threshold. More...

struct	time_point_data
	Single data point in time series. More...

class	time_series
	Thread-safe time series data storage. More...

class	time_series_buffer
	Thread-safe ring buffer for time-series data with statistics. More...

struct	time_series_buffer_config
	Configuration for time series buffer. More...

struct	time_series_config
	Configuration for time series storage. More...

struct	time_series_query
	Query parameters for time series data. More...

struct	time_series_sample
	Single sample in time series with timestamp. More...

struct	time_series_statistics
	Statistics calculated from time series data. More...

struct	timer_data
	Timer data with percentile calculations. More...

class	timer_scope
	RAII timer scope for automatic duration recording with timer_data. More...

class	token_bucket_limiter
	Token bucket rate limiter implementation. More...

struct	trace_context
	Trace context for propagation across service boundaries. More...

struct	trace_export_config
	Configuration for trace exporters. More...

struct	trace_export_settings
	Configuration settings for trace export behavior. More...

class	trace_exporter_factory
	Factory for creating trace exporters. More...

class	trace_exporter_interface
	Abstract interface for trace exporters. More...

struct	trace_span
	Trace span representing a unit of work in distributed tracing. More...

class	transaction
	Transaction containing multiple operations. More...

struct	transaction_config
	Transaction configuration. More...

class	transaction_manager
	Transaction manager for coordinating transactions. More...

struct	transaction_metrics
	Transaction metrics. More...

class	transaction_operation
	Single transaction operation with execute and rollback capabilities. More...

struct	udp_send_result
	Result of a UDP send operation. More...

struct	udp_statistics
	Statistics for UDP transport operations. More...

class	udp_transport
	Abstract UDP transport interface. More...

class	uptime_collector
	System uptime monitoring collector implementing collector_plugin interface. More...

class	uptime_info_collector
	Uptime data collector using platform abstraction layer. More...

struct	uptime_metrics
	Aggregated uptime metrics for the system. More...

struct	validation_config
	Validation configuration. More...

struct	validation_metrics
	Validation metrics. More...

class	vm_collector
	Virtualization metrics monitoring collector. More...

class	vm_info_collector
	Platform-specific virtualization data collector implementation. More...

struct	vm_metrics
	Virtualization specific metrics. More...

struct	webhook_config
	Configuration for webhook notifier. More...

class	webhook_notifier
	Sends alerts to a webhook endpoint. More...

class	zipkin_exporter
	Zipkin trace exporter implementation. More...

struct	zipkin_span_data
	Zipkin-specific span representation. More...

Typedefs
using	logger_system_adapter = logger_to_monitoring_adapter

using	thread_system_adapter = thread_to_monitoring_adapter

using	config_map = std::unordered_map<std::string, std::string>
	Type alias for configuration map.

using	stats_map = std::unordered_map<std::string, double>
	Type alias for statistics map.

using	tag_map = std::unordered_map<std::string, std::string>
	Type alias for metric tags/labels.

using	collector_factory_fn = std::function<std::unique_ptr<collector_interface>()>
	Factory function type for creating collectors.

using	plugin_factory_fn = std::unique_ptr<collector_plugin> (*)()
	Type alias for plugin factory function.

using	circuit_state = common::resilience::circuit_state

using	circuit_breaker_config = common::resilience::circuit_breaker_config

using	circuit_breaker = common::resilience::circuit_breaker

using	aggregation_result_stream = stream_aggregation_result

Enumerations
enum class	adaptation_strategy { conservative , balanced , aggressive }
	Adaptation strategy for monitoring behavior. More...

enum class	load_level { idle , low , moderate , high , critical }
	System load levels. More...

enum class	comparison_operator { greater_than , greater_or_equal , less_than , less_or_equal , equal , not_equal }
	Comparison operators for threshold triggers. More...

enum class	composite_operation { AND , OR , XOR , NOT }
	Logical operations for combining triggers. More...

enum class	alert_severity : uint8_t { info = 0 , warning , critical , emergency }
	Severity levels for alerts. More...

enum class	alert_state : uint8_t { inactive = 0 , pending , firing , resolved , suppressed }
	State machine states for alert lifecycle. More...

enum class	battery_status { unknown , charging , discharging , not_charging , full }
	Current battery charging status. More...

enum class	cgroup_version : uint8_t { none = 0 , v1 = 1 , v2 = 2 }

enum class	gpu_vendor { unknown , nvidia , amd , intel , apple , other }
	GPU vendor identification. More...

enum class	gpu_type { unknown , discrete , integrated , virtual_gpu }
	GPU type classification. More...

enum class	tcp_state { ESTABLISHED = 1 , SYN_SENT = 2 , SYN_RECV = 3 , FIN_WAIT1 = 4 , FIN_WAIT2 = 5 , TIME_WAIT = 6 , CLOSE = 7 , CLOSE_WAIT = 8 , LAST_ACK = 9 , LISTEN = 10 , CLOSING = 11 , UNKNOWN = 0 }
	TCP connection states as defined in RFC 793. More...

enum class	power_source_type { unknown , battery , ac , usb , wireless , cpu , gpu , memory , package , platform , other }
	Type of power source. More...

enum class	security_event_type { login_success = 1 , login_failure = 2 , logout = 3 , sudo_usage = 4 , permission_change = 5 , account_created = 6 , account_deleted = 7 , account_modified = 8 , session_start = 9 , session_end = 10 , unknown = 0 }
	Types of security events tracked. More...

enum class	sensor_type { unknown , cpu , gpu , motherboard , storage , ambient , other }
	Type of temperature sensor. More...

enum class	vm_type { none = 0 , kvm = 1 , hyperv = 2 , vmware = 3 , virtualbox = 4 , xen = 5 , docker = 6 , other = 7 }
	Detected virtualization platform. More...

enum class	monitoring_error_code : std::uint32_t { success = 0 , collector_not_found = 1000 , collection_failed = 1001 , collector_initialization_failed = 1002 , collector_already_exists = 1003 , collector_disabled = 1004 , invalid_collector_config = 1005 , monitoring_disabled = 1006 , storage_full = 2000 , storage_corrupted = 2001 , compression_failed = 2002 , storage_not_initialized = 2003 , storage_write_failed = 2004 , storage_read_failed = 2005 , storage_empty = 2006 , invalid_configuration = 3000 , invalid_interval = 3001 , invalid_capacity = 3002 , configuration_not_found = 3003 , configuration_parse_error = 3004 , system_resource_unavailable = 4000 , permission_denied = 4001 , out_of_memory = 4002 , memory_allocation_failed = 4003 , operation_timeout = 4004 , operation_cancelled = 4005 , thread_system_not_available = 5000 , logger_system_not_available = 5001 , incompatible_version = 5002 , adapter_initialization_failed = 5003 , metric_not_found = 6000 , invalid_metric_type = 6001 , metric_overflow = 6002 , aggregation_failed = 6003 , processing_failed = 6004 , health_check_failed = 7000 , health_check_timeout = 7001 , health_check_not_registered = 7002 , circuit_breaker_open = 8000 , circuit_breaker_half_open = 8001 , retry_attempts_exhausted = 8002 , operation_failed = 8003 , network_error = 8004 , service_unavailable = 8005 , service_degraded = 8006 , error_boundary_triggered = 8007 , fallback_failed = 8008 , recovery_failed = 8009 , invalid_argument = 8100 , invalid_state = 8101 , not_found = 8102 , already_exists = 8103 , resource_exhausted = 8104 , already_started = 8105 , dependency_missing = 8106 , quota_exceeded = 8200 , rate_limit_exceeded = 8201 , cpu_throttled = 8202 , memory_quota_exceeded = 8203 , bandwidth_exceeded = 8204 , resource_unavailable = 8205 , transaction_failed = 8300 , transaction_timeout = 8301 , transaction_aborted = 8302 , validation_failed = 8303 , data_corrupted = 8304 , state_inconsistent = 8305 , deadlock_detected = 8306 , rollback_failed = 8307 , unknown_error = 9999 }
	Comprehensive error codes for monitoring system operations. More...

enum class	recorded_metric_type { counter , gauge , histogram }
	Types of recorded metrics. More...

enum class	metric_export_format { prometheus_text , prometheus_protobuf , statsd_plain , statsd_datadog , otlp_grpc , otlp_http_json , otlp_http_protobuf }
	Supported metric export formats. More...

enum class	metric_type { counter , gauge , histogram , summary , timer , counter = 0 , gauge , histogram , summary , timer , set }
	Metric types supported by exporters. More...

enum class	otel_resource_type { service , service_instance , host , container , process , runtime , telemetry_sdk , custom }
	OpenTelemetry resource types. More...

enum class	otel_span_kind { unspecified = 0 , internal = 1 , server = 2 , client = 3 , producer = 4 , consumer = 5 }
	OpenTelemetry span kinds. More...

enum class	otel_status_code { unset = 0 , ok = 1 , error = 2 }
	OpenTelemetry status codes. More...

enum class	trace_export_format { jaeger_thrift , jaeger_grpc , zipkin_json , zipkin_protobuf , otlp_grpc , otlp_http_json , otlp_http_protobuf }
	Supported trace export formats. More...

enum class	health_check_type { liveness , readiness , startup }
	Types of health checks following Kubernetes probe conventions. More...

enum class	event_priority { low , normal , high , critical }

enum class	health_status { healthy , degraded , unhealthy , unknown }
	System health status levels. More...

enum class	plugin_category { system , hardware , platform , network , process , custom }
	Categorization of collector plugins. More...

enum class	plugin_load_error { none = 0 , file_not_found , library_load_failed , symbol_not_found , incompatible_api_version , create_function_failed , plugin_unavailable , already_loaded , not_loaded , invalid_metadata }
	Error codes for plugin loading operations. More...

enum class	transaction_state { active , committed , aborted }
	Transaction states. More...

enum class	validation_result { valid , invalid }
	Validation result states. More...

enum class	degradation_level { normal = 0 , limited = 1 , minimal = 2 , emergency = 3 }
	Degradation levels for error boundary. More...

enum class	error_boundary_policy { fail_fast , isolate , degrade , fallback }
	Error boundary policies. More...

enum class	service_priority { optional = 0 , normal = 1 , important = 2 , critical = 3 }
	Service priority levels. More...

enum class	throttling_strategy { reject , delay }
	Strategy for handling resource exhaustion. More...

enum class	resource_type { memory , cpu }
	Type of resource being managed. More...

enum class	retry_strategy { fixed_delay , exponential_backoff , linear_backoff , fibonacci_backoff }
	Retry strategies. More...

enum class	storage_backend_type { memory_buffer , file_json , file_binary , file_csv , database_sqlite , database_postgresql , database_mysql , cloud_s3 , cloud_gcs , cloud_azure_blob }
	Storage backend types. More...

enum class	compression_algorithm { none , gzip , lz4 , zstd }
	Compression algorithms. More...

enum class	metric_type : uint8_t { counter , gauge , histogram , summary , timer , counter = 0 , gauge , histogram , summary , timer , set }

Functions
std::shared_ptr< common::interfaces::IMonitor >	make_monitor_adapter (std::shared_ptr< performance_monitor > monitor)
	Factory function to create performance_monitor_adapter.

adaptive_monitor &	global_adaptive_monitor ()
	Global adaptive monitor instance.

constexpr const char *	comparison_operator_to_string (comparison_operator op) noexcept
	Convert comparison operator to string.

constexpr const char *	alert_severity_to_string (alert_severity severity) noexcept
	Convert alert severity to string.

constexpr const char *	alert_state_to_string (alert_state state) noexcept
	Convert alert state to string.

std::string	battery_status_to_string (battery_status status)
	Convert battery_status to string representation.

std::string	gpu_vendor_to_string (gpu_vendor vendor)
	Convert gpu_vendor to string representation.

std::string	gpu_type_to_string (gpu_type type)
	Convert gpu_type to string representation.

std::string	tcp_state_to_string (tcp_state state)
	Convert tcp_state to string representation.

std::string	power_source_type_to_string (power_source_type type)
	Convert power_source_type to string representation.

std::string	security_event_type_to_string (security_event_type type)
	Convert security_event_type to string representation.

std::string	sensor_type_to_string (sensor_type type)
	Convert sensor_type to string representation.

std::string	vm_type_to_string (vm_type type)
	Convert vm_type to string representation.

std::string	error_code_to_string (monitoring_error_code code)
	Convert error code to string representation.

std::string	get_error_details (monitoring_error_code code)
	Get detailed error message.

performance_monitor &	global_performance_monitor ()
	Global performance monitor instance.

std::unique_ptr< grpc_transport >	create_default_grpc_transport ()
	Create default gRPC transport.

std::unique_ptr< stub_grpc_transport >	create_stub_grpc_transport ()
	Create stub gRPC transport for testing.

std::unique_ptr< http_transport >	create_default_transport ()
	Create default HTTP transport.

std::unique_ptr< stub_http_transport >	create_stub_transport ()
	Create stub HTTP transport for testing.

std::unique_ptr< prometheus_exporter >	create_prometheus_exporter (std::uint16_t port=9090, const std::string &job_name="monitoring_system")
	Helper function to create a Prometheus exporter.

std::unique_ptr< statsd_exporter >	create_statsd_exporter (const std::string &host="localhost", std::uint16_t port=8125, bool datadog_format=false)
	Helper function to create a StatsD exporter.

std::unique_ptr< otlp_metrics_exporter >	create_otlp_metrics_exporter (const std::string &endpoint, const otel_resource &resource, metric_export_format format=metric_export_format::otlp_grpc)
	Helper function to create an OTLP metrics exporter.

otel_resource	create_service_resource (const std::string &service_name, const std::string &service_version="1.0.0", const std::string &service_namespace="")
	Create OpenTelemetry resource with service information.

std::unique_ptr< opentelemetry_compatibility_layer >	create_opentelemetry_compatibility_layer (const otel_resource &resource)
	Create OpenTelemetry compatibility layer.

std::unique_ptr< opentelemetry_compatibility_layer >	create_opentelemetry_compatibility_layer (const std::string &service_name, const std::string &service_version="1.0.0")
	Create OpenTelemetry compatibility layer with service resource.

std::unique_ptr< otlp_grpc_exporter >	create_otlp_grpc_exporter (const std::string &endpoint="localhost:4317")
	Create OTLP gRPC exporter with default configuration.

std::unique_ptr< otlp_grpc_exporter >	create_otlp_grpc_exporter (const otlp_grpc_config &config)
	Create OTLP gRPC exporter with custom configuration.

std::unique_ptr< jaeger_exporter >	create_jaeger_exporter (const std::string &endpoint, trace_export_format format=trace_export_format::jaeger_grpc)
	Helper function to create a Jaeger exporter.

std::unique_ptr< zipkin_exporter >	create_zipkin_exporter (const std::string &endpoint, trace_export_format format=trace_export_format::zipkin_json)
	Helper function to create a Zipkin exporter.

std::unique_ptr< otlp_exporter >	create_otlp_exporter (const std::string &endpoint, const otel_resource &resource, trace_export_format format=trace_export_format::otlp_grpc)
	Helper function to create an OTLP exporter.

std::unique_ptr< udp_transport >	create_default_udp_transport ()
	Create default UDP transport.

std::unique_ptr< stub_udp_transport >	create_stub_udp_transport ()
	Create stub UDP transport for testing.

bool	register_builtin_collectors ()
	Register all built-in collectors with the collector_registry.

std::vector< std::string >	get_builtin_collector_names ()
	Get list of all built-in collector names.

template<typename T >
bool	register_plugin_collector (const std::string &name)
	Helper function to register a plugin-based collector.

template<typename T >
bool	register_crtp_collector (const std::string &name)
	Helper function to register a CRTP-based collector.

template<typename T >
bool	register_standalone_collector (const std::string &name)
	Helper function to register a standalone collector.

health_monitor &	global_health_monitor ()
	Get the global health monitor singleton instance.

template<typename T >
std::unique_ptr< lockfree_queue< T > >	make_lockfree_queue ()
	Create a lock-free queue with default configuration.

template<typename T >
std::unique_ptr< lockfree_queue< T > >	make_lockfree_queue (const lockfree_queue_config &config)
	Create a lock-free queue with configuration.

std::vector< lockfree_queue_config >	create_default_queue_configs ()
	Create default queue configurations for different use cases.

std::unique_ptr< memory_pool >	make_memory_pool ()
	Create a memory pool with default configuration.

std::unique_ptr< memory_pool >	make_memory_pool (const memory_pool_config &config)
	Create a memory pool with configuration.

std::vector< memory_pool_config >	create_default_pool_configs ()
	Create default pool configurations for different use cases.

std::unique_ptr< simd_aggregator >	make_simd_aggregator ()
	Create a SIMD aggregator with default configuration.

std::unique_ptr< simd_aggregator >	make_simd_aggregator (const simd_config &config)
	Create a SIMD aggregator with configuration.

std::vector< simd_config >	create_default_simd_configs ()
	Create default SIMD configurations for different use cases.

auto	to_string (plugin_load_error error) -> std::string
	Convert plugin_load_error to string.

std::shared_ptr< transaction_manager >	create_transaction_manager (const std::string &name)
	Factory function to create a transaction manager.

std::shared_ptr< state_validator >	create_state_validator (const std::string &name)
	Factory function to create a state validator.

std::shared_ptr< data_consistency_manager >	create_data_consistency_manager (const std::string &name)
	Factory function to create a data consistency manager.

template<typename T , typename Func >
common::Result< T >	execute_with_circuit_breaker (circuit_breaker &cb, const std::string &name, Func &&func)
	Execute an operation through a circuit breaker.

circuit_breaker_registry &	global_circuit_breaker_registry ()
	Get global circuit breaker registry.

retry_executor_registry &	global_retry_executor_registry ()
	Get global retry executor registry.

fault_tolerance_registry &	global_fault_tolerance_registry ()
	Get global fault tolerance manager registry.

error_boundary_registry &	global_error_boundary_registry ()
	Get global error boundary registry.

std::shared_ptr< graceful_degradation_manager >	create_degradation_manager (const std::string &name)
	Create a graceful degradation manager.

service_config	create_service_config (const std::string &name, service_priority priority)
	Create a service configuration.

degradation_plan	create_degradation_plan (const std::string &name, const std::vector< std::string > &maintain, const std::vector< std::string > &disable, degradation_level level)
	Create a degradation plan.

template<typename T >
std::shared_ptr< degradable_service< T > >	create_degradable_service (const std::string &name, std::shared_ptr< graceful_degradation_manager > manager, typename degradable_service< T >::normal_operation normal_op, typename degradable_service< T >::degraded_operation degraded_op)
	Create a degradable service.

std::unique_ptr< token_bucket_limiter >	create_token_bucket_limiter (const std::string &name, double rate, size_t capacity, throttling_strategy strategy=throttling_strategy::reject)
	Create a token bucket rate limiter.

std::unique_ptr< leaky_bucket_limiter >	create_leaky_bucket_limiter (const std::string &name, double rate, size_t capacity)
	Create a leaky bucket rate limiter.

std::unique_ptr< memory_quota_manager >	create_memory_quota_manager (const std::string &name, size_t max_bytes, throttling_strategy strategy=throttling_strategy::reject)
	Create a memory quota manager.

std::unique_ptr< resource_manager >	create_resource_manager (const std::string &name)
	Create a resource manager.

retry_config	create_exponential_backoff_config (size_t max_attempts=3, std::chrono::milliseconds initial_delay=std::chrono::milliseconds(1000))
	Factory function for exponential backoff config.

retry_config	create_fixed_delay_config (size_t max_attempts=3, std::chrono::milliseconds delay=std::chrono::milliseconds(1000))
	Factory function for fixed delay config.

retry_config	create_fibonacci_backoff_config (size_t max_attempts=3, std::chrono::milliseconds initial_delay=std::chrono::milliseconds(1000))
	Factory function for Fibonacci backoff config.

std::unique_ptr< snapshot_storage_backend >	create_file_storage (const std::string &path, storage_backend_type type, size_t capacity)
	Create a file storage backend.

std::unique_ptr< snapshot_storage_backend >	create_database_storage (storage_backend_type type, const std::string &path, const std::string &table)
	Create a database storage backend.

std::unique_ptr< snapshot_storage_backend >	create_cloud_storage (storage_backend_type type, const std::string &bucket)
	Create a cloud storage backend.

distributed_tracer &	global_tracer ()
	Global tracer instance.

std::vector< aggregation_rule >	create_standard_aggregation_rules ()
	Create standard aggregation rules for common metrics.

constexpr const char *	metric_type_to_string (metric_type type) noexcept
	Convert metric type to string.

uint32_t	hash_metric_name (const std::string &name) noexcept
	Hash function for metric names.

metric_metadata	create_metric_metadata (const std::string &name, metric_type type, size_t tag_count=0)
	Create metric metadata from name and type.

template<typename T >
std::unique_ptr< ring_buffer< T > >	make_ring_buffer (size_t capacity=8192)
	Helper function to create a ring buffer with default configuration.

template<typename T >
std::unique_ptr< ring_buffer< T > >	make_ring_buffer (const ring_buffer_config &config)
	Helper function to create a ring buffer with custom configuration.

double	pearson_correlation (const std::vector< double > &x, const std::vector< double > &y)
	Calculate Pearson correlation coefficient.

alert	create_sample_alert (const std::string &name, alert_severity severity, alert_state state, double value, const std::string &team="ops")

Typedef Documentation

◆ aggregation_result_stream

using kcenon::monitoring::aggregation_result_stream = stream_aggregation_result

Definition at line 78 of file aggregation_processor.h.

◆ circuit_breaker

using kcenon::monitoring::circuit_breaker = common::resilience::circuit_breaker

Definition at line 26 of file circuit_breaker.h.

◆ circuit_breaker_config

using kcenon::monitoring::circuit_breaker_config = common::resilience::circuit_breaker_config

Definition at line 25 of file circuit_breaker.h.

◆ circuit_state

using kcenon::monitoring::circuit_state = common::resilience::circuit_state

Definition at line 24 of file circuit_breaker.h.

◆ collector_factory_fn

using kcenon::monitoring::collector_factory_fn = std::function<std::unique_ptr<collector_interface>()>

Factory function type for creating collectors.

Definition at line 103 of file metric_factory.h.

◆ config_map

typedef std::unordered_map< std::string, std::string > kcenon::monitoring::config_map = std::unordered_map<std::string, std::string>

Type alias for configuration map.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/plugins/collector_plugin.h.

Definition at line 63 of file collector_base.h.

◆ logger_system_adapter

using kcenon::monitoring::logger_system_adapter = logger_to_monitoring_adapter

Definition at line 21 of file logger_adapters.h.

◆ plugin_factory_fn

using kcenon::monitoring::plugin_factory_fn = std::unique_ptr<collector_plugin> (*)()

Type alias for plugin factory function.

Factories enable lazy instantiation and dynamic loading. Signature: unique_ptr<collector_plugin>(void)

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/plugins/collector_plugin.h.

Definition at line 256 of file collector_plugin.h.

◆ stats_map

using kcenon::monitoring::stats_map = std::unordered_map<std::string, double>

Type alias for statistics map.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/plugins/collector_plugin.h.

Definition at line 68 of file collector_base.h.

◆ tag_map

using kcenon::monitoring::tag_map = std::unordered_map<std::string, std::string>

Type alias for metric tags/labels.

Tags are key-value pairs that add dimensions to metrics, enabling filtering and aggregation by service, endpoint, host, etc.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/core/performance_monitor.h.

Definition at line 46 of file performance_monitor.h.

◆ thread_system_adapter

using kcenon::monitoring::thread_system_adapter = thread_to_monitoring_adapter

Definition at line 21 of file thread_adapters.h.

Enumeration Type Documentation

◆ adaptation_strategy

enum class kcenon::monitoring::adaptation_strategy

strong

Adaptation strategy for monitoring behavior.

Enumerator
conservative
balanced
aggressive

Definition at line 40 of file adaptive_monitor.h.

                               {
    conservative,  // Prefer system stability over monitoring detail
    balanced,      // Balance between monitoring and performance
    aggressive     // Prefer monitoring detail over system resources
};

◆ alert_severity

enum class kcenon::monitoring::alert_severity : uint8_t

strong

Severity levels for alerts.

Defines the urgency and importance of alerts, affecting routing and notification behavior.

Enumerator
info	Informational, no action required.
warning	Warning condition, may require attention.
critical	Critical condition, immediate attention required.
emergency	Emergency condition, system-wide impact.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h, /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_rule.h, and alert_notifiers_example.cpp.

Definition at line 35 of file alert_types.h.

                          : uint8_t {
    info = 0,       
    warning,        
    critical,       
    emergency       
};

◆ alert_state

enum class kcenon::monitoring::alert_state : uint8_t

strong

State machine states for alert lifecycle.

State machine: inactive ─[condition met]─> pending pending ─[for_duration elapsed]─> firing firing ─[condition cleared]─> resolved resolved ─[condition met]─> pending any state ─[silenced]─> suppressed suppressed ─[silence expired]─> previous state

Enumerator
inactive	Alert condition not met.
pending	Condition met, waiting for duration threshold.
firing	Alert is active and notifications sent.
resolved	Alert condition cleared.
suppressed	Alert is silenced.

Examples: alert_notifiers_example.cpp.

Definition at line 69 of file alert_types.h.

                       : uint8_t {
    inactive = 0,   
    pending,        
    firing,         
    resolved,       
    suppressed      
};

◆ battery_status

enum class kcenon::monitoring::battery_status

strong

Current battery charging status.

Enumerator
unknown	Unknown status.
charging	Battery is charging.
discharging	Battery is discharging.
not_charging	Battery is not charging (plugged in but not charging)
full	Battery is fully charged.

Definition at line 37 of file battery_collector.h.

                          {
    unknown,      
    charging,     
    discharging,  
    not_charging, 
    full          
};

◆ cgroup_version

enum class kcenon::monitoring::cgroup_version : uint8_t

strong

Cgroup version detection

Enumerator
none	Not in a cgroup or not Linux.
v1	Legacy cgroups v1.
v2	Unified cgroups v2 hierarchy.

Definition at line 79 of file container_collector.h.

                          : uint8_t {
    none = 0,  
    v1 = 1,    
    v2 = 2     
};

◆ comparison_operator

enum class kcenon::monitoring::comparison_operator

strong

Comparison operators for threshold triggers.

Enumerator
greater_than	value > threshold
greater_or_equal	value >= threshold
less_than	value < threshold
less_or_equal	value <= threshold
equal	value == threshold (with epsilon)
not_equal	value != threshold (with epsilon)

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_triggers.h.

Definition at line 32 of file alert_triggers.h.

                               {
    greater_than,       
    greater_or_equal,   
    less_than,          
    less_or_equal,      
    equal,              
    not_equal           
};

◆ composite_operation

enum class kcenon::monitoring::composite_operation

strong

Logical operations for combining triggers.

Enumerator
AND	All triggers must fire.
OR	Any trigger fires.
XOR	Exactly one trigger fires.
NOT	Invert single trigger (uses first trigger only)

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_triggers.h.

Definition at line 501 of file alert_triggers.h.

◆ compression_algorithm

enum class kcenon::monitoring::compression_algorithm

strong

Compression algorithms.

Enumerator
none
gzip
lz4
zstd

Definition at line 46 of file storage_backends.h.

                                 {
    none,
    gzip,
    lz4,
    zstd
};

◆ degradation_level

enum class kcenon::monitoring::degradation_level

strong

Degradation levels for error boundary.

Enumerator
normal
limited
minimal
emergency

Definition at line 28 of file error_boundary.h.

                             {
    normal = 0,
    limited = 1,
    minimal = 2,
    emergency = 3
};

◆ error_boundary_policy

enum class kcenon::monitoring::error_boundary_policy

strong

Error boundary policies.

Enumerator
fail_fast
isolate
degrade
fallback

Definition at line 38 of file error_boundary.h.

                                 {
    fail_fast,
    isolate,
    degrade,
    fallback
};

◆ event_priority

enum class kcenon::monitoring::event_priority

strong

Enumerator
low
normal
high
critical

Definition at line 151 of file event_bus_interface.h.

                          {
    low,
    normal,
    high,
    critical
};

◆ gpu_type

enum class kcenon::monitoring::gpu_type

strong

GPU type classification.

Enumerator
unknown	Unknown GPU type.
discrete	Discrete GPU (dedicated graphics card)
integrated	Integrated GPU (part of CPU/SoC)
virtual_gpu	Virtual GPU (cloud/VM)

Definition at line 70 of file gpu_collector.h.

                    {
    unknown,     
    discrete,    
    integrated,  
    virtual_gpu  
};

◆ gpu_vendor

enum class kcenon::monitoring::gpu_vendor

strong

GPU vendor identification.

Enumerator
unknown	Unknown vendor.
nvidia	NVIDIA Corporation.
amd	Advanced Micro Devices.
intel	Intel Corporation.
apple	Apple (Apple Silicon GPU)
other	Other vendor.

Definition at line 37 of file gpu_collector.h.

                      {
    unknown,  
    nvidia,   
    amd,      
    intel,    
    apple,    
    other     
};

◆ health_check_type

enum class kcenon::monitoring::health_check_type

strong

Types of health checks following Kubernetes probe conventions.

See also: https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/

Enumerator
liveness	Indicates whether the process is alive and should be restarted if failing.
readiness	Indicates whether the service is ready to accept traffic.
startup	Indicates whether the application has finished initializing.

Definition at line 69 of file health_monitor.h.

                             {
    liveness,   
    readiness,  
    startup     
};

◆ health_status

enum class kcenon::monitoring::health_status

strong

System health status levels.

Enumerator
healthy
degraded
unhealthy
unknown

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/interfaces/monitoring_core.h.

Definition at line 113 of file monitoring_core.h.

                         {
    healthy,
    degraded,
    unhealthy,
    unknown
};

◆ load_level

enum class kcenon::monitoring::load_level

strong

System load levels.

Enumerator
idle
low
moderate
high
critical

Definition at line 49 of file adaptive_monitor.h.

                      {
    idle,          // < 20% CPU
    low,           // 20-40% CPU
    moderate,      // 40-60% CPU
    high,          // 60-80% CPU
    critical       // > 80% CPU
};

◆ metric_export_format

enum class kcenon::monitoring::metric_export_format

strong

Supported metric export formats.

Enumerator
prometheus_text	Prometheus text exposition format.
prometheus_protobuf	Prometheus protocol buffers format.
statsd_plain	StatsD plain UDP format.
statsd_datadog	StatsD DataDog extension format.
otlp_grpc	OTLP gRPC metrics protocol.
otlp_http_json	OTLP HTTP JSON metrics protocol.
otlp_http_protobuf	OTLP HTTP Protocol Buffers metrics.

Definition at line 50 of file metric_exporters.h.

                                {
    prometheus_text,        
    prometheus_protobuf,    
    statsd_plain,          
    statsd_datadog,        
    otlp_grpc,             
    otlp_http_json,        
    otlp_http_protobuf     
};

◆ metric_type [1/2]

enum class kcenon::monitoring::metric_type

strong

Metric types supported by exporters.

Types of metrics supported by the system.

Enumerator
counter	Monotonically increasing counter.
gauge	Instantaneous value that can go up and down.
histogram	Distribution of values with buckets.
summary	Pre-calculated quantiles and count/sum.
timer	StatsD-specific timer metric.
counter
gauge
histogram
summary
timer
set

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/interfaces/metric_collector_interface.h, and /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/interfaces/metric_types_adapter.h.

Definition at line 64 of file metric_exporters.h.

                       {
    counter,    
    gauge,      
    histogram,  
    summary,    
    timer       
};

◆ metric_type [2/2]

enum class kcenon::monitoring::metric_type : uint8_t

strong

Enumerator
counter	Monotonically increasing counter.
gauge	Instantaneous value that can go up and down.
histogram	Distribution of values with buckets.
summary	Pre-calculated quantiles and count/sum.
timer	StatsD-specific timer metric.
counter
gauge
histogram
summary
timer
set

Definition at line 50 of file metric_types.h.

                       : uint8_t {
    counter = 0,        // Monotonically increasing value
    gauge,              // Instantaneous value
    histogram,          // Distribution of values
    summary,            // Summary statistics
    timer,              // Duration measurements
    set                 // Unique value counting
};

◆ monitoring_error_code

enum class kcenon::monitoring::monitoring_error_code : std::uint32_t

strong

Comprehensive error codes for monitoring system operations.

Enumerator
success
collector_not_found
collection_failed
collector_initialization_failed
collector_already_exists
collector_disabled
invalid_collector_config
monitoring_disabled
storage_full
storage_corrupted
compression_failed
storage_not_initialized
storage_write_failed
storage_read_failed
storage_empty
invalid_configuration
invalid_interval
invalid_capacity
configuration_not_found
configuration_parse_error
system_resource_unavailable
permission_denied
out_of_memory
memory_allocation_failed
operation_timeout
operation_cancelled
thread_system_not_available
logger_system_not_available
incompatible_version
adapter_initialization_failed
metric_not_found
invalid_metric_type
metric_overflow
aggregation_failed
processing_failed
health_check_failed
health_check_timeout
health_check_not_registered
circuit_breaker_open
circuit_breaker_half_open
retry_attempts_exhausted
operation_failed
network_error
service_unavailable
service_degraded
error_boundary_triggered
fallback_failed
recovery_failed
invalid_argument
invalid_state
not_found
already_exists
resource_exhausted
already_started
dependency_missing
quota_exceeded
rate_limit_exceeded
cpu_throttled
memory_quota_exceeded
bandwidth_exceeded
resource_unavailable
transaction_failed
transaction_timeout
transaction_aborted
validation_failed
data_corrupted
state_inconsistent
deadlock_detected
rollback_failed
unknown_error

Definition at line 25 of file error_codes.h.

                                 : std::uint32_t {
    // Success
    success = 0,
    
    // Collection errors (1000-1999)
    collector_not_found = 1000,
    collection_failed = 1001,
    collector_initialization_failed = 1002,
    collector_already_exists = 1003,
    collector_disabled = 1004,
    invalid_collector_config = 1005,
    monitoring_disabled = 1006,
    
    // Storage errors (2000-2999)
    storage_full = 2000,
    storage_corrupted = 2001,
    compression_failed = 2002,
    storage_not_initialized = 2003,
    storage_write_failed = 2004,
    storage_read_failed = 2005,
    storage_empty = 2006,
    
    // Configuration errors (3000-3999)
    invalid_configuration = 3000,
    invalid_interval = 3001,
    invalid_capacity = 3002,
    configuration_not_found = 3003,
    configuration_parse_error = 3004,
    
    // System errors (4000-4999)
    system_resource_unavailable = 4000,
    permission_denied = 4001,
    out_of_memory = 4002,
    memory_allocation_failed = 4003,
    operation_timeout = 4004,
    operation_cancelled = 4005,
    
    // Integration errors (5000-5999)
    thread_system_not_available = 5000,
    logger_system_not_available = 5001,
    incompatible_version = 5002,
    adapter_initialization_failed = 5003,
    
    // Metrics errors (6000-6999)
    metric_not_found = 6000,
    invalid_metric_type = 6001,
    metric_overflow = 6002,
    aggregation_failed = 6003,
    processing_failed = 6004,
    
    // Health check errors (7000-7999)
    health_check_failed = 7000,
    health_check_timeout = 7001,
    health_check_not_registered = 7002,
    
    // Fault tolerance errors (8000-8099)
    circuit_breaker_open = 8000,
    circuit_breaker_half_open = 8001,
    retry_attempts_exhausted = 8002,
    operation_failed = 8003,
    network_error = 8004,
    service_unavailable = 8005,
    service_degraded = 8006,
    error_boundary_triggered = 8007,
    fallback_failed = 8008,
    recovery_failed = 8009,
    
    // General errors (8100-8999)
    invalid_argument = 8100,
    invalid_state = 8101,
    not_found = 8102,
    already_exists = 8103,
    resource_exhausted = 8104,
    already_started = 8105,
    dependency_missing = 8106,
    
    // Resource management errors (8200-8299)
    quota_exceeded = 8200,
    rate_limit_exceeded = 8201,
    cpu_throttled = 8202,
    memory_quota_exceeded = 8203,
    bandwidth_exceeded = 8204,
    resource_unavailable = 8205,
    
    // Data consistency errors (8300-8399)
    transaction_failed = 8300,
    transaction_timeout = 8301,
    transaction_aborted = 8302,
    validation_failed = 8303,
    data_corrupted = 8304,
    state_inconsistent = 8305,
    deadlock_detected = 8306,
    rollback_failed = 8307,
    
    // Unknown error
    unknown_error = 9999
};

◆ otel_resource_type

enum class kcenon::monitoring::otel_resource_type

strong

OpenTelemetry resource types.

Enumerator
service
service_instance
host
container
process
runtime
telemetry_sdk
custom

Definition at line 36 of file opentelemetry_adapter.h.

                              {
    service,
    service_instance,
    host,
    container,
    process,
    runtime,
    telemetry_sdk,
    custom
};

◆ otel_span_kind

enum class kcenon::monitoring::otel_span_kind

strong

OpenTelemetry span kinds.

Enumerator
unspecified
internal
server
client
producer
consumer

Definition at line 51 of file opentelemetry_adapter.h.

                          {
    unspecified = 0,
    internal = 1,
    server = 2,
    client = 3,
    producer = 4,
    consumer = 5
};

◆ otel_status_code

enum class kcenon::monitoring::otel_status_code

strong

OpenTelemetry status codes.

Enumerator
unset
ok
error

Definition at line 64 of file opentelemetry_adapter.h.

                            {
    unset = 0,
    ok = 1,
    error = 2
};

◆ plugin_category

enum class kcenon::monitoring::plugin_category

strong

Categorization of collector plugins.

Categories help organize plugins by their data source type, enabling selective loading and filtering.

Enumerator
system	System integration (threads, loggers, containers)
hardware	Hardware sensors (GPU, temperature, battery, power)
platform	Platform-specific (VM, uptime, interrupts)
network	Network metrics (connectivity, bandwidth)
process	Process-level metrics (resources, performance)
custom	User-defined plugins.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/plugins/collector_plugin.h.

Definition at line 69 of file collector_plugin.h.

                           {
    system,      
    hardware,    
    platform,    
    network,     
    process,     
    custom       
};

◆ plugin_load_error

enum class kcenon::monitoring::plugin_load_error

strong

Error codes for plugin loading operations.

Enumerator
none
file_not_found
library_load_failed
symbol_not_found
incompatible_api_version
create_function_failed
plugin_unavailable
already_loaded
not_loaded
invalid_metadata

Definition at line 52 of file plugin_loader.h.

                             {
    none = 0,
    file_not_found,
    library_load_failed,
    symbol_not_found,
    incompatible_api_version,
    create_function_failed,
    plugin_unavailable,
    already_loaded,
    not_loaded,
    invalid_metadata
};

◆ power_source_type

enum class kcenon::monitoring::power_source_type

strong

Type of power source.

Enumerator
unknown	Unknown power source type.
battery	Battery power source.
ac	AC adapter / mains power.
usb	USB power delivery.
wireless	Wireless charging.
cpu	CPU power domain (RAPL)
gpu	GPU power domain.
memory	Memory/DRAM power domain (RAPL)
package	Processor package power domain (RAPL)
platform	Platform/system power domain.
other	Other power source type.

Definition at line 38 of file power_collector.h.

                             {
    unknown,   
    battery,   
    ac,        
    usb,       
    wireless,  
    cpu,       
    gpu,       
    memory,    
    package,   
    platform,  
    other      
};

◆ recorded_metric_type

enum class kcenon::monitoring::recorded_metric_type

strong

Types of recorded metrics.

Enumerator
counter	Monotonically increasing counter.
gauge	Instantaneous value that can go up and down.
histogram	Distribution of values with buckets.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/core/performance_monitor.h.

Definition at line 52 of file performance_monitor.h.

                                {
    counter,    
    gauge,      
    histogram   
};

◆ resource_type

enum class kcenon::monitoring::resource_type

strong

Type of resource being managed.

Enumerator
memory	Memory resource.
cpu	CPU resource.

Definition at line 40 of file resource_manager.h.

                         {
    memory,  
    cpu      
};

◆ retry_strategy

enum class kcenon::monitoring::retry_strategy

strong

Retry strategies.

Enumerator
fixed_delay
exponential_backoff
linear_backoff
fibonacci_backoff

Definition at line 27 of file retry_policy.h.

                          {
    fixed_delay,
    exponential_backoff,
    linear_backoff,
    fibonacci_backoff
};

◆ security_event_type

enum class kcenon::monitoring::security_event_type

strong

Types of security events tracked.

Enumerator
login_success	Successful login attempt.
login_failure	Failed login attempt.
logout	User logout.
sudo_usage	Privilege escalation (sudo)
permission_change	Permission/ACL change.
account_created	New account creation.
account_deleted	Account deletion.
account_modified	Account modification.
session_start	Session started.
session_end	Session ended.
unknown	Unknown event type.

Definition at line 40 of file security_collector.h.

                               {
    login_success = 1,     
    login_failure = 2,     
    logout = 3,            
    sudo_usage = 4,        
    permission_change = 5, 
    account_created = 6,   
    account_deleted = 7,   
    account_modified = 8,  
    session_start = 9,     
    session_end = 10,      
    unknown = 0            
};

◆ sensor_type

enum class kcenon::monitoring::sensor_type

strong

Type of temperature sensor.

Enumerator
unknown	Unknown sensor type.
cpu	CPU temperature sensor.
gpu	GPU temperature sensor.
motherboard	Motherboard/chipset sensor.
storage	Storage device sensor.
ambient	Ambient/case temperature.
other	Other sensor type.

Definition at line 37 of file temperature_collector.h.

                       {
    unknown,      
    cpu,          
    gpu,          
    motherboard,  
    storage,      
    ambient,      
    other         
};

◆ service_priority

enum class kcenon::monitoring::service_priority

strong

Service priority levels.

Enumerator
optional
normal
important
critical

Definition at line 30 of file graceful_degradation.h.

                            {
    optional = 0,
    normal = 1,
    important = 2,
    critical = 3
};

◆ storage_backend_type

enum class kcenon::monitoring::storage_backend_type

strong

Storage backend types.

Enumerator
memory_buffer
file_json
file_binary
file_csv
database_sqlite
database_postgresql
database_mysql
cloud_s3
cloud_gcs
cloud_azure_blob

Definition at line 30 of file storage_backends.h.

                                {
    memory_buffer,
    file_json,
    file_binary,
    file_csv,
    database_sqlite,
    database_postgresql,
    database_mysql,
    cloud_s3,
    cloud_gcs,
    cloud_azure_blob
};

◆ tcp_state

enum class kcenon::monitoring::tcp_state

strong

TCP connection states as defined in RFC 793.

Enumerator
ESTABLISHED	Connection established.
SYN_SENT	SYN sent, waiting for SYN-ACK.
SYN_RECV	SYN received, SYN-ACK sent.
FIN_WAIT1	FIN sent, waiting for ACK or FIN.
FIN_WAIT2	FIN-ACK received, waiting for FIN.
TIME_WAIT	Waiting for enough time to pass (2MSL)
CLOSE	Connection closed.
CLOSE_WAIT	Remote side has closed, waiting for local close.
LAST_ACK	FIN sent after CLOSE_WAIT, waiting for ACK.
LISTEN	Listening for incoming connections.
CLOSING	Both sides sent FIN simultaneously.
UNKNOWN	Unknown or invalid state.

Definition at line 44 of file network_metrics_collector.h.

                     {
    ESTABLISHED = 1,   
    SYN_SENT = 2,      
    SYN_RECV = 3,      
    FIN_WAIT1 = 4,     
    FIN_WAIT2 = 5,     
    TIME_WAIT = 6,     
    CLOSE = 7,         
    CLOSE_WAIT = 8,    
    LAST_ACK = 9,      
    LISTEN = 10,       
    CLOSING = 11,      
    UNKNOWN = 0        
};

◆ throttling_strategy

enum class kcenon::monitoring::throttling_strategy

strong

Strategy for handling resource exhaustion.

Enumerator
reject	Reject requests immediately when limit exceeded.
delay	Delay requests until resources are available.

Definition at line 32 of file resource_manager.h.

                               {
    reject,  
    delay    
};

◆ trace_export_format

enum class kcenon::monitoring::trace_export_format

strong

Supported trace export formats.

Enumerator
jaeger_thrift	Jaeger Thrift protocol.
jaeger_grpc	Jaeger gRPC protocol.
zipkin_json	Zipkin JSON v2 format.
zipkin_protobuf	Zipkin Protocol Buffers format.
otlp_grpc	OTLP gRPC protocol.
otlp_http_json	OTLP HTTP JSON protocol.
otlp_http_protobuf	OTLP HTTP Protocol Buffers.

Definition at line 47 of file trace_exporters.h.

                               {
    jaeger_thrift,      
    jaeger_grpc,        
    zipkin_json,        
    zipkin_protobuf,    
    otlp_grpc,          
    otlp_http_json,     
    otlp_http_protobuf  
};

◆ transaction_state

enum class kcenon::monitoring::transaction_state

strong

Transaction states.

Enumerator
active
committed
aborted

Definition at line 32 of file data_consistency.h.

                             {
    active,
    committed,
    aborted
};

◆ validation_result

enum class kcenon::monitoring::validation_result

strong

Validation result states.

Enumerator
valid
invalid

Definition at line 41 of file data_consistency.h.

                             {
    valid,
    invalid
};

◆ vm_type

enum class kcenon::monitoring::vm_type

strong

Detected virtualization platform.

Enumerator
none	Bare metal (or undetected)
kvm	KVM / QEMU.
hyperv	Microsoft Hyper-V.
vmware	VMware.
virtualbox	Oracle VirtualBox.
xen	Xen.
docker	Docker Container (if distinguishable)
other	Other detected virtualization.

Definition at line 35 of file vm_collector.h.

                   {
    none = 0,       
    kvm = 1,        
    hyperv = 2,     
    vmware = 3,     
    virtualbox = 4, 
    xen = 5,        
    docker = 6,     
    other = 7       
};

Function Documentation

◆ alert_severity_to_string()

const char * kcenon::monitoring::alert_severity_to_string ( alert_severity severity )

constexprnoexcept

Convert alert severity to string.

Parameters

severity The severity level

Returns: String representation of severity

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h, /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h, and alert_notifiers_example.cpp.

Definition at line 47 of file alert_types.h.

                                                                                 {
    switch (severity) {
        case alert_severity::info:      return "info";
        case alert_severity::warning:   return "warning";
        case alert_severity::critical:  return "critical";
        case alert_severity::emergency: return "emergency";
        default:                        return "unknown";
    }
}

References critical, emergency, info, and warning.

Referenced by kcenon::monitoring::json_alert_formatter::format(), kcenon::monitoring::text_alert_formatter::format(), kcenon::monitoring::json_alert_formatter::format_group(), kcenon::monitoring::text_alert_formatter::format_group(), main(), kcenon::monitoring::console_color_notifier::notify(), print_alert_state(), kcenon::monitoring::statistics_notifier::print_statistics(), kcenon::monitoring::alert_template::render(), and TEST().

Here is the caller graph for this function:

◆ alert_state_to_string()

const char * kcenon::monitoring::alert_state_to_string ( alert_state state )

constexprnoexcept

Convert alert state to string.

Parameters

state The alert state

Returns: String representation of state

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h, /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h, and alert_notifiers_example.cpp.

Definition at line 82 of file alert_types.h.

                                                                        {
    switch (state) {
        case alert_state::inactive:   return "inactive";
        case alert_state::pending:    return "pending";
        case alert_state::firing:     return "firing";
        case alert_state::resolved:   return "resolved";
        case alert_state::suppressed: return "suppressed";
        default:                      return "unknown";
    }
}

References firing, inactive, pending, resolved, and suppressed.

Referenced by kcenon::monitoring::json_alert_formatter::format(), kcenon::monitoring::text_alert_formatter::format(), kcenon::monitoring::text_alert_formatter::format_group(), main(), kcenon::monitoring::console_color_notifier::notify(), print_alert_state(), kcenon::monitoring::statistics_notifier::print_statistics(), kcenon::monitoring::alert_template::render(), and TEST().

Here is the caller graph for this function:

◆ battery_status_to_string()

std::string kcenon::monitoring::battery_status_to_string ( battery_status status )

inline

Convert battery_status to string representation.

Definition at line 48 of file battery_collector.h.

                                                                 {
    switch (status) {
        case battery_status::charging:
            return "charging";
        case battery_status::discharging:
            return "discharging";
        case battery_status::not_charging:
            return "not_charging";
        case battery_status::full:
            return "full";
        default:
            return "unknown";
    }
}

References charging, discharging, full, and not_charging.

◆ comparison_operator_to_string()

const char * kcenon::monitoring::comparison_operator_to_string ( comparison_operator op )

constexprnoexcept

Convert comparison operator to string.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_triggers.h.

Definition at line 44 of file alert_triggers.h.

                                                                                     {
    switch (op) {
        case comparison_operator::greater_than:     return ">";
        case comparison_operator::greater_or_equal: return ">=";
        case comparison_operator::less_than:        return "<";
        case comparison_operator::less_or_equal:    return "<=";
        case comparison_operator::equal:            return "==";
        case comparison_operator::not_equal:        return "!=";
        default:                                    return "?";
    }
}

References equal, greater_or_equal, greater_than, less_or_equal, less_than, and not_equal.

Referenced by kcenon::monitoring::threshold_trigger::description(), and TEST().

Here is the caller graph for this function:

◆ create_cloud_storage()

std::unique_ptr< snapshot_storage_backend > kcenon::monitoring::create_cloud_storage	(	storage_backend_type	type,
		const std::string &	bucket )

inline

Create a cloud storage backend.

Parameters

type	Cloud type (cloud_s3, cloud_gcs, cloud_azure_blob)
bucket	Bucket or container name

Returns: Unique pointer to cloud storage backend

Definition at line 536 of file storage_backends.h.

                             {
 
    storage_config config;
    config.type = type;
    config.path = bucket;
    config.max_capacity = 100000;
 
    return storage_backend_factory::create_backend(config);
}

References kcenon::monitoring::storage_backend_factory::create_backend(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, and kcenon::monitoring::storage_config::type.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_data_consistency_manager()

std::shared_ptr< data_consistency_manager > kcenon::monitoring::create_data_consistency_manager ( const std::string & name )

inline

Factory function to create a data consistency manager.

Definition at line 597 of file data_consistency.h.

                                                                                                      {
    return std::make_shared<data_consistency_manager>(name);
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_database_storage()

std::unique_ptr< snapshot_storage_backend > kcenon::monitoring::create_database_storage	(	storage_backend_type	type,
		const std::string &	path,
		const std::string &	table )

inline

Create a database storage backend.

Parameters

type	Database type (database_sqlite, database_postgresql, database_mysql)
path	Database path or connection string
table	Table name

Returns: Unique pointer to database storage backend

Definition at line 516 of file storage_backends.h.

                            {
 
    storage_config config;
    config.type = type;
    config.path = path;
    config.table_name = table;
    config.max_capacity = 10000;
 
    return storage_backend_factory::create_backend(config);
}

References kcenon::monitoring::storage_backend_factory::create_backend(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::storage_config::table_name, and kcenon::monitoring::storage_config::type.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_default_grpc_transport()

std::unique_ptr< grpc_transport > kcenon::monitoring::create_default_grpc_transport ( )

inline

Create default gRPC transport.

Returns a real gRPC transport if available, otherwise falls back to a stub implementation.

Definition at line 590 of file grpc_transport.h.

                                                                     {
#ifdef MONITORING_HAS_GRPC
    return std::make_unique<network_grpc_transport>();
#else
    return std::make_unique<stub_grpc_transport>();
#endif
}

Referenced by TEST().

Here is the caller graph for this function:

◆ create_default_pool_configs()

std::vector< memory_pool_config > kcenon::monitoring::create_default_pool_configs ( )

inline

Create default pool configurations for different use cases.

Returns: Vector of configurations

Definition at line 458 of file memory_pool.h.

                                                                   {
    return {
        // Small objects pool
        {.initial_blocks = 512, .max_blocks = 2048, .block_size = 32, .alignment = 8},
        // Medium objects pool
        {.initial_blocks = 256, .max_blocks = 1024, .block_size = 128, .alignment = 16},
        // Large objects pool
        {.initial_blocks = 64, .max_blocks = 256, .block_size = 512, .alignment = 32},
        // Thread-local cache enabled pool
        {.initial_blocks = 256, .max_blocks = 1024, .block_size = 64, .alignment = 8, .use_thread_local_cache = true}
    };
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_default_queue_configs()

std::vector< lockfree_queue_config > kcenon::monitoring::create_default_queue_configs ( )

inline

Create default queue configurations for different use cases.

Returns: Vector of configurations

Definition at line 337 of file lockfree_queue.h.

                                                                       {
    return {
        // Small queue for low-throughput scenarios
        {.initial_capacity = 64, .max_capacity = 256, .allow_overwrite = false},
        // Medium queue for general use
        {.initial_capacity = 1024, .max_capacity = 4096, .allow_overwrite = false},
        // Large queue for high-throughput scenarios
        {.initial_capacity = 4096, .max_capacity = 65536, .allow_overwrite = false},
        // Overwrite queue for streaming data
        {.initial_capacity = 1024, .max_capacity = 1024, .allow_overwrite = true}
    };
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_default_simd_configs()

std::vector< simd_config > kcenon::monitoring::create_default_simd_configs ( )

inline

Create default SIMD configurations for different use cases.

Returns: Vector of configurations

Definition at line 690 of file simd_aggregator.h.

                                                            {
    return {
        // SIMD enabled with default settings
        {.enable_simd = true, .vector_size = 8, .alignment = 32, .use_fma = true},
        // SIMD disabled for comparison
        {.enable_simd = false, .vector_size = 8, .alignment = 32, .use_fma = false},
        // Small vector size for smaller datasets
        {.enable_simd = true, .vector_size = 4, .alignment = 16, .use_fma = true},
        // Large vector size for AVX-512
        {.enable_simd = true, .vector_size = 16, .alignment = 64, .use_fma = true}
    };
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_default_transport()

std::unique_ptr< http_transport > kcenon::monitoring::create_default_transport ( )

inline

Create default HTTP transport.

Returns a network_system-based transport if available, otherwise falls back to a stub implementation.

Definition at line 319 of file http_transport.h.

                                                                {
#ifdef MONITORING_HAS_NETWORK_SYSTEM
    return std::make_unique<network_http_transport>();
#else
    return std::make_unique<simple_http_client>();
#endif
}

◆ create_default_udp_transport()

std::unique_ptr< udp_transport > kcenon::monitoring::create_default_udp_transport ( )

inline

Create default UDP transport.

Returns a network_system-based transport if available, common_system transport if available, otherwise falls back to a stub implementation.

Definition at line 466 of file udp_transport.h.

                                                                   {
#ifdef MONITORING_HAS_NETWORK_SYSTEM
    return std::make_unique<network_udp_transport>();
#else
    return std::make_unique<stub_udp_transport>();
#endif
}

Referenced by TEST().

Here is the caller graph for this function:

◆ create_degradable_service()

template<typename T >

std::shared_ptr< degradable_service< T > > kcenon::monitoring::create_degradable_service	(	const std::string &	name,
		std::shared_ptr< graceful_degradation_manager >	manager,
		typename degradable_service< T >::normal_operation	normal_op,
		typename degradable_service< T >::degraded_operation	degraded_op )

Create a degradable service.

Definition at line 488 of file graceful_degradation.h.

                                                                  {
    return std::make_shared<degradable_service<T>>(name, std::move(manager),
                                                    std::move(normal_op), std::move(degraded_op));
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_degradation_manager()

std::shared_ptr< graceful_degradation_manager > kcenon::monitoring::create_degradation_manager ( const std::string & name )

inline

Create a graceful degradation manager.

Definition at line 455 of file graceful_degradation.h.

                                                                                                     {
    return std::make_shared<graceful_degradation_manager>(name);
}

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_degradation_plan()

degradation_plan kcenon::monitoring::create_degradation_plan	(	const std::string &	name,
		const std::vector< std::string > &	maintain,
		const std::vector< std::string > &	disable,
		degradation_level	level )

inline

Create a degradation plan.

Definition at line 472 of file graceful_degradation.h.

                                                                         {
    degradation_plan plan;
    plan.name = name;
    plan.services_to_maintain = maintain;
    plan.services_to_disable = disable;
    plan.target_level = level;
    return plan;
}

References kcenon::monitoring::degradation_plan::name, kcenon::monitoring::degradation_plan::services_to_disable, kcenon::monitoring::degradation_plan::services_to_maintain, and kcenon::monitoring::degradation_plan::target_level.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_exponential_backoff_config()

retry_config kcenon::monitoring::create_exponential_backoff_config	(	size_t	max_attempts = 3,
		std::chrono::milliseconds	initial_delay = std::chrono::milliseconds(1000) )

inline

Factory function for exponential backoff config.

Parameters

max_attempts	Maximum retry attempts
initial_delay	Initial delay between retries

Returns: retry_config configured for exponential backoff

Definition at line 83 of file retry_policy.h.

                                                                       {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::exponential_backoff;
    config.initial_delay = initial_delay;
    config.backoff_multiplier = 2.0;
    return config;
}

References kcenon::monitoring::retry_config::backoff_multiplier, exponential_backoff, kcenon::monitoring::retry_config::initial_delay, kcenon::monitoring::retry_config::max_attempts, and kcenon::monitoring::retry_config::strategy.

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_fibonacci_backoff_config()

retry_config kcenon::monitoring::create_fibonacci_backoff_config	(	size_t	max_attempts = 3,
		std::chrono::milliseconds	initial_delay = std::chrono::milliseconds(1000) )

inline

Factory function for Fibonacci backoff config.

Parameters

max_attempts	Maximum retry attempts
initial_delay	Base delay for Fibonacci sequence

Returns: retry_config configured for Fibonacci backoff

Definition at line 116 of file retry_policy.h.

                                                                       {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::fibonacci_backoff;
    config.initial_delay = initial_delay;
    return config;
}

References fibonacci_backoff, kcenon::monitoring::retry_config::initial_delay, kcenon::monitoring::retry_config::max_attempts, and kcenon::monitoring::retry_config::strategy.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_file_storage()

std::unique_ptr< snapshot_storage_backend > kcenon::monitoring::create_file_storage	(	const std::string &	path,
		storage_backend_type	type,
		size_t	capacity )

inline

Create a file storage backend.

Parameters

path	File path
type	Storage type (file_json, file_binary, file_csv)
capacity	Maximum capacity

Returns: Unique pointer to file storage backend

Definition at line 496 of file storage_backends.h.

                     {
 
    storage_config config;
    config.type = type;
    config.path = path;
    config.max_capacity = capacity;
 
    return storage_backend_factory::create_backend(config);
}

References kcenon::monitoring::storage_backend_factory::create_backend(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, and kcenon::monitoring::storage_config::type.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_fixed_delay_config()

retry_config kcenon::monitoring::create_fixed_delay_config	(	size_t	max_attempts = 3,
		std::chrono::milliseconds	delay = std::chrono::milliseconds(1000) )

inline

Factory function for fixed delay config.

Parameters

max_attempts	Maximum retry attempts
delay	Fixed delay between retries

Returns: retry_config configured for fixed delay

Definition at line 100 of file retry_policy.h.

                                                               {
    retry_config config;
    config.max_attempts = max_attempts;
    config.strategy = retry_strategy::fixed_delay;
    config.initial_delay = delay;
    return config;
}

References delay, fixed_delay, kcenon::monitoring::retry_config::initial_delay, kcenon::monitoring::retry_config::max_attempts, and kcenon::monitoring::retry_config::strategy.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_jaeger_exporter()

std::unique_ptr< jaeger_exporter > kcenon::monitoring::create_jaeger_exporter	(	const std::string &	endpoint,
		trace_export_format	format = trace_export_format::jaeger_grpc )

inline

Helper function to create a Jaeger exporter.

Definition at line 806 of file trace_exporters.h.

                                                                 {
    
    trace_export_config config;
    config.endpoint = endpoint;
    config.format = format;
    return std::make_unique<jaeger_exporter>(config);
}

References kcenon::monitoring::trace_export_config::endpoint, and kcenon::monitoring::trace_export_config::format.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_leaky_bucket_limiter()

std::unique_ptr< leaky_bucket_limiter > kcenon::monitoring::create_leaky_bucket_limiter	(	const std::string &	name,
		double	rate,
		size_t	capacity )

inline

Create a leaky bucket rate limiter.

Definition at line 614 of file resource_manager.h.

                                                         {
    return std::make_unique<leaky_bucket_limiter>(name, rate, capacity);
}

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_memory_quota_manager()

std::unique_ptr< memory_quota_manager > kcenon::monitoring::create_memory_quota_manager	(	const std::string &	name,
		size_t	max_bytes,
		throttling_strategy	strategy = throttling_strategy::reject )

inline

Create a memory quota manager.

Definition at line 622 of file resource_manager.h.

                                                              {
    return std::make_unique<memory_quota_manager>(name, max_bytes, strategy);
}

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_metric_metadata()

metric_metadata kcenon::monitoring::create_metric_metadata	(	const std::string &	name,
		metric_type	type,
		size_t	tag_count = 0 )

inline

Create metric metadata from name and type.

Definition at line 616 of file metric_types.h.

                                                                   {
    return metric_metadata(
        hash_metric_name(name),
        type,
        static_cast<uint8_t>((std::min)(tag_count, size_t(255)))
    );
}

References hash_metric_name().

Referenced by demonstrate_metric_batch(), demonstrate_metric_metadata(), kcenon::monitoring::metric_storage::store_metric(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_opentelemetry_compatibility_layer() [1/2]

std::unique_ptr< opentelemetry_compatibility_layer > kcenon::monitoring::create_opentelemetry_compatibility_layer ( const otel_resource & resource )

inline

Create OpenTelemetry compatibility layer.

Definition at line 553 of file opentelemetry_adapter.h.

                                                                        {
    return std::make_unique<opentelemetry_compatibility_layer>(resource);
}

Referenced by create_opentelemetry_compatibility_layer(), OpenTelemetryAdapterTest::SetUp(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_opentelemetry_compatibility_layer() [2/2]

std::unique_ptr< opentelemetry_compatibility_layer > kcenon::monitoring::create_opentelemetry_compatibility_layer	(	const std::string &	service_name,
		const std::string &	service_version = "1.0.0" )

inline

Create OpenTelemetry compatibility layer with service resource.

Definition at line 561 of file opentelemetry_adapter.h.

                                                                                    {
    auto resource = create_service_resource(service_name, service_version);
    return create_opentelemetry_compatibility_layer(resource);
}

References create_opentelemetry_compatibility_layer(), and create_service_resource().

Here is the call graph for this function:

◆ create_otlp_exporter()

std::unique_ptr< otlp_exporter > kcenon::monitoring::create_otlp_exporter	(	const std::string &	endpoint,
		const otel_resource &	resource,
		trace_export_format	format = trace_export_format::otlp_grpc )

inline

Helper function to create an OTLP exporter.

Definition at line 832 of file trace_exporters.h.

                                                               {
    
    trace_export_config config;
    config.endpoint = endpoint;
    config.format = format;
    return std::make_unique<otlp_exporter>(config, resource);
}

References kcenon::monitoring::trace_export_config::endpoint, and kcenon::monitoring::trace_export_config::format.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_otlp_grpc_exporter() [1/2]

std::unique_ptr< otlp_grpc_exporter > kcenon::monitoring::create_otlp_grpc_exporter ( const otlp_grpc_config & config )

inline

Create OTLP gRPC exporter with custom configuration.

Parameters

config Exporter configuration

Returns: Unique pointer to exporter

Definition at line 647 of file otlp_grpc_exporter.h.

                                    {
 
    return std::make_unique<otlp_grpc_exporter>(config);
}

◆ create_otlp_grpc_exporter() [2/2]

std::unique_ptr< otlp_grpc_exporter > kcenon::monitoring::create_otlp_grpc_exporter ( const std::string & endpoint = "localhost:4317" )

inline

Create OTLP gRPC exporter with default configuration.

Parameters

endpoint OTLP receiver endpoint

Returns: Unique pointer to exporter

Definition at line 634 of file otlp_grpc_exporter.h.

                                          :4317") {
 
    otlp_grpc_config config;
    config.endpoint = endpoint;
    return std::make_unique<otlp_grpc_exporter>(config);
}

References kcenon::monitoring::otlp_grpc_config::endpoint.

Referenced by demonstrate_batch_export(), demonstrate_otlp_export(), and TEST_F().

Here is the caller graph for this function:

◆ create_otlp_metrics_exporter()

std::unique_ptr< otlp_metrics_exporter > kcenon::monitoring::create_otlp_metrics_exporter	(	const std::string &	endpoint,
		const otel_resource &	resource,
		metric_export_format	format = metric_export_format::otlp_grpc )

inline

Helper function to create an OTLP metrics exporter.

Definition at line 1176 of file metric_exporters.h.

                                                                 {
    
    metric_export_config config;
    config.endpoint = endpoint;
    config.format = format;
    return std::make_unique<otlp_metrics_exporter>(config, resource);
}

References kcenon::monitoring::metric_export_config::endpoint, and kcenon::monitoring::metric_export_config::format.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_prometheus_exporter()

std::unique_ptr< prometheus_exporter > kcenon::monitoring::create_prometheus_exporter	(	std::uint16_t	port = 9090,
		const std::string &	job_name = "monitoring_system" )

inline

Helper function to create a Prometheus exporter.

Definition at line 1147 of file metric_exporters.h.

                                                     {
    
    metric_export_config config;
    config.port = port;
    config.format = metric_export_format::prometheus_text;
    config.job_name = job_name;
    return std::make_unique<prometheus_exporter>(config);
}

References kcenon::monitoring::metric_export_config::format, kcenon::monitoring::metric_export_config::job_name, kcenon::monitoring::metric_export_config::port, and prometheus_text.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_resource_manager()

std::unique_ptr< resource_manager > kcenon::monitoring::create_resource_manager ( const std::string & name )

inline

Create a resource manager.

Definition at line 631 of file resource_manager.h.

                                                                                      {
    return std::make_unique<resource_manager>(name);
}

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_sample_alert()

alert kcenon::monitoring::create_sample_alert	(	const std::string &	name,
		alert_severity	severity,
		alert_state	state,
		double	value,
		const std::string &	team = "ops" )

Examples: alert_notifiers_example.cpp.

Definition at line 40 of file alert_notifiers_example.cpp.

                                                         {
    alert a;
    a.name = name;
    a.severity = severity;
    a.state = state;
    a.value = value;
    a.labels.set("team", team);
    a.labels.set("environment", "production");
    a.annotations.summary = "Alert: " + name;
    a.annotations.description = "Detailed description for " + name;
    a.rule_name = name + "_rule";
    return a;
}

References kcenon::monitoring::alert::annotations, kcenon::monitoring::alert_annotations::description, kcenon::monitoring::alert::labels, kcenon::monitoring::alert::name, kcenon::monitoring::alert::rule_name, kcenon::monitoring::alert_labels::set(), kcenon::monitoring::alert::severity, kcenon::monitoring::alert::state, kcenon::monitoring::alert_annotations::summary, and kcenon::monitoring::alert::value.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_service_config()

service_config kcenon::monitoring::create_service_config	(	const std::string &	name,
		service_priority	priority )

inline

Create a service configuration.

Definition at line 462 of file graceful_degradation.h.

                                                                                              {
    service_config config;
    config.name = name;
    config.priority = priority;
    return config;
}

References kcenon::monitoring::service_config::name, and kcenon::monitoring::service_config::priority.

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_service_resource()

otel_resource kcenon::monitoring::create_service_resource	(	const std::string &	service_name,
		const std::string &	service_version = "1.0.0",
		const std::string &	service_namespace = "" )

inline

Create OpenTelemetry resource with service information.

Definition at line 532 of file opentelemetry_adapter.h.

                                                                                     {
    otel_resource resource;
    resource.type = otel_resource_type::service;
    resource.add_attribute("service.name", service_name);
    resource.add_attribute("service.version", service_version);
    if (!service_namespace.empty()) {
        resource.add_attribute("service.namespace", service_namespace);
    }
    resource.add_attribute("telemetry.sdk.name", "monitoring_system");
    resource.add_attribute("telemetry.sdk.version", "0.5.0");
    resource.add_attribute("telemetry.sdk.language", "cpp");
    
    return resource;
}

References kcenon::monitoring::otel_resource::add_attribute(), service, and kcenon::monitoring::otel_resource::type.

Referenced by create_opentelemetry_compatibility_layer(), MetricExportersTest::SetUp(), OpenTelemetryAdapterTest::SetUp(), TraceExportersTest::SetUp(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_standard_aggregation_rules()

std::vector< aggregation_rule > kcenon::monitoring::create_standard_aggregation_rules ( )

inline

Create standard aggregation rules for common metrics.

Returns: Vector of pre-configured aggregation rules

Definition at line 308 of file aggregation_processor.h.

                                                                       {
    std::vector<aggregation_rule> rules;
 
    // Response time metrics
    {
        aggregation_rule rule;
        rule.source_metric = "response_time";
        rule.target_metric_prefix = "response_time_agg";
        rule.aggregation_interval = std::chrono::milliseconds(60000);
        rule.percentiles = {0.5, 0.9, 0.95, 0.99};
        rule.compute_rate = false;
        rule.detect_outliers = true;
        rules.push_back(rule);
    }
 
    // Request count metrics
    {
        aggregation_rule rule;
        rule.source_metric = "request_count";
        rule.target_metric_prefix = "request_count_agg";
        rule.aggregation_interval = std::chrono::milliseconds(60000);
        rule.percentiles = {0.5, 0.9, 0.95, 0.99};
        rule.compute_rate = true;
        rule.detect_outliers = false;
        rules.push_back(rule);
    }
 
    // Error count metrics
    {
        aggregation_rule rule;
        rule.source_metric = "error_count";
        rule.target_metric_prefix = "error_count_agg";
        rule.aggregation_interval = std::chrono::milliseconds(60000);
        rule.percentiles = {0.5, 0.9, 0.95, 0.99};
        rule.compute_rate = true;
        rule.detect_outliers = true;
        rule.outlier_threshold = 2.0;  // More sensitive for errors
        rules.push_back(rule);
    }
 
    // CPU usage metrics
    {
        aggregation_rule rule;
        rule.source_metric = "cpu_usage";
        rule.target_metric_prefix = "cpu_usage_agg";
        rule.aggregation_interval = std::chrono::milliseconds(60000);
        rule.percentiles = {0.5, 0.9, 0.95, 0.99};
        rule.compute_rate = false;
        rule.detect_outliers = true;
        rules.push_back(rule);
    }
 
    // Memory usage metrics
    {
        aggregation_rule rule;
        rule.source_metric = "memory_usage";
        rule.target_metric_prefix = "memory_usage_agg";
        rule.aggregation_interval = std::chrono::milliseconds(60000);
        rule.percentiles = {0.5, 0.9, 0.95, 0.99};
        rule.compute_rate = false;
        rule.detect_outliers = true;
        rules.push_back(rule);
    }
 
    return rules;
}

References kcenon::monitoring::aggregation_rule::aggregation_interval, kcenon::monitoring::aggregation_rule::compute_rate, kcenon::monitoring::aggregation_rule::detect_outliers, kcenon::monitoring::aggregation_rule::outlier_threshold, kcenon::monitoring::aggregation_rule::percentiles, kcenon::monitoring::aggregation_rule::source_metric, and kcenon::monitoring::aggregation_rule::target_metric_prefix.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_state_validator()

std::shared_ptr< state_validator > kcenon::monitoring::create_state_validator ( const std::string & name )

inline

Factory function to create a state validator.

Definition at line 589 of file data_consistency.h.

                                                                                    {
    validation_config config;
    return std::make_shared<state_validator>(name, config);
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_statsd_exporter()

std::unique_ptr< statsd_exporter > kcenon::monitoring::create_statsd_exporter	(	const std::string &	host = "localhost",
		std::uint16_t	port = 8125,
		bool	datadog_format = false )

inline

Helper function to create a StatsD exporter.

Definition at line 1161 of file metric_exporters.h.

                                 {
    
    metric_export_config config;
    config.endpoint = host;
    config.port = port;
    config.format = datadog_format ? metric_export_format::statsd_datadog : metric_export_format::statsd_plain;
    return std::make_unique<statsd_exporter>(config);
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, host, kcenon::monitoring::metric_export_config::port, statsd_datadog, and statsd_plain.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_stub_grpc_transport()

std::unique_ptr< stub_grpc_transport > kcenon::monitoring::create_stub_grpc_transport ( )

inline

Create stub gRPC transport for testing.

Definition at line 601 of file grpc_transport.h.

                                                                       {
    return std::make_unique<stub_grpc_transport>();
}

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_stub_transport()

std::unique_ptr< stub_http_transport > kcenon::monitoring::create_stub_transport ( )

inline

Create stub HTTP transport for testing.

Definition at line 330 of file http_transport.h.

                                                                  {
    return std::make_unique<stub_http_transport>();
}

Referenced by TEST(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_stub_udp_transport()

std::unique_ptr< stub_udp_transport > kcenon::monitoring::create_stub_udp_transport ( )

inline

Create stub UDP transport for testing.

Definition at line 477 of file udp_transport.h.

                                                                     {
    return std::make_unique<stub_udp_transport>();
}

Referenced by TEST(), TEST(), TEST(), TEST(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_token_bucket_limiter()

std::unique_ptr< token_bucket_limiter > kcenon::monitoring::create_token_bucket_limiter	(	const std::string &	name,
		double	rate,
		size_t	capacity,
		throttling_strategy	strategy = throttling_strategy::reject )

inline

Create a token bucket rate limiter.

Definition at line 605 of file resource_manager.h.

                                                              {
    return std::make_unique<token_bucket_limiter>(name, rate, capacity, strategy);
}

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ create_transaction_manager()

std::shared_ptr< transaction_manager > kcenon::monitoring::create_transaction_manager ( const std::string & name )

inline

Factory function to create a transaction manager.

Definition at line 581 of file data_consistency.h.

                                                                                            {
    transaction_config config;
    return std::make_shared<transaction_manager>(name, config);
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ create_zipkin_exporter()

std::unique_ptr< zipkin_exporter > kcenon::monitoring::create_zipkin_exporter	(	const std::string &	endpoint,
		trace_export_format	format = trace_export_format::zipkin_json )

inline

Helper function to create a Zipkin exporter.

Definition at line 819 of file trace_exporters.h.

                                                                 {
    
    trace_export_config config;
    config.endpoint = endpoint;
    config.format = format;
    return std::make_unique<zipkin_exporter>(config);
}

References kcenon::monitoring::trace_export_config::endpoint, and kcenon::monitoring::trace_export_config::format.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ error_code_to_string()

std::string kcenon::monitoring::error_code_to_string ( monitoring_error_code code )

inline

Convert error code to string representation.

Parameters

code	The error code to convert

Returns: String representation of the error code

Definition at line 128 of file error_codes.h.

                                                                  {
    switch (code) {
        case monitoring_error_code::success:
            return "Success";
            
        // Collection errors
        case monitoring_error_code::collector_not_found:
            return "Collector not found";
        case monitoring_error_code::collection_failed:
            return "Collection failed";
        case monitoring_error_code::collector_initialization_failed:
            return "Collector initialization failed";
        case monitoring_error_code::collector_already_exists:
            return "Collector already exists";
        case monitoring_error_code::collector_disabled:
            return "Collector is disabled";
        case monitoring_error_code::invalid_collector_config:
            return "Invalid collector configuration";
        case monitoring_error_code::monitoring_disabled:
            return "Monitoring is disabled";
            
        // Storage errors
        case monitoring_error_code::storage_full:
            return "Storage is full";
        case monitoring_error_code::storage_corrupted:
            return "Storage is corrupted";
        case monitoring_error_code::compression_failed:
            return "Compression failed";
        case monitoring_error_code::storage_not_initialized:
            return "Storage not initialized";
        case monitoring_error_code::storage_write_failed:
            return "Storage write failed";
        case monitoring_error_code::storage_read_failed:
            return "Storage read failed";
        case monitoring_error_code::storage_empty:
            return "Storage is empty";
            
        // Configuration errors
        case monitoring_error_code::invalid_configuration:
            return "Invalid configuration";
        case monitoring_error_code::invalid_interval:
            return "Invalid interval";
        case monitoring_error_code::invalid_capacity:
            return "Invalid capacity";
        case monitoring_error_code::configuration_not_found:
            return "Configuration not found";
        case monitoring_error_code::configuration_parse_error:
            return "Configuration parse error";
            
        // System errors
        case monitoring_error_code::system_resource_unavailable:
            return "System resource unavailable";
        case monitoring_error_code::permission_denied:
            return "Permission denied";
        case monitoring_error_code::out_of_memory:
            return "Out of memory";
        case monitoring_error_code::memory_allocation_failed:
            return "Memory allocation failed";
        case monitoring_error_code::operation_timeout:
            return "Operation timeout";
        case monitoring_error_code::operation_cancelled:
            return "Operation cancelled";
            
        // Integration errors
        case monitoring_error_code::thread_system_not_available:
            return "Thread system not available";
        case monitoring_error_code::logger_system_not_available:
            return "Logger system not available";
        case monitoring_error_code::incompatible_version:
            return "Incompatible version";
        case monitoring_error_code::adapter_initialization_failed:
            return "Adapter initialization failed";
            
        // Metrics errors
        case monitoring_error_code::metric_not_found:
            return "Metric not found";
        case monitoring_error_code::invalid_metric_type:
            return "Invalid metric type";
        case monitoring_error_code::metric_overflow:
            return "Metric overflow";
        case monitoring_error_code::aggregation_failed:
            return "Aggregation failed";
            
        // Health check errors
        case monitoring_error_code::health_check_failed:
            return "Health check failed";
        case monitoring_error_code::health_check_timeout:
            return "Health check timeout";
        case monitoring_error_code::health_check_not_registered:
            return "Health check not registered";
            
        // Fault tolerance errors
        case monitoring_error_code::circuit_breaker_open:
            return "Circuit breaker is open";
        case monitoring_error_code::circuit_breaker_half_open:
            return "Circuit breaker is half-open";
        case monitoring_error_code::retry_attempts_exhausted:
            return "Retry attempts exhausted";
        case monitoring_error_code::operation_failed:
            return "Operation failed";
        case monitoring_error_code::network_error:
            return "Network error";
        case monitoring_error_code::service_unavailable:
            return "Service unavailable";
        case monitoring_error_code::service_degraded:
            return "Service operating in degraded mode";
        case monitoring_error_code::error_boundary_triggered:
            return "Error boundary triggered";
        case monitoring_error_code::fallback_failed:
            return "Fallback operation failed";
        case monitoring_error_code::recovery_failed:
            return "Recovery operation failed";
            
        // General errors
        case monitoring_error_code::invalid_argument:
            return "Invalid argument";
        case monitoring_error_code::invalid_state:
            return "Invalid state";
        case monitoring_error_code::not_found:
            return "Not found";
        case monitoring_error_code::already_exists:
            return "Already exists";
        case monitoring_error_code::resource_exhausted:
            return "Resource exhausted";
        case monitoring_error_code::already_started:
            return "Already started";
        case monitoring_error_code::dependency_missing:
            return "Dependency missing";
 
        // Resource management errors
        case monitoring_error_code::quota_exceeded:
            return "Quota exceeded";
        case monitoring_error_code::rate_limit_exceeded:
            return "Rate limit exceeded";
        case monitoring_error_code::cpu_throttled:
            return "CPU throttled";
        case monitoring_error_code::memory_quota_exceeded:
            return "Memory quota exceeded";
        case monitoring_error_code::bandwidth_exceeded:
            return "Bandwidth exceeded";
        case monitoring_error_code::resource_unavailable:
            return "Resource unavailable";
            
        // Data consistency errors
        case monitoring_error_code::transaction_failed:
            return "Transaction failed";
        case monitoring_error_code::transaction_timeout:
            return "Transaction timeout";
        case monitoring_error_code::transaction_aborted:
            return "Transaction aborted";
        case monitoring_error_code::validation_failed:
            return "Validation failed";
        case monitoring_error_code::data_corrupted:
            return "Data corrupted";
        case monitoring_error_code::state_inconsistent:
            return "State inconsistent";
        case monitoring_error_code::deadlock_detected:
            return "Deadlock detected";
        case monitoring_error_code::rollback_failed:
            return "Rollback failed";
            
        // Unknown error
        case monitoring_error_code::unknown_error:
        default:
            return "Unknown error";
    }
}

References adapter_initialization_failed, aggregation_failed, already_exists, already_started, bandwidth_exceeded, circuit_breaker_half_open, circuit_breaker_open, collection_failed, collector_already_exists, collector_disabled, collector_initialization_failed, collector_not_found, compression_failed, configuration_not_found, configuration_parse_error, cpu_throttled, data_corrupted, deadlock_detected, dependency_missing, error_boundary_triggered, fallback_failed, health_check_failed, health_check_not_registered, health_check_timeout, incompatible_version, invalid_argument, invalid_capacity, invalid_collector_config, invalid_configuration, invalid_interval, invalid_metric_type, invalid_state, logger_system_not_available, memory_allocation_failed, memory_quota_exceeded, metric_not_found, metric_overflow, monitoring_disabled, network_error, not_found, operation_cancelled, operation_failed, operation_timeout, out_of_memory, permission_denied, quota_exceeded, rate_limit_exceeded, recovery_failed, resource_exhausted, resource_unavailable, retry_attempts_exhausted, rollback_failed, service_degraded, service_unavailable, state_inconsistent, storage_corrupted, storage_empty, storage_full, storage_not_initialized, storage_read_failed, storage_write_failed, success, system_resource_unavailable, thread_system_not_available, transaction_aborted, transaction_failed, transaction_timeout, unknown_error, and validation_failed.

Referenced by get_error_details(), TEST_F(), and kcenon::monitoring::error_info::to_string().

Here is the caller graph for this function:

◆ execute_with_circuit_breaker()

template<typename T , typename Func >

common::Result< T > kcenon::monitoring::execute_with_circuit_breaker	(	circuit_breaker &	cb,
		const std::string &	name,
		Func &&	func )

Execute an operation through a circuit breaker.

Wraps the allow_request/record_success/record_failure pattern into a functional execute() call for convenience.

Template Parameters

T	The return value type
Func	The function type (must return common::Result<T>)

Parameters

cb	The circuit breaker instance
name	The circuit breaker name (for error messages)
func	The function to execute

Returns: common::Result<T> containing success value or error

Definition at line 82 of file fault_tolerance_manager.h.

                                                                                                      {
    if (!cb.allow_request()) {
        return common::make_error<T>(static_cast<int>(monitoring_error_code::circuit_breaker_open),
                           "Circuit breaker '" + name + "' is open");
    }
 
    auto op_result = func();
    if (op_result.is_ok()) {
        cb.record_success();
    } else {
        cb.record_failure();
    }
    return op_result;
}

References circuit_breaker_open.

Referenced by demonstrate_circuit_breaker(), demonstrate_combined_patterns(), kcenon::monitoring::fault_tolerance_manager< T >::execute_circuit_breaker_first(), kcenon::monitoring::fault_tolerance_manager< T >::execute_retry_first(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ get_builtin_collector_names()

std::vector< std::string > kcenon::monitoring::get_builtin_collector_names ( )

inline

Get list of all built-in collector names.

Returns: Vector of built-in collector names

Definition at line 105 of file builtin_collectors.h.

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

◆ get_error_details()

std::string kcenon::monitoring::get_error_details ( monitoring_error_code code )

inline

Get detailed error message.

Parameters

code	The error code

Returns: Detailed error message with suggestions

Definition at line 301 of file error_codes.h.

                                                               {
    switch (code) {
        case monitoring_error_code::collector_not_found:
            return "The specified collector was not found. Check collector name and ensure it's registered.";
        case monitoring_error_code::storage_full:
            return "Storage capacity exceeded. Consider increasing buffer size or reducing collection frequency.";
        case monitoring_error_code::invalid_configuration:
            return "Configuration validation failed. Review configuration parameters and constraints.";
        case monitoring_error_code::thread_system_not_available:
            return "Thread system integration not available. Ensure thread_system is properly linked.";
        case monitoring_error_code::circuit_breaker_open:
            return "Circuit breaker is open, rejecting calls to protect downstream services. Wait for recovery or check service health.";
        case monitoring_error_code::retry_attempts_exhausted:
            return "All retry attempts have been exhausted. The operation failed permanently. Check service availability and error conditions.";
        case monitoring_error_code::operation_failed:
            return "The requested operation failed. Check service status, network connectivity, and input parameters.";
        case monitoring_error_code::service_degraded:
            return "Service is operating in degraded mode due to detected issues. Some features may be unavailable.";
        case monitoring_error_code::error_boundary_triggered:
            return "Error boundary has been triggered to prevent error propagation. Check upstream service health.";
        case monitoring_error_code::fallback_failed:
            return "Both primary operation and fallback mechanism failed. Check alternative service configurations.";
        case monitoring_error_code::quota_exceeded:
            return "Resource quota has been exceeded. Reduce resource consumption or increase quota limits.";
        case monitoring_error_code::rate_limit_exceeded:
            return "Rate limit has been exceeded. Reduce request frequency or increase rate limits.";
        case monitoring_error_code::cpu_throttled:
            return "Operation has been throttled due to high CPU usage. Reduce system load or adjust CPU limits.";
        case monitoring_error_code::memory_quota_exceeded:
            return "Memory quota has been exceeded. Free memory or increase memory quota limits.";
        case monitoring_error_code::bandwidth_exceeded:
            return "Bandwidth quota has been exceeded. Reduce data transfer or increase bandwidth limits.";
        case monitoring_error_code::resource_unavailable:
            return "Required resource is currently unavailable. Try again later or check resource status.";
        case monitoring_error_code::transaction_failed:
            return "Transaction failed to complete successfully. Check operation prerequisites and system state.";
        case monitoring_error_code::transaction_timeout:
            return "Transaction exceeded its timeout limit. Consider increasing timeout or reducing transaction scope.";
        case monitoring_error_code::transaction_aborted:
            return "Transaction was aborted due to conflicts or errors. Review transaction operations and retry.";
        case monitoring_error_code::validation_failed:
            return "Data validation failed. Check data integrity and consistency requirements.";
        case monitoring_error_code::data_corrupted:
            return "Data corruption detected. Run data repair operations or restore from backup.";
        case monitoring_error_code::state_inconsistent:
            return "System state is inconsistent across components. Synchronization or recovery needed.";
        case monitoring_error_code::deadlock_detected:
            return "Deadlock detected in transaction processing. Review locking strategy and transaction ordering.";
        case monitoring_error_code::rollback_failed:
            return "Transaction rollback failed. Manual cleanup may be required to restore consistent state.";
        default:
            return error_code_to_string(code);
    }
}

References bandwidth_exceeded, circuit_breaker_open, collector_not_found, cpu_throttled, data_corrupted, deadlock_detected, error_boundary_triggered, error_code_to_string(), fallback_failed, invalid_configuration, memory_quota_exceeded, operation_failed, quota_exceeded, rate_limit_exceeded, resource_unavailable, retry_attempts_exhausted, rollback_failed, service_degraded, state_inconsistent, storage_full, thread_system_not_available, transaction_aborted, transaction_failed, transaction_timeout, and validation_failed.

Here is the call graph for this function:

◆ global_adaptive_monitor()

adaptive_monitor & kcenon::monitoring::global_adaptive_monitor ( )

Global adaptive monitor instance.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ global_circuit_breaker_registry()

circuit_breaker_registry & kcenon::monitoring::global_circuit_breaker_registry ( )

inline

Get global circuit breaker registry.

Definition at line 406 of file fault_tolerance_manager.h.

                                                                   {
    static circuit_breaker_registry instance;
    return instance;
}

Referenced by FaultToleranceTest::TearDown(), and TEST_F().

Here is the caller graph for this function:

◆ global_error_boundary_registry()

error_boundary_registry & kcenon::monitoring::global_error_boundary_registry ( )

inline

Get global error boundary registry.

Definition at line 447 of file graceful_degradation.h.

                                                                 {
    static error_boundary_registry instance;
    return instance;
}

Referenced by ErrorBoundariesTest::TearDown(), and TEST_F().

Here is the caller graph for this function:

◆ global_fault_tolerance_registry()

fault_tolerance_registry & kcenon::monitoring::global_fault_tolerance_registry ( )

inline

Get global fault tolerance manager registry.

Definition at line 422 of file fault_tolerance_manager.h.

                                                                   {
    static fault_tolerance_registry instance;
    return instance;
}

Referenced by FaultToleranceTest::TearDown(), and TEST_F().

Here is the caller graph for this function:

◆ global_health_monitor()

health_monitor & kcenon::monitoring::global_health_monitor ( )

inline

Get the global health monitor singleton instance.

Returns: Reference to the global health monitor

Definition at line 1019 of file health_monitor.h.

                                               {
    static health_monitor instance;
    return instance;
}

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ global_performance_monitor()

performance_monitor & kcenon::monitoring::global_performance_monitor ( )

Global performance monitor instance.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/core/performance_monitor.h.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ global_retry_executor_registry()

retry_executor_registry & kcenon::monitoring::global_retry_executor_registry ( )

inline

Get global retry executor registry.

Definition at line 414 of file fault_tolerance_manager.h.

                                                                 {
    static retry_executor_registry instance;
    return instance;
}

Referenced by FaultToleranceTest::TearDown(), and TEST_F().

Here is the caller graph for this function:

◆ global_tracer()

distributed_tracer & kcenon::monitoring::global_tracer ( )

Global tracer instance.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ gpu_type_to_string()

std::string kcenon::monitoring::gpu_type_to_string ( gpu_type type )

inline

Convert gpu_type to string representation.

Definition at line 80 of file gpu_collector.h.

                                                   {
    switch (type) {
        case gpu_type::discrete:
            return "discrete";
        case gpu_type::integrated:
            return "integrated";
        case gpu_type::virtual_gpu:
            return "virtual";
        default:
            return "unknown";
    }
}

References discrete, integrated, and virtual_gpu.

◆ gpu_vendor_to_string()

std::string kcenon::monitoring::gpu_vendor_to_string ( gpu_vendor vendor )

inline

Convert gpu_vendor to string representation.

Definition at line 49 of file gpu_collector.h.

                                                         {
    switch (vendor) {
        case gpu_vendor::nvidia:
            return "nvidia";
        case gpu_vendor::amd:
            return "amd";
        case gpu_vendor::intel:
            return "intel";
        case gpu_vendor::apple:
            return "apple";
        case gpu_vendor::other:
            return "other";
        default:
            return "unknown";
    }
}

References amd, apple, intel, nvidia, and other.

◆ hash_metric_name()

uint32_t kcenon::monitoring::hash_metric_name ( const std::string & name )

inlinenoexcept

Hash function for metric names.

Definition at line 603 of file metric_types.h.

                                                                 {
    // Simple FNV-1a hash for fast metric name hashing
    uint32_t hash = 2166136261U;
    for (char c : name) {
        hash ^= static_cast<uint32_t>(c);
        hash *= 16777619U;
    }
    return hash;
}

Referenced by create_metric_metadata(), and kcenon::monitoring::metric_storage::get_or_create_series().

Here is the caller graph for this function:

◆ make_lockfree_queue() [1/2]

template<typename T >

std::unique_ptr< lockfree_queue< T > > kcenon::monitoring::make_lockfree_queue ( )

Create a lock-free queue with default configuration.

Template Parameters

T	The element type

Returns: Unique pointer to the queue

Definition at line 318 of file lockfree_queue.h.

                                                       {
    return std::make_unique<lockfree_queue<T>>();
}

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ make_lockfree_queue() [2/2]

template<typename T >

std::unique_ptr< lockfree_queue< T > > kcenon::monitoring::make_lockfree_queue ( const lockfree_queue_config & config )

Create a lock-free queue with configuration.

Template Parameters

T	The element type

Parameters

config Queue configuration

Returns: Unique pointer to the queue

Definition at line 329 of file lockfree_queue.h.

                                                                                          {
    return std::make_unique<lockfree_queue<T>>(config);
}

◆ make_memory_pool() [1/2]

std::unique_ptr< memory_pool > kcenon::monitoring::make_memory_pool ( )

inline

Create a memory pool with default configuration.

Returns: Unique pointer to the pool

Definition at line 441 of file memory_pool.h.

                                                     {
    return std::make_unique<memory_pool>();
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ make_memory_pool() [2/2]

std::unique_ptr< memory_pool > kcenon::monitoring::make_memory_pool ( const memory_pool_config & config )

inline

Create a memory pool with configuration.

Parameters

config Pool configuration

Returns: Unique pointer to the pool

Definition at line 450 of file memory_pool.h.

                                                                                     {
    return std::make_unique<memory_pool>(config);
}

◆ make_monitor_adapter()

std::shared_ptr< common::interfaces::IMonitor > kcenon::monitoring::make_monitor_adapter ( std::shared_ptr< performance_monitor > monitor )

inline

Factory function to create performance_monitor_adapter.

Parameters

monitor The performance_monitor to wrap

Returns: Shared pointer to the adapter implementing IMonitor

Definition at line 225 of file performance_monitor_adapter.h.

                                                {
    return std::make_shared<performance_monitor_adapter>(std::move(monitor));
}

◆ make_ring_buffer() [1/2]

template<typename T >

std::unique_ptr< ring_buffer< T > > kcenon::monitoring::make_ring_buffer ( const ring_buffer_config & config )

Helper function to create a ring buffer with custom configuration.

Definition at line 489 of file ring_buffer.h.

                                                                                 {
    return std::make_unique<ring_buffer<T>>(config);
}

◆ make_ring_buffer() [2/2]

template<typename T >

std::unique_ptr< ring_buffer< T > > kcenon::monitoring::make_ring_buffer ( size_t capacity = 8192 )

Helper function to create a ring buffer with default configuration.

Definition at line 479 of file ring_buffer.h.

                                                                       {
    ring_buffer_config config;
    config.capacity = capacity;
    return std::make_unique<ring_buffer<T>>(config);
}

References kcenon::monitoring::ring_buffer_config::capacity.

◆ make_simd_aggregator() [1/2]

std::unique_ptr< simd_aggregator > kcenon::monitoring::make_simd_aggregator ( )

inline

Create a SIMD aggregator with default configuration.

Returns: Unique pointer to the aggregator

Definition at line 673 of file simd_aggregator.h.

                                                             {
    return std::make_unique<simd_aggregator>();
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ make_simd_aggregator() [2/2]

std::unique_ptr< simd_aggregator > kcenon::monitoring::make_simd_aggregator ( const simd_config & config )

inline

Create a SIMD aggregator with configuration.

Parameters

config Aggregator configuration

Returns: Unique pointer to the aggregator

Definition at line 682 of file simd_aggregator.h.

                                                                                      {
    return std::make_unique<simd_aggregator>(config);
}

◆ metric_type_to_string()

const char * kcenon::monitoring::metric_type_to_string ( metric_type type )

constexprnoexcept

Convert metric type to string.

Definition at line 62 of file metric_types.h.

                                                                       {
    switch (type) {
        case metric_type::counter:   return "counter";
        case metric_type::gauge:     return "gauge";
        case metric_type::histogram: return "histogram";
        case metric_type::summary:   return "summary";
        case metric_type::timer:     return "timer";
        case metric_type::set:       return "set";
        default:                     return "unknown";
    }
}

References counter, gauge, histogram, set, summary, and timer.

Referenced by demonstrate_metric_metadata().

Here is the caller graph for this function:

◆ pearson_correlation()

double kcenon::monitoring::pearson_correlation	(	const std::vector< double > &	x,
		const std::vector< double > &	y )

inline

Calculate Pearson correlation coefficient.

Parameters

x	First data series
y	Second data series

Returns: Correlation coefficient (-1 to 1), 0 if sizes differ

Definition at line 660 of file stream_aggregator.h.

                                                               {
    if (x.size() != y.size() || x.size() < 2) {
        return 0.0;
    }
 
    size_t n = x.size();
    double sum_x = 0, sum_y = 0, sum_xy = 0;
    double sum_x2 = 0, sum_y2 = 0;
 
    for (size_t i = 0; i < n; ++i) {
        sum_x += x[i];
        sum_y += y[i];
        sum_xy += x[i] * y[i];
        sum_x2 += x[i] * x[i];
        sum_y2 += y[i] * y[i];
    }
 
    double num = n * sum_xy - sum_x * sum_y;
    double den = std::sqrt((n * sum_x2 - sum_x * sum_x) *
                           (n * sum_y2 - sum_y * sum_y));
 
    if (den < 1e-10) {
        return 0.0;
    }
 
    return num / den;
}

Referenced by TEST_F().

Here is the caller graph for this function:

◆ power_source_type_to_string()

std::string kcenon::monitoring::power_source_type_to_string ( power_source_type type )

inline

Convert power_source_type to string representation.

Definition at line 55 of file power_collector.h.

                                                                     {
    switch (type) {
        case power_source_type::battery:
            return "battery";
        case power_source_type::ac:
            return "ac";
        case power_source_type::usb:
            return "usb";
        case power_source_type::wireless:
            return "wireless";
        case power_source_type::cpu:
            return "cpu";
        case power_source_type::gpu:
            return "gpu";
        case power_source_type::memory:
            return "memory";
        case power_source_type::package:
            return "package";
        case power_source_type::platform:
            return "platform";
        case power_source_type::other:
            return "other";
        default:
            return "unknown";
    }
}

References ac, battery, cpu, gpu, memory, other, package, platform, usb, and wireless.

◆ register_builtin_collectors()

bool kcenon::monitoring::register_builtin_collectors ( )

inline

Register all built-in collectors with the collector_registry.

This function registers the following collectors:

battery_collector (plugin-based)
uptime_collector (plugin-based)
interrupt_collector (plugin-based)
network_metrics_collector (plugin-based)
platform_metrics_collector (plugin-based)
process_metrics_collector (plugin-based)
security_collector (plugin-based)
smart_collector (plugin-based)
vm_collector (plugin-based)
system_resource_collector (standalone, metric_factory only)

Plugin-based collectors (using collector_plugin interface) are registered with the collector_registry using factory-based lazy loading, enabling runtime enable/disable and plugin management.

All collectors are also registered with metric_factory for backward compatibility.

Call this function once at application startup before using the registry.

Returns: true if all collectors were registered successfully

Definition at line 70 of file builtin_collectors.h.

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

References kcenon::monitoring::collector_registry::instance(), register_plugin_collector(), and register_standalone_collector().

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_crtp_collector()

template<typename T >

bool kcenon::monitoring::register_crtp_collector ( const std::string & name )

Helper function to register a CRTP-based collector.

Template Parameters

T	The collector type

Parameters

name	The collector name

Returns: true if registration successful

Definition at line 147 of file collector_adapters.h.

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

References kcenon::monitoring::metric_factory::instance(), and kcenon::monitoring::metric_factory::register_collector().

Here is the call graph for this function:

◆ register_plugin_collector()

template<typename T >

bool kcenon::monitoring::register_plugin_collector ( const std::string & name )

Helper function to register a plugin-based collector.

Template Parameters

T	The collector type

Parameters

name	The collector name

Returns: true if registration successful

Definition at line 134 of file collector_adapters.h.

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

References kcenon::monitoring::metric_factory::instance(), and kcenon::monitoring::metric_factory::register_collector().

Referenced by register_builtin_collectors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_standalone_collector()

template<typename T >

bool kcenon::monitoring::register_standalone_collector ( const std::string & name )

Helper function to register a standalone collector.

Template Parameters

T	The collector type

Parameters

name	The collector name

Returns: true if registration successful

Definition at line 160 of file collector_adapters.h.

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

References kcenon::monitoring::metric_factory::instance(), and kcenon::monitoring::metric_factory::register_collector().

Referenced by register_builtin_collectors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ security_event_type_to_string()

std::string kcenon::monitoring::security_event_type_to_string ( security_event_type type )

inline

Convert security_event_type to string representation.

Parameters

type	The event type to convert

Returns: String name of the event type

Definition at line 59 of file security_collector.h.

                                                                         {
    switch (type) {
        case security_event_type::login_success: return "LOGIN_SUCCESS";
        case security_event_type::login_failure: return "LOGIN_FAILURE";
        case security_event_type::logout: return "LOGOUT";
        case security_event_type::sudo_usage: return "SUDO_USAGE";
        case security_event_type::permission_change: return "PERMISSION_CHANGE";
        case security_event_type::account_created: return "ACCOUNT_CREATED";
        case security_event_type::account_deleted: return "ACCOUNT_DELETED";
        case security_event_type::account_modified: return "ACCOUNT_MODIFIED";
        case security_event_type::session_start: return "SESSION_START";
        case security_event_type::session_end: return "SESSION_END";
        default: return "UNKNOWN";
    }
}

References account_created, account_deleted, account_modified, login_failure, login_success, logout, permission_change, session_end, session_start, and sudo_usage.

◆ sensor_type_to_string()

std::string kcenon::monitoring::sensor_type_to_string ( sensor_type type )

inline

Convert sensor_type to string representation.

Definition at line 50 of file temperature_collector.h.

                                                         {
    switch (type) {
        case sensor_type::cpu:
            return "cpu";
        case sensor_type::gpu:
            return "gpu";
        case sensor_type::motherboard:
            return "motherboard";
        case sensor_type::storage:
            return "storage";
        case sensor_type::ambient:
            return "ambient";
        case sensor_type::other:
            return "other";
        default:
            return "unknown";
    }
}

References ambient, cpu, gpu, motherboard, other, and storage.

◆ tcp_state_to_string()

std::string kcenon::monitoring::tcp_state_to_string ( tcp_state state )

inline

Convert tcp_state to string representation.

Parameters

state The TCP state to convert

Returns: String name of the state

Definition at line 64 of file network_metrics_collector.h.

                                                      {
    switch (state) {
        case tcp_state::ESTABLISHED: return "ESTABLISHED";
        case tcp_state::SYN_SENT: return "SYN_SENT";
        case tcp_state::SYN_RECV: return "SYN_RECV";
        case tcp_state::FIN_WAIT1: return "FIN_WAIT1";
        case tcp_state::FIN_WAIT2: return "FIN_WAIT2";
        case tcp_state::TIME_WAIT: return "TIME_WAIT";
        case tcp_state::CLOSE: return "CLOSE";
        case tcp_state::CLOSE_WAIT: return "CLOSE_WAIT";
        case tcp_state::LAST_ACK: return "LAST_ACK";
        case tcp_state::LISTEN: return "LISTEN";
        case tcp_state::CLOSING: return "CLOSING";
        default: return "UNKNOWN";
    }
}

References CLOSE, CLOSE_WAIT, CLOSING, ESTABLISHED, FIN_WAIT1, FIN_WAIT2, LAST_ACK, LISTEN, SYN_RECV, SYN_SENT, and TIME_WAIT.

◆ to_string()

auto kcenon::monitoring::to_string ( plugin_load_error error ) -> std::string

Convert plugin_load_error to string.

Examples: bidirectional_di_example.cpp, logger_di_integration_example.cpp, and monitor_factory_pattern_example.cpp.

Referenced by demo_bidirectional_integration(), demo_monitor_with_logger(), example_5_provider_interface(), console_logger::log(), example_logger::log(), and simple_console_logger::log().

Here is the caller graph for this function:

◆ vm_type_to_string()

std::string kcenon::monitoring::vm_type_to_string ( vm_type type )

inline

Convert vm_type to string representation.

Parameters

type	The VM type to convert

Returns: String name of the VM type

Definition at line 51 of file vm_collector.h.

                                                 {
    switch (type) {
        case vm_type::none: return "NONE";
        case vm_type::kvm: return "KVM";
        case vm_type::hyperv: return "HYPER-V";
        case vm_type::vmware: return "VMWARE";
        case vm_type::virtualbox: return "VIRTUALBOX";
        case vm_type::xen: return "XEN";
        case vm_type::docker: return "DOCKER";
        case vm_type::other: return "OTHER";
        default: return "UNKNOWN";
    }
}

References docker, hyperv, kvm, none, other, virtualbox, vmware, and xen.

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ aggregation_result_stream

◆ circuit_breaker

◆ circuit_breaker_config

◆ circuit_state

◆ collector_factory_fn

◆ config_map

◆ logger_system_adapter

◆ plugin_factory_fn

◆ stats_map

◆ tag_map

◆ thread_system_adapter

Enumeration Type Documentation

◆ adaptation_strategy

◆ alert_severity

◆ alert_state

◆ battery_status

◆ cgroup_version

◆ comparison_operator

◆ composite_operation

◆ compression_algorithm

◆ degradation_level

◆ error_boundary_policy

◆ event_priority

◆ gpu_type

◆ gpu_vendor

◆ health_check_type

◆ health_status

◆ load_level

◆ metric_export_format

◆ metric_type [1/2]

◆ metric_type [2/2]

◆ monitoring_error_code

◆ otel_resource_type

◆ otel_span_kind

◆ otel_status_code

◆ plugin_category

◆ plugin_load_error

◆ power_source_type

◆ recorded_metric_type

◆ resource_type

◆ retry_strategy

◆ security_event_type

◆ sensor_type

◆ service_priority

◆ storage_backend_type

◆ tcp_state

◆ throttling_strategy

◆ trace_export_format

◆ transaction_state

◆ validation_result

◆ vm_type

Function Documentation

◆ alert_severity_to_string()

◆ alert_state_to_string()

◆ battery_status_to_string()

◆ comparison_operator_to_string()

◆ create_cloud_storage()

◆ create_data_consistency_manager()

◆ create_database_storage()

◆ create_default_grpc_transport()

◆ create_default_pool_configs()

◆ create_default_queue_configs()

◆ create_default_simd_configs()

◆ create_default_transport()

◆ create_default_udp_transport()

◆ create_degradable_service()

◆ create_degradation_manager()

◆ create_degradation_plan()

◆ create_exponential_backoff_config()

◆ create_fibonacci_backoff_config()

◆ create_file_storage()

◆ create_fixed_delay_config()

◆ create_jaeger_exporter()

◆ create_leaky_bucket_limiter()