call: Call,
    ioe: IOException,
  ) {
    logWithTime("requestFailed: $ioe")

    delegate.requestFailed(call, ioe)
  }

  override fun responseHeadersStart(call: Call) {
    logWithTime("responseHeadersStart")

    delegate.responseHeadersStart(call)
  }

  override fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
    logWithTime("responseHeadersEnd: $response")

      "ConnectStart", "ConnectEnd", "ConnectionAcquired", "RequestHeadersStart",
      "RequestHeadersEnd", "ResponseHeadersStart", "ResponseHeadersEnd", "ResponseBodyStart",
      "ResponseBodyEnd", "RequestHeadersStart", "RequestHeadersEnd", "ResponseHeadersStart",
      "ResponseHeadersEnd", "ResponseBodyStart", "ResponseBodyEnd", "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test

        if ("100-continue".equals(request.header("Expect"), ignoreCase = true)) {
          exchange.flushRequest()
          responseBuilder = exchange.readResponseHeaders(expectContinue = true)
          exchange.responseHeadersStart()
          invokeStartEvent = false
        }
        if (responseBuilder == null) {
          if (requestBody.isDuplex()) {
            // Prepare a duplex body so that the application can send a request body later.

  }

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

  data class ResponseHeadersEnd(
    override val timestampNs: Long,
    override val call: Call,
    val headerLength: Long,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is ResponseHeadersStart && call == event.call
  }

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) = logEvent(RequestFailed(System.nanoTime(), call, ioe))

  override fun responseHeadersStart(call: Call) = logEvent(ResponseHeadersStart(System.nanoTime(), call))

  override fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) = logEvent(ResponseHeadersEnd(System.nanoTime(), call, response.headers.byteCount()))

  }

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("requestFailed: $ioe")
  }

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

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

    try {
      codec.finishRequest()
    } catch (e: IOException) {
      eventListener.requestFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  fun responseHeadersStart() {
    eventListener.responseHeadersStart(call)
  }

  @Throws(IOException::class)
  fun readResponseHeaders(expectContinue: Boolean): Response.Builder? {
    try {
      val result = codec.readResponseHeaders(expectContinue)

   * This was misleading for tracing because it was too early.
   */
  open fun responseHeadersStart(call: Call) {
  }

  /**
   * Invoked immediately after receiving response headers.
   *
   * This method is always invoked after [responseHeadersStart].
   *
   * @param response the response received over the network. It is an error to access the body of
   *     this response.

        ),
      )
      .assertLogMatch(Regex("""requestHeadersStart"""))
      .assertLogMatch(Regex("""requestHeadersEnd"""))
      .assertLogMatch(Regex("""responseHeadersStart"""))
      .assertLogMatch(Regex("""responseHeadersEnd: Response\{protocol=http/1\.1, code=200, message=OK, url=$url\}"""))
      .assertLogMatch(Regex("""responseBodyStart"""))

      "SecureConnectStart", "SecureConnectEnd", "ConnectEnd", "ConnectionAcquired",
      "RequestHeadersStart", "RequestHeadersEnd", "RequestBodyStart", "ResponseHeadersStart",
      "ResponseHeadersEnd", "ResponseBodyStart", "ResponseBodyEnd", "RequestHeadersStart",
      "RequestHeadersEnd", "ResponseHeadersStart", "ResponseHeadersEnd", "ResponseBodyStart",
      "ResponseBodyEnd", "ConnectionReleased", "CallEnd", "RequestFailed",
    )
  }

  /**