Add zipf distributing ratelimiter

source/common/rate_limiter_impl.cc

@@ -96,7 +96,6 @@ bool LinearRampingRateLimiterImpl::tryAcquireOne() {
     acquired_count_++;
     return acquireable_count_--;
   }
-
   const std::chrono::nanoseconds elapsed_time = elapsed();
   double elapsed_fraction = 1.0;
   if (elapsed_time < ramp_time_) {
@@ -191,4 +190,10 @@ GraduallyOpeningRateLimiterFilter::GraduallyOpeningRateLimiterFilter(
   }
 }
 
+ZipfRateLimiterImpl::ZipfRateLimiterImpl(RateLimiterPtr&& rate_limiter, bool deterministic,
+                                         double q, double v)
+    : FilteringRateLimiterImpl(std::move(rate_limiter),
+                               [this]() { return deterministic_ ? dist_(mt_) : dist_(g_); }),
+      dist_(1, q, v), deterministic_(deterministic) {}
+
 } // namespace Nighthawk

source/common/rate_limiter_impl.h

@@ -11,6 +11,7 @@
 #include "common/frequency.h"
 
 #include "absl/random/random.h"
+#include "absl/random/zipf_distribution.h"
 #include "absl/types/optional.h"
 
 namespace Nighthawk {
@@ -203,4 +204,30 @@ class GraduallyOpeningRateLimiterFilter : public FilteringRateLimiterImpl {
   const std::chrono::nanoseconds ramp_time_;
 };
 
+/**
+ * Thin wrapper around absl::zipf_distribution that will pull zeroes and ones from the distribution
+ * with the intent to probabilistically suppress the wrapped rate limiter.
+ * This may need further consideration, because it will shoot holes in the pacing, lowering the
+ * actual achieved frequency.
+ */
+class ZipfRateLimiterImpl : public FilteringRateLimiterImpl {
+public:
+  /**
+   * From the absl header associated to the zipf distribution:
+   * Preconditions: v > 0, q > 1
+   * The precondidtions are validated when NDEBUG is not defined via
+   * a pair of assert() directives.
+   * If NDEBUG is defined and either or both of these parameters take invalid
+   * values, the behavior of the class is undefined.
+   */
+  ZipfRateLimiterImpl(RateLimiterPtr&& rate_limiter, bool deterministic, double q = 2.0,
+                      double v = 1.0);
+
+private:
+  absl::zipf_distribution<uint64_t> dist_;
+  absl::InsecureBitGen g_;
+  std::mt19937_64 mt_;
+  bool deterministic_;
+};
+
 } // namespace Nighthawk

test/rate_limiter_test.cc

@@ -340,4 +340,28 @@ TEST_F(GraduallyOpeningRateLimiterFilterTest, TimingVerificationTest) {
                                   760, 780, 840, 860, 880, 900, 920, 940, 960, 980, 1000}));
 }
 
+class ZipfRateLimiterImplTest : public Test {};
+
+TEST_F(ZipfRateLimiterImplTest, TimingVerificationTest) {
+  Envoy::Event::SimulatedTimeSystem time_system;
+  auto rate_limiter = std::make_unique<ZipfRateLimiterImpl>(
+      std::make_unique<LinearRateLimiter>(time_system, 10_Hz), true);
+  const std::chrono::seconds duration = 15s;
+  std::vector<int64_t> aquisition_timings;
+  auto total_ms_elapsed = 0ms;
+  auto clock_tick = 1ms;
+
+  do {
+    if (rate_limiter->tryAcquireOne()) {
+      aquisition_timings.push_back(total_ms_elapsed.count());
+    }
+    time_system.sleep(clock_tick);
+    total_ms_elapsed += clock_tick;
+  } while (total_ms_elapsed <= duration);
+  EXPECT_EQ(aquisition_timings,
+            std::vector<int64_t>({500,   800,   1300,  2400,  2900,  3900,  4200,  4400,  4500,
+                                  5800,  6000,  6400,  7900,  8400,  8600,  9900,  10200, 10500,
+                                  10600, 12000, 12300, 12600, 13300, 13600, 13700, 13800, 13900}));
+}
+
 } // namespace Nighthawk