performance_monitor.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <string>
#include <memory>
#include <chrono>
#include <vector>
#include <deque>
#include <unordered_map>
#include <mutex>
#include <atomic>
#include <functional>
#include <thread>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <shared_mutex>
 
#include "../core/result_types.h"
#include "../core/error_codes.h"
#include "../interfaces/monitoring_core.h"
 
// Use common_system interfaces (Phase 2.3.4)
#include <kcenon/common/interfaces/monitoring_interface.h>
 
namespace kcenon { namespace monitoring {
 
using tag_map = std::unordered_map<std::string, std::string>;
 
enum class recorded_metric_type {
    counter,    
    gauge,      
    histogram   
};
 
struct tagged_metric {
    std::string name;
    double value;
    recorded_metric_type type;
    tag_map tags;
    std::chrono::system_clock::time_point timestamp;
 
    tagged_metric(const std::string& n, double v, recorded_metric_type t,
                  const tag_map& tgs = {})
        : name(n)
        , value(v)
        , type(t)
        , tags(tgs)
        , timestamp(std::chrono::system_clock::now()) {}
 
    std::string key() const {
        std::string k = name;
        // Sort tags for consistent key generation
        std::vector<std::pair<std::string, std::string>> sorted_tags(
            tags.begin(), tags.end());
        std::sort(sorted_tags.begin(), sorted_tags.end());
        for (const auto& [tag_key, tag_value] : sorted_tags) {
            k += ";" + tag_key + "=" + tag_value;
        }
        return k;
    }
};
 
struct performance_metrics {
    std::string operation_name;
    std::chrono::nanoseconds min_duration{std::chrono::nanoseconds::max()};
    std::chrono::nanoseconds max_duration{std::chrono::nanoseconds::zero()};
    std::chrono::nanoseconds total_duration{std::chrono::nanoseconds::zero()};
    std::chrono::nanoseconds mean_duration{std::chrono::nanoseconds::zero()};
    std::chrono::nanoseconds median_duration{std::chrono::nanoseconds::zero()};
    std::chrono::nanoseconds p95_duration{std::chrono::nanoseconds::zero()};
    std::chrono::nanoseconds p99_duration{std::chrono::nanoseconds::zero()};
    std::uint64_t call_count{0};
    std::uint64_t error_count{0};
    double throughput{0.0};  // Operations per second
    
};
 
struct system_metrics {
    double cpu_usage_percent{0.0};
    double memory_usage_percent{0.0};
    std::size_t memory_usage_bytes{0};
    std::size_t available_memory_bytes{0};
    std::uint32_t thread_count{0};
    std::uint32_t handle_count{0};
    double disk_io_read_rate{0.0};   // MB/s
    double disk_io_write_rate{0.0};  // MB/s
    double network_io_recv_rate{0.0}; // MB/s
    double network_io_send_rate{0.0}; // MB/s
    
    std::chrono::system_clock::time_point timestamp;
};
 
class performance_profiler {
private:
    struct profile_data {
        // Using deque instead of vector for O(1) pop_front performance
        // when removing oldest samples in ring buffer behavior
        std::deque<std::chrono::nanoseconds> samples;
        std::atomic<std::uint64_t> call_count{0};
        std::atomic<std::uint64_t> error_count{0};
        // Store time as atomic integer for thread-safe access without locks
        std::atomic<std::chrono::steady_clock::rep> last_access_time{std::chrono::steady_clock::now().time_since_epoch().count()};
        mutable std::mutex mutex;
    };
 
    std::unordered_map<std::string, std::unique_ptr<profile_data>> profiles_;
    mutable std::shared_mutex profiles_mutex_;
    std::atomic<bool> enabled_{true};
    std::size_t max_samples_per_operation_{10000};
    std::size_t max_profiles_{10000};  // LRU eviction threshold
 
    // Lock-free collection path (Sprint 3-4)
    std::atomic<bool> use_lock_free_path_{false};
    
public:
    common::Result<bool> record_sample(
        const std::string& operation_name,
        std::chrono::nanoseconds duration,
        bool success = true
    );
 
    common::Result<performance_metrics> get_metrics(
        const std::string& operation_name
    ) const;
    
    std::vector<performance_metrics> get_all_metrics() const;
    
    common::Result<bool> clear_samples(const std::string& operation_name);
    
    void clear_all_samples();
    
    void set_enabled(bool enabled) { enabled_ = enabled; }
 
    bool is_enabled() const { return enabled_; }
 
