monitoring_integration.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
#ifndef KCENON_NETWORK_INTERNAL_INTEGRATION_MONITORING_INTEGRATION_H_
#define KCENON_NETWORK_INTERNAL_INTEGRATION_MONITORING_INTEGRATION_H_
 
#include <map>
#include <memory>
#include <string>
 
#include "kcenon/network/integration/thread_integration.h"
 
namespace kcenon::network::integration
{
 
    enum class metric_type
    {
        counter,   
        gauge,     
        histogram, 
        summary    
    };
 
    class monitoring_interface
    {
    public:
        virtual ~monitoring_interface() = default;
 
        virtual void report_counter(const std::string& name, double value,
                                    const std::map<std::string, std::string>& labels = {}) = 0;
 
        virtual void report_gauge(const std::string& name, double value,
                                  const std::map<std::string, std::string>& labels = {}) = 0;
 
        virtual void report_histogram(const std::string& name, double value,
                                      const std::map<std::string, std::string>& labels = {}) = 0;
 
        virtual void report_health(const std::string& connection_id, bool is_alive,
                                   double response_time_ms, size_t missed_heartbeats,
                                   double packet_loss_rate) = 0;
    };
 
    class basic_monitoring : public monitoring_interface
    {
    public:
        explicit basic_monitoring(bool enable_logging = true);
 
        ~basic_monitoring() override;
 
        // monitoring_interface implementation
        void report_counter(const std::string& name, double value,
                            const std::map<std::string, std::string>& labels = {}) override;
 
        void report_gauge(const std::string& name, double value,
                          const std::map<std::string, std::string>& labels = {}) override;
 
        void report_histogram(const std::string& name, double value,
                              const std::map<std::string, std::string>& labels = {}) override;
 
        void report_health(const std::string& connection_id, bool is_alive,
                           double response_time_ms, size_t missed_heartbeats,
                           double packet_loss_rate) override;
 
        void set_logging_enabled(bool enabled);
 
        bool is_logging_enabled() const;
 
    private:
        class impl;
        std::unique_ptr<impl> pimpl_;
    };
 
    // Note: monitoring_system_adapter has been removed in favor of EventBus-based
    // metric publishing. See issue #342 for details.
    //
    // External consumers (like monitoring_system) should subscribe to
    // network_metric_event via common_system's EventBus:
    //
    //   auto& bus = common::get_event_bus();
    //   bus.subscribe<network::events::network_metric_event>(
    //       [](const auto& event) { /* process metric */ }
    //   );
 
    class monitoring_integration_manager
    {
    public:
        static monitoring_integration_manager& instance();
 
        void set_monitoring(std::shared_ptr<monitoring_interface> monitoring);
 
        std::shared_ptr<monitoring_interface> get_monitoring();
 
        void report_counter(const std::string& name, double value,
                            const std::map<std::string, std::string>& labels = {});
 
        void report_gauge(const std::string& name, double value,
                          const std::map<std::string, std::string>& labels = {});
 
        void report_histogram(const std::string& name, double value,
                              const std::map<std::string, std::string>& labels = {});
 
        void report_health(const std::string& connection_id, bool is_alive,
                           double response_time_ms, size_t missed_heartbeats,
                           double packet_loss_rate);
 
    private:
        monitoring_integration_manager();
        ~monitoring_integration_manager();
 
        class impl;
        std::unique_ptr<impl> pimpl_;
    };
 
} // namespace kcenon::network::integration
 
// Backward compatibility namespace alias is defined in thread_integration.h
 
#endif // KCENON_NETWORK_INTERNAL_INTEGRATION_MONITORING_INTEGRATION_H_