Change all fb303 timeseries to use millisecond duration

Summary:
This diff changes the clock for all fb303 timeseries to be of millisecond granularity. MultiLevelTimeSeries is also used for fb303 historgram, its clock type is left unchanged to keep this diff small.

The fb303 timeseries test is carefully updated to ensure the rate calculation is per-second instead of per-Duration (which is the default) for all fb303 timeseries, and captures other existing nuances from bucketed timeseries that are not obvious before due to its clock granularity.

A few things are temporarily introduced
* `fb303::ExportedStatForHistogram` which is the MultiLevelTimeSeries with second granularity still used for fb303 histogram
* `fb303::MultiLevelTimeSeries` still takes a CT template argument instead of hard-coding to have millisecond clock because it needs to support both timeseries (moving to second granularity clock in this diff) and histogram (staying on second granularity clock temporarily)

The change should be a no-op for services because all clients are still adding value to the timeseries using a clock with second granularity. That being said, the underlying timeseires will have more buckets now especially for the small timeseires (e.g. 1s, 5s). It would have a small memory regression. We will measure the memory regression with zippydb, which has the most number of timeseries per server process.

The default timeseries starts from minute (https://fburl.com/code/ia0wbvhb), so the overall memory regression should not be a major concern. For 1s timeseries the memory regression is only 59 (buckets) * 16 bytes (8 bytes for sum, and 8 bytes for count per bucket).

D82152395 has more info about the impact and why we are making this change.

#buildall

Reviewed By: islamismailov

Differential Revision: D80005386

fbshipit-source-id: 1d378ee32fd5b087e8445c482bedbb8e6ec6b45d

Author: uvdn7

fb303/ExportedHistogramMap.h

@@ -30,7 +30,9 @@ namespace facebook {
 namespace fb303 {
 
 using ExportedHistogram = TimeseriesHistogram<CounterType>;
-using ExportedStat = MultiLevelTimeSeries<CounterType>;
+using ExportedStatForHistogram = MultiLevelTimeSeries<
+    CounterType,
+    folly::LegacyStatsClock<std::chrono::seconds>>;
 
 /**
  * class ExportedHistogramMap
@@ -95,23 +97,25 @@ class ExportedHistogramMap {
   /**
    * Set defaultStat_ field.
    */
-  void setDefaultStat(const ExportedStat& defaultStat) {
-    *defaultStat_.wlock() = std::make_shared<ExportedStat>(defaultStat);
+  void setDefaultStat(const ExportedStatForHistogram& defaultStat) {
+    *defaultStat_.wlock() =
+        std::make_shared<ExportedStatForHistogram>(defaultStat);
   }
 
   /**
    * Set defaultStat_ field.
    */
-  void setDefaultStatPtr(std::shared_ptr<ExportedStat> defaultStat) {
+  void setDefaultStatPtr(
+      std::shared_ptr<ExportedStatForHistogram> defaultStat) {
     *defaultStat_.wlock() = std::move(defaultStat);
   }
 
-  [[deprecated("Use getDefaultStatPtr")]] const ExportedStat& getDefaultStat()
-      const {
+  [[deprecated("Use getDefaultStatPtr")]] const ExportedStatForHistogram&
+  getDefaultStat() const {
     return **defaultStat_.rlock();
   }
 
-  std::shared_ptr<ExportedStat> getDefaultStatPtr() const {
+  std::shared_ptr<ExportedStatForHistogram> getDefaultStatPtr() const {
     return *defaultStat_.rlock();
   }
 
@@ -407,13 +411,13 @@ class ExportedHistogramMap {
   DynamicCounters* dynamicCounters_;
   DynamicStrings* dynamicStrings_;
   folly::Synchronized<std::shared_ptr<ExportedHistogram>> defaultHist_;
-  // note: We slice defaultStat by copying it to a ExportedStat
+  // note: We slice defaultStat by copying it to a ExportedStatForHistogram
   // (non-pointer, non-reference), but that's according to plan: the
   // derived classes only set data members in the base class, nothing
   // more (they have no data members of their own).
-  folly::Synchronized<std::shared_ptr<ExportedStat>> defaultStat_{
-      std::make_shared<ExportedStat>(
-          MinuteTenMinuteHourTimeSeries<CounterType>())};
+  folly::Synchronized<std::shared_ptr<ExportedStatForHistogram>> defaultStat_{
+      std::make_shared<ExportedStatForHistogram>(
+          HistogramMinuteTenMinuteHourTimeSeries<CounterType>())};
 };
 
 // Lock the histogram and calculate the percentile

fb303/ThreadCachedServiceData.h

@@ -373,7 +373,7 @@ struct HistogramSpec {
   int64_t max;
   std::vector<ExportType> stats;
   std::vector<int> percentiles;
-  MultiLevelTimeSeries<CounterType> levels;
+  ExportedStatForHistogram levels;
 
   template <typename... Args>
   HistogramSpec(
@@ -384,7 +384,7 @@ struct HistogramSpec {
       : bucketWidth(bucketWidth_),
         min(min_),
         max(max_),
-        levels(MinuteTenMinuteHourTimeSeries<CounterType>()) {
+        levels(HistogramMinuteTenMinuteHourTimeSeries<CounterType>()) {
     ctorHandleArgs(args...);
   }
 
@@ -409,7 +409,7 @@ struct HistogramSpec {
     this->percentiles.push_back(pctile);
   }
 
-  void ctorHandleArg(const MultiLevelTimeSeries<CounterType>& levels_) {
+  void ctorHandleArg(const ExportedStatForHistogram& levels_) {
     this->levels = levels_;
   }
 
@@ -1211,7 +1211,9 @@ class MultiLevelTimeseriesWrapper : public TimeseriesWrapperBase {
         key,
         60,
         sizeof...(LevelDurations),
-        std::array{std::chrono::seconds{LevelDurations}...}.data());
+        std::array{std::chrono::duration_cast<std::chrono::milliseconds>(
+                       std::chrono::seconds{LevelDurations})...}
+            .data());
   }
 
  private:
@@ -1225,7 +1227,9 @@ class MultiLevelTimeseriesWrapper : public TimeseriesWrapperBase {
     static const folly::Indestructible<MultiLevelTimeSeries<CounterType>> obj(
         sizeof...(LevelDurations),
         60,
-        std::array{std::chrono::seconds{LevelDurations}...}.data());
+        std::array{std::chrono::duration_cast<std::chrono::milliseconds>(
+                       std::chrono::seconds{LevelDurations})...}
+            .data());
     return *obj.get();
   }
 };
@@ -1290,7 +1294,7 @@ class MinuteOnlyHistogram : public HistogramWrapper {
             min,
             max,
             args...,
-            MinuteOnlyTimeSeries<CounterType>()) {}
+            HistogramMinuteOnlyTimeSeries<CounterType>()) {}
 };
 
 class SubminuteMinuteOnlyHistogram : public HistogramWrapper {
@@ -1308,7 +1312,7 @@ class SubminuteMinuteOnlyHistogram : public HistogramWrapper {
             min,
             max,
             args...,
-            SubminuteMinuteOnlyTimeSeries<CounterType>()) {}
+            HistogramSubminuteMinuteOnlyTimeSeries<CounterType>()) {}
 };
 
 /**

fb303/Timeseries.h

@@ -21,6 +21,29 @@
 
 namespace facebook::fb303 {
 
+template <typename T, typename CT>
+class MultiLevelTimeSeries;
+
+namespace detail {
+template <typename Duration, typename ValueType, typename CLOCK>
+std::vector<Duration> getDurations(
+    const MultiLevelTimeSeries<ValueType, CLOCK>& timeseries) {
+  std::vector<Duration> res;
+  size_t levels = timeseries.numLevels();
+  res.reserve(levels);
+  for (size_t i = 0; i < levels; ++i) {
+    typename CLOCK::duration original = timeseries.getLevel(i).duration();
+    Duration duration = std::chrono::duration_cast<Duration>(original);
+    DCHECK(
+        std::chrono::duration_cast<typename CLOCK::duration>(duration) ==
+        original)
+        << "precision loss when converting MultiLevelTimeSeries to a different clock type";
+    res.push_back(duration);
+  }
+  return res;
+}
+} // namespace detail
+
 /** class MultiLevelTimeSeries
  *
  * This class has been moved to folly/stats/MultiLevelTimeSeries.h. This is left
@@ -50,10 +73,12 @@ namespace facebook::fb303 {
  *
  * @author Mark Rabkin (mrabkin@facebook.com)
  */
-template <class T>
-class MultiLevelTimeSeries : public folly::MultiLevelTimeSeries<T> {
+template <
+    class T,
+    typename CT = folly::LegacyStatsClock<std::chrono::milliseconds>>
+class MultiLevelTimeSeries : public folly::MultiLevelTimeSeries<T, CT> {
  public:
-  using BaseType = folly::MultiLevelTimeSeries<T>;
+  using BaseType = folly::MultiLevelTimeSeries<T, CT>;
   using Duration = typename BaseType::Duration;
   using TimePoint = typename BaseType::TimePoint;
   // The legacy TimeType.  The older code used this instead of Duration and
@@ -72,9 +97,49 @@ class MultiLevelTimeSeries : public folly::MultiLevelTimeSeries<T> {
       const Duration* durations)
       : MultiLevelTimeSeries(num_buckets, folly::Range(durations, num_levels)) {
   }
+
+  /*
+   * Convert between MultiLevelTimeSeries of the same value type but different
+   * clock type.
+   */
+  template <typename CLOCK>
+  explicit MultiLevelTimeSeries(
+      const MultiLevelTimeSeries<T, CLOCK>& timeseries)
+      : MultiLevelTimeSeries(
+            timeseries.numBuckets(),
+            detail::getDurations<Duration>(timeseries)) {}
+
+  /* convert all the rate to std::chrono::seconds to be backwards compatible */
+  template <typename ReturnType = double>
+  ReturnType rate(size_t level) const {
+    return BaseType::template rate<ReturnType, std::chrono::seconds>(level);
+  }
+
+  template <typename ReturnType = double>
+  ReturnType rate(Duration duration) const {
+    return BaseType::template rate<ReturnType, std::chrono::seconds>(duration);
+  }
+
+  template <typename ReturnType = double>
+  ReturnType rate(TimePoint start, TimePoint end) const {
+    return BaseType::template rate<ReturnType, std::chrono::seconds>(
+        start, end);
+  }
+
+  template <typename ReturnType = double>
+  ReturnType countRate(size_t level) const {
+    return BaseType::template countRate<ReturnType, std::chrono::seconds>(
+        level);
+  }
+
+  template <typename ReturnType = double>
+  ReturnType countRate(Duration duration) const {
+    return BaseType::template countRate<ReturnType, std::chrono::seconds>(
+        duration);
+  }
 };
 
-const std::chrono::seconds kMinuteDurations[] = {
+const std::chrono::milliseconds kMinuteDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(0)};
 
@@ -91,7 +156,7 @@ class MinuteTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kMinuteDurations) {}
 };
 
-const std::chrono::seconds kMinuteHourDurations[] = {
+const std::chrono::milliseconds kMinuteHourDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(3600),
     std::chrono::seconds(0)};
@@ -110,7 +175,7 @@ class MinuteHourTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kMinuteHourDurations) {}
 };
 
-const std::chrono::seconds kMinuteTenMinuteHourDurations[] = {
+const std::chrono::milliseconds kMinuteTenMinuteHourDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(600),
     std::chrono::seconds(3600),
@@ -132,7 +197,7 @@ class MinuteTenMinuteHourTimeSeries : public MultiLevelTimeSeries<T> {
   }
 };
 
-const std::chrono::seconds kMinuteHourDayDurations[] = {
+const std::chrono::milliseconds kMinuteHourDayDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(3600),
     std::chrono::seconds(86400),
@@ -153,7 +218,7 @@ class MinuteHourDayTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kMinuteHourDayDurations) {}
 };
 
-const std::chrono::seconds kMinuteTenMinuteDurations[] = {
+const std::chrono::milliseconds kMinuteTenMinuteDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(600),
     std::chrono::seconds(0)};
@@ -172,7 +237,7 @@ class MinuteTenMinuteTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kMinuteTenMinuteDurations) {}
 };
 
