fix: treat a zero pool idle timeout as no pooling at all

AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS=0 asks for no keep-alive, but passing
Duration::ZERO to hyper does not deliver it: expiry is decided lazily at
checkout via saturating_duration_since(idle_at) > timeout, and hyper skips
spawning its idle-eviction task entirely for a zero timeout. The socket is
therefore parked after the response and only dropped when the next checkout
evicts it — a file descriptor held open for a connection no request may reuse.

build_client now maps a zero idle timeout onto the same pool_max_idle_per_host(0)
that Pooling::Disabled uses, so the connection is dropped as the response
completes. Documented in the README and guide env-var tables, which did not
mention the value before.

Author: bnusunny

CHANGELOG.md

@@ -22,8 +22,9 @@
     consumers keep the last published release (`1.0.0-rc1`) unchanged.
 - Add `AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS` to configure the idle keep-alive
   (fractional seconds allowed, e.g. `0.5`) of the adapter's HTTP connection to your
-  app. Default: 4 seconds. A value that is set but unusable falls back to the
-  default and logs a warning.
+  app. Default: 4 seconds. `0` turns connection reuse off entirely rather than relying
+  on expiry, so every request opens a fresh connection. A value that is set but
+  unusable falls back to the default and logs a warning.
 - Add `AWS_LWA_READINESS_CHECK_TIMEOUT_SECONDS` to bound the readiness check
   (fractional seconds allowed, e.g. `0.5`), applied to both the initial cold-start
   readiness wait and the post-SnapStart-restore readiness check. When set and the app

README.md

@@ -69,7 +69,7 @@ The readiness check port/path and traffic port can be configured using environme
 | AWS_LWA_LAMBDA_RUNTIME_API_PROXY      | overwrites `AWS_LAMBDA_RUNTIME_API` to allow proxying request                   | None         |
 | AWS_LWA_SNAPSTART_BEFORE_CHECKPOINT_PATH | inner-app path the adapter POSTs to before a SnapStart snapshot (drain resources) | None         |
 | AWS_LWA_SNAPSTART_AFTER_RESTORE_PATH     | inner-app path the adapter POSTs to after a SnapStart restore (reconnect/reseed)  | None         |
-| AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS        | idle keep-alive (seconds) for the adapter's connection to your app                | "4"          |
+| AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS        | idle keep-alive (seconds, fractional allowed) for the adapter's connection to your app; `0` turns connection reuse off entirely | "4"          |
 | AWS_LWA_READINESS_CHECK_TIMEOUT_SECONDS  | seconds (fractional allowed, e.g. 0.5) to wait for the app to report ready (cold-start init and after a SnapStart restore); on expiry the adapter FAILS (init fails and the runtime never starts; a restore fails) rather than serving. Unset, 0, or negative all mean wait indefinitely (a set-but-<=0 or malformed value is ignored with a warning). async_init keeps its own ~9.8s bound | unset / <=0 (unbounded) |
 
 > **Deprecation Notice:** The following non-namespaced environment variables are deprecated and will be removed in version 2.0:

docs/guide/src/configuration/environment-variables.md

@@ -21,7 +21,7 @@ All configuration is done through environment variables, set either in your Dock
 | `AWS_LWA_LAMBDA_RUNTIME_API_PROXY` | Proxy URL for Lambda Runtime API requests | None |
 | `AWS_LWA_SNAPSTART_BEFORE_CHECKPOINT_PATH` | Inner-app path the adapter POSTs to before a SnapStart snapshot | None |
 | `AWS_LWA_SNAPSTART_AFTER_RESTORE_PATH` | Inner-app path the adapter POSTs to after a SnapStart restore | None |
