ref(core): Collapse the HostnameCache constructor chain (JAVA-579)

The four constructors were a telescoping chain of test seams: one to shorten the
5-hour TTL, one to stub the localhost lookup, one to fake the ticker. With a fake
ticker a test can advance past the real TTL instantly, so the duration parameter
has no remaining purpose and the chain collapses to a single seam.

HostnameCache(long) had no callers at all — both apparent call sites were Kotlin
trailing-lambda calls that SAM-convert to HostnameCache(long, Callable).

MainEventProcessorTest's cache-expiry test now advances the ticker instead of
polling with awaitility, making it deterministic rather than just fast.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: runningcode

sentry/src/main/java/io/sentry/HostnameCache.java

@@ -25,9 +25,9 @@
  * Time sensitive cache in charge of keeping track of the hostname. The {@code
  * InetAddress.getLocalHost().getCanonicalHostName()} call can be quite expensive and could be
  * called for the creation of each {@link SentryEvent}. This system will prevent unnecessary costs
- * by keeping track of the hostname for a period defined during the construction. For performance
- * purposes, the operation of retrieving the hostname will automatically fail after a period of time
- * defined by {@link #GET_HOSTNAME_TIMEOUT} without result.
+ * by keeping track of the hostname for a period defined by {@link #HOSTNAME_CACHE_DURATION}. For
+ * performance purposes, the operation of retrieving the hostname will automatically fail after a
+ * period of time defined by {@link #GET_HOSTNAME_TIMEOUT} without result.
  *
  * <p>HostnameCache is a singleton and its instance should be obtained through {@link
  * HostnameCache#getInstance()}.
@@ -46,9 +46,6 @@ public final class HostnameCache {
   private static final @NotNull AutoClosableReentrantLock staticLock =
       new AutoClosableReentrantLock();
 
-  /** Time for which the cache is kept, in milliseconds. */
-  private final long cacheDurationMillis;
-
   private final @NotNull MonotonicTicker ticker;
 
   /** Current value for hostname (might change over time). */
@@ -77,32 +74,20 @@ public final class HostnameCache {
   }
 
   private HostnameCache() {
-    this(HOSTNAME_CACHE_DURATION);
-  }
-
-  HostnameCache(long cacheDurationMillis) {
     // avoid method refs on Android due to some issues with older AGP setups
     // noinspection Convert2MethodRef
-    this(cacheDurationMillis, () -> InetAddress.getLocalHost());
-  }
-
-  HostnameCache(long cacheDurationMillis, final @NotNull Callable<InetAddress> getLocalhost) {
-    this(cacheDurationMillis, getLocalhost, JavaMonotonicTicker.getInstance());
+    this(() -> InetAddress.getLocalHost(), JavaMonotonicTicker.getInstance());
   }
 
   /**
    * Sets up a cache for the hostname.
    *
-   * @param cacheDurationMillis cache duration in milliseconds.
    * @param getLocalhost a callback to obtain the localhost address - this is mostly here because of
    *     testability
    * @param ticker the ticker the cache lifetime is measured on
    */
   HostnameCache(
-      long cacheDurationMillis,
-      final @NotNull Callable<InetAddress> getLocalhost,
-      final @NotNull MonotonicTicker ticker) {
-    this.cacheDurationMillis = cacheDurationMillis;
+      final @NotNull Callable<InetAddress> getLocalhost, final @NotNull MonotonicTicker ticker) {
     this.getLocalhost = Objects.requireNonNull(getLocalhost, "getLocalhost is required");
     this.ticker = Objects.requireNonNull(ticker, "ticker is required");
     // Nothing resolved yet, so the cache is stale rather than fresh until updateCache says
@@ -145,7 +130,8 @@ private void updateCache() {
         () -> {
           try {
             hostname = getLocalhost.call().getCanonicalHostName();
-            cacheFreshUntil = Deadline.after(ticker, cacheDurationMillis, TimeUnit.MILLISECONDS);
+            cacheFreshUntil =
+                Deadline.after(ticker, HOSTNAME_CACHE_DURATION, TimeUnit.MILLISECONDS);
           } finally {
             updateRunning.set(false);
           }

sentry/src/test/java/io/sentry/HostnameCacheTest.kt

@@ -16,7 +16,7 @@ class HostnameCacheTest {
   private fun getSut(): HostnameCache {
     val address = mock<InetAddress>()
     whenever(address.canonicalHostName).thenReturn("myhost")
-    return HostnameCache(TimeUnit.HOURS.toMillis(1)) { address }
+    return HostnameCache({ address }, TestMonotonicTicker())
   }
 
   @Test
@@ -30,7 +30,7 @@ class HostnameCacheTest {
     val ticker = TestMonotonicTicker()
     val address = mock<InetAddress>()
     whenever(address.canonicalHostName).thenReturn("first", "second")
-    val cache = HostnameCache(TimeUnit.HOURS.toMillis(5), { address }, ticker)
+    val cache = HostnameCache({ address }, ticker)
 
     assertThat(cache.hostname).isEqualTo("first")
 
@@ -46,11 +46,11 @@ class HostnameCacheTest {
     val ticker = TestMonotonicTicker()
     val address = mock<InetAddress>()
     whenever(address.canonicalHostName).thenReturn("myhost")
-    val cache = HostnameCache(TimeUnit.HOURS.toMillis(1), { address }, ticker)
+    val cache = HostnameCache({ address }, ticker)
     // Reject the next submit the way an executor that could not start a thread would, and let the
     // cache go stale so that reading the hostname attempts a refresh.
     cache.getProperty<ThreadPoolExecutor>("executorService").shutdown()
-    ticker.advance(1, TimeUnit.HOURS)
+    ticker.advance(5, TimeUnit.HOURS)
 
     assertThat(cache.hostname).isEqualTo("myhost")
 

sentry/src/test/java/io/sentry/MainEventProcessorTest.kt

@@ -7,9 +7,11 @@ import io.sentry.protocol.DebugMeta
 import io.sentry.protocol.SdkVersion
 import io.sentry.protocol.SentryTransaction
 import io.sentry.protocol.User
+import io.sentry.time.TestMonotonicTicker
 import io.sentry.util.HintUtils
 import java.lang.RuntimeException
 import java.net.InetAddress
+import java.util.concurrent.TimeUnit
 import kotlin.test.AfterTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -18,7 +20,6 @@ import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
-import org.awaitility.kotlin.await
 import org.mockito.Mockito
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.reset
@@ -37,6 +38,7 @@ class MainEventProcessorTest {
       }
     val scopes = mock<IScopes>()
     val getLocalhost = mock<InetAddress>()
+    val hostnameCacheTicker = TestMonotonicTicker()
     lateinit var sentryTracer: SentryTracer
     private val hostnameCacheMock = Mockito.mockStatic(HostnameCache::class.java)
 
@@ -49,7 +51,6 @@ class MainEventProcessorTest {
       serverName: String? = "server",
       host: String? = null,
       resolveHostDelay: Long? = null,
-      hostnameCacheDuration: Long = 10,
       proguardUuid: String? = null,
       bundleIds: List<String>? = null,
       modules: Map<String, String>? = null,
@@ -77,7 +78,7 @@ class MainEventProcessorTest {
       whenever(scopes.options).thenReturn(sentryOptions)
       sentryTracer = SentryTracer(TransactionContext("", ""), scopes)
 
-      val hostnameCache = HostnameCache(hostnameCacheDuration) { getLocalhost }
+      val hostnameCache = HostnameCache({ getLocalhost }, hostnameCacheTicker)
       hostnameCacheMock.`when`<Any> { HostnameCache.getInstance() }.thenReturn(hostnameCache)
 
       return MainEventProcessor(sentryOptions)
@@ -435,7 +436,7 @@ class MainEventProcessorTest {
 
   @Test
   fun `uses cache to retrieve servername for subsequent events`() {
-    val processor = fixture.getSut(serverName = null, host = "aHost", hostnameCacheDuration = 1000)
+    val processor = fixture.getSut(serverName = null, host = "aHost")
     val firstEvent = SentryEvent()
     processor.process(firstEvent, Hint())
     assertEquals("aHost", firstEvent.serverName)
@@ -454,12 +455,11 @@ class MainEventProcessorTest {
 
     reset(fixture.getLocalhost)
     whenever(fixture.getLocalhost.canonicalHostName).thenReturn("newHost")
+    fixture.hostnameCacheTicker.advance(6, TimeUnit.HOURS)
 
-    await.untilAsserted {
-      val secondEvent = SentryEvent()
-      processor.process(secondEvent, Hint())
-      assertEquals("newHost", secondEvent.serverName)
-    }
+    val secondEvent = SentryEvent()
+    processor.process(secondEvent, Hint())
+    assertEquals("newHost", secondEvent.serverName)
   }
 
   @Test