public class RecordedRequest(
  /**
   * The index of the socket connection that carried this request. If two recorded requests share a
   * connection index, they also shared a socket connection.
   */
  public val connectionIndex: Int,
  /**
   * The index of this exchange on its HTTP connection. A request is uniquely identified by the
   * (connection index, exchange index) pair.
   */
  public val exchangeIndex: Int,
  /**

plugins {
  kotlin("jvm")
  id("okhttp.jvm-conventions")
  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
  application
}

application {
  mainClass.set("okhttp3.sample.Crawler")
}

dependencies {
  implementation(projects.okhttp)
  implementation(libs.jsoup)
}

tasks.compileJava {
  options.isWarnings = false

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import ru.vyarus.gradle.plugin.animalsniffer.AnimalSnifferExtension

plugins {
  kotlin("jvm")
  id("okhttp.publish-conventions")
  id("okhttp.jvm-conventions")
  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
  id("com.gradleup.shadow")
}

tasks.withType<KotlinCompile> {
  compilerOptions {
    jvmTarget.set(JvmTarget.JVM_17)
  }
}

stuck on the old version.

 *  **There is no longer a global singleton connection pool.** In OkHttp 2.x,
    all `OkHttpClient` instances shared a common connection pool by default.
    In OkHttp 3.x, each new `OkHttpClient` gets its own private connection pool.
    Applications should avoid creating many connection pools as doing so
    prevents connection reuse. Each connection pool holds its own set of

      ProtocolException::class.java,
      "Expected 'Connection' header value 'Upgrade' but was 'null'",
    )
    webSocket.cancel()
  }

  @Test
  @Throws(IOException::class)
  fun wrongConnectionHeader() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(101)
        .setHeader("Upgrade", "websocket")
        .setHeader("Connection", "Downgrade")

plugins {
  kotlin("jvm")
  id("okhttp.jvm-conventions")
  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
  id("ru.vyarus.animalsniffer")
}

dependencies {
  api(libs.square.okio)
  api(libs.square.kotlin.poet)
  testImplementation(libs.assertk)
  testImplementation(libs.junit.jupiter.api)
  testImplementation(libs.junit.jupiter.params)

  testImplementation(rootProject.libs.junit.jupiter.engine)
}

   */
  @JvmField val minimumConcurrentCalls: Int = 0,
  /** How long to wait to retry pre-emptive connection attempts that fail. */
  @JvmField val backoffDelayMillis: Long = 60 * 1000,
  /** How much jitter to introduce in connection retry backoff delays */
  @JvmField val backoffJitterMillis: Int = 100,

  ) {
    logWithTime("connectFailed: $protocol $ioe")
  }

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionAcquired: $connection")
  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionReleased")
  }

  override fun requestHeadersStart(call: Call) {

 * limitations under the License.
 */
package okhttp3.internal

import okhttp3.Cache
import okhttp3.Dispatcher
import okhttp3.Response
import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,

  )

  override fun connectEnd(
    connection: Connection,
    route: Route,
    call: Call,
  ) {
    logEvent(ConnectionEvent.ConnectEnd(System.nanoTime(), connection, route, call))
  }

  override fun connectionClosed(connection: Connection) = logEvent(ConnectionEvent.ConnectionClosed(System.nanoTime(), connection))

  override fun connectionAcquired(
    connection: Connection,
    call: Call,
  ) {