monitoring.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <concepts>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
 
namespace kcenon::common {
 
// Forward declarations
namespace interfaces {
using metric_labels = std::unordered_map<std::string, std::string>;
}  // namespace interfaces
 
namespace concepts {
 
template <typename T>
concept CounterMetric = requires(T t,
                                 std::string_view name,
                                 double value,
                                 const interfaces::metric_labels& labels) {
    { t.increment(name, value, labels) } -> std::same_as<void>;
};
 
template <typename T>
concept GaugeMetric = requires(T t,
                               std::string_view name,
                               double value,
                               const interfaces::metric_labels& labels) {
    { t.gauge(name, value, labels) } -> std::same_as<void>;
};
 
template <typename T>
concept HistogramMetric = requires(T t,
                                   std::string_view name,
                                   double value,
                                   const interfaces::metric_labels& labels) {
    { t.histogram(name, value, labels) } -> std::same_as<void>;
};
 
template <typename T>
concept TimingMetric = requires(T t,
                                std::string_view name,
                                std::chrono::nanoseconds duration,
                                const interfaces::metric_labels& labels) {
    { t.timing(name, duration, labels) } -> std::same_as<void>;
};
 
template <typename T>
concept MetricCollectorLike = CounterMetric<T> &&
                              GaugeMetric<T> &&
                              HistogramMetric<T> &&
                              TimingMetric<T>;
 
template <typename T>
concept NamedImplementation = requires(const T t) {
    { t.get_implementation_name() } -> std::convertible_to<std::string>;
};
 
template <typename T>
concept MetricCollectorProviderLike = requires(T t, const std::string& prefix) {
    { t.get_metric_collector() };
    { t.create_metric_collector(prefix) };
};
 
}  // namespace concepts
}  // namespace kcenon::common