feat: Reduce streaming DNS failures with stale-fallback DNS cache

launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/CachingDns.java

@@ -0,0 +1,113 @@
+package com.launchdarkly.sdk.android;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.launchdarkly.logging.LDLogger;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+import okhttp3.Dns;
+
+/**
+ * A DNS resolver that caches successful lookups and falls back to stale cache
+ * entries when a fresh resolution fails. This is particularly useful on mobile
+ * networks where DNS can be unreliable during network transitions.
+ * <p>
+ * Although Android API 34+ exposes {@code DnsOptions.StaleDnsOptions} in
+ * {@code DnsResolver}, OkHttp's {@code Dns.SYSTEM} uses
+ * {@code InetAddress.getAllByName} which does not opt into that mechanism.
+ * This class is therefore used on all API levels.
+ * <p>
+ * Instances of this class are thread-safe and designed to be shared across
+ * multiple OkHttpClient instances so that the cache persists even when the
+ * HTTP client is recreated (e.g. on EventSource reconnections).
+ */
+final class CachingDns implements Dns {
+
+    @VisibleForTesting
+    static final long DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 minutes
+    @VisibleForTesting
+    static final int MAX_ENTRIES = 30;
+
+    private final Dns delegate;
+    private final long ttlMs;
+    private final LDLogger logger;
+    private final ConcurrentHashMap<String, CacheEntry> cache = new ConcurrentHashMap<>();
+
+    static final class CacheEntry {
+        final List<InetAddress> addresses;
+        final long expiresAtMs;
+
+        CacheEntry(List<InetAddress> addresses, long expiresAtMs) {
+            this.addresses = Collections.unmodifiableList(new ArrayList<>(addresses));
+            this.expiresAtMs = expiresAtMs;
+        }
+
+        boolean isExpired(long nowMs) {
+            return nowMs >= expiresAtMs;
+        }
+    }
+
+    CachingDns(Dns delegate, long ttlMs, LDLogger logger) {
+        this.delegate = delegate;
+        this.ttlMs = ttlMs;
+        this.logger = logger;
+    }
+
+    CachingDns(LDLogger logger) {
+        this(Dns.SYSTEM, DEFAULT_TTL_MS, logger);
+    }
+
+    @Override
+    public List<InetAddress> lookup(String hostname) throws UnknownHostException {
+        long now = System.currentTimeMillis();
+        CacheEntry entry = cache.get(hostname);
+
+        if (entry != null && !entry.isExpired(now)) {
+            return entry.addresses;
+        }
+
+        try {
+            List<InetAddress> addresses = delegate.lookup(hostname);
+            long afterLookup = System.currentTimeMillis();
+            if (cache.size() >= MAX_ENTRIES) {
+                evictExpired(afterLookup);
+            }
+            cache.put(hostname, new CacheEntry(addresses, afterLookup + ttlMs));
+            return addresses;
+        } catch (UnknownHostException e) {
+            if (entry != null) {
+                logger.warn(
+                        "DNS lookup failed for {}, falling back to cached address (age {}ms)",
+                        hostname, System.currentTimeMillis() - (entry.expiresAtMs - ttlMs)
+                );
+                return entry.addresses;
+            }
+            throw e;
+        }
+    }
+
+    private void evictExpired(long now) {
+        java.util.Iterator<java.util.Map.Entry<String, CacheEntry>> it = cache.entrySet().iterator();
+        while (it.hasNext()) {
+            if (it.next().getValue().isExpired(now)) {
+                it.remove();
+            }
+        }
+    }
+
+    @VisibleForTesting
+    int cacheSize() {
+        return cache.size();
+    }
+
+    @VisibleForTesting
+    CacheEntry getCacheEntry(String hostname) {
+        return cache.get(hostname);
+    }
+}

launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java

