a field, `callStartNanos`, to track the elapsed time of each event. This is handy, but it won’t work if multiple calls are executing concurrently. To accommodate this, use a `Factory` to create a new `EventListener` instance for each `Call`. This allows each listener to keep call-specific state.

This [sample factory](https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/PrintEvents.java) creates a unique ID for each call and uses that ID to differentiate...

  ).int().default(DEFAULT_TIMEOUT)

  val followRedirects: Boolean by option("-L", "--location", help = "Follow redirects").flag()

  val allowInsecure: Boolean by option("-k", "--insecure", help = "Allow connections to SSL sites without certs").flag()

  val showHeaders: Boolean by option("-i", "--include", help = "Include protocol headers in the output").flag()

 * save a small amount of file I/O and data copying.
 */
class Relay private constructor(
  /**
   * Read/write persistence of the upstream source and its metadata. Its layout is as follows:
   *
   *  * 16 bytes: either `OkHttp cache v1\n` if the persisted file is complete. This is another
   *    sequence of bytes if the file is incomplete and should not be used.
   *  * 8 bytes: *n*: upstream data size

    Get these strings with `HeldCertificate.certificatePem()` and `privateKeyPkcs8Pem()`.

 *  Fix: Handshake now returns peer certificates in canonical order: each certificate is signed by
    the certificate that follows and the last certificate is signed by a trusted root.

 *  Fix: Don't lose HTTP/2 flow control bytes when incoming data races with a stream close. If this
    happened enough then eventually the connection would stall.

    assertFailsWith<IOException> {
      getResponse(newRequest("/foo"))
    }.also { expected ->
      when (expected) {
        is SSLHandshakeException -> {
          // Allow conscrypt to fail in different ways
          if (!platform.isConscrypt()) {
            assertThat(expected.cause!!).isInstanceOf<CertificateException>()
          }
        }
        is TlsFatalAlert -> {}

            is Inet6Address -> "[${inetAddress.hostAddress}]:$localPort"
            else -> "${inetAddress.hostAddress}:$localPort"
          }

      // Allow null in failure case to allow for testing bad requests
      this.requestUrl = "$scheme://$hostAndPort$path".toHttpUrlOrNull()
    } else {
      this.requestUrl = null
      this.method = null
      this.path = null
    }
  }

 *    Note that the private key is not a part of the certificate!
 *
 *  * **A signature issued by another certificate's private key.** This mechanism allows a trusted
 *    third-party to endorse a certificate. Third parties should only endorse certificates once
 *    they've confirmed that the owner of the private key is also the owner of the certificate's
 *    other properties.
 *

 *  New: `LoggingEventListener` makes it easy to get basic visibility into a call's performance.
    This class is in the `logging-interceptor` artifact.
 *  New: `Headers.Builder.addUnsafeNonAscii()` allows non-ASCII values to be added without an
    immediate exception.
 *  New: Headers can be redacted in `HttpLoggingInterceptor`.
 *  New: `Headers.Builder` now accepts dates.

 5. It sends the HTTP request and reads the response.

If there's a problem with the connection, OkHttp will select another route and try again. This allows OkHttp to recover when a subset of a server's addresses are unreachable. It's also useful when a pooled connection is stale or if the attempted TLS version is unsupported.

    }
    assertThat(socket.enabledCipherSuites)
      .containsExactly(*expectedCipherSuites.toTypedArray())
  }

  @Test
  fun tls_stringCiphersAndVersions() {
    // Supporting arbitrary input strings allows users to enable suites and versions that are not
    // yet known to the library, but are supported by the platform.
    ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
      .cipherSuites("MAGIC-CIPHER")