    void set_max_samples(std::size_t max_samples) {
        max_samples_per_operation_ = max_samples;
    }
 
    void set_lock_free_mode(bool enable) {
        use_lock_free_path_ = enable;
    }
 
    bool is_lock_free_mode() const {
        return use_lock_free_path_;
    }
};
 
class scoped_timer {
private:
    performance_profiler* profiler_;
    std::string operation_name_;
    std::chrono::high_resolution_clock::time_point start_time_;
    bool success_{true};
    bool completed_{false};
    
public:
    scoped_timer(performance_profiler* profiler, const std::string& operation_name)
        : profiler_(profiler)
        , operation_name_(operation_name)
        , start_time_(std::chrono::high_resolution_clock::now()) {}
    
    ~scoped_timer() {
        if (!completed_ && profiler_) {
            complete();
        }
    }
    
    void mark_failed() { success_ = false; }
    
    void complete() {
        if (completed_) return;
        
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
            end_time - start_time_
        );
        
        if (profiler_) {
            profiler_->record_sample(operation_name_, duration, success_);
        }
        
        completed_ = true;
    }
    
    std::chrono::nanoseconds elapsed() const {
        auto now = std::chrono::high_resolution_clock::now();
        return std::chrono::duration_cast<std::chrono::nanoseconds>(
            now - start_time_
        );
    }
};
 
class system_monitor {
private:
    struct monitor_impl;
    std::unique_ptr<monitor_impl> impl_;
    
public:
    system_monitor();
    ~system_monitor();
    
    // Disable copy
    system_monitor(const system_monitor&) = delete;
    system_monitor& operator=(const system_monitor&) = delete;
    
    // Enable move
    system_monitor(system_monitor&&) noexcept;
    system_monitor& operator=(system_monitor&&) noexcept;
    
    common::Result<system_metrics> get_current_metrics() const;
 
    common::Result<bool> start_monitoring(
        std::chrono::milliseconds interval = std::chrono::milliseconds(1000)
    );
 
    common::Result<bool> stop_monitoring();
    
    bool is_monitoring() const;
    
    std::vector<system_metrics> get_history(
        std::chrono::seconds duration = std::chrono::seconds(60)
    ) const;
};
 
class performance_monitor : public metrics_collector {
private:
    performance_profiler profiler_;
    system_monitor system_monitor_;
    std::string name_;
    bool enabled_{true};
 
    // Performance thresholds for alerting
    struct thresholds {
        double cpu_threshold{80.0};
        double memory_threshold{90.0};
        std::chrono::milliseconds latency_threshold{1000};
    } thresholds_;
    mutable std::mutex thresholds_mutex_;  // Protects thresholds_
 
    // Tagged metrics storage for counters, gauges, and histograms
    struct metric_data {
        double value{0.0};
        recorded_metric_type type;
        tag_map tags;
        std::chrono::system_clock::time_point last_update;
        std::vector<double> histogram_values;  // For histogram type only
        std::size_t max_histogram_samples{1000};
    };
    std::unordered_map<std::string, std::unique_ptr<metric_data>> tagged_metrics_;
    mutable std::shared_mutex metrics_mutex_;  // Protects tagged_metrics_
    
public:
    explicit performance_monitor(const std::string& name = "performance_monitor")
        : name_(name) {}
    
    // Implement metrics_collector interface
 
    std::string get_name() const override { return name_; }
 
    bool is_enabled() const override { return enabled_; }
    
    common::VoidResult set_enabled(bool enable) override {
        enabled_ = enable;
        profiler_.set_enabled(enable);
        return common::ok();
    }
 
    common::VoidResult initialize() override {
        auto result = system_monitor_.start_monitoring();
        if (result.is_err()) {
            return common::VoidResult::err(result.error());
        }
        return common::ok();
    }
 
    common::VoidResult cleanup() override {
        auto result = system_monitor_.stop_monitoring();
        if (result.is_err()) {
            return common::VoidResult::err(result.error());
        }
        return common::ok();
    }
 
    common::Result<metrics_snapshot> collect() override;
    
    scoped_timer time_operation(const std::string& operation_name) {
        return scoped_timer(&profiler_, operation_name);
    }
    
    performance_profiler& get_profiler() { return profiler_; }
 
    const performance_profiler& get_profiler() const { return profiler_; }
 
    system_monitor& get_system_monitor() { return system_monitor_; }
 
    const system_monitor& get_system_monitor() const { return system_monitor_; }
    
