Gauge.hpp

#pragma once
 
#include "util/prometheus/MetricBase.hpp"
#include "util/prometheus/OStream.hpp"
#include "util/prometheus/impl/AnyCounterBase.hpp"
 
#include <cstdint>
#include <string>
#include <type_traits>
#include <utility>
 
namespace util::prometheus {

template <SomeNumberType NumberType>
struct AnyGauge : MetricBase, impl::AnyCounterBase<NumberType> {
    using ValueType = NumberType;

    template <impl::SomeCounterImpl ImplType = impl::CounterImpl<ValueType>>
        requires std::same_as<ValueType, typename std::remove_cvref_t<ImplType>::ValueType>
    AnyGauge(std::string name, std::string labelsString, ImplType&& impl = ImplType{})
        : MetricBase(std::move(name), std::move(labelsString))
        , impl::AnyCounterBase<ValueType>(std::forward<ImplType>(impl))
    {
    }

    AnyGauge&
    operator++()
    {
        this->pimpl_->add(ValueType{1});
        return *this;
    }

    AnyGauge&
    operator--()
    {
        this->pimpl_->add(ValueType{-1});
        return *this;
    }

    AnyGauge&
    operator+=(ValueType const value)
    {
        this->pimpl_->add(value);
        return *this;
    }

    AnyGauge&
    operator-=(ValueType const value)
    {
        this->pimpl_->add(-value);
        return *this;
    }

    void
    set(ValueType const value)
    {
        this->pimpl_->set(value);
    }

    [[nodiscard]] ValueType
    value() const
    {
        return this->pimpl_->value();
    }

    void
    serializeValue(OStream& stream) const override
    {
        stream << name() << labelsString() << ' ' << value();
    }
};

using GaugeInt = AnyGauge<std::int64_t>;

using GaugeDouble = AnyGauge<double>;
 
}  // namespace util::prometheus