Fix CI: formatting and clippy dead_code warnings

- Run cargo fmt to fix line-length formatting issues
- Add #[allow(dead_code)] to unused but intentionally kept items:
  - circuit_breaker.rs: stats() and CircuitBreakerStats
  - error.rs: ProxyError enum (some variants for future use)
  - listener.rs: TLS/H2C bind methods and protocol accessors
  - metrics.rs: Metrics struct fields and unused metric methods

Author: HueCodes

src/circuit_breaker.rs

@@ -179,6 +179,7 @@ impl CircuitBreaker {
     }
 
     /// Returns statistics about the circuit breaker.
+    #[allow(dead_code)]
     pub fn stats(&self) -> CircuitBreakerStats {
         CircuitBreakerStats {
             total_requests: self.total_requests.load(Ordering::Relaxed),
@@ -200,6 +201,7 @@ impl CircuitBreaker {
 
 /// Statistics for the circuit breaker.
 #[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub struct CircuitBreakerStats {
     pub total_requests: usize,
     pub total_failures: usize,

src/error.rs

@@ -5,6 +5,7 @@ use thiserror::Error;
 
 /// Errors that can occur during proxy operations.
 #[derive(Error, Debug)]
+#[allow(dead_code)]
 pub enum ProxyError {
     /// Failed to bind to the listener address.
     #[error("failed to bind listener to {addr}: {source}")]

src/listener.rs

@@ -110,6 +110,7 @@ impl Listener {
     ///
     /// Returns `ProxyError::ListenerBind` if binding fails or
     /// `ProxyError::TlsConfig` if TLS configuration is invalid.
+    #[allow(dead_code)]
     #[instrument(level = "info", skip(upstream_addrs, tls_config))]
     pub async fn bind_with_tls(
         addr: &str,
@@ -149,6 +150,7 @@ impl Listener {
     ///
     /// This enables HTTP/2 without TLS, using prior knowledge that the
     /// client will speak HTTP/2.
+    #[allow(dead_code)]
     #[instrument(level = "info", skip(upstream_addrs))]
     pub async fn bind_h2c(
         addr: &str,
@@ -186,11 +188,13 @@ impl Listener {
     }
 
     /// Returns whether TLS is enabled.
+    #[allow(dead_code)]
     pub fn is_tls_enabled(&self) -> bool {
         self.tls_acceptor.is_some()
     }
 
     /// Returns the default HTTP protocol.
+    #[allow(dead_code)]
     pub fn default_protocol(&self) -> HttpProtocol {
         self.default_protocol
     }

src/metrics.rs

@@ -60,6 +60,7 @@ static METRICS: Lazy<Arc<Mutex<Metrics>>> = Lazy::new(|| Arc::new(Mutex::new(Met
 ///
 /// Tracks request counts, latencies, circuit breaker states, rate limits,
 /// and connection statistics following RED methodology.
+#[allow(dead_code)]
 pub struct Metrics {
     registry: Registry,
     // Request metrics (RED)
@@ -199,13 +200,15 @@ impl Metrics {
     }
 
     /// Increments the in-flight request counter.
+    #[allow(dead_code)]
     pub fn inc_requests_in_flight() {
         if let Ok(metrics) = METRICS.lock() {
             metrics.requests_in_flight.inc();
         }
     }
 
     /// Decrements the in-flight request counter.
+    #[allow(dead_code)]
     pub fn dec_requests_in_flight() {
         if let Ok(metrics) = METRICS.lock() {
             metrics.requests_in_flight.dec();
@@ -251,6 +254,7 @@ impl Metrics {
     /// # Arguments
     ///
     /// * `limit_type` - The type of limit (global, per_client)
+    #[allow(dead_code)]
     pub fn record_rate_limit_rejection(limit_type: &str) {
         let labels = RateLimitLabels {
             limit_type: limit_type.to_string(),
@@ -269,6 +273,7 @@ impl Metrics {
     /// # Arguments
     ///
     /// * `state` - The connection state (accepted, rejected, closed)
+    #[allow(dead_code)]
     pub fn record_connection(state: &str) {
         let labels = ConnectionLabels {
             state: state.to_string(),
@@ -280,6 +285,7 @@ impl Metrics {
     }
 
     /// Sets the number of active connections.
+    #[allow(dead_code)]
     pub fn set_active_connections(count: i64) {
         if let Ok(metrics) = METRICS.lock() {
             metrics.connections_active.set(count);

src/service.rs

@@ -310,7 +310,8 @@ impl ProxyService {
                         "upstream returned server error"
                     );
                     circuit_breaker.record_failure().await;
-                    self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker).await;
+                    self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker)
+                        .await;
                 } else {
                     info!(
                         method = %method,
@@ -323,7 +324,8 @@ impl ProxyService {
                 }
 
                 // Update circuit breaker metrics after state may have changed
-                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker).await;
+                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker)
+                    .await;
 
                 Metrics::record_request(&method, status, &upstream_owned, duration);
 
@@ -339,8 +341,10 @@ impl ProxyService {
                     "upstream connection failed"
                 );
                 circuit_breaker.record_failure().await;
-                self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker).await;
-                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker).await;
+                self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker)
+                    .await;
+                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker)
+                    .await;
 
                 let duration = start.elapsed().as_secs_f64();
                 Metrics::record_request(&method, 502, &upstream_owned, duration);
@@ -357,8 +361,10 @@ impl ProxyService {
                     "upstream request timed out"
                 );
                 circuit_breaker.record_failure().await;
-                self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker).await;
-                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker).await;
+                self.maybe_record_circuit_trip(&upstream_owned, &circuit_breaker)
+                    .await;
+                self.record_circuit_breaker_metrics(&upstream_owned, &circuit_breaker)
+                    .await;
 
                 let duration = start.elapsed().as_secs_f64();
                 Metrics::record_request(&method, 504, &upstream_owned, duration);