Revert "Merge branch 'ver/route-reqs-mtx'"

This reverts commit fdd2128, reversing
changes made to 7859b9a.

Author: olix0r

Cargo.lock

@@ -1032,7 +1032,6 @@ dependencies = [
 name = "linkerd-app-outbound"
 version = "0.1.0"
 dependencies = [
- "ahash",
  "bytes",
  "futures",
  "http",

linkerd/app/outbound/Cargo.toml

@@ -16,7 +16,6 @@ test-subscriber = []
 test-util = ["linkerd-app-test", "linkerd-meshtls-rustls/test-util"]
 
 [dependencies]
-ahash = "0.8"
 bytes = "1"
 http = "0.2"
 futures = { version = "0.3", default-features = false }

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

@@ -162,8 +162,7 @@ where
         S::Future: Send,
     {
         svc::layer::mk(move |concrete: N| {
-            let policy = svc::stack(concrete.clone())
-                .push(policy::Policy::layer(metrics.http_route_backends.clone()));
+            let policy = svc::stack(concrete.clone()).push(policy::Policy::layer());
             let profile =
                 svc::stack(concrete.clone()).push(profile::Params::layer(metrics.proxy.clone()));
             svc::stack(concrete)

linkerd/app/outbound/src/http/logical/policy.rs

@@ -8,7 +8,7 @@ mod router;
 mod tests;
 
 pub use self::{
-    route::{backend::RouteBackendMetrics, errors},
+    route::errors,
     router::{GrpcParams, HttpParams},
 };
 pub use linkerd_proxy_client_policy::{ClientPolicy, FailureAccrual};
@@ -45,17 +45,11 @@ where
     // Parent target type.
     T: Debug + Eq + Hash,
     T: Clone + Send + Sync + 'static,
-    route::backend::ExtractMetrics:
-        svc::ExtractParam<route::backend::RequestCount, route::backend::Http<T>>,
-    // route::backend::ExtractMetrics:
-    //     svc::ExtractParam<route::backend::RequestCount, route::backend::Grpc<T>>,
 {
     /// Builds a stack that dynamically updates and applies HTTP or gRPC policy
     /// routing configurations to route requests over cached inner backend
     /// services.
-    pub(super) fn layer<N, S>(
-        route_backend_metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
+    pub(super) fn layer<N, S>() -> impl svc::Layer<
         N,
         Service = svc::ArcNewService<
             Self,
@@ -80,9 +74,8 @@ where
         S::Future: Send,
     {
         svc::layer::mk(move |inner: N| {
-            let http =
-                svc::stack(inner.clone()).push(router::Http::layer(route_backend_metrics.clone()));
-            let grpc = svc::stack(inner).push(router::Grpc::layer(route_backend_metrics.clone()));
+            let http = svc::stack(inner.clone()).push(router::Http::layer());
+            let grpc = svc::stack(inner).push(router::Grpc::layer());
 
             http.push_switch(
                 |pp: Policy<T>| {

linkerd/app/outbound/src/http/logical/policy/route.rs

@@ -1,6 +1,4 @@
-use crate::RouteRef;
-
-use super::{super::Concrete, RouteBackendMetrics};
+use super::super::Concrete;
 use linkerd_app_core::{classify, proxy::http, svc, Addr, Error, Result};
 use linkerd_distribute as distribute;
 use linkerd_http_route as http_route;
@@ -27,7 +25,7 @@ pub(crate) struct Matched<M, P> {
 pub(crate) struct Route<T, F, E> {
     pub(super) parent: T,
     pub(super) addr: Addr,
-    pub(super) route_ref: RouteRef,
+    pub(super) meta: Arc<policy::Meta>,
     pub(super) filters: Arc<[F]>,
     pub(super) distribution: BackendDistribution<T, F>,
     pub(super) failure_policy: E,
@@ -68,14 +66,11 @@ where
     Self: filters::Apply,
     Self: svc::Param<classify::Request>,
     MatchedBackend<T, M, F>: filters::Apply,
-    backend::ExtractMetrics: svc::ExtractParam<backend::RequestCount, MatchedBackend<T, M, F>>,
 {
     /// Builds a route stack that applies policy filters to requests and
     /// distributes requests over each route's backends. These [`Concrete`]
     /// backends are expected to be cached/shared by the inner stack.
-    pub(crate) fn layer<N, S>(
-        backend_metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
+    pub(crate) fn layer<N, S>() -> impl svc::Layer<
         N,
         Service = svc::ArcNewService<
             Self,
@@ -103,7 +98,7 @@ where
             svc::stack(inner)
                 // Distribute requests across route backends, applying policies
                 // and filters for each of the route-backends.
-                .push(MatchedBackend::layer(backend_metrics.clone()))
+                .push(MatchedBackend::layer())
                 .lift_new_with_target()
                 .push(NewDistribute::layer())
                 // The router does not take the backend's availability into

linkerd/app/outbound/src/http/logical/policy/route/backend.rs

@@ -1,19 +1,11 @@
-use crate::RouteRef;
-
 use super::{super::Concrete, filters};
 use linkerd_app_core::{proxy::http, svc, Error, Result};
 use linkerd_http_route as http_route;
 use linkerd_proxy_client_policy as policy;
 use std::{fmt::Debug, hash::Hash, sync::Arc};
 
-mod count_reqs;
-mod metrics;
-
-pub use self::{count_reqs::RequestCount, metrics::RouteBackendMetrics};
-
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub(crate) struct Backend<T, F> {
-    pub(crate) route_ref: RouteRef,
     pub(crate) concrete: Concrete<T>,
     pub(crate) filters: Arc<[F]>,
 }
@@ -24,17 +16,11 @@ pub(crate) type Http<T> =
 pub(crate) type Grpc<T> =
     MatchedBackend<T, http_route::grpc::r#match::RouteMatch, policy::grpc::Filter>;
 
-#[derive(Clone, Debug)]
-pub struct ExtractMetrics {
-    metrics: RouteBackendMetrics,
-}
-
 // === impl Backend ===
 
 impl<T: Clone, F> Clone for Backend<T, F> {
     fn clone(&self) -> Self {
         Self {
-            route_ref: self.route_ref.clone(),
             filters: self.filters.clone(),
             concrete: self.concrete.clone(),
         }
@@ -65,16 +51,13 @@ where
     F: Clone + Send + Sync + 'static,
     // Assert that filters can be applied.
     Self: filters::Apply,
-    ExtractMetrics: svc::ExtractParam<RequestCount, Self>,
 {
     /// Builds a stack that applies per-route-backend policy filters over an
     /// inner [`Concrete`] stack.
     ///
     /// This [`MatchedBackend`] must implement [`filters::Apply`] to apply these
     /// filters.
-    pub(crate) fn layer<N, S>(
-        metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
+    pub(crate) fn layer<N, S>() -> impl svc::Layer<
         N,
         Service = svc::ArcNewService<
             Self,
@@ -107,9 +90,6 @@ where
                      }| concrete,
                 )
                 .push(filters::NewApplyFilters::<Self, _, _>::layer())
-                .push(count_reqs::NewCountRequests::layer_via(ExtractMetrics {
-                    metrics: metrics.clone(),
-                }))
                 .push(svc::ArcNewService::layer())
                 .into_inner()
         })
@@ -129,23 +109,3 @@ impl<T> filters::Apply for Grpc<T> {
         filters::apply_grpc(&self.r#match, &self.params.filters, req)
     }
 }
-
-impl<T> svc::ExtractParam<RequestCount, Http<T>> for ExtractMetrics {
-    fn extract_param(&self, params: &Http<T>) -> RequestCount {
-        RequestCount(self.metrics.http_requests_total(
-            params.params.concrete.parent_ref.clone(),
-            params.params.route_ref.clone(),
-            params.params.concrete.backend_ref.clone(),
-        ))
-    }
-}
-
-impl<T> svc::ExtractParam<RequestCount, Grpc<T>> for ExtractMetrics {
-    fn extract_param(&self, params: &Grpc<T>) -> RequestCount {
-        RequestCount(self.metrics.grpc_requests_total(
-            params.params.concrete.parent_ref.clone(),
-            params.params.route_ref.clone(),
-            params.params.concrete.backend_ref.clone(),
-        ))
-    }
-}