kcenon::monitoring::performance_monitor_adapter Class Reference

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

#include <performance_monitor_adapter.h>

Inheritance diagram for kcenon::monitoring::performance_monitor_adapter:

Collaboration diagram for kcenon::monitoring::performance_monitor_adapter:

Classes
struct	validated_tag

Public Member Functions
	performance_monitor_adapter (std::shared_ptr< performance_monitor > monitor)
	Construct adapter with existing performance_monitor.
common::VoidResult	record_metric (const std::string &name, double value) override
	Record a simple metric value.
common::VoidResult	record_metric (const std::string &name, double value, const std::unordered_map< std::string, std::string > &tags) override
	Record a metric with additional tags.
common::Result< common::interfaces::metrics_snapshot >	get_metrics () override
	Get current metrics snapshot.
common::Result< common::interfaces::health_check_result >	check_health () override
	Perform health check on the performance_monitor.
common::VoidResult	reset () override
	Reset all metrics in the wrapped performance_monitor.
std::shared_ptr< performance_monitor >	get_wrapped_monitor () const
	Get the wrapped performance_monitor.

Static Public Member Functions
static common::Result< std::shared_ptr< performance_monitor_adapter > >	create (std::shared_ptr< performance_monitor > monitor)
	Create an adapter with validated monitor pointer.

Private Member Functions
	performance_monitor_adapter (std::shared_ptr< performance_monitor > monitor, validated_tag)

Private Attributes
std::shared_ptr< performance_monitor >	monitor_

Detailed Description

Adapter that wraps performance_monitor to implement IMonitor interface.

This adapter follows the Adapter design pattern to eliminate multiple inheritance. It provides a clean separation between the monitoring system's internal interface (metrics_collector) and the common system's standard interface (IMonitor).

Thread Safety:

Thread-safe if the wrapped performance_monitor is thread-safe

Example usage:

auto monitor = std::make_shared<performance_monitor>("my_monitor");
auto adapter = std::make_shared<performance_monitor_adapter>(monitor);
 
// Use through IMonitor interface
adapter->record_metric("requests_count", 42.0);
auto snapshot = adapter->get_metrics();

Definition at line 45 of file performance_monitor_adapter.h.

Constructor & Destructor Documentation

performance_monitor_adapter() [1/2]

kcenon::monitoring::performance_monitor_adapter::performance_monitor_adapter ( std::shared_ptr< performance_monitor > monitor )

inlineexplicit

Construct adapter with existing performance_monitor.

Parameters

monitor

Shared pointer to the performance_monitor to wrap

Exceptions

std::invalid_argument

if monitor is nullptr

Deprecated

Use create() for Result-based error handling

Definition at line 71 of file performance_monitor_adapter.h.

        : monitor_(std::move(monitor)) {
        if (!monitor_) {
            throw std::invalid_argument("performance_monitor cannot be null");
        }
    }

References monitor_.

Referenced by create().

Here is the caller graph for this function:

performance_monitor_adapter() [2/2]

kcenon::monitoring::performance_monitor_adapter::performance_monitor_adapter ( std::shared_ptr< performance_monitor > monitor, validated_tag  )

inlineprivate

Definition at line 239 of file performance_monitor_adapter.h.

        : monitor_(std::move(monitor)) {}

Member Function Documentation

check_health()

common::Result< common::interfaces::health_check_result > kcenon::monitoring::performance_monitor_adapter::check_health ( )

inlineoverride

Perform health check on the performance_monitor.

Returns

Result containing health check result @override

Definition at line 188 of file performance_monitor_adapter.h.

                                                                              {
        try {
            common::interfaces::health_check_result result;
            result.timestamp = std::chrono::system_clock::now();
 
            if (monitor_->is_enabled()) {
                result.status = common::interfaces::health_status::healthy;
                result.message = "Performance monitor is operational";
            } else {
                result.status = common::interfaces::health_status::degraded;
                result.message = "Performance monitor is disabled";
            }
 
            return common::ok(std::move(result));
        } catch (const std::exception& e) {
            common::interfaces::health_check_result result;
            result.status = common::interfaces::health_status::unhealthy;
            result.message = std::string("Health check failed: ") + e.what();
            result.timestamp = std::chrono::system_clock::now();
            return common::ok(std::move(result));
        }
    }

References monitor_.

create()

static common::Result< std::shared_ptr< performance_monitor_adapter > > kcenon::monitoring::performance_monitor_adapter::create ( std::shared_ptr< performance_monitor > monitor )

inlinestatic

Create an adapter with validated monitor pointer.

Parameters

monitor

Shared pointer to the performance_monitor to wrap

Returns

Result containing the adapter or error if monitor is nullptr

Definition at line 52 of file performance_monitor_adapter.h.

                                                    {
        if (!monitor) {
            return common::Result<std::shared_ptr<performance_monitor_adapter>>::err(
                common::error_info{
                    static_cast<int>(monitoring_error_code::invalid_configuration),
                    "performance_monitor cannot be null",
                    "performance_monitor_adapter"});
        }
        return common::ok(std::shared_ptr<performance_monitor_adapter>(
            new performance_monitor_adapter(std::move(monitor), validated_tag{})));
    }

References kcenon::monitoring::invalid_configuration, and performance_monitor_adapter().

Referenced by kcenon::monitoring::make_monitor_adapter(), TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

get_metrics()

common::Result< common::interfaces::metrics_snapshot > kcenon::monitoring::performance_monitor_adapter::get_metrics ( )

inlineoverride

Get current metrics snapshot.

Returns

Result containing metrics snapshot compatible with common::interfaces @override

