Add prometheus metrics for Central controllers (#1969)

* add header-only prometheus lib to ext

* rename folder

* Undo rename directory

* prometheus simpleapi included on mac & linux

* wip

* wire up some controller stats

* Get windows building with prometheus

* bsd build flags for prometheus

* Fix multiple network join from environment entrypoint.sh.release (#1961)

* _bond_m guards _bond, not _paths_m (#1965)

* Fix: warning: mutex '_aqm_m' is not held on every path through here [-Wthread-safety-analysis] (#1964)

* Serve prom metrics from /metrics endpoint

* Add prom metrics for Central controller specific things

* reorganize metric initialization

* testing out a labled gauge on Networks

* increment error counter on throw

* Consolidate metrics definitions

Put all metric definitions into node/Metrics.hpp.  Accessed as needed
from there.

* Revert "testing out a labled gauge on Networks"

This reverts commit 499ed6d95e11452019cdf48e32ed4cd878c2705b.

* still blows up but adding to the record for completeness right now

* Fix runtime issues with metrics

* Add metrics files to visual studio project

* Missed an "extern"

* add copyright headers to new files

* Add metrics for sent/received bytes (total)

* put /metrics endpoint behind auth

* sendto returns int on Win32

---------

Co-authored-by: Leonardo Amaral <leleobhz@users.noreply.github.com>
Co-authored-by: Brenton Bostick <bostick@gmail.com>

ext/prometheus-cpp-lite-1.0/core/include/prometheus/gauge.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "prometheus/atomic_floating.h"
+#include "prometheus/metric.h"
+#include "prometheus/family.h"
+
+#include "prometheus/builder.h"
+
+#include <atomic>
+#include <ctime>
+
+namespace prometheus {
+
+  /// \brief A gauge metric to represent a value that can arbitrarily go up and
+  /// down.
+  ///
+  /// The class represents the metric type gauge:
+  /// https://prometheus.io/docs/concepts/metric_types/#gauge
+  ///
+  /// Gauges are typically used for measured values like temperatures or current
+  /// memory usage, but also "counts" that can go up and down, like the number of
+  /// running processes.
+  ///
+  /// The class is thread-safe. No concurrent call to any API of this type causes
+  /// a data race.
+  template <typename Value_ = uint64_t>
+  class Gauge : public Metric {
+
+    std::atomic<Value_> value { 0 };
+
+    public:
+
+      using Value  = Value_;
+      using Family = CustomFamily<Gauge<Value>>;
+
+      static const Metric::Type static_type = Metric::Type::Gauge;
+
+
+      Gauge()                   : Metric (static_type) {}                  ///< \brief Create a gauge that starts at 0.
+      Gauge(const Value value_) : Metric(static_type), value{ value_ } {}  ///< \brief Create a gauge that starts at the given amount.
+
+      // original API
+
+      void Increment() { ++value; }                      ///< \brief Increment the gauge by 1.
+      void Increment(const Value& val) { value += val; } ///< \brief Increment the gauge by the given amount.
+
+      void Decrement() { --value; }                      ///< \brief Decrement the gauge by 1.
+      void Decrement(const Value& val) { value -= val; } ///< \brief Decrement the gauge by the given amount.
+
+      void SetToCurrentTime() {                          ///< \brief Set the gauge to the current unixtime in seconds.
+        const time_t time = std::time(nullptr);
+        value = static_cast<Value>(time);
+      }
+      void Set(const Value& val) { value = val; }        ///< \brief Set the gauge to the given value.
+      const Value Get() const { return value; }          ///< \brief Get the current value of the gauge.
+
+      virtual ClientMetric Collect() const {             ///< \brief Get the current value of the gauge. Collect is called by the Registry when collecting metrics.
+        ClientMetric metric;
+        metric.gauge.value = static_cast<double>(value);
+        return metric;
+      }
+
+      // new API
+
+      Gauge& operator ++() {
+        ++value;
+        return *this;
+      }
+
+      Gauge& operator++ (int) {
+        ++value;
+        return *this;
+      }
+
+      Gauge& operator --() {
+        --value;
+        return *this;
+      }
+
+      Gauge& operator-- (int) {
+        --value;
+        return *this;
+      }
+
+      Gauge& operator+=(const Value& val) {
+        value += val;
+        return *this;
+      }
+
+      Gauge& operator-=(const Value& val) {
+        value -= val;
+        return *this;
+      }
+
+  };
+
+
+  /// \brief Return a builder to configure and register a Gauge metric.
+  ///
+  /// @copydetails Family<>::Family()
+  ///
+  /// Example usage:
+  ///
+  /// \code
+  /// auto registry = std::make_shared<Registry>();
+  /// auto& gauge_family = prometheus::BuildGauge()
+  ///                          .Name("some_name")
+  ///                          .Help("Additional description.")
+  ///                          .Labels({{"key", "value"}})
+  ///                          .Register(*registry);
+  ///
+  /// ...
+  /// \endcode
+  ///
+  /// \return An object of unspecified type T, i.e., an implementation detail
+  /// except that it has the following members:
+  ///
+  /// - Name(const std::string&) to set the metric name,
+  /// - Help(const std::string&) to set an additional description.
+  /// - Label(const std::map<std::string, std::string>&) to assign a set of
+  ///   key-value pairs (= labels) to the metric.
+  ///
+  /// To finish the configuration of the Gauge metric register it with
+  /// Register(Registry&).
+  using BuildGauge = Builder<Gauge<double>>;
+
+
+}  // namespace prometheus