chore: remove the ProxyInner trait

crates/rproxy/src/config.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 use thiserror::Error;
 
 use crate::server::{
-    config::{ConfigLoggingError, ConfigLogging, ConfigMetrics, ConfigMetricsError},
+    config::{ConfigLogging, ConfigLoggingError, ConfigMetrics, ConfigMetricsError},
     proxy::config::{
         ConfigAuthrpc,
         ConfigAuthrpcError,

crates/rproxy/src/jrpc/jrpc_request.rs

@@ -1,6 +1,7 @@
-use serde::Deserialize;
 use std::borrow::Cow;
 
+use serde::Deserialize;
+
 // JrpcRequestMeta -----------------------------------------------------
 
 const JRPC_METHOD_FCUV1_WITH_PAYLOAD: Cow<'static, str> =

crates/rproxy/src/server.rs

@@ -20,7 +20,6 @@ use crate::{
     server::{
         metrics::Metrics,
         proxy::{
-            ProxyInner,
             circuit_breaker::CircuitBreaker,
             config::{ConfigAuthrpc, ConfigFlashblocks, ConfigRpc},
             http::{ProxyHttp, ProxyHttpInnerAuthrpc, ProxyHttpInnerRpc},
@@ -102,13 +101,14 @@ impl Server {
                         config,
                         tls,
                         metrics,
+                        "rproxy-authrpc",
                         canceller.clone(),
                         resetter,
                     )
                     .await
                     .inspect_err(|err| {
                         error!(
-                            proxy = ProxyHttpInnerRpc::name(),
+                            proxy = "rproxy-authrpc",
                             error = ?err,
                             "Failed to start http-proxy, terminating...",
                         );
@@ -130,13 +130,14 @@ impl Server {
                         config,
                         tls,
                         metrics,
+                        "rproxy-rpc",
                         canceller.clone(),
                         resetter,
                     )
                     .await
                     .inspect_err(|err| {
                         error!(
-                            proxy = ProxyHttpInnerRpc::name(),
+                            proxy = "rproxy-rpc",
                             error = ?err,
                             "Failed to start http-proxy, terminating...",
                         );
@@ -158,13 +159,14 @@ impl Server {
                         config,
                         tls,
                         metrics,
+                        "rproxy-flashblocks",
                         canceller.clone(),
                         resetter,
                     )
                     .await
                     .inspect_err(|err| {
                         error!(
-                            proxy = ProxyHttpInnerRpc::name(),
+                            proxy = "rproxy-flashblocks",
                             error = ?err,
                             "Failed to start websocket-proxy, terminating...",
                         );

crates/rproxy/src/server/proxy.rs

@@ -21,18 +21,16 @@ use crate::server::metrics::{LabelsProxy, Metrics};
 
 // Proxy ---------------------------------------------------------------
 
-pub(crate) trait Proxy<P>
-where
-    P: ProxyInner,
-{
+pub(crate) trait Proxy {
     fn on_connect(
         metrics: Arc<Metrics>,
         client_connections_count: Arc<AtomicI64>,
+        proxy_name: &'static str,
     ) -> impl Fn(&dyn Any, &mut Extensions) {
         move |connection, extensions| {
             {
                 let val = client_connections_count.fetch_add(1, Ordering::Relaxed) + 1;
-                let metric_labels = LabelsProxy { proxy: P::name() };
+                let metric_labels = LabelsProxy { proxy: proxy_name };
 
                 metrics.client_connections_active_count.get_or_create(&metric_labels).set(val);
                 metrics.client_connections_established_count.get_or_create(&metric_labels).inc();
@@ -54,20 +52,20 @@ where
                 let remote_addr = match stream.peer_addr() {
                     Ok(local_addr) => Some(local_addr.to_string()),
                     Err(err) => {
-                        warn!(proxy = P::name(), error = ?err, "Failed to get remote address");
+                        warn!(proxy = proxy_name, error = ?err, "Failed to get remote address");
                         None
                     }
                 };
                 let local_addr = match stream.local_addr() {
                     Ok(local_addr) => Some(local_addr.to_string()),
                     Err(err) => {
-                        warn!(proxy = P::name(), error = ?err, "Failed to get remote address");
+                        warn!(proxy = proxy_name, error = ?err, "Failed to get remote address");
                         None
                     }
                 };
 
                 debug!(
-                    proxy = P::name(),
+                    proxy = proxy_name,
                     connection_id = %id,
                     remote_addr = remote_addr.as_ref().map_or("unknown", |v| v.as_str()),
                     local_addr = local_addr.as_ref().map_or("unknown", |v| v.as_str()),
@@ -76,7 +74,7 @@ where
 
                 extensions.insert(ProxyConnectionGuard::new(
                     id,
-                    P::name(),
+                    proxy_name,
                     remote_addr,
                     local_addr,
                     &metrics,
@@ -87,12 +85,6 @@ where
     }
 }
 
-// ProxyInner ----------------------------------------------------------
-
-pub(crate) trait ProxyInner: 'static {
-    fn name() -> &'static str;
-}
-
 // ProxyConnectionGuard ------------------------------------------------
 
 pub struct ProxyConnectionGuard {

crates/rproxy/src/server/proxy/http/authrpc.rs

@@ -1,28 +1,18 @@
 use crate::{
     jrpc::{JrpcRequestMeta, JrpcRequestMetaMaybeBatch},
     server::proxy::{
-        ProxyInner,
         config::ConfigAuthrpc,
         http::{ProxiedHttpRequest, ProxiedHttpResponse, ProxyHttpInner},
     },
 };
 
-const PROXY_HTTP_INNER_AUTHRPC_NAME: &str = "rproxy-authrpc";
-
 // ProxyHttpInnerAuthrpc -----------------------------------------------
 
 #[derive(Clone)]
 pub(crate) struct ProxyHttpInnerAuthrpc {
     config: ConfigAuthrpc,
 }
 
-impl ProxyInner for ProxyHttpInnerAuthrpc {
-    #[inline]
-    fn name() -> &'static str {
-        PROXY_HTTP_INNER_AUTHRPC_NAME
-    }
-}
-
 impl ProxyHttpInner<ConfigAuthrpc> for ProxyHttpInnerAuthrpc {
     fn new(config: ConfigAuthrpc) -> Self {
         Self { config }

crates/rproxy/src/server/proxy/http/inner.rs

@@ -1,15 +1,11 @@
 use crate::{
     jrpc::JrpcRequestMetaMaybeBatch,
-    server::proxy::{
-        ProxyInner,
-        http::{ProxiedHttpRequest, ProxiedHttpResponse, config::ConfigProxyHttp},
-    },
+    server::proxy::http::{ProxiedHttpRequest, ProxiedHttpResponse, config::ConfigProxyHttp},
 };
 
 // ProxyHttpInner ------------------------------------------------------
 
-pub(crate) trait ProxyHttpInner<C>:
-    ProxyInner + Clone + Send + Sized + Sync + 'static
+pub(crate) trait ProxyHttpInner<C>: Clone + Send + Sized + Sync + 'static
 where
     C: ConfigProxyHttp,
 {