feat: customize metric for personio use cases

.github/workflows/release.yml

@@ -18,7 +18,7 @@ env:
   CARGO_NET_RETRY: 10
   CHECKSEC_VERSION: 2.5.0
   RUSTFLAGS: "-D warnings -A deprecated"
-  RUSTUP_MAX_RETRIES: 10
+  RUSTUP_MAX_RETRIES: 11
 
 jobs:
   meta:

linkerd/app/admin/src/stack.rs

@@ -225,8 +225,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)]
@@ -300,17 +295,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(())
     }
 }
@@ -368,14 +353,8 @@ impl FmtLabels for RouteAuthzLabels {
 
 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

@@ -406,8 +406,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/integration/src/tests/discovery.rs

@@ -438,7 +438,6 @@ mod http2 {
             .route("/bye", "bye")
             .run()
             .await;
-        let srv1_addr = srv1.addr;
 
         // Start with the first server.
         let dstctl = controller::new();
@@ -465,7 +464,6 @@ mod http2 {
         metrics::metric("tcp_close_total")
             .label("peer", "dst")
             .label("direction", "outbound")
-            .label("target_addr", srv1_addr.to_string())
             .value(1u64)
             .assert_in(&metrics)
             .await;

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

@@ -218,7 +218,6 @@ async fn admin_request_count() {
     let metrics = fixture.metrics;
     let metric = metrics::metric("request_total")
         .label("direction", "inbound")
-        .label("target_addr", metrics.target_addr())
         .value(1usize);
 
     // We can't assert that the metric is not present, since `GET /metrics`
@@ -233,7 +232,6 @@ async fn admin_transport_metrics() {
     let metrics = fixture.metrics;
     let labels = metrics::labels()
         .label("direction", "inbound")
-        .label("target_addr", metrics.target_addr())
         .label("peer", "src");
 
     let mut open_total = labels.metric("tcp_open_total").value(1usize);

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

@@ -294,8 +294,7 @@ async fn inbound_invalid_ip() {
 
     let client = client::tcp(proxy.inbound);
     let metric = metric(&proxy)
-        .label("error", "unexpected")
-        .label("target_addr", fake_ip);
+        .label("error", "unexpected");
 
     let tcp_client = client.connect().await;
     tcp_client.write(TcpFixture::HELLO_MSG).await;
@@ -359,7 +358,6 @@ async fn inbound_direct_success() {
     let no_tls_client = client::tcp(proxy1.inbound);
 
     let metric = metrics::metric(METRIC)
-        .label("target_addr", proxy1.inbound)
         .label("error", "tls detection timeout")
         .value(1u64);
 

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

@@ -18,7 +18,7 @@ use linkerd_app_core::{
     Error, Infallible, NameAddr,
 };
 use linkerd_proxy_client_policy::FailureAccrual;
-use std::{fmt::Debug, net::SocketAddr, sync::Arc};
+use std::{collections::BTreeMap, fmt::Debug, net::SocketAddr, sync::Arc};
 use tracing::info_span;
 
 mod metrics;
@@ -342,11 +342,19 @@ where
     T: svc::Param<Option<http::uri::Authority>>,
 {
     fn param(&self) -> OutboundEndpointLabels {
+        // self.metadata.labels() could return Err in some cases
+        // if that case the dst_labels won't carry any value
+        let mut dst_labels = match Arc::try_unwrap(self.metadata.labels()) {
+            Ok(result) => result,
+            Err(_e) => BTreeMap::new(),
+        };
+
+        dst_labels.remove("pod");
+        dst_labels.remove("pod_template_hash");
+
         OutboundEndpointLabels {
-            authority: self.parent.param(),
-            labels: prefix_labels("dst", self.metadata.labels().iter()),
+            labels: prefix_labels("dst", dst_labels.iter()),
             server_id: self.param(),
-            target_addr: self.addr.into(),
         }
     }
 }

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

@@ -289,10 +289,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

@@ -246,16 +246,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_labels("dst", self.metadata.labels().iter()),
             server_id: self.param(),
-            target_addr: self.addr.into(),
         }
     }
 }