Performance Optimizations for Near-Zero Check-In Latency

[VedanthR5]

Performance Optimizations for Near-Zero Check-In Latency

Title

perf: Add HTTP session pooling, connection pre-warming, and optimized retry delays for faster check-ins

---

Description

This PR implements several performance optimizations to minimize latency during the critical check-in window. Since Southwest check-in opens exactly 24 hours before departure, every millisecond counts.

Summary of Changes

Optimization	File	Impact
HTTP Session pooling	lib/utils.py	~100-300ms saved per request
Connection pre-warming	lib/checkin_handler.py, lib/checkin_scheduler.py	TCP/TLS handshake completed before check-in
Exponential backoff retries	lib/utils.py	Faster recovery: 50ms → 500ms vs fixed 500ms
Improved NTP fallback	lib/utils.py	3 servers, 5s timeout (was 2 servers, 10s)

---

Detailed Changes

1. HTTP Session Pooling (lib/utils.py)

Problem: Each requests.post()/requests.get() call created a new TCP connection, requiring a full TCP handshake + TLS negotiation (~100-300ms overhead).

Solution: Added create_session() function that returns a configured requests.Session with connection pooling via HTTPAdapter:

def create_session() -> requests.Session:
    session = requests.Session()
    adapter = HTTPAdapter(pool_connections=10, pool_maxsize=10)
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    return session

Updated make_request() and _do_request() to accept an optional session parameter for connection reuse.

2. Session Management (lib/checkin_scheduler.py)

Added session lifecycle management to CheckInScheduler:

• session property - Lazy initialization of session
• close_session() - Clean up session resources
• refresh_session() - Close old session and create new one (useful before check-in)
• pre_warm_connection() - Makes a lightweight HEAD request to establish the connection pool

def pre_warm_connection(self) -> None:
    """Pre-warm the connection pool by making a lightweight request."""
    try:
        self.session.head("https://mobile.southwest.com", timeout=5)
    except Exception:
        pass  # Best effort - don't fail if pre-warm fails

3. Connection Pre-Warming (lib/checkin_handler.py)

In _wait_for_check_in(), added pre-warming right before the check-in attempt:

# Pre-warm the connection right before check-in for minimal latency
logger.debug("Pre-warming connection before check-in")
self.checkin_scheduler.refresh_session()
self.checkin_scheduler.pre_warm_connection()

Updated _check_in_to_flight() to pass the session to both POST requests.

4. Exponential Backoff for Check-In Retries (lib/utils.py)

Before: Fixed 500ms delay between retries
After: Exponential backoff starting at 50ms, doubling each attempt (capped at 500ms)

if not random_sleep:
    # Exponential backoff for check-in: 50ms, 100ms, 200ms, 400ms, 500ms (capped)
    sleep_time = min(0.05 * (2 ** (attempts - 1)), 0.5)
    time.sleep(sleep_time)

This allows faster recovery on transient failures while preventing server overload.

5. Improved NTP Timing (lib/utils.py)

• Added tertiary NTP server: pool.ntp.org
• Reduced timeout from 10s to 5s per server
• Iterates through all 3 servers before falling back to local time

NTP_PRIMARY_SERVER = "time.nist.gov"
NTP_BACKUP_SERVER = "time.cloudflare.com"
NTP_TERTIARY_SERVER = "pool.ntp.org"

for server in [NTP_PRIMARY_SERVER, NTP_BACKUP_SERVER, NTP_TERTIARY_SERVER]:
    try:
        response = client.request(server, version=3)
        # ...

---

Testing

All 329 unit tests pass with these changes.

New tests added:

• test_create_session_returns_configured_session
• test_do_request_uses_session_when_provided
• test_do_request_uses_session_for_get_when_provided
• test_make_request_uses_session_when_provided
• test_session_property_creates_session_lazily
• test_close_session_closes_and_clears_session
• test_refresh_session_closes_old_and_creates_new
• test_pre_warm_connection_makes_request
• test_pre_warm_connection_handles_errors_gracefully
• test_get_current_time_returns_a_datetime_from_tertiary_ntp_server

Updated tests:

• Retry delay test updated for exponential backoff expectations
• Check-in handler tests mock new refresh_session and pre_warm_connection methods

pytest tests/unit -q
# 329 passed in 1.86s

---

Performance Impact

Metric	Before	After	Improvement
First HTTP request	~300ms	~50ms	~250ms (pre-warmed connection)
First retry delay	500ms	50ms	450ms faster
NTP server timeout	10s	5s	50% faster failover
Connection overhead	Per-request	Pooled	Eliminates repeated handshakes

Estimated total latency reduction: 200-500ms for the check-in request sequence, which can be the difference between boarding positions A1 and B30.

---

Breaking Changes

None. All changes are backward compatible:

• make_request() session parameter is optional (defaults to None)
• Session management methods are additive

---

Checklist

• Tests pass (pytest tests/unit)
• Code follows project conventions (method ordering, type hints)
• No breaking changes
• Targeted at develop branch

---

[jdholtz]

Thanks for the PR! A quick scan over it, and this looks very good. I've wanted to try session pooling for a while. Do you have the logs for a check-in that succeeded with these changes? I unfortunately won't have another check-in before Southwest removes the check-in policy.