DNS ttl not honored

[yks0000]

We are creating a session as below

    def _create_session() -> httpx.Client:
        """
        Initialize a sync client with retry logic and connection pool settings.
        """

        retries = Retry(
            total=3,
            backoff_factor=0.2,
            status_forcelist=[500, 502, 503, 504],
            allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS"],
        )
        limits = httpx.Limits(max_connections=100, max_keepalive_connections=20, keepalive_expiry=60)
        transport = httpx.HTTPTransport(http2=True, limits=limits)

        retry_transport = RetryTransport(retry=retries, transport=transport)

        session = httpx.Client(
            base_url="https://qal.api.example.com",
            transport=retry_transport,
            http2=True,
            limits=limits,
            headers={
                "User-Agent": f"Python/{__version__}",
                "Content-Type": "application/json",
            },
        )

        # Warm up the connection immediately after creation
        try:
            # Use HEAD request to minimize data transfer
            response = session.head(
                url="/health/local",
                timeout=2.0
            )
            logger.debug(f"Connection warm-up during creation: status={response.status_code}")
        except Exception as e:
            logger.warning(f"Connection warm-up during creation failed: {e}")

        return session

and then using it in post

def post():
   self.session.post(....)

Need help knowing that if qal.api.example.com failover to another ALB due to region failover (DNS TTL=15 second), will the session created during class initialization (self.session = self._create_session() in new or init) honour the change in DNS response or it will continue to use connection and dns response that was created during initialization.

[yks0000]

We did a test, though DNS response was changed (dig/nslookup), we continued to see request going to old region. Is there something similar to aiohttp.TCPConnector which has ttl_dns_cache options

[Muguett-DBY]

An existing connection can keep sending requests to the old ALB after DNS changes. DNS is consulted when opening a connection; it doesn't move an established TCP connection to the new address.

In your configuration, keepalive_expiry=60 is an idle timeout, not a maximum connection age. Requests less than 60 seconds apart can keep reusing that connection well beyond the DNS TTL. That's the distinction in the resource-limits docs.

For a sequential diagnostic, try disabling idle connection retention on the inner transport:

limits = httpx.Limits(
    max_connections=100,
    max_keepalive_connections=0,
)
transport = httpx.HTTPTransport(http2=True, limits=limits)
retry_transport = RetryTransport(retry=retries, transport=transport)

Pass that transport to your client as before. Put the setting on HTTPTransport, as your example already does, rather than only on Client around a custom transport. This increases connection setup costs; it also isn't an absolute connection-age limit for concurrent HTTP/2 traffic.

HTTPX has no equivalent ttl_dns_cache setting. New connections use the resolver, which can have its own caching. If you need a bounded failover window while keeping pooling, retire old client/transport pools on a controlled lifecycle, letting in-flight work finish before closing them.

I checked the pooling behavior with HTTPX 0.28.1/httpcore 1.0.9, two local HTTP/1.1 servers, and controlled resolver answers and clock. Repeated requests reused the old address for 135 simulated seconds with a 60-second idle expiry; after 61 seconds idle, the next request resolved the new address. Disabling idle retention or replacing the client also switched addresses. That doesn't test your ALB, OS DNS cache, HTTP/2 or retry wrapper. Codex-assisted.