MetricsFamily.hpp

#pragma once
 
#include "util/prometheus/Label.hpp"
#include "util/prometheus/MetricBase.hpp"
#include "util/prometheus/MetricBuilder.hpp"
#include "util/prometheus/OStream.hpp"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace util::prometheus {

class MetricsFamily {
public:
    static std::unique_ptr<MetricBuilderInterface>
        defaultMetricBuilder;  

    MetricsFamily(
        std::string name,
        std::optional<std::string> description,
        MetricType type,
        MetricBuilderInterface& builder = *defaultMetricBuilder
    );
 
    MetricsFamily(MetricsFamily const&) = delete;
    MetricsFamily(MetricsFamily&&) = default;
    MetricsFamily&
    operator=(MetricsFamily const&) = delete;
    MetricsFamily&
    operator=(MetricsFamily&&) = delete;

    MetricBase&
    getMetric(Labels labels, std::vector<std::int64_t> const& buckets = {});

    MetricBase&
    getMetric(Labels labels, std::vector<double> const& buckets);

    friend OStream&
    operator<<(OStream& stream, MetricsFamily const& metricsFamily);

    [[nodiscard]] std::string const&
    name() const;

    [[nodiscard]] MetricType
    type() const;
 
private:
    std::string name_;
    std::optional<std::string> description_;
    std::unordered_map<std::string, std::unique_ptr<MetricBase>> metrics_;
    MetricType type_;
    MetricBuilderInterface& metricBuilder_;
 
    template <typename ValueType>
        requires std::same_as<ValueType, std::int64_t> || std::same_as<ValueType, double>
    MetricBase&
    getMetricImpl(Labels labels, std::vector<ValueType> const& buckets);
};
 
}  // namespace util::prometheus