Merge 88478e4 into d83dd68

core/include/prometheus/family.h

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <numeric>
 #include <string>
+#include <tuple>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -90,6 +91,13 @@ class Family : public Collectable {
   Family(const std::string& name, const std::string& help,
          const std::map<std::string, std::string>& constant_labels);
 
+  bool IsSameAs(
+      const std::string& name, const std::string& help,
+      const std::map<std::string, std::string>& constant_labels) const {
+    return std::tie(name, help, constant_labels) ==
+           std::tie(name_, help_, constant_labels_);
+  }
+
   /// \brief Add a new dimensional data.
   ///
   /// Each new set of labels adds a new dimensional data and is exposed in

core/include/prometheus/registry.h

@@ -36,6 +36,9 @@ namespace prometheus {
 /// a data race.
 class Registry : public Collectable {
  public:
+  explicit Registry(bool merge_families = false)
+      : merge_families_{merge_families} {}
+
   /// \brief Returns a list of metrics and their samples.
   ///
   /// Every time the Registry is scraped it calls each of the metrics Collect
@@ -52,19 +55,44 @@ class Registry : public Collectable {
 
   template <typename T>
   Family<T>& Add(const std::string& name, const std::string& help,
-                 const std::map<std::string, std::string>& labels);
+                 const std::map<std::string, std::string>& labels,
+                 std::vector<std::unique_ptr<Family<T>>>& families);
+
+  Family<Counter>& AddCounter(const std::string& name, const std::string& help,
+                              const std::map<std::string, std::string>& labels);
+  Family<Gauge>& AddGauge(const std::string& name, const std::string& help,
+                          const std::map<std::string, std::string>& labels);
+  Family<Histogram>& AddHistogram(
+      const std::string& name, const std::string& help,
+      const std::map<std::string, std::string>& labels);
+  Family<Summary>& AddSummary(const std::string& name, const std::string& help,
+                              const std::map<std::string, std::string>& labels);
 
-  std::vector<std::unique_ptr<Collectable>> collectables_;
+  bool merge_families_;
+  std::vector<std::unique_ptr<Family<Counter>>> counters_;
+  std::vector<std::unique_ptr<Family<Gauge>>> gauges_;
+  std::vector<std::unique_ptr<Family<Histogram>>> histograms_;
+  std::vector<std::unique_ptr<Family<Summary>>> summaries_;
   std::mutex mutex_;
 };
 
 template <typename T>
 Family<T>& Registry::Add(const std::string& name, const std::string& help,
-                         const std::map<std::string, std::string>& labels) {
+                         const std::map<std::string, std::string>& labels,
+                         std::vector<std::unique_ptr<Family<T>>>& families) {
   std::lock_guard<std::mutex> lock{mutex_};
+
+  if (merge_families_) {
+    for (auto& family : families) {
+      if (family->IsSameAs(name, help, labels)) {
+        return *family;
+      }
+    }
+  }
+
   auto family = detail::make_unique<Family<T>>(name, help, labels);
   auto& ref = *family;
-  collectables_.push_back(std::move(family));
+  families.push_back(std::move(family));
   return ref;
 }
 

core/src/detail/counter_builder.cc

@@ -22,7 +22,7 @@ CounterBuilder& CounterBuilder::Help(const std::string& help) {
 }
 
 Family<Counter>& CounterBuilder::Register(Registry& registry) {
-  return registry.Add<Counter>(name_, help_, labels_);
+  return registry.AddCounter(name_, help_, labels_);
 }
 
 }  // namespace detail

core/src/detail/gauge_builder.cc

@@ -22,7 +22,7 @@ GaugeBuilder& GaugeBuilder::Help(const std::string& help) {
 }
 
 Family<Gauge>& GaugeBuilder::Register(Registry& registry) {
-  return registry.Add<Gauge>(name_, help_, labels_);
+  return registry.AddGauge(name_, help_, labels_);
 }
 
 }  // namespace detail

core/src/detail/histogram_builder.cc

@@ -22,7 +22,7 @@ HistogramBuilder& HistogramBuilder::Help(const std::string& help) {
 }
 
 Family<Histogram>& HistogramBuilder::Register(Registry& registry) {
-  return registry.Add<Histogram>(name_, help_, labels_);
+  return registry.AddHistogram(name_, help_, labels_);
 }
 
 }  // namespace detail

core/src/detail/summary_builder.cc

@@ -22,7 +22,7 @@ SummaryBuilder& SummaryBuilder::Help(const std::string& help) {
 }
 
 Family<Summary>& SummaryBuilder::Register(Registry& registry) {
-  return registry.Add<Summary>(name_, help_, labels_);
+  return registry.AddSummary(name_, help_, labels_);
 }
 
 }  // namespace detail

core/src/registry.cc

@@ -4,10 +4,46 @@
 
 namespace prometheus {
 
+Family<Counter>& Registry::AddCounter(
+    const std::string& name, const std::string& help,
+    const std::map<std::string, std::string>& labels) {
+  return Add(name, help, labels, counters_);
+}
+Family<Gauge>& Registry::AddGauge(
+    const std::string& name, const std::string& help,
+    const std::map<std::string, std::string>& labels) {
+  return Add(name, help, labels, gauges_);
+}
+Family<Histogram>& Registry::AddHistogram(
+    const std::string& name, const std::string& help,
+    const std::map<std::string, std::string>& labels) {
+  return Add(name, help, labels, histograms_);
+}
+Family<Summary>& Registry::AddSummary(
+    const std::string& name, const std::string& help,
+    const std::map<std::string, std::string>& labels) {
+  return Add(name, help, labels, summaries_);
+}
+
 std::vector<MetricFamily> Registry::Collect() {
   std::lock_guard<std::mutex> lock{mutex_};
   auto results = std::vector<MetricFamily>{};
-  for (auto&& collectable : collectables_) {
+  for (auto&& collectable : counters_) {
+    auto metrics = collectable->Collect();
+    results.insert(results.end(), std::make_move_iterator(metrics.begin()),
+                   std::make_move_iterator(metrics.end()));
+  }
+  for (auto&& collectable : gauges_) {
+    auto metrics = collectable->Collect();
+    results.insert(results.end(), std::make_move_iterator(metrics.begin()),
+                   std::make_move_iterator(metrics.end()));
+  }
+  for (auto&& collectable : histograms_) {
+    auto metrics = collectable->Collect();
+    results.insert(results.end(), std::make_move_iterator(metrics.begin()),
+                   std::make_move_iterator(metrics.end()));
+  }
+  for (auto&& collectable : summaries_) {
     auto metrics = collectable->Collect();
     results.insert(results.end(), std::make_move_iterator(metrics.begin()),
                    std::make_move_iterator(metrics.end()));

core/tests/registry_test.cc

@@ -37,5 +37,20 @@ TEST(RegistryTest, build_histogram_family) {
   ASSERT_EQ(collected.size(), 1U);
 }
 
+TEST(RegistryTest, merge_same_families) {
+  Registry registry{true};
+
+  std::size_t loops = 4;
+
+  while (loops-- > 0) {
+    auto& family =
+        BuildCounter().Name("counter").Help("Test Counter").Register(registry);
+    auto& counter = family.Add({{"name", "test_counter"}});
+  }
+
+  auto collected = registry.Collect();
+  EXPECT_EQ(1U, collected.size());
+}
+
 }  // namespace
 }  // namespace prometheus