Update adaptive advert limiter stats to include limit hit count and last limit hit age

Author: ViezeVingertjes

docs/cli_commands.md

@@ -144,7 +144,7 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 
 ---
 
-### Advert Limiter Stats - Limit, Remaining, Denied, Load Average and Last Limit Reached Time (Repeater Only)
+### Advert Limiter Stats - Limit, Remaining, Denied, Load Average, Limit Hit Count and Last Limit Hit Age (Repeater Only)
 **Usage:** `stats-advert-ratelimit`
 
 **Serial Only:** No

examples/simple_repeater/MyMesh.cpp

@@ -1258,9 +1258,9 @@ void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply
     }
   } else if (memcmp(command, "stats-advert-ratelimit", 22) == 0 && (command[22] == 0 || command[22] == ' ')) {
     AdaptiveRateLimiterStats stats = advert_limiter.stats(rtc_clock.getCurrentTime());
-    sprintf(reply, "{\"limit\":%u,\"remaining\":%u,\"denied\":%u,\"load_avg\":%u,\"last_limit_reached_at\":%lu}",
+    sprintf(reply, "{\"limit\":%u,\"remaining\":%u,\"denied\":%u,\"load_avg\":%u,\"limit_reached\":%u,\"last_limit_reached_ago\":%lu}",
             (unsigned)stats.limit, (unsigned)stats.remaining, (unsigned)stats.denied,
-            (unsigned)stats.load_avg, (unsigned long)stats.last_limit_reached_at);
+            (unsigned)stats.load_avg, (unsigned)stats.limit_reached, (unsigned long)stats.last_limit_reached_ago);
   } else{
     _cli.handleCommand(sender_timestamp, command, reply);  // common CLI commands
   }

examples/simple_repeater/RateLimiter.h

