null_adapter.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <prom/adapter.hpp>
 
#include <logman/logman.hpp>
 
#include <memory>
#include <span>
#include <string_view>
 
namespace prom {
 
class NullAdapter final : public Adapter {
public:
    NullAdapter() : logger_(logman::get("prom.null")), inert_(std::make_shared<MetricState>()) {}
 
    [[nodiscard]] std::string_view backend_name() const noexcept override {
        return "null";
    }
 
    [[nodiscard]] MetricHandle register_metric(const MetricMeta& meta) noexcept override {
        if (logger_) {
            logger_->debug(
                "register_metric type={} name={} (no-op)", to_string(meta.type), meta.name);
        }
        return inert_;
    }
 
    [[nodiscard]] MetricHandle resolve(const MetricHandle& /*family*/,
                                       const Labels& dynamic) noexcept override {
        if (logger_) {
            logger_->trace("resolve labels={} (no-op)", dynamic.size());
        }
        return inert_;
    }
 
    void inc(const MetricHandle& /*handle*/, const double amount) noexcept override {
        trace("inc", amount);
    }
 
    void dec(const MetricHandle& /*handle*/, const double amount) noexcept override {
        trace("dec", amount);
    }
 
    void set(const MetricHandle& /*handle*/, const double value) noexcept override {
        trace("set", value);
    }
 
    void observe(const MetricHandle& /*handle*/, const double value) noexcept override {
        trace("observe", value);
    }
 
    void set_info(const MetricHandle& /*handle*/,
                  const std::span<const Label> labels) noexcept override {
        if (logger_) {
            logger_->trace("set_info labels={} (no-op)", labels.size());
        }
    }
 
    void set_state(const MetricHandle& /*handle*/,
                   std::string_view state,
                   bool active) noexcept override {
        if (logger_) {
            logger_->trace("set_state {}={} (no-op)", state, active);
        }
    }
 
    void set_unit(const MetricHandle& /*handle*/, const Unit& unit) noexcept override {
        if (logger_) {
            logger_->trace("set_unit {} (no-op)", unit.name);
        }
    }
 
private:
    void trace(std::string_view op, double value) const noexcept {
        if (logger_) {
            logger_->trace("{} {} (no-op)", op, value);
        }
    }
 
    std::shared_ptr<spdlog::logger> logger_;
    MetricHandle inert_;
};
 
}  // namespace prom