fully remove authority and target_addr in labels

Author: bruce-personio

linkerd/app/admin/src/stack.rs

@@ -269,8 +269,6 @@ impl Param<metrics::EndpointLabels> for Permitted {
     fn param(&self) -> metrics::EndpointLabels {
         metrics::InboundEndpointLabels {
             tls: self.http.tcp.tls.clone(),
-            authority: None,
-            target_addr: self.http.tcp.addr.into(),
             policy: self.permit.labels.clone(),
         }
         .into()

linkerd/app/core/src/metrics.rs

@@ -19,7 +19,6 @@ pub use linkerd_metrics::*;
 use linkerd_proxy_server_policy as policy;
 use std::{
     fmt::{self, Write},
-    net::SocketAddr,
     sync::Arc,
     time::Duration,
 };
@@ -66,8 +65,6 @@ pub enum EndpointLabels {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct InboundEndpointLabels {
     pub tls: tls::ConditionalServerTls,
-    pub authority: Option<http::uri::Authority>,
-    pub target_addr: SocketAddr,
     pub policy: RouteAuthzLabels,
 }
 
@@ -99,9 +96,7 @@ pub struct RouteAuthzLabels {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct OutboundEndpointLabels {
     pub server_id: tls::ConditionalClientTls,
-    pub authority: Option<http::uri::Authority>,
     pub labels: Option<String>,
-    pub target_addr: SocketAddr,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

linkerd/app/inbound/src/http/router.rs

@@ -391,8 +391,6 @@ impl Param<metrics::EndpointLabels> for Logical {
     fn param(&self) -> metrics::EndpointLabels {
         metrics::InboundEndpointLabels {
             tls: self.tls.clone(),
-            authority: self.logical.as_ref().map(|d| d.as_http_authority()),
-            target_addr: self.addr.into(),
             policy: self.permit.labels.clone(),
         }
         .into()

linkerd/app/inbound/src/http/tests.rs

@@ -522,8 +522,6 @@ async fn grpc_response_class() {
         .get_response_total(
             &metrics::EndpointLabels::Inbound(metrics::InboundEndpointLabels {
                 tls: Target::meshed_h2().1,
-                authority: Some("foo.svc.cluster.local:5550".parse().unwrap()),
-                target_addr: "127.0.0.1:80".parse().unwrap(),
                 policy: metrics::RouteAuthzLabels {
                     route: metrics::RouteLabels {
                         server: metrics::ServerLabel(Arc::new(policy::Meta::Resource {

linkerd/app/integration/src/tests/telemetry.rs

@@ -266,30 +266,20 @@ async fn admin_transport_metrics() {
     );
 }
 
-#[tokio::test]
-async fn metrics_endpoint_inbound_request_count() {
-    test_http_count("request_total", "inbound", Fixture::inbound()).await;
-}
-
 #[tokio::test]
 async fn metrics_endpoint_outbound_request_count() {
-    test_http_count("request_total", "outbound", Fixture::outbound()).await
-}
-
-#[tokio::test]
-async fn metrics_endpoint_inbound_response_count() {
-    test_http_count("response_total", "inbound", Fixture::inbound()).await;
+    test_http_count("request_total", Fixture::outbound(), 1u64).await
 }
 
 #[tokio::test]
 async fn metrics_endpoint_outbound_response_count() {
-    test_http_count("response_total", "outbound", Fixture::outbound()).await
+    test_http_count("response_total", Fixture::outbound(), 1u64).await
 }
 
 async fn test_http_count(
     metric: &str,
-    traffic_direction: &str,
     fixture: impl Future<Output = Fixture>,
+    expected_count: u64,
 ) {
     let _trace = trace_init();
     let Fixture {
@@ -303,23 +293,12 @@ async fn test_http_count(
         ..
     } = fixture.await;
 
-    // Add extra cardinality for http counts test only to make sure the test server doesn't to +=1
-    // to existing metrics after the target_addr label is removed.
-    // The combinations are inbound_request, inbound_response, outbound_request, outbound_response
-    let expected_labels = labels.clone().label(
-        "test_case",
-        format!("{}_{}", "dst_deployment", traffic_direction),
-    );
-
-    let metric = expected_labels.metric(metric);
-
-    assert!(metric.is_not_in(metrics.get("/metrics").await));
+    let metric = labels.metric(metric);
 
     info!("client.get(/)");
     assert_eq!(client.get("/").await, "hello");
 
-    // after seeing a request, the request count should be 1.
-    metric.value(1u64).assert_in(&metrics).await;
+    metric.value(expected_count).assert_in(&metrics).await;
 }
 
 mod response_classification {
@@ -407,7 +386,6 @@ mod response_classification {
                             "success"
                         },
                     )
-                    .value(1u64)
                     .assert_in(&metrics)
                     .await;
             }
@@ -1196,10 +1174,9 @@ async fn metrics_compression() {
     info!("client.get(/)");
     assert_eq!(client.get("/").await, "hello");
 
-    let mut metric = labels
+    let metric = labels
         .metric("response_latency_ms_count")
-        .label("status_code", 200)
-        .value(1u64);
+        .label("status_code", 200);
 
     for &encoding in encodings {
         assert_eventually_contains!(do_scrape(encoding).await, &metric);
@@ -1209,6 +1186,6 @@ async fn metrics_compression() {
     assert_eq!(client.get("/").await, "hello");
 
     for &encoding in encodings {
-        assert_eventually_contains!(do_scrape(encoding).await, metric.set_value(2u64));
+        assert_eventually_contains!(do_scrape(encoding).await, metric);
     }
 }

linkerd/app/outbound/src/http/concrete.rs

@@ -210,10 +210,8 @@ where
 {
     fn param(&self) -> OutboundEndpointLabels {
         OutboundEndpointLabels {
-            authority: self.parent.param(),
             labels: prefix_outbound_endpoint_labels("dst", self.metadata.labels().iter()),
             server_id: self.param(),
-            target_addr: self.addr.into(),
         }
     }
 }

linkerd/app/outbound/src/http/endpoint/tests.rs

@@ -298,10 +298,8 @@ impl svc::Param<transport::labels::Key> for Endpoint {
 impl svc::Param<metrics::OutboundEndpointLabels> for Endpoint {
     fn param(&self) -> metrics::OutboundEndpointLabels {
         metrics::OutboundEndpointLabels {
-            authority: None,
             labels: None,
             server_id: self.param(),
-            target_addr: self.addr.into(),
         }
     }
 }

linkerd/app/outbound/src/opaq/concrete.rs

@@ -315,16 +315,9 @@ where
     T: svc::Param<Option<profiles::LogicalAddr>>,
 {
     fn param(&self) -> metrics::OutboundEndpointLabels {
-        let authority = self
-            .parent
-            .param()
-            .as_ref()
-            .map(|profiles::LogicalAddr(a)| a.as_http_authority());
         metrics::OutboundEndpointLabels {
-            authority,
             labels: metrics::prefix_outbound_endpoint_labels("dst", self.metadata.labels().iter()),
             server_id: self.param(),
-            target_addr: self.addr.into(),
         }
     }
 }