) {
    logWithTime("cacheHit: $response")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {
    logWithTime("cacheConditionalHit: $cachedResponse")
  }

  private fun logWithTime(message: String) {
    val timeMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

 - CallStart
 - **CacheMiss**
 - ProxySelectStart
 - ... Standard Events ...
 - CallEnd

### Conditional Cache Hit

When cache flags require checking the cache results are still valid an early cacheConditionalHit event is
received followed by a cache hit or miss.  Critically in the cache hit scenario the server won’t send the response body.

  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit")
  }

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {
    logWithTime("cacheConditionalHit")
  }

  override fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,
  ) {
    logWithTime("retryDecision")

  override fun cacheHit(
    call: Call,
    response: Response,
  ) = onEvent(CacheHit(System.nanoTime(), call))

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) = onEvent(CacheConditionalHit(System.nanoTime(), call))

  override fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,

	public static final field Companion Lokhttp3/logging/LoggingEventListener$Companion;
	public synthetic fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
	public fun cacheConditionalHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V

        .build()
    val listener = loggingEventListenerFactory.create(call)
    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

    override val call: Call,
  ) : CallEvent()

  data class CacheMiss(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CacheConditionalHit(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RetryDecision(
    override val timestampNs: Long,
    override val call: Call,

      for (delegate in eventListeners) {
        delegate.cacheMiss(call)
      }
    }

    override fun cacheConditionalHit(
      call: Call,
      cachedResponse: Response,
    ) {
      for (delegate in eventListeners) {
        delegate.cacheConditionalHit(call, cachedResponse)
      }
    }

    override fun retryDecision(
      call: Call,
      exception: IOException,

import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CacheConditionalHit
import okhttp3.CallEvent.CacheHit
import okhttp3.CallEvent.CacheMiss
import okhttp3.CallEvent.CallEnd
import okhttp3.CallEvent.CallFailed
import okhttp3.CallEvent.CallStart
import okhttp3.CallEvent.Canceled

    val client = OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
        .build()
    ```

 *  New: Add `cacheHit`, `cacheMiss`, and `cacheConditionalHit()` events to `EventListener`. Use
    these in logs, metrics, and even test cases to confirm your cache headers are configured as
    expected.