@@ -28,6 +28,10 @@
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.ConnectionPool;
+import okhttp3.Dns;
 
 /**
  * This class contains the package-private implementations of component factories and builders whose
@@ -322,6 +326,27 @@ public PollingDataSourceBuilder pollIntervalMillisNoMinimum(int pollIntervalMill
 
     static final class StreamingDataSourceBuilderImpl extends StreamingDataSourceBuilder
             implements DiagnosticDescription, DataSourceRequiresFeatureFetcher {
+
+        // Shared across StreamingDataSource instances so that DNS cache and pooled
+        // connections survive data-source restarts (context switches, network transitions).
+        private volatile CachingDns sharedDns;
+        private final ConnectionPool sharedConnectionPool =
+                new ConnectionPool(1, 5, TimeUnit.MINUTES);
+
+        private Dns getOrCreateDns(LDLogger logger) {
+            CachingDns dns = sharedDns;
+            if (dns == null) {
+                synchronized (this) {
+                    dns = sharedDns;
+                    if (dns == null) {
+                        dns = new CachingDns(logger);
+                        sharedDns = dns;
+                    }
+                }
+            }
+            return dns;
+        }
+
         @Override
         public DataSource build(ClientContext clientContext) {
             // Even though this is called StreamingDataSourceBuilder, it doesn't always create a
@@ -342,7 +367,9 @@ public DataSource build(ClientContext clientContext) {
                     clientContext.getDataSourceUpdateSink(),
                     clientContextImpl.getFetcher(),
                     initialReconnectDelayMillis,
-                    streamEvenInBackground
+                    streamEvenInBackground,
+                    getOrCreateDns(clientContext.getBaseLogger()),
+                    sharedConnectionPool
             );
         }
 

launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/StreamingDataSource.java

@@ -24,6 +24,8 @@
 import java.net.URI;
 import java.util.concurrent.TimeUnit;
 
+import okhttp3.ConnectionPool;
+import okhttp3.Dns;
 import okhttp3.OkHttpClient;
 import okhttp3.RequestBody;
 
@@ -65,14 +67,18 @@ final class StreamingDataSource implements DataSource {
     private final DiagnosticStore diagnosticStore;
     private long eventSourceStarted;
     private final LDLogger logger;
+    private final Dns dns;
+    private final ConnectionPool connectionPool;
 
     StreamingDataSource(
             @NonNull ClientContext clientContext,
             @NonNull LDContext context,
             @NonNull DataSourceUpdateSink dataSourceUpdateSink,
             @NonNull FeatureFetcher fetcher,
             int initialReconnectDelayMillis,
-            boolean streamEvenInBackground
+            boolean streamEvenInBackground,
+            @NonNull Dns dns,
+            @NonNull ConnectionPool connectionPool
     ) {
         this.context = context;
         this.dataSourceUpdateSink = dataSourceUpdateSink;
@@ -85,6 +91,8 @@ final class StreamingDataSource implements DataSource {
         this.streamEvenInBackground = streamEvenInBackground;
         this.diagnosticStore = ClientContextImpl.get(clientContext).getDiagnosticStore();
         this.logger = clientContext.getBaseLogger();
+        this.dns = dns;
+        this.connectionPool = connectionPool;
     }
 
     public void start(@NonNull Callback<Boolean> resultCallback) {
@@ -152,6 +160,9 @@ public void onError(Throwable t) {
                 public void configure(OkHttpClient.Builder clientBuilder) {
                     httpProperties.applyToHttpClientBuilder(clientBuilder);
                     clientBuilder.readTimeout(READ_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                    clientBuilder.dns(dns);
+                    clientBuilder.connectionPool(connectionPool);
+                    clientBuilder.retryOnConnectionFailure(true);
                 }
             });
 

launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/CachingDnsTest.java

@@ -0,0 +1,171 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+
+import com.launchdarkly.logging.LDLogger;
+
+import org.junit.Test;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import okhttp3.Dns;
+
+public class CachingDnsTest {
+
+    private static final LDLogger logger = LDLogger.none();
+
+    private static Dns counting(List<InetAddress> result, AtomicInteger counter) {
+        return hostname -> {
+            counter.incrementAndGet();
+            return result;
+        };
+    }
+
+    private static Dns failing() {
+        return hostname -> {
+            throw new UnknownHostException("simulated DNS failure for " + hostname);
+        };
+    }
+
+    @Test
+    public void returnsFreshResultFromDelegate() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> expected = Collections.singletonList(addr);
+        AtomicInteger lookups = new AtomicInteger();
+        CachingDns dns = new CachingDns(counting(expected, lookups), 60_000, logger);
+
+        List<InetAddress> result = dns.lookup("example.com");
+        assertEquals(expected, result);
+        assertEquals(1, lookups.get());
+    }
+
+    @Test
+    public void returnsCachedResultWithinTtl() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> expected = Collections.singletonList(addr);
+        AtomicInteger lookups = new AtomicInteger();
+        CachingDns dns = new CachingDns(counting(expected, lookups), 60_000, logger);
+
+        dns.lookup("example.com");
+        List<InetAddress> result = dns.lookup("example.com");
+
+        assertEquals(expected, result);
+        assertEquals(1, lookups.get());
+    }
+
+    @Test
+    public void refreshesAfterTtlExpires() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> expected = Collections.singletonList(addr);
+        AtomicInteger lookups = new AtomicInteger();
+        CachingDns dns = new CachingDns(counting(expected, lookups), 0, logger);
+
+        dns.lookup("example.com");
+        dns.lookup("example.com");
+
+        assertEquals(2, lookups.get());
+    }
+
+    @Test
+    public void fallsBackToStaleCacheOnFailure() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> cached = Collections.singletonList(addr);
+
+        AtomicInteger lookups = new AtomicInteger();
+        Dns flaky = hostname -> {
+            if (lookups.incrementAndGet() == 1) {
+                return cached;
+            }
+            throw new UnknownHostException("simulated failure");
+        };
+
+        CachingDns dns = new CachingDns(flaky, 0, logger);
+        dns.lookup("example.com");
+
+        List<InetAddress> result = dns.lookup("example.com");
+        assertEquals(cached, result);
+    }
+
+    @Test(expected = UnknownHostException.class)
+    public void throwsWhenDelegateFailsAndNoCacheExists() throws Exception {
+        CachingDns dns = new CachingDns(failing(), 60_000, logger);
+        dns.lookup("no-such-host.invalid");
+    }
+
+    @Test
+    public void cachesPerHostname() throws Exception {
+        InetAddress addr1 = InetAddress.getByName("10.0.0.1");
+        InetAddress addr2 = InetAddress.getByName("10.0.0.2");
+        List<InetAddress> list1 = Collections.singletonList(addr1);
+        List<InetAddress> list2 = Collections.singletonList(addr2);
+
+        AtomicInteger lookups = new AtomicInteger();
+        Dns delegate = hostname -> {
+            lookups.incrementAndGet();
+            return hostname.equals("a.example.com") ? list1 : list2;
+        };
+        CachingDns dns = new CachingDns(delegate, 60_000, logger);
+
+        assertEquals(list1, dns.lookup("a.example.com"));
+        assertEquals(list2, dns.lookup("b.example.com"));
+        assertEquals(2, lookups.get());
+
+        assertEquals(list1, dns.lookup("a.example.com"));
+        assertEquals(list2, dns.lookup("b.example.com"));
+        assertEquals(2, lookups.get());
+    }
+
+    @Test
+    public void evictsExpiredEntriesWhenCacheExceedsMax() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> addrs = Collections.singletonList(addr);
+        AtomicInteger lookups = new AtomicInteger();
+
+        // TTL of 0 means every entry expires immediately
+        CachingDns dns = new CachingDns(counting(addrs, lookups), 0, logger);
+
+        // Fill beyond MAX_ENTRIES with distinct hostnames; each previous entry
+        // is already expired by the time the next lookup runs.
+        for (int i = 0; i <= CachingDns.MAX_ENTRIES; i++) {
+            dns.lookup("host-" + i + ".example.com");
+        }
+
+        // The last put should have triggered eviction of all expired entries,
+        // leaving only the most recent (non-expired at the instant it was stored).
+        assertEquals(1, dns.cacheSize());
+    }
+
+    @Test
+    public void retainsNonExpiredEntriesAcrossEviction() throws Exception {
+        InetAddress addr = InetAddress.getByName("127.0.0.1");
+        List<InetAddress> addrs = Collections.singletonList(addr);
+        AtomicInteger lookups = new AtomicInteger();
+
+        // Long TTL so nothing expires during the test
+        CachingDns dns = new CachingDns(counting(addrs, lookups), 600_000, logger);
+
+        for (int i = 0; i <= CachingDns.MAX_ENTRIES; i++) {
+            dns.lookup("host-" + i + ".example.com");
+        }
+
+        // Nothing is expired, so eviction can't remove anything
+        assertEquals(CachingDns.MAX_ENTRIES + 1, dns.cacheSize());
+    }
+
+    @Test
+    public void cacheEntryRecordsExpiration() {
+        InetAddress loopback = InetAddress.getLoopbackAddress();
+        List<InetAddress> addrs = Collections.singletonList(loopback);
+
+        long now = System.currentTimeMillis();
+        CachingDns.CacheEntry entry = new CachingDns.CacheEntry(addrs, now + 5000);
+
+        assertEquals(false, entry.isExpired(now));
+        assertEquals(true, entry.isExpired(now + 5000));
+        assertEquals(true, entry.isExpired(now + 6000));
+    }
+}