-const std::chrono::seconds kTenMinuteHourDurations[] = {
+const std::chrono::milliseconds kTenMinuteHourDurations[] = {
     std::chrono::seconds(600),
     std::chrono::seconds(3600)};
 
@@ -189,7 +254,7 @@ class TenMinuteHourTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kTenMinuteHourDurations) {}
 };
 
-const std::chrono::seconds kQuarterMinuteOnlyDurations[] = {
+const std::chrono::milliseconds kQuarterMinuteOnlyDurations[] = {
     std::chrono::seconds(15)};
 
 template <class T>
@@ -204,7 +269,8 @@ class QuarterMinuteOnlyTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 15, kQuarterMinuteOnlyDurations) {}
 };
 
-const std::chrono::seconds kMinuteOnlyDurations[] = {std::chrono::seconds(60)};
+const std::chrono::milliseconds kMinuteOnlyDurations[] = {
+    std::chrono::seconds(60)};
 
 template <class T>
 class MinuteOnlyTimeSeries : public MultiLevelTimeSeries<T> {
@@ -218,7 +284,7 @@ class MinuteOnlyTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kMinuteOnlyDurations) {}
 };
 
-const std::chrono::seconds kTenMinuteOnlyDurations[] = {
+const std::chrono::milliseconds kTenMinuteOnlyDurations[] = {
     std::chrono::seconds(600)};
 
 template <class T>
@@ -233,7 +299,7 @@ class TenMinuteOnlyTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kTenMinuteOnlyDurations) {}
 };
 