Definition at line 131 of file performance_monitor_adapter.h.

                                                                          {
        try {
            // Get all recorded metrics from the performance_monitor
            common::interfaces::metrics_snapshot snapshot;
            snapshot.source_id = monitor_->get_name();
            snapshot.capture_time = std::chrono::system_clock::now();
 
            // Get performance metrics from the monitor's profiler
            const auto& perf_metrics = monitor_->get_profiler().get_all_metrics();
 
            // Convert each performance_metrics (operation timing) into multiple metric_value entries
            for (const auto& perf : perf_metrics) {
                // Add various duration metrics as gauges
                snapshot.add_metric(perf.operation_name + "_min_ns",
                                  static_cast<double>(perf.min_duration.count()));
                snapshot.add_metric(perf.operation_name + "_max_ns",
                                  static_cast<double>(perf.max_duration.count()));
                snapshot.add_metric(perf.operation_name + "_mean_ns",
                                  static_cast<double>(perf.mean_duration.count()));
                snapshot.add_metric(perf.operation_name + "_median_ns",
                                  static_cast<double>(perf.median_duration.count()));
                snapshot.add_metric(perf.operation_name + "_p95_ns",
                                  static_cast<double>(perf.p95_duration.count()));
                snapshot.add_metric(perf.operation_name + "_p99_ns",
                                  static_cast<double>(perf.p99_duration.count()));
 
                // Add count metrics as counters (conceptually)
                snapshot.add_metric(perf.operation_name + "_call_count",
                                  static_cast<double>(perf.call_count));
                snapshot.add_metric(perf.operation_name + "_error_count",
                                  static_cast<double>(perf.error_count));
            }
 
            // Add tagged metrics (counters, gauges, histograms with tags)
            const auto& tagged_metrics = monitor_->get_all_tagged_metrics();
            for (const auto& metric : tagged_metrics) {
                // Create metric_value with tags directly
                common::interfaces::metric_value mv(metric.name, metric.value);
                mv.tags = std::unordered_map<std::string, std::string>(
                    metric.tags.begin(), metric.tags.end());
                mv.timestamp = metric.timestamp;
                snapshot.metrics.push_back(std::move(mv));
            }
 
            return common::ok(std::move(snapshot));
        } catch (const std::exception& e) {
            return common::Result<common::interfaces::metrics_snapshot>(
                common::error_info{3, std::string("Exception in get_metrics: ") + e.what(), "performance_monitor_adapter"}
            );
        }
    }

References monitor_, kcenon::monitoring::metric::name, kcenon::monitoring::metric::tags, kcenon::monitoring::metric::timestamp, and kcenon::monitoring::metric::value.

get_wrapped_monitor()

std::shared_ptr< performance_monitor > kcenon::monitoring::performance_monitor_adapter::get_wrapped_monitor ( ) const

inline

Get the wrapped performance_monitor.

Returns

Shared pointer to the wrapped monitor

Definition at line 231 of file performance_monitor_adapter.h.

                                                                   {
        return monitor_;
    }

References monitor_.

record_metric() [1/2]

common::VoidResult kcenon::monitoring::performance_monitor_adapter::record_metric ( const std::string & name, double value )

inlineoverride

Record a simple metric value.

Parameters

name	Metric name
value	Metric value

Returns

VoidResult indicating success or error @override

Note

performance_monitor is designed for operation timing, not arbitrary metrics. This method is a no-op for compatibility with IMonitor interface. Use start_operation() / scoped_timer for actual performance monitoring.

Definition at line 89 of file performance_monitor_adapter.h.

                                                                                 {
        // performance_monitor is specifically designed for timing operations,
        // not recording arbitrary metric values. For IMonitor compatibility,
        // we accept the call but don't store it.
        (void)name;   // Suppress unused parameter warning
        (void)value;
        return common::ok();
    }

record_metric() [2/2]

common::VoidResult kcenon::monitoring::performance_monitor_adapter::record_metric ( const std::string & name, double value, const std::unordered_map< std::string, std::string > & tags )

inlineoverride

Record a metric with additional tags.

Parameters

name	Metric name
value	Metric value
tags	Metadata tags for the metric

Returns

VoidResult indicating success or error @override

Records the metric using the underlying performance_monitor's tag-aware counter recording. Tags are preserved and passed through to enable multi-dimensional metric analysis.

Definition at line 110 of file performance_monitor_adapter.h.

                                                                     {
        // Convert to tag_map and record as counter with tags
        tag_map converted_tags(tags.begin(), tags.end());
        auto result = monitor_->record_counter(name, value, converted_tags);
        if (result.is_err()) {
            const auto& err = result.error();
            return common::VoidResult(
                common::error_info{static_cast<int>(err.code), err.message, "performance_monitor_adapter"}
            );
        }
        return common::ok();
    }

References monitor_.

reset()

common::VoidResult kcenon::monitoring::performance_monitor_adapter::reset ( )

inlineoverride

Reset all metrics in the wrapped performance_monitor.

Returns

VoidResult indicating success or error @override

Definition at line 216 of file performance_monitor_adapter.h.

                                      {
        try {
            monitor_->reset();
            return common::ok();
        } catch (const std::exception& e) {
            return common::VoidResult(
                common::error_info{4, std::string("Failed to reset monitor: ") + e.what(), "performance_monitor_adapter"}
            );
        }
    }

References monitor_.

Member Data Documentation

monitor_

std::shared_ptr<performance_monitor> kcenon::monitoring::performance_monitor_adapter::monitor_

private

Definition at line 242 of file performance_monitor_adapter.h.

Referenced by check_health(), get_metrics(), get_wrapped_monitor(), performance_monitor_adapter(), record_metric(), and reset().

---

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

• include/kcenon/monitoring/adapters/performance_monitor_adapter.h