-| `AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS` | Idle keep-alive (seconds) for the adapter's connection to your app | `4` |
+| `AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS` | Idle keep-alive (seconds, fractional allowed, e.g. `0.5`) for the adapter's connection to your app. `0` turns connection reuse off entirely, so every request opens a fresh connection. A set-but-unusable value falls back to the default with a `warn!`. | `4` |
 | `AWS_LWA_READINESS_CHECK_TIMEOUT_SECONDS` | Seconds (fractional allowed, e.g. `0.5`) the adapter waits for the app to report ready (cold-start init **and** after a SnapStart restore). On expiry the adapter **fails** rather than serving: cold-start init fails (the runtime never starts) and a restore fails. Unset, `0`, or a negative value all mean **wait indefinitely** (no bound); a set-but-`<= 0` or malformed value is ignored with a `warn!`. The `async_init` path keeps its own ~9.8s bound (non-fatal) and is unaffected. | unset / `<= 0` (unbounded) |
 
 ## Deprecated Variables

src/lib.rs

@@ -827,16 +827,20 @@ pub struct Adapter<C, B> {
 ///
 /// [`Pooling::Disabled`] sets `pool_max_idle_per_host(0)`, turning hyper's pool off
 /// outright so reuse is impossible by construction. A zero `idle_timeout` is NOT a
-/// substitute: expiry is decided by `saturating_duration_since(idle_at) > timeout`,
-/// which reads as not-expired when the clock has not advanced (`ZERO > ZERO` is
-/// false) — the very condition hyper#3810 / rust-lang/rust#79462 describe.
+/// substitute for that, so it is mapped onto the same setting rather than trusted to
+/// expire entries: hyper decides expiry with
+/// `saturating_duration_since(idle_at) > timeout`, which reads as not-expired when the
+/// clock has not advanced (`ZERO > ZERO` is false) — the very condition hyper#3810 /
+/// rust-lang/rust#79462 describe — and it skips spawning the idle-eviction task
+/// altogether for a zero timeout, so on its own zero would park a socket that no
+/// request may reuse until the next checkout evicts it.
 ///
 /// Reads no environment: the caller decides, so the post-restore rebuild cannot
 /// inherit the pre-snapshot restriction.
 fn build_client(idle_timeout: Duration, pooling: Pooling) -> Client<HttpConnector, Body> {
     let mut builder = Client::builder(hyper_util::rt::TokioExecutor::new());
     builder.pool_idle_timeout(idle_timeout);
-    if pooling == Pooling::Disabled {
+    if pooling == Pooling::Disabled || idle_timeout.is_zero() {
         builder.pool_max_idle_per_host(0);
     }
     builder.build(HttpConnector::new())
@@ -1748,7 +1752,8 @@ mod tests {
         assert_eq!(pool_idle_timeout_from_env(), Duration::from_secs(30));
         assert_eq!(AdapterOptions::default().pool_idle_timeout, Duration::from_secs(30));
 
-        // Zero is honored (disables idle keep-alive by timeout).
+        // Zero is honored; `build_client` turns the pool off for it, so no connection
+        // is kept alive at all (see `test_zero_idle_timeout_disables_pooling`).
         std::env::set_var(ENV_POOL_IDLE_TIMEOUT_SECONDS, "0");
         assert_eq!(pool_idle_timeout_from_env(), Duration::from_secs(0));
 
@@ -1931,6 +1936,20 @@ mod tests {
         );
     }
 
+    /// `AWS_LWA_POOL_IDLE_TIMEOUT_SECONDS=0` asks for no keep-alive at all, so
+    /// `build_client` must turn the pool off for it. Left to hyper's expiry the socket
+    /// would instead be parked until the next checkout evicts it — a file descriptor
+    /// held open for a connection nothing may reuse.
+    #[tokio::test]
+    async fn test_zero_idle_timeout_disables_pooling() {
+        let client = build_client(Duration::ZERO, Pooling::Enabled);
+        let retained = connection_retained_after_request(&client).await;
+        assert!(
+            !retained,
+            "a zero idle timeout must DROP the connection, not park it in the idle pool"
+        );
+    }
+
     /// `AWS_LWA_ASYNC_INIT` must be ignored under SnapStart and Provisioned
     /// Concurrency, where its premise does not hold.
     ///