performance_monitor_adapter.h

Go to the documentation of this file.

#pragma once
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
 
#include "../core/performance_monitor.h"
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <memory>
#include <string>
 
namespace kcenon { namespace monitoring {
 
class performance_monitor_adapter : public common::interfaces::IMonitor {
public:
    static common::Result<std::shared_ptr<performance_monitor_adapter>> create(
        std::shared_ptr<performance_monitor> monitor) {
        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{})));
    }
 
    explicit performance_monitor_adapter(std::shared_ptr<performance_monitor> monitor)
        : monitor_(std::move(monitor)) {
        if (!monitor_) {
            throw std::invalid_argument("performance_monitor cannot be null");
        }
    }
 
    common::VoidResult record_metric(const std::string& name, double value) override {
        // 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();
    }
 
    common::VoidResult record_metric(
        const std::string& name,
        double value,
        const std::unordered_map<std::string, std::string>& tags) override {
        // 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();
    }
 
    common::Result<common::interfaces::metrics_snapshot> get_metrics() override {
        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"}
            );
        }
    }
 
    common::Result<common::interfaces::health_check_result> check_health() override {
        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));
        }
    }
 
    common::VoidResult reset() override {
        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"}
            );
        }
    }
 
    std::shared_ptr<performance_monitor> get_wrapped_monitor() const {
        return monitor_;
    }
 
private:
    struct validated_tag {};
 
    // Private constructor for validated creation via create()
    performance_monitor_adapter(std::shared_ptr<performance_monitor> monitor, validated_tag)
        : monitor_(std::move(monitor)) {}
 
    std::shared_ptr<performance_monitor> monitor_;
};
 
inline common::Result<std::shared_ptr<common::interfaces::IMonitor>> make_monitor_adapter(
    std::shared_ptr<performance_monitor> monitor) {
    auto result = performance_monitor_adapter::create(std::move(monitor));
    if (result.is_err()) {
        return common::Result<std::shared_ptr<common::interfaces::IMonitor>>::err(
            result.error());
    }
    return common::ok(
        std::shared_ptr<common::interfaces::IMonitor>(result.value()));
}
 
} } // namespace kcenon::monitoring