[router][client] Unused router metrics cleanup (linkedin#1882)

This is part of an effort to reduce metric usage across Venice services and this
PR is targeting venice router metrics.

For `SINGLE_GET` request type, this PR removes the following metrics:
"--key_num"
"--fanout_request_count"
"--multiget_fallback"
"--unavailable_replica_streaming_request"

For `MULTIGET_STREAMING`:
"--multiget_streaming_read_quota_usage_kps"
"--multiget_streaming_request_usage"
"--multiget_streaming_multiget_fallback"

For `COMPUTE_STREAMING`:
"--compute_streaming_request_usage"

Author: Lei Lu

internal/venice-client-common/src/main/java/com/linkedin/venice/read/RequestType.java

@@ -31,4 +31,16 @@ public VeniceMetricsDimensions getDimensionName() {
   public String getDimensionValue() {
     return name().toLowerCase();
   }
+
+  public static boolean isSingleGet(RequestType requestType) {
+    return requestType == SINGLE_GET;
+  }
+
+  public static boolean isCompute(RequestType requestType) {
+    return requestType == COMPUTE;
+  }
+
+  public static boolean isStreaming(RequestType requestType) {
+    return requestType == MULTI_GET_STREAMING || requestType == COMPUTE_STREAMING;
+  }
 }

internal/venice-client-common/src/test/java/com/linkedin/venice/read/RequestTypeTest.java

@@ -0,0 +1,35 @@
+package com.linkedin.venice.read;
+
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import org.testng.annotations.Test;
+
+
+public class RequestTypeTest {
+  @Test
+  public void testBooleanFuncInRequestType() {
+    // Test the boolean functions in RequestType enum.
+    for (RequestType requestType: RequestType.values()) {
+      if (requestType == RequestType.SINGLE_GET) {
+        assertTrue(RequestType.isSingleGet(requestType), "SINGLE_GET should be recognized as a single GET");
+      } else {
+        assertFalse(RequestType.isSingleGet(requestType), requestType + " should not be recognized as a single GET");
+      }
+
+      if (requestType == RequestType.COMPUTE) {
+        assertTrue(RequestType.isCompute(requestType), "COMPUTE should be recognized as a compute request");
+      } else {
+        assertFalse(RequestType.isCompute(requestType), requestType + " should not be recognized as a compute request");
+      }
+
+      if (requestType == RequestType.MULTI_GET_STREAMING || requestType == RequestType.COMPUTE_STREAMING) {
+        assertTrue(RequestType.isStreaming(requestType), requestType + " should be recognized as a streaming request");
+      } else {
+        assertFalse(
+            RequestType.isStreaming(requestType),
+            requestType + " should not be recognized as a streaming request");
+      }
+    }
+  }
+}

services/venice-router/src/main/java/com/linkedin/venice/router/stats/RouterHttpRequestStats.java

@@ -185,7 +185,9 @@ public RouterHttpRequestStats(
         registerSensor(new TehutiUtils.SimpleRatioStat(healthyRequestRate, requestRate, "healthy_request_ratio"));
     tardyRequestRatioSensor =
         registerSensor(new TehutiUtils.SimpleRatioStat(tardyRequestRate, requestRate, "tardy_request_ratio"));
-    keyNumSensor = registerSensor("key_num", new Avg(), new Max(0));
+
+    keyNumSensor = RequestType.isSingleGet(requestType) ? null : registerSensor("key_num", new Avg(), new Max(0));
+
     badRequestKeyCountSensor = registerSensor("bad_request_key_count", new OccurrenceRate(), new Avg(), new Max());
 
     healthyRequestMetric = MetricEntityStateThreeEnums.create(
@@ -374,9 +376,12 @@ public RouterHttpRequestStats(
     errorRetryAttemptTriggeredByPendingRequestCheckSensor =
         registerSensor("error_retry_attempt_triggered_by_pending_request_check", new OccurrenceRate());
 
-    unavailableReplicaStreamingRequestSensor = registerSensor("unavailable_replica_streaming_request", new Count());
+    unavailableReplicaStreamingRequestSensor = !RequestType.isStreaming(requestType)
+        ? null
+        : registerSensor("unavailable_replica_streaming_request", new Count());
     requestThrottledByRouterCapacitySensor = registerSensor("request_throttled_by_router_capacity", new Count());
-    fanoutRequestCountSensor = registerSensor("fanout_request_count", new Avg(), new Max(0));
+    fanoutRequestCountSensor =
+        RequestType.isSingleGet(requestType) ? null : registerSensor("fanout_request_count", new Avg(), new Max(0));
 
     routerResponseWaitingTimeSensor = registerSensor(
         "response_waiting_time",
@@ -420,22 +425,28 @@ public RouterHttpRequestStats(
     /**
      * request_usage.Total is incoming KPS while request_usage.OccurrenceRate is QPS
      */
-    requestUsageSensor = registerSensor("request_usage", new Total(), new OccurrenceRate());
+    requestUsageSensor = RequestType.isSingleGet(requestType)
+        ? registerSensor("request_usage", new Total(), new OccurrenceRate())
+        : null;
 
     /**
      * A count version of this sensor is needed, as an internal system depends on the sensor to be
      * of type Count to measure QPS.
      */
-    requestCallCountSensor = registerSensor("request_call_count", new Count());
+    requestCallCountSensor =
+        RequestType.isSingleGet(requestType) ? registerSensor("request_call_count", new Count()) : null;
 
-    multiGetFallbackSensor = registerSensor("multiget_fallback", new Total(), new OccurrenceRate());
+    multiGetFallbackSensor = !RequestType.isCompute(requestType)
+        ? null
+        : registerSensor("multiget_fallback", new Total(), new OccurrenceRate());
 
     requestParsingLatencySensor = registerSensor("request_parse_latency", new Avg());
     requestRoutingLatencySensor = registerSensor("request_route_latency", new Avg());
 
     unAvailableRequestSensor = registerSensor("unavailable_request", new Count());
 
-    readQuotaUsageSensor = registerSensor("read_quota_usage_kps", new Total());
+    readQuotaUsageSensor =
+        RequestType.isSingleGet(requestType) ? registerSensor("read_quota_usage_kps", new Total()) : null;
 
     inFlightRequestSensor = registerSensor("in_flight_request_count", new Min(), new Max(0), new Avg());
 
@@ -519,15 +530,19 @@ private void recordRequestMetrics(
   }
 
   public void recordUnavailableReplicaStreamingRequest() {
-    unavailableReplicaStreamingRequestSensor.record();
+    if (unavailableReplicaStreamingRequestSensor != null) {
+      unavailableReplicaStreamingRequestSensor.record();
+    }
   }
 
   /**
    * Record read quota usage based on healthy KPS.
    * @param quotaUsage
    */
   public void recordReadQuotaUsage(int quotaUsage) {
-    readQuotaUsageSensor.record(quotaUsage);
+    if (readQuotaUsageSensor != null) {
+      readQuotaUsageSensor.record(quotaUsage);
+    }
   }
 
   public void recordTardyRequest(double latency, HttpResponseStatus responseStatus, int keyNum) {
@@ -602,7 +617,7 @@ public void recordRequestThrottledByRouterCapacity() {
   }
 
   public void recordFanoutRequestCount(int count) {
-    if (!getRequestType().equals(RequestType.SINGLE_GET)) {
+    if (fanoutRequestCountSensor != null) {
       fanoutRequestCountSensor.record(count);
     }
   }
@@ -644,7 +659,9 @@ public void recordFindUnhealthyHostRequest() {
   }
 
   public void recordIncomingKeyCountMetric(int keyNum) {
-    keyNumSensor.record(keyNum);
+    if (keyNumSensor != null) {
+      keyNumSensor.record(keyNum);
+    }
   }
 
   public void recordIncomingBadRequestKeyCountMetric(HttpResponseStatus responseStatus, int keyNum) {
@@ -657,12 +674,18 @@ public void recordIncomingBadRequestKeyCountMetric(HttpResponseStatus responseSt
   }
 
   public void recordRequestUsage(int usage) {
-    requestUsageSensor.record(usage);
-    requestCallCountSensor.record();
+    if (requestUsageSensor != null) {
+      requestUsageSensor.record(usage);
+    }
+    if (requestCallCountSensor != null) {
+      requestCallCountSensor.record();
+    }
   }
 
   public void recordMultiGetFallback(int keyCount) {
-    multiGetFallbackSensor.record(keyCount);
+    if (multiGetFallbackSensor != null) {
+      multiGetFallbackSensor.record(keyCount);
+    }
   }
 
   public void recordRequestParsingLatency(double latency) {