Update proxer-cli to version 0.3.4 and improve error logging

- Bump version of `proxer-cli` in `Cargo.toml` and `Cargo.lock` from 0.3.3 to 0.3.4.
- Enhance error logging in `src/server/proxy.rs` by adding color formatting to error messages for better visibility.
- Refactor connection limit handling in `src/server/mod.rs` to simplify the logic and improve clarity.

Author: doroved

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "proxer-cli"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 authors = ["doroved"]
 description = "Proxy TCP traffic on macOS with domain filtering."

Cargo.toml

@@ -48,26 +48,15 @@ pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
     // Parse command-line options
     let options = Opt::parse();
 
+    // Set open connection limit
+    let default_connection_limit = rlimit::Resource::NOFILE.get_soft()?;
+    let _ = rlimit::setrlimit(rlimit::Resource::NOFILE, 999999, rlimit::INFINITY);
     tracing::info!(
-        "Default open connection limit: {:?}",
-        rlimit::Resource::NOFILE.get_soft()?
+        "Setting open connection limit to {}, default limit is {}",
+        rlimit::Resource::NOFILE.get_soft()?,
+        default_connection_limit
     );
 
-    // Set open connection limit
-    let connection_limit = match rlimit::Resource::NOFILE.get() {
-        Ok(limit) if limit.0 < 1024 * 10 => {
-            tracing::info!("Setting open connection limit to {}", limit.1);
-            limit.1
-        }
-        Ok(limit) => limit.0,
-        Err(err) => {
-            tracing::error!("Failed to get open connection limit: {}", err);
-            return Err(Box::new(err));
-        }
-    };
-
-    let _ = rlimit::setrlimit(rlimit::Resource::NOFILE, connection_limit, rlimit::INFINITY);
-
     // Read the config file or use the default one
     let config_path = options.config.unwrap_or_else(|| {
         tracing::info!("Using default config file ~/.proxer-cli/config.json5");

src/server/mod.rs

@@ -29,13 +29,15 @@ pub async fn handle_request(
                             if let Err(e) =
                                 tunnel_via_proxy(upgraded, &addr, proxy, &filter_name).await
                             {
-                                tracing::error!("{addr} → PROXY connection error: {e}");
+                                tracing::error!(
+                                    "\x1B[31m{addr} → PROXY connection error: {e}\x1B[0m"
+                                );
                             };
                         } else if let Err(e) = tunnel_direct(upgraded, &addr).await {
-                            tracing::error!("{addr} → DIRECT connection error: {e}");
+                            tracing::error!("\x1B[31m{addr} → DIRECT connection error: {e}\x1B[0m");
                         }
                     }
-                    Err(e) => tracing::error!("{addr} → UPGRADE error: {e}"),
+                    Err(e) => tracing::error!("\x1B[31m{addr} → UPGRADE error: {e}\x1B[0m"),
                 }
             });
 
@@ -66,15 +68,15 @@ pub async fn handle_request(
 
                 tokio::spawn(async move {
                     if let Err(err) = conn.await {
-                        tracing::error!("Connection failed: {:?}", err);
+                        tracing::error!("\x1B[31mConnection failed: {:?}\x1B[0m", err);
                     }
                 });
 
                 let resp = sender.send_request(req).await?;
                 Ok(resp.map(|b| b.boxed()))
             }
             Err(e) => {
-                tracing::error!("{host}:{port} → Failed to connect: {:?}", e);
+                tracing::error!("\x1B[31m{host}:{port} → Failed to connect: {:?}\x1B[0m", e);
                 let mut resp = Response::new(full("Failed to connect to host"));
                 *resp.status_mut() = http::StatusCode::BAD_GATEWAY;