interrupt_collector.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 <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../interfaces/metric_types_adapter.h"
#include "../plugins/collector_plugin.h"
 
namespace kcenon {
namespace monitoring {
 
struct cpu_interrupt_info {
    uint32_t cpu_id{0};              
    uint64_t interrupt_count{0};     
    double interrupts_per_sec{0.0};  
};
 
struct interrupt_metrics {
    uint64_t interrupts_total{0};          
    double interrupts_per_sec{0.0};        
    uint64_t soft_interrupts_total{0};     
    double soft_interrupts_per_sec{0.0};   
    std::vector<cpu_interrupt_info> per_cpu;  
    bool metrics_available{false};         
    bool soft_interrupts_available{false}; 
    std::chrono::system_clock::time_point timestamp;  
};
 
// Forward declaration
namespace platform {
class metrics_provider;
}  // namespace platform
 
class interrupt_info_collector {
   public:
    interrupt_info_collector();
    ~interrupt_info_collector();
 
    // Non-copyable, non-moveable due to internal state
    interrupt_info_collector(const interrupt_info_collector&) = delete;
    interrupt_info_collector& operator=(const interrupt_info_collector&) = delete;
    interrupt_info_collector(interrupt_info_collector&&) = delete;
    interrupt_info_collector& operator=(interrupt_info_collector&&) = delete;
 
    bool is_interrupt_monitoring_available() const;
 
    interrupt_metrics collect_metrics();
 
   private:
    std::unique_ptr<platform::metrics_provider> provider_;
 
    // Previous sample for rate calculation
    uint64_t prev_interrupts_total_{0};
    uint64_t prev_soft_interrupts_total_{0};
    std::chrono::system_clock::time_point prev_timestamp_;
    bool has_previous_sample_{false};
};
 
class interrupt_collector : public collector_plugin {
   public:
    interrupt_collector();
    ~interrupt_collector() override = default;
 
    // Non-copyable, non-moveable due to internal state
    interrupt_collector(const interrupt_collector&) = delete;
    interrupt_collector& operator=(const interrupt_collector&) = delete;
    interrupt_collector(interrupt_collector&&) = delete;
    interrupt_collector& operator=(interrupt_collector&&) = delete;
 
    // collector_plugin implementation
    auto name() const -> std::string_view override { return "interrupt_collector"; }
    auto collect() -> std::vector<metric> override;
    auto interval() const -> std::chrono::milliseconds override { return std::chrono::seconds(15); }
    auto is_available() const -> bool override;
    auto get_metric_types() const -> std::vector<std::string> override;
 
    auto get_metadata() const -> plugin_metadata override {
        return plugin_metadata{
            .name = name(),
            .description = "Hardware and software interrupt statistics",
            .category = plugin_category::platform,
            .version = "1.0.0",
            .dependencies = {},
            .requires_platform_support = true
        };
    }
 
    auto initialize(const config_map& config) -> bool override;
 
    auto get_statistics() const -> stats_map override;
 
    interrupt_metrics get_last_metrics() const;
 
    bool is_interrupt_monitoring_available() const;
 
   private:
    std::unique_ptr<interrupt_info_collector> collector_;
 
    // Configuration
    bool enabled_{true};
    bool collect_per_cpu_{false};
    bool collect_soft_interrupts_{true};
 
    // Last metrics cache
    interrupt_metrics last_metrics_;
 
    // Statistics
    std::atomic<size_t> collection_count_{0};
    std::atomic<size_t> collection_errors_{0};
 
    // Helper methods
    void add_interrupt_metrics(std::vector<metric>& metrics, const interrupt_metrics& data);
};
 
}  // namespace monitoring
}  // namespace kcenon