metric_collector_interface.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 <memory>
#include <string>
#include <string_view>
#include <unordered_map>
 
namespace kcenon::common {
namespace interfaces {
 
using metric_labels = std::unordered_map<std::string, std::string>;
 
class IMetricCollector {
public:
    virtual ~IMetricCollector() = default;
 
    virtual void increment(std::string_view name,
                          double value = 1.0,
                          const metric_labels& labels = {}) = 0;
 
    virtual void gauge(std::string_view name,
                      double value,
                      const metric_labels& labels = {}) = 0;
 
    virtual void histogram(std::string_view name,
                          double value,
                          const metric_labels& labels = {}) = 0;
 
    virtual void timing(std::string_view name,
                       std::chrono::nanoseconds duration,
                       const metric_labels& labels = {}) = 0;
 
    [[nodiscard]] virtual std::string get_implementation_name() const {
        return "IMetricCollector";
    }
};
 
class scoped_timer {
public:
    scoped_timer(IMetricCollector& collector,
                 std::string_view name,
                 metric_labels labels = {})
        : collector_(collector)
        , name_(name)
        , labels_(std::move(labels))
        , start_(std::chrono::steady_clock::now()) {}
 
    ~scoped_timer() {
        auto elapsed = std::chrono::steady_clock::now() - start_;
        collector_.timing(
            name_,
            std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed),
            labels_);
    }
 
    // Non-copyable and non-movable
    scoped_timer(const scoped_timer&) = delete;
    scoped_timer& operator=(const scoped_timer&) = delete;
    scoped_timer(scoped_timer&&) = delete;
    scoped_timer& operator=(scoped_timer&&) = delete;
 
    [[nodiscard]] std::chrono::nanoseconds elapsed() const {
        return std::chrono::duration_cast<std::chrono::nanoseconds>(
            std::chrono::steady_clock::now() - start_);
    }
 
private:
    IMetricCollector& collector_;
    std::string name_;
    metric_labels labels_;
    std::chrono::steady_clock::time_point start_;
};
 
class null_metric_collector : public IMetricCollector {
public:
    void increment(std::string_view /*name*/,
                  double /*value*/ = 1.0,
                  const metric_labels& /*labels*/ = {}) override {}
 
    void gauge(std::string_view /*name*/,
              double /*value*/,
              const metric_labels& /*labels*/ = {}) override {}
 
    void histogram(std::string_view /*name*/,
                  double /*value*/,
                  const metric_labels& /*labels*/ = {}) override {}
 
    void timing(std::string_view /*name*/,
               std::chrono::nanoseconds /*duration*/,
               const metric_labels& /*labels*/ = {}) override {}
 
    [[nodiscard]] std::string get_implementation_name() const override {
        return "null_metric_collector";
    }
};
 
using MetricCollectorFactory = std::function<std::shared_ptr<IMetricCollector>()>;
 
class IMetricCollectorProvider {
public:
    virtual ~IMetricCollectorProvider() = default;
 
    virtual std::shared_ptr<IMetricCollector> get_metric_collector() = 0;
 
    virtual std::shared_ptr<IMetricCollector> create_metric_collector(
        const std::string& prefix) = 0;
};
 
}  // namespace interfaces
}  // namespace kcenon::common