-const std::chrono::seconds kMinuteTenMinuteOnlyDurations[] = {
+const std::chrono::milliseconds kMinuteTenMinuteOnlyDurations[] = {
     std::chrono::seconds(60),
     std::chrono::seconds(600)};
 
@@ -251,7 +317,7 @@ class MinuteTenMinuteOnlyTimeSeries : public MultiLevelTimeSeries<T> {
   }
 };
 
-const std::chrono::seconds kHourDurations[] = {
+const std::chrono::milliseconds kHourDurations[] = {
     std::chrono::seconds(3600),
     std::chrono::seconds(0)};
 
@@ -267,7 +333,7 @@ class HourTimeSeries : public MultiLevelTimeSeries<T> {
   HourTimeSeries() : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kHourDurations) {}
 };
 
-const std::chrono::seconds kTenMinutesChunksDurations[] = {
+const std::chrono::milliseconds kTenMinutesChunksDurations[] = {
     std::chrono::seconds(600),
     std::chrono::seconds(1200),
     std::chrono::seconds(1800)};
@@ -286,7 +352,7 @@ class TenMinutesChunksTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kTenMinutesChunksDurations) {}
 };
 
-const std::chrono::seconds kSubminuteMinuteDurations[] = {
+const std::chrono::milliseconds kSubminuteMinuteDurations[] = {
     std::chrono::seconds(5),
     std::chrono::seconds(10),
     std::chrono::seconds(20),
@@ -311,7 +377,7 @@ class SubminuteMinuteTimeSeries : public MultiLevelTimeSeries<T> {
       : MultiLevelTimeSeries<T>(NUM_LEVELS, 60, kSubminuteMinuteDurations) {}
 };
 
-const std::chrono::seconds kSubminuteMinuteOnlyDurations[] = {
+const std::chrono::milliseconds kSubminuteMinuteOnlyDurations[] = {
     std::chrono::seconds(5),
     std::chrono::seconds(10),
     std::chrono::seconds(20),

fb303/TimeseriesExporter.cpp

@@ -80,44 +80,6 @@ CounterType TimeseriesExporter::getStatValue(
   LOG(FATAL) << "invalid stat export type: " << type;
 }
 
-/* static */
-void TimeseriesExporter::getCounterName(
-    char* counterName,
-    const int counterNameSize,
-    const ExportedStat* stat,
-    StringPiece statName,
-    ExportType type,
-    const int level) {
-  // NOTE:  We access the stat object here without locking.  This depends
-  // on the fact that getLevel(), and Level::isAllTime() and
-  // Level::duration() are all non-volatile calls meaning they only read things
-  // that are constant once the stat is constructed (number of levels can never
-  // change, nor their durations).
-  //   - mrabkin
-  if (stat->getLevel(level).isAllTime()) {
-    // typical name: 'ad_request.rate' or 'ad_request_elapsed_time.avg'
-    snprintf(
-        counterName,
-        counterNameSize,
-        "%.*s.%s",
-        static_cast<int>(statName.size()),
-        statName.data(),
-        TimeseriesExporter::getTypeString()[type]);
-  } else {
-    // typical name: 'ad_request.rate.600' or 'ad_request_elapsed_time.avg.3600'
-    auto durationSecs =
-        duration_cast<std::chrono::seconds>(stat->getLevel(level).duration());
-    snprintf(
-        counterName,
-        counterNameSize,
-        "%.*s.%s.%ld",
-        static_cast<int>(statName.size()),
-        statName.data(),
-        TimeseriesExporter::getTypeString()[type],
-        static_cast<long>(durationSecs.count()));
-  }
-}
-
 /* static */
 void TimeseriesExporter::exportStat(
     const StatPtr& stat,