feat: remove high cardinality metric labels

This MR removes these labels from the fmtLabel implementation of Outbound/InboundEndpointMetrics

These metrics will be removed: target_addr, dst_pod, dst_pod_template_hash, dst_zone, authority

They are all metrics with high cardinality

This MR also reduces the number of buckets for response_latency_bucket_ms metric.

It will use another approach for the larger buckets: instead of deleting
buckets in a roll, it will buckets alternately

Author: bruce-personio

.github/workflows/release.yml

@@ -49,7 +49,7 @@ env:
   CARGO_INCREMENTAL: 0
   CARGO_NET_RETRY: 10
   RUSTFLAGS: "-D warnings -A deprecated --cfg tokio_unstable"
-  RUSTUP_MAX_RETRIES: 10
+  RUSTUP_MAX_RETRIES: 11
 
 concurrency:
   group: ${{ github.workflow }}-${{ inputs.ref || github.head_ref }}
@@ -69,7 +69,7 @@ jobs:
           shopt -s extglob
           if [[ "$GITHUB_EVENT_NAME" == pull_request ]]; then
             echo version="0.0.0-test.${GITHUB_SHA:0:7}"
-            echo archs='["amd64"]'
+            echo archs='["amd64", "arm64"]'
             exit 0
           fi >> "$GITHUB_OUTPUT"
           if ! [[ "$VERSION" =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z-]+)?(\+[0-9A-Za-z-]+)?$ ]]; then

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

@@ -18,7 +18,6 @@ use linkerd_proxy_server_policy as policy;
 use prometheus_client::encoding::EncodeLabelValue;
 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,10 +96,8 @@ 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 zone_locality: OutboundZoneLocality,
-    pub target_addr: SocketAddr,
 }
 
 #[derive(Debug, Copy, Clone, Default, Hash, Eq, PartialEq, EncodeLabelValue)]
@@ -163,6 +158,23 @@ where
     Some(out)
 }
 
+pub fn prefix_outbound_endpoint_labels<'i, I>(prefix: &str, mut labels_iter: I) -> Option<String>
+where
+    I: Iterator<Item = (&'i String, &'i String)>,
+{
+    let (k0, v0) = labels_iter.next()?;
+    let mut out = format!("{}_{}=\"{}\"", prefix, k0, v0);
+
+    for (k, v) in labels_iter {
+        if k == "pod" || k == "pod_template_hash" || k == "zone" {
+            continue;
+        }
+
+        write!(out, ",{}_{}=\"{}\"", prefix, k, v).expect("label concat must succeed");
+    }
+    Some(out)
+}
+
 // === impl Metrics ===
 
 impl Metrics {
@@ -317,16 +329,7 @@ impl FmtLabels for EndpointLabels {
 
 impl FmtLabels for InboundEndpointLabels {
     fn fmt_labels(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(a) = self.authority.as_ref() {
-            Authority(a).fmt_labels(f)?;
-            write!(f, ",")?;
-        }
-
-        (
-            (TargetAddr(self.target_addr), TlsAccept::from(&self.tls)),
-            &self.policy,
-        )
-            .fmt_labels(f)?;
+        ((TlsAccept::from(&self.tls)), &self.policy).fmt_labels(f)?;
 
         Ok(())
     }
@@ -391,14 +394,8 @@ impl svc::Param<OutboundZoneLocality> for OutboundEndpointLabels {
 
 impl FmtLabels for OutboundEndpointLabels {
     fn fmt_labels(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(a) = self.authority.as_ref() {
-            Authority(a).fmt_labels(f)?;
-            write!(f, ",")?;
-        }
-
-        let ta = TargetAddr(self.target_addr);
         let tls = TlsConnect::from(&self.server_id);
-        (ta, tls).fmt_labels(f)?;
+        tls.fmt_labels(f)?;
 
         if let Some(labels) = self.labels.as_ref() {
             write!(f, ",{}", labels)?;

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/discovery.rs

@@ -454,15 +454,12 @@ mod http2 {
         // Simulate the first server falling over without discovery
         // knowing about it...
         tracing::info!(%alpha.addr, "Stopping");
-        let alpha_addr = alpha.addr;
         alpha.join().await;
 
         // Wait until the proxy has seen the `alpha` disconnect...
         metrics::metric("tcp_close_total")
             .label("peer", "dst")
             .label("direction", "outbound")
-            .label("target_addr", alpha_addr.to_string())
-            .value(1u64)
             .assert_in(&metrics)
             .await;
         tracing::info!("Connection closed");