metric_tag_impl.hpp

#pragma once
 
#include <atomic>
#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
 
#include <userver/formats/json/value.hpp>
#include <userver/formats/json/value_builder.hpp>
#include <userver/utils/meta_light.hpp>
#include <userver/utils/statistics/writer.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils::statistics::impl {
 
template <typename Metric>
formats::json::ValueBuilder DumpMetric(const std::atomic<Metric>& m) {
  static_assert(std::atomic<Metric>::is_always_lock_free, "std::atomic misuse");
  return m.load();
}
 
template <typename Metric>
void ResetMetric(std::atomic<Metric>& m) {
  static_assert(std::atomic<Metric>::is_always_lock_free, "std::atomic misuse");
  m = Metric();
}
 
template <typename Metric>
using HasDumpMetric = decltype(DumpMetric(std::declval<Metric&>()));
 
template <typename Metric>
using HasResetMetric = decltype(ResetMetric(std::declval<Metric&>()));
 
// TODO remove after C++20 atomic value-initialization
template <typename T>
void InitializeAtomic(T& /*value*/) {}
 
template <typename T>
void InitializeAtomic(std::atomic<T>& value) {
  value.store(T(), std::memory_order_relaxed);
}
 
class MetricWrapperBase {
 public:
  MetricWrapperBase& operator=(MetricWrapperBase&&) = delete;
  virtual ~MetricWrapperBase();
 
  virtual formats::json::ValueBuilder DeprecatedJsonDump() = 0;
 
  virtual void DumpToWriter(utils::statistics::Writer& writer) = 0;
 
  virtual bool HasWriterSupport() const noexcept = 0;
 
  virtual void Reset() = 0;
};
 
template <typename Metric>
class MetricWrapper final : public MetricWrapperBase {
  static_assert(
      meta::kIsDetected<HasDumpMetric, Metric> || kHasWriterSupport<Metric>,
      "Provide a `void DumpMetric(utils::statistics::Writer&, const Metric&)`"
      "function in the namespace of `Metric`.");
 
  static_assert(!std::is_arithmetic_v<Metric>,
                "Type is not atomic, use std::atomic<T> instead");
 
 public:
  template <typename... Args>
  explicit MetricWrapper(std::in_place_t, const Args&... args)
      : data_(args...) {
    if constexpr (sizeof...(Args) == 0) {
      InitializeAtomic(data_);
    }
  }
 
  formats::json::ValueBuilder DeprecatedJsonDump() override {
    if constexpr (!kHasWriterSupport<Metric>) {
      return DumpMetric(data_);
    }
    return {};
  }
 
  void DumpToWriter(Writer& writer) override {
    if constexpr (kHasWriterSupport<Metric>) {
      writer = data_;
    }
  }
 
  bool HasWriterSupport() const noexcept override {
    return kHasWriterSupport<Metric>;
  }
 
  void Reset() override {
    if constexpr (meta::kIsDetected<HasResetMetric, Metric>) {
      ResetMetric(data_);
    }
  }
 
  Metric& Get() { return data_; }
 
 private:
  Metric data_;
};
 
using MetricFactory = std::function<std::unique_ptr<MetricWrapperBase>()>;
 
template <typename Metric, typename... Args>
// NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
MetricFactory MakeMetricFactory(Args&&... args) {
  if constexpr (sizeof...(Args) == 0) {
    static_assert(std::is_default_constructible_v<Metric>,
                  "Metric type is not default-constructible. You can pass "
                  "additional args to MetricTag to forward them to Metric.");
  } else {
    static_assert(std::is_constructible_v<Metric, const Args&...>,
                  "Metric type is not constructible from the given args");
    static_assert(
        (true && ... && std::is_copy_constructible_v<std::decay_t<Args>>),
        "Metric args must be copy-constructible");
  }
 
  return [args...] {
    return std::make_unique<MetricWrapper<Metric>>(std::in_place, args...);
  };
}
 
struct MetricKey final {
  std::type_index idx;
  std::string path;
 
  bool operator==(const MetricKey& other) const noexcept {
    return idx == other.idx && path == other.path;
  }
};
 
struct MetricKeyHash final {
  std::size_t operator()(const MetricKey& key) const noexcept;
};
 
using MetricMap =
    std::unordered_map<MetricKey, std::unique_ptr<MetricWrapperBase>,
                       MetricKeyHash>;
 
void RegisterMetricInfo(const MetricKey& key, MetricFactory factory);
 
template <typename Metric>
Metric& GetMetric(MetricMap& metrics, const MetricKey& key) {
  return dynamic_cast<impl::MetricWrapper<Metric>&>(*metrics.at(key)).Get();
}
 
}  // namespace utils::statistics::impl
 
USERVER_NAMESPACE_END