@@ -32,7 +32,8 @@ struct AdaptiveRateLimiterStats {
   uint8_t remaining;
   uint8_t denied;
   uint8_t load_avg;
-  uint32_t last_limit_reached_at;
+  uint16_t limit_reached;
+  uint32_t last_limit_reached_ago;
 };
 
 class AdaptiveRateLimiter {
@@ -54,6 +55,7 @@ class AdaptiveRateLimiter {
   uint8_t _burst_multiplier;
   uint8_t _min_limit;
   uint8_t _denied;
+  uint16_t _limit_reached;
   uint32_t _last_limit_reached_at;
 
   static uint8_t clampU8(uint16_t v) { return v > 255 ? 255 : (uint8_t)v; }
@@ -99,7 +101,7 @@ class AdaptiveRateLimiter {
 public:
   AdaptiveRateLimiter(uint16_t window_secs, uint8_t burst_multiplier, uint8_t min_limit)
       : _window_start(0), _window_secs(window_secs), _window_count(0), _window_limit(min_limit), _load_avg(min_limit),
-        _burst_multiplier(burst_multiplier), _min_limit(min_limit), _denied(0), _last_limit_reached_at(0) {}
+        _burst_multiplier(burst_multiplier), _min_limit(min_limit), _denied(0), _limit_reached(0), _last_limit_reached_at(0) {}
 
   bool allow(uint32_t now) {
     advanceWindow(now);
@@ -111,20 +113,24 @@ class AdaptiveRateLimiter {
 
     _window_count++;
 
-    if (_window_count >= _window_limit)
+    if (_window_count >= _window_limit) {
+      if (_limit_reached < 65535) _limit_reached++;
       _last_limit_reached_at = now;
+    }
 
     return true;
   }
 
   void clearStats() {
     _denied = 0;
+    _limit_reached = 0;
     _last_limit_reached_at = 0;
   }
 
   AdaptiveRateLimiterStats stats(uint32_t now) {
     advanceWindow(now);
     uint8_t remaining = (_window_count < _window_limit) ? (_window_limit - _window_count) : 0;
-    return { _window_limit, remaining, _denied, _load_avg, _last_limit_reached_at };
+    uint32_t last_limit_reached_ago = (_last_limit_reached_at == 0) ? 0 : (now - _last_limit_reached_at);
+    return { _window_limit, remaining, _denied, _load_avg, _limit_reached, last_limit_reached_ago };
   }
 };

test/test_simple_repeater/test_adaptive_rate_limiter.cpp

@@ -100,7 +100,8 @@ TEST(AdaptiveRateLimiter, StatsInitialState) {
   EXPECT_EQ(5, stats.remaining);
   EXPECT_EQ(0, stats.denied);
   EXPECT_EQ(5, stats.load_avg);
-  EXPECT_EQ(0, stats.last_limit_reached_at);
+  EXPECT_EQ(0, stats.limit_reached);
+  EXPECT_EQ(0, stats.last_limit_reached_ago);
 }
 
 TEST(AdaptiveRateLimiter, StatsRemainingDecreasesOnAllow) {
@@ -114,7 +115,7 @@ TEST(AdaptiveRateLimiter, StatsRemainingDecreasesOnAllow) {
   EXPECT_EQ(0, stats.denied);
 }
 
-TEST(AdaptiveRateLimiter, StatsRecordsDeniedAndLastLimitReachedAt) {
+TEST(AdaptiveRateLimiter, StatsRecordsDeniedAndLastLimitReachedAge) {
   AdaptiveRateLimiter limiter(10, 3, 2);
 
   EXPECT_TRUE(limiter.allow(1));
@@ -126,10 +127,11 @@ TEST(AdaptiveRateLimiter, StatsRecordsDeniedAndLastLimitReachedAt) {
 
   EXPECT_EQ(0, stats.remaining);
   EXPECT_EQ(2, stats.denied);
-  EXPECT_EQ(1, stats.last_limit_reached_at);
+  EXPECT_EQ(1, stats.limit_reached);
+  EXPECT_EQ(2, stats.last_limit_reached_ago);
 }
 
-TEST(AdaptiveRateLimiter, StatsDeniedResetsOnWindowRollover) {
+TEST(AdaptiveRateLimiter, StatsDeniedResetsOnWindowRolloverAndKeepsLimitReachedAge) {
   AdaptiveRateLimiter limiter(10, 3, 2);
 
   EXPECT_TRUE(limiter.allow(1));
@@ -139,7 +141,22 @@ TEST(AdaptiveRateLimiter, StatsDeniedResetsOnWindowRollover) {
   const AdaptiveRateLimiterStats stats = limiter.stats(10);
 
   EXPECT_EQ(0, stats.denied);
-  EXPECT_EQ(1, stats.last_limit_reached_at);
+  EXPECT_EQ(1, stats.limit_reached);
+  EXPECT_EQ(9, stats.last_limit_reached_ago);
+}
+
+TEST(AdaptiveRateLimiter, StatsLimitReachedCountsEachWindowHit) {
+  AdaptiveRateLimiter limiter(10, 1, 1);
+
+  EXPECT_TRUE(limiter.allow(1));
+  EXPECT_FALSE(limiter.allow(1));
+
+  EXPECT_TRUE(limiter.allow(10));
+  EXPECT_FALSE(limiter.allow(10));
+
+  const AdaptiveRateLimiterStats stats = limiter.stats(10);
+
+  EXPECT_EQ(2, stats.limit_reached);
 }
 
 TEST(AdaptiveRateLimiter, StatsDeniedSaturatesAt255) {
@@ -166,7 +183,8 @@ TEST(AdaptiveRateLimiter, ClearStatsOnlyClearsReportingCounters) {
 
   EXPECT_EQ(0, beforeClear.remaining);
   EXPECT_EQ(1, beforeClear.denied);
-  EXPECT_EQ(1, beforeClear.last_limit_reached_at);
+  EXPECT_EQ(1, beforeClear.limit_reached);
+  EXPECT_EQ(1, beforeClear.last_limit_reached_ago);
 
   limiter.clearStats();
   const AdaptiveRateLimiterStats afterClear = limiter.stats(2);
@@ -175,7 +193,8 @@ TEST(AdaptiveRateLimiter, ClearStatsOnlyClearsReportingCounters) {
   EXPECT_EQ(0, afterClear.remaining);
   EXPECT_EQ(0, afterClear.denied);
   EXPECT_EQ(2, afterClear.load_avg);
-  EXPECT_EQ(0, afterClear.last_limit_reached_at);
+  EXPECT_EQ(0, afterClear.limit_reached);
+  EXPECT_EQ(0, afterClear.last_limit_reached_ago);
   EXPECT_FALSE(limiter.allow(2));
 }