Disable rate limit via runtime key

docs/configuration/http_filters/rate_limit_filter.rst

@@ -132,3 +132,7 @@ ratelimit.http_filter_enabled
 ratelimit.http_filter_enforcing
   % of requests that will call the rate limit service and enforce the decision. Defaults to 100.
   This can be used to test what would happen before fully enforcing the outcome.
+
+ratelimit.<route_key>.http_filter_enabled
+  % of requests that will call the rate limit service for a given *route_key* specified in the
+  :ref:`route <config_http_conn_man_route_table_route_rate_limit>`. Defaults to 100.

source/common/http/filter/ratelimit.cc

@@ -89,23 +89,32 @@ FilterHeadersStatus Filter::decodeHeaders(HeaderMap& headers, bool) {
   }
 
   const Router::RouteEntry* route = callbacks_->routeTable().routeForRequest(headers);
-  if (route && route->rateLimitPolicy().doGlobalLimiting()) {
-    std::vector<::RateLimit::Descriptor> descriptors;
-    for (const ActionPtr& action : config_->actions()) {
-      action->populateDescriptors(*route, descriptors, *config_, headers, *callbacks_);
+  if (route) {
+    // Check if the route_key is enabled for rate limiting.
+    const std::string& route_key = route->rateLimitPolicy().routeKey();
+    if (!route_key.empty() &&
+        !config_->runtime().snapshot().featureEnabled(
+            fmt::format("ratelimit.{}.http_filter_enabled", route_key), 100)) {
+      return FilterHeadersStatus::Continue;
     }
 
-    if (!descriptors.empty()) {
-      cluster_stat_prefix_ = fmt::format("cluster.{}.", route->clusterName());
-      cluster_ratelimit_stat_prefix_ = fmt::format("{}ratelimit.", cluster_stat_prefix_);
-
-      state_ = State::Calling;
-      initiating_call_ = true;
-      client_->limit(*this, config_->domain(), descriptors);
-      initiating_call_ = false;
+    if (route->rateLimitPolicy().doGlobalLimiting()) {
+      std::vector<::RateLimit::Descriptor> descriptors;
+      for (const ActionPtr& action : config_->actions()) {
+        action->populateDescriptors(*route, descriptors, *config_, headers, *callbacks_);
+      }
+
+      if (!descriptors.empty()) {
+        cluster_stat_prefix_ = fmt::format("cluster.{}.", route->clusterName());
+        cluster_ratelimit_stat_prefix_ = fmt::format("{}ratelimit.", cluster_stat_prefix_);
+
+        state_ = State::Calling;
+        initiating_call_ = true;
+        client_->limit(*this, config_->domain(), descriptors);
+        initiating_call_ = false;
+      }
     }
   }
-
   return (state_ == State::Calling || state_ == State::Responded)
              ? FilterHeadersStatus::StopIteration
              : FilterHeadersStatus::Continue;

test/common/http/filter/ratelimit_test.cc

@@ -60,6 +60,8 @@ class HttpRateLimitFilterTest : public testing::Test {
         .WillByDefault(Return(true));
     ON_CALL(runtime_.snapshot_, featureEnabled("ratelimit.http_filter_enforcing", 100))
         .WillByDefault(Return(true));
+    ON_CALL(runtime_.snapshot_, featureEnabled("ratelimit.test_key.http_filter_enabled", 100))
+        .WillByDefault(Return(true));
   }
 
   void SetUpTest(const std::string json) {
@@ -388,5 +390,20 @@ TEST_F(HttpRateLimitFilterTest, NoAddressRateLimiting) {
   EXPECT_EQ(FilterTrailersStatus::Continue, filter_->decodeTrailers(request_headers_));
 }
 
+TEST_F(HttpRateLimitFilterTest, RateLimitDisabledForRouteKey) {
+  SetUpTest(request_headers_json);
+
+  filter_callbacks_.route_table_.route_entry_.rate_limit_policy_.do_global_limiting_ = true;
+  filter_callbacks_.route_table_.route_entry_.rate_limit_policy_.route_key_ = "test_key";
+  ON_CALL(runtime_.snapshot_, featureEnabled("ratelimit.test_key.http_filter_enabled", 100))
+      .WillByDefault(Return(false));
+
+  EXPECT_CALL(*client_, limit(_, _, _)).Times(0);
+
+  EXPECT_EQ(FilterHeadersStatus::Continue, filter_->decodeHeaders(request_headers_, false));
+  EXPECT_EQ(FilterDataStatus::Continue, filter_->decodeData(data_, false));
+  EXPECT_EQ(FilterTrailersStatus::Continue, filter_->decodeTrailers(request_headers_));
+}
+
 } // RateLimit
 } // Http