metric_collector_interface.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 <algorithm>
#include <chrono>
#include <concepts>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
#include "../core/result_types.h"
#include "../config/feature_flags.h"
#include "metric_types_adapter.h"
#include "observer_interface.h"
 
#if KCENON_HAS_COMMON_SYSTEM
#include <kcenon/common/concepts/service.h>
#endif
 
namespace kcenon { namespace monitoring {
 
namespace concepts {
 
template <typename T>
concept Validatable = requires(const T t) {
    { t.validate() };
};
 
template <typename T>
concept MetricSourceLike = requires(const T t) {
    { t.get_current_metrics() };
    { t.get_source_name() } -> std::convertible_to<std::string>;
    { t.is_healthy() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept MetricCollectorLike = requires(T t) {
    { t.collect_metrics() };
    { t.is_collecting() } -> std::convertible_to<bool>;
    { t.get_metric_types() };
};
 
} // namespace concepts
 
class metric_filter {
public:
    enum class filter_type {
        include_all,
        include_specific,
        exclude_specific
    };
 
    metric_filter(filter_type type = filter_type::include_all)
        : type_(type) {}
 
    void add_metric_type(const std::string& type) {
        metric_types_.push_back(type);
    }
 
    bool should_collect(const std::string& metric_type) const {
        switch (type_) {
            case filter_type::include_all:
                return true;
            case filter_type::include_specific:
                return std::find(metric_types_.begin(), metric_types_.end(), metric_type) != metric_types_.end();
            case filter_type::exclude_specific:
                return std::find(metric_types_.begin(), metric_types_.end(), metric_type) == metric_types_.end();
        }
        return true;
    }
 
private:
    filter_type type_;
    std::vector<std::string> metric_types_;
};
 
struct collection_config {
    std::chrono::milliseconds interval{std::chrono::seconds(1)};
    metric_filter filter;
    bool batch_collection{false};
    size_t batch_size{100};
    bool async_collection{true};
 
    [[nodiscard]] common::VoidResult validate() const {
        if (interval.count() <= 0) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration, "Collection interval must be positive").to_common_error());
        }
        if (batch_collection && batch_size == 0) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration, "Batch size must be positive when batch collection is enabled").to_common_error());
        }
        return common::ok();
    }
};
 
// Compile-time verification that collection_config satisfies Validatable concept
static_assert(concepts::Validatable<collection_config>,
              "collection_config must satisfy Validatable concept");
 
class interface_metric_collector : public interface_observable {
public:
    virtual ~interface_metric_collector() = default;
 
    virtual common::Result<std::vector<metric>> collect_metrics() = 0;
 
    virtual common::VoidResult start_collection(const collection_config& config) = 0;
 
    virtual common::VoidResult stop_collection() = 0;
 
    virtual bool is_collecting() const = 0;
 
    virtual std::vector<std::string> get_metric_types() const = 0;
 
    virtual collection_config get_config() const = 0;
 
    virtual common::VoidResult update_config(const collection_config& config) = 0;
 
    virtual common::Result<std::vector<metric>> force_collect() = 0;
 
    virtual metric_stats get_stats() const = 0;
 
    virtual void reset_stats() = 0;
};
 
class interface_metric_source {
public:
    virtual ~interface_metric_source() = default;
 
    virtual std::vector<metric> get_current_metrics() const = 0;
 
    virtual std::string get_source_name() const = 0;
 
    virtual bool is_healthy() const = 0;
};
 
class interface_aggregated_collector : public interface_metric_collector {
public:
    virtual ~interface_aggregated_collector() = default;
 
    virtual common::VoidResult register_source(std::shared_ptr<interface_metric_source> source) = 0;
 
    virtual common::VoidResult unregister_source(const std::string& source_name) = 0;
 
    virtual std::vector<std::string> get_registered_sources() const = 0;
};
 
} } // namespace kcenon::monitoring