arangodb · mchacki · Mar 16, 2020 · Dec 3, 2019 · Dec 4, 2019 · Dec 4, 2019
diff --git a/CHANGELOG b/CHANGELOG
@@ -16,11 +16,11 @@ devel
 
   The traversal speedups observed by these changes alone were around 8 to 10% for
   single-server traversals and traversals in OneShard setups. Cluster traversals
-  will also benefit from these changes, but to a lesser extent. This is because the 
+  will also benefit from these changes, but to a lesser extent. This is because the
   network roundtrips have a higher share of the total query execution times there.
 
 * Traversal performance can also be improved by not fetching the visited vertices
-  from the storage engine in case the traversal query does not refer to them. 
+  from the storage engine in case the traversal query does not refer to them.
   For example, in the query
 
       FOR v, e, p IN 1..3 OUTBOUND 'collection/startVertex' edges
@@ -56,7 +56,7 @@ devel
   specified by providing the new `validation` collection property when creating a
   new collection or when updating the properties of an existing collection:
 
-      db.mycollection.properties({ 
+      db.mycollection.properties({
         validation: {
           rule : { nums : { type : "array", items : { type : "number", maximum : 6 }}},
           message : "Json-Schema validation failed"

diff --git a/arangod/Agency/Agent.cpp b/arangod/Agency/Agent.cpp
@@ -88,8 +88,9 @@ Agent::Agent(ApplicationServer& server, config_t const& config)
         _server.getFeature<arangodb::MetricsFeature>().counter(
           "agency_agent_read_no_leader", 0, "Agency write no leader")),
       _write_hist_msec(
-        _server.getFeature<arangodb::MetricsFeature>().histogram(
-          "agency_agent_write_hist", 10, 0., 20., "Agency write histogram [ms]")) {
+        _server.getFeature<arangodb::MetricsFeature>().histogram<log_scale_t<float>>(
+          "agency_agent_write_hist", log_scale_t<float>(2., 0.2, 200., 20),
+          "Agency write histogram [ms]")) {
   _state.configure(this);
   _constituent.configure(this);
   if (size() > 1) {

diff --git a/arangod/Agency/Agent.h b/arangod/Agency/Agent.h
@@ -499,7 +499,7 @@ class Agent final : public arangodb::Thread, public AgentInterface {
   Counter& _write_no_leader;
   Counter& _read_ok;
   Counter& _read_no_leader;
-  Histogram<double>& _write_hist_msec;
+  Histogram<log_scale_t<float>>& _write_hist_msec;
 
 };
 }  // namespace consensus

diff --git a/arangod/RestServer/Metrics.h b/arangod/RestServer/Metrics.h
@@ -40,7 +40,8 @@
 #include "counter.h"
 
 class Counter;
-template<typename T> class Histogram;
+
+template<typename Scale> class Histogram;
 
 class Metric {
 public:
@@ -136,55 +137,233 @@ template<typename T> class Gauge : public Metric {
 
 std::ostream& operator<< (std::ostream&, Metrics::hist_type const&);
 
+enum ScaleType {LINEAR, LOGARITHMIC};
+
+template<typename T>
+struct scale_t {
+public:
+
+  using value_type = T;
+
+  scale_t(T const& low, T const& high, size_t n) :
+    _low(low), _high(high), _n(n) {
+    TRI_ASSERT(n > 1);
+    _delim.resize(n-1);
+  }
+  virtual ~scale_t() {}
+  /**
+   * @brief number of buckets
+   */
+  size_t n() const {
+    return _n;
+  }
+  /**
+   * @brief number of buckets
+   */
+  T low() const {
+    return _low;
+  }
+  /**
+   * @brief number of buckets
+   */
+  T high() const {
+    return _high;
+  }
+  /**
+   * @brief number of buckets
+   */
+  T const& delim(size_t const& s) const {
+    return (s < _delim.size()) ? _delim.at(s) : _high;
+  }
+  /**
+   * @brief number of buckets
+   */
+  std::vector<T> const& delims() const {
+    return _delim;
+  }
+  /**
+   * @brief dump to builder
+   */
+  virtual void toVelocyPack(VPackBuilder& b) const {
+    TRI_ASSERT(b.isOpenObject());
+    b.add("lower-limit", VPackValue(_low));
+    b.add("upper-limit", VPackValue(_high));
+    b.add("value-type", VPackValue(typeid(T).name()));
+    b.add(VPackValue("range"));
+    VPackArrayBuilder abb(&b);
+    for (auto const& i : _delim) {
+      b.add(VPackValue(i));
+    }
+  }
+  /**
+   * @brief dump to
+   */
+  std::ostream& print(std::ostream& o) const {
+    VPackBuilder b;
+    {
+      VPackObjectBuilder bb(&b);
+      this->toVelocyPack(b);
+    }
+    o << b.toJson();
+    return o;
+  }
+protected:
+  T _low, _high;
+  std::vector<T> _delim;
+  size_t _n;
+};
+
+template<typename T>
+std::ostream& operator<< (std::ostream& o, scale_t<T> const& s) {
+  return s.print(o);
+}
+
+template<typename T>
+struct log_scale_t : public scale_t<T> {
+public:
+
+  using value_type = T;
+  static constexpr ScaleType scale_type = LOGARITHMIC;
+
+  log_scale_t(T const& base, T const& low, T const& high, size_t n) :
+    scale_t<T>(low, high, n), _base(base) {
+    double nn = -1.0*n;
+    for (auto& i : this->_delim) {
+      i = (high-low) * std::pow(base, nn++) + low;
+    }
+    _div = this->_delim.front() - low;
+    TRI_ASSERT(_div > 0);
+    _lbase = logf(_base);
+  }
+  virtual ~log_scale_t() {}
+  /**
+   * @brief index for val
+   * @param val value
+   * @return    index
+   */
+  size_t pos(T const& val) const {
+    return static_cast<size_t>(1+std::floor(logf((val - this->_low)/_div)/_lbase));
+  }
+  /**
+   * @brief Dump to builder
+   * @param b Envelope
+   */
+  virtual void toVelocyPack(VPackBuilder& b) const {
+    b.add("scale-type", VPackValue("logarithmic"));
+    b.add("base", VPackValue(_base));
+    scale_t<T>::toVelocyPack(b);
+  }
+  /**
+   * @brief Base
+   * @return base
+   */
+  T base() const {
+    return _base;
+  }
+private:
+  T _base, _div, _lbase;
+};
+
+template<typename T>
+struct lin_scale_t : public scale_t<T> {
+public:
+
+  using value_type = T;
+  static constexpr ScaleType scale_type = LINEAR;
+
+  lin_scale_t(T const& low, T const& high, size_t n) :
+    scale_t<T>(low, high, n) {
+    this->_delim.resize(n-1);
+    _div = (high - low) / (T)n;
+    if (_div <= 0) {
+    }
+    TRI_ASSERT(_div > 0);
+    T le = low;
+    for (auto& i : this->_delim) {
+      le += _div;
+      i = le;
+    }
+  }
+  virtual ~lin_scale_t() {}
+  /**
+   * @brief index for val
+   * @param val value
+   * @return    index
+   */
+  size_t pos(T const& val) const {
+    return static_cast<size_t>(std::floor((val - this->_low)/ _div));
+  }
+
+  virtual void toVelocyPack(VPackBuilder& b) const {
+    b.add("scale-type", VPackValue("linear"));
+    scale_t<T>::toVelocyPack(b);
+  }
+private:
+  T _base, _div;
+};
+
+
+template<typename ... Args>
+std::string strfmt (std::string const& format, Args ... args) {
+  size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;
+  if( size <= 0 ) {
+    throw std::runtime_error( "Error during formatting." );
+  }
+  std::unique_ptr<char[]> buf(new char[size]);
+  snprintf(buf.get(), size, format.c_str(), args ...);
+  return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+}
+
+
+
 /**
  * @brief Histogram functionality
  */
-template<typename T> class Histogram : public Metric {
+template<typename Scale> class Histogram : public Metric {
 
 public:
 
+  using value_type = typename Scale::value_type;
+
   Histogram() = delete;
 
-  Histogram (size_t const& buckets, T const& low, T const& high, std::string const& name, std::string const& help = "")
-    : Metric(name, help), _c(Metrics::hist_type(buckets)), _low(low), _high(high),
-      _lowr(std::numeric_limits<T>::max()), _highr(std::numeric_limits<T>::min()) {
-    TRI_ASSERT(_c.size() > 0);
-    _n = _c.size() - 1;
-    _div = (high - low) / (double)_c.size();
-    TRI_ASSERT(_div != 0);
-  }
+  Histogram (Scale scale, std::string const& name, std::string const& help = "")
+    : Metric(name, help), _c(Metrics::hist_type(scale.n())), _scale(std::move(scale)),
+      _lowr(std::numeric_limits<value_type>::max()),
+      _highr(std::numeric_limits<value_type>::min()),
+      _n(scale.n()-1) {}
 
   ~Histogram() = default;
 
-  void records(T const& t) {
-    if(t < _lowr) {
-      _lowr = t;
-    } else if (t > _highr) {
-      _highr = t;
+  void records(value_type const& val) {
+    if(val < _lowr) {
+      _lowr = val;
+    } else if (val > _highr) {
+      _highr = val;
     }
   }
 
-  size_t pos(T const& t) const {
-    return static_cast<size_t>(std::floor((t - _low)/ _div));
+  size_t pos(value_type const& t) const {
+    return _scale.pos(t);
   }
 
-  void count(T const& t) {
+  void count(value_type const& t) {
     count(t, 1);
   }
 
-  void count(T const& t, uint64_t n) {
-    if (t < _low) {
+  void count(value_type const& t, uint64_t n) {
+    if (t < _scale.delims().front()) {
       _c[0] += n;
-    } else if (t >= _high) {
+    } else if (t >= _scale.delims().back()) {
       _c[_n] += n;
     } else {
       _c[pos(t)] += n;
     }
     records(t);
   }
 
-  T const& low() const { return _low; }
-  T const& high() const { return _high; }
+  value_type const& low() const { return _scale.low(); }
+  value_type const& high() const { return _scale.high(); }
 
   Metrics::hist_type::value_type& operator[](size_t n) {
     return _c[n];
@@ -205,36 +384,33 @@ template<typename T> class Histogram : public Metric {
   virtual void toPrometheus(std::string& result) const override {
     result += "#TYPE " + name() + " histogram\n";
     result += "#HELP " + name() + " " + help() + "\n";
-    T le = _low;
-    T sum = T(0);
+    value_type sum(0);
     for (size_t i = 0; i < size(); ++i) {
       uint64_t n = load(i);
       sum += n;
-      result += name() + "_bucket{le=\"" + std::to_string(le) + "\"} " +
+      result += name() + "_bucket{le=\"" + std::to_string(_scale.delim(i)) + "\"} " +
         std::to_string(n) + "\n";
-      le += _div;
     }
     result += name() + "_count " + std::to_string(sum) + "\n";
   }
 
   std::ostream& print(std::ostream& o) const {
-    o << "_div: " << _div << ", _c: " << _c << ", _r: [" << _lowr << ", " << _highr << "] " << name();
+    o << name() << " scale: " <<  _scale << " extremes: [" << _lowr << ", " << _highr << "]";
     return o;
   }
 
 private:
   Metrics::hist_type _c;
-  T _low, _high, _div, _lowr, _highr;
+  Scale _scale;
+  value_type _lowr, _highr;
   size_t _n;
 
 };
 
-
 std::ostream& operator<< (std::ostream&, Metrics::counter_type const&);
 template<typename T>
 std::ostream& operator<<(std::ostream& o, Histogram<T> const& h) {
   return h.print(o);
 }
 
-
 #endif
diff --git a/arangod/RestServer/MetricsFeature.cpp b/arangod/RestServer/MetricsFeature.cpp
@@ -75,6 +75,10 @@ bool MetricsFeature::exportAPI() const {
 void MetricsFeature::validateOptions(std::shared_ptr<ProgramOptions>) {}
 
 void MetricsFeature::toPrometheus(std::string& result) const {
+
+  // minimize reallocs
+  result.reserve(65536);
+
   {
     std::lock_guard<std::mutex> guard(_lock);
     for (auto const& i : _registry) {