monitoring_concepts.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 <concepts>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include "../config/feature_flags.h"
 
#if KCENON_HAS_COMMON_SYSTEM
#include <kcenon/common/concepts/concepts.h>
#endif
 
namespace kcenon::monitoring {
namespace concepts {
 
template <typename T>
concept MetricValue = std::is_arithmetic_v<T>;
 
template <typename T>
concept MetricType =
    std::is_class_v<T> && std::is_copy_constructible_v<T> && requires(const T t) {
        { t.name } -> std::convertible_to<std::string>;
        { t.value } -> std::convertible_to<double>;
    };
 
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() };
};
 
template <typename T>
concept ObserverLike = requires(T t) {
    { t.on_metrics_updated(std::declval<std::vector<int>>()) };
};
 
template <typename T>
concept MonitoringEventType = std::is_class_v<T> && std::is_copy_constructible_v<T>;
 
template <typename H, typename E>
concept MonitoringEventHandler =
    std::invocable<H, const E&> && std::is_void_v<std::invoke_result_t<H, const E&>>;
 
template <typename F, typename M>
concept MetricFilterPredicate =
    std::invocable<F, const M&> && std::convertible_to<std::invoke_result_t<F, const M&>, bool>;
 
template <typename F, typename M>
concept MetricTransformer = std::invocable<F, const M&>;
 
template <typename T>
concept ConfigValidatable = requires(const T t) {
    { t.validate() };
};
 
template <typename T>
concept StorageBackendLike = requires(T t) {
    { t.store(std::declval<std::vector<int>>()) };
    { t.is_connected() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept ExporterLike = requires(T t) {
    { t.export_metrics(std::declval<std::vector<int>>()) };
    { t.is_ready() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept HealthCheckable = requires(const T t) {
    { t.is_healthy() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept TracingContextLike = requires(const T t) {
    { t.get_trace_id() } -> std::convertible_to<std::string>;
    { t.get_span_id() } -> std::convertible_to<std::string>;
};
 
} // namespace concepts
} // namespace kcenon::monitoring