    void set_cpu_threshold(double threshold) {
        std::lock_guard<std::mutex> lock(thresholds_mutex_);
        thresholds_.cpu_threshold = threshold;
    }
 
    void set_memory_threshold(double threshold) {
        std::lock_guard<std::mutex> lock(thresholds_mutex_);
        thresholds_.memory_threshold = threshold;
    }
 
    void set_latency_threshold(std::chrono::milliseconds threshold) {
        std::lock_guard<std::mutex> lock(thresholds_mutex_);
        thresholds_.latency_threshold = threshold;
    }
 
    thresholds get_thresholds() const {
        std::lock_guard<std::mutex> lock(thresholds_mutex_);
        return thresholds_;
    }
    
    common::Result<bool> check_thresholds() const;
 
    // IMonitor interface implementation (Phase 2.3.4)
 
    void reset() {
        profiler_.clear_all_samples();
        clear_all_metrics();
    }
 
    // =========================================================================
    // Tagged Metric Recording Methods
    // =========================================================================
 
    common::VoidResult record_counter(const std::string& name, double value,
                                      const tag_map& tags = {});
 
    common::VoidResult record_gauge(const std::string& name, double value,
                                    const tag_map& tags = {});
 
    common::VoidResult record_histogram(const std::string& name, double value,
                                        const tag_map& tags = {});
 
    std::vector<tagged_metric> get_all_tagged_metrics() const;
 
    void clear_all_metrics();
 
private:
    static std::string make_metric_key(const std::string& name, const tag_map& tags);
 
    common::VoidResult record_metric_internal(const std::string& name, double value,
                                              recorded_metric_type type, const tag_map& tags);
};
 
performance_monitor& global_performance_monitor();
 
#define PERF_TIMER(operation_name) \
    kcenon::monitoring::scoped_timer _perf_timer( \
        &kcenon::monitoring::global_performance_monitor().get_profiler(), \
        operation_name \
    )
 
#define PERF_TIMER_CUSTOM(profiler, operation_name) \
    kcenon::monitoring::scoped_timer _perf_timer(profiler, operation_name)
 
class performance_benchmark {
private:
    performance_profiler profiler_;
    std::string name_;
    std::uint32_t iterations_{1000};
    std::uint32_t warmup_iterations_{100};
    
public:
    explicit performance_benchmark(const std::string& name)
        : name_(name) {}
    
    void set_iterations(std::uint32_t iterations) {
        iterations_ = iterations;
    }
 
    void set_warmup_iterations(std::uint32_t warmup) {
        warmup_iterations_ = warmup;
    }
    
    template<typename Func>
    common::Result<performance_metrics> run(
        const std::string& operation_name,
        Func&& func
    ) {
        // Warmup
        for (std::uint32_t i = 0; i < warmup_iterations_; ++i) {
            func();
        }
        
        // Actual benchmark
        for (std::uint32_t i = 0; i < iterations_; ++i) {
            auto start = std::chrono::high_resolution_clock::now();
            
            try {
                func();
            } catch (...) {
                // Record error
                auto end = std::chrono::high_resolution_clock::now();
                auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
                    end - start
                );
                profiler_.record_sample(operation_name, duration, false);
                continue;
            }
            
            auto end = std::chrono::high_resolution_clock::now();
            auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
                end - start
            );
            profiler_.record_sample(operation_name, duration, true);
        }
        
        return profiler_.get_metrics(operation_name);
    }
    
    template<typename Func1, typename Func2>
    common::Result<std::pair<performance_metrics, performance_metrics>> compare(
        const std::string& operation1_name,
        Func1&& func1,
        const std::string& operation2_name,
        Func2&& func2
    ) {
        auto result1 = run(operation1_name, std::forward<Func1>(func1));
        if (result1.is_err()) {
            return common::Result<std::pair<performance_metrics, performance_metrics>>::err(result1.error());
        }
 
        auto result2 = run(operation2_name, std::forward<Func2>(func2));
        if (result2.is_err()) {
            return common::Result<std::pair<performance_metrics, performance_metrics>>::err(result2.error());
        }
 
        return common::ok(std::make_pair(result1.value(), result2.value()));
    }
};
 
// Platform-specific system metrics collection functions
#if defined(__linux__)
common::Result<system_metrics> get_linux_system_metrics();
#endif
 
#if defined(_WIN32)
common::Result<system_metrics> get_windows_system_metrics();
#endif
 
} } // namespace kcenon::monitoring