```java
logging.redactHeader("Authorization");
logging.redactHeader("Cookie");
```

Download
--------

```kotlin
implementation("com.squareup.okhttp3:logging-interceptor:5.3.0")
```

    // Call the next interceptor in the chain.
    val next = copy(index = index + 1, request = request)
    val interceptor = interceptors[index]

    @Suppress("USELESS_ELVIS")
    val response =
      interceptor.intercept(next) ?: throw NullPointerException(
        "interceptor $interceptor returned null",
      )

    if (exchange != null) {
      check(index + 1 >= interceptors.size || next.calls == 1) {

    // Build a full stack of interceptors.
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor()
    interceptors += BridgeInterceptor()
    interceptors += CacheInterceptor()
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }

      }

    /**
     * Returns a modifiable list of interceptors that observe the full span of each call: from
     * before the connection is established (if any) until after the response source is selected
     * (either the origin server, cache, or both).
     */
    fun interceptors(): MutableList<Interceptor> = interceptors

    fun addInterceptor(interceptor: Interceptor) =
      apply {
        interceptors += interceptor

 *   }
 * ```
 */
fun interface Interceptor {
  @Throws(IOException::class)
  fun intercept(chain: Chain): Response

  companion object {
    /**
     * Constructs an interceptor for a lambda. This compact syntax is most useful for inline
     * interceptors.
     *
     * ```kotlin
     * val interceptor = Interceptor { chain: Interceptor.Chain ->
     *     chain.proceed(chain.request())
     * }

     * [Request.tag]. Use null to remove any existing tag assigned for [T].
     *
     * Use this API to attach timing, debugging, or other application data to a request so that
     * you may read it in interceptors, event listeners, or callbacks.
     */
    @JvmName("reifiedTag")
    inline fun <reified T : Any> tag(tag: T?): Builder = tag(T::class, tag)

    /**

import okio.IOException
import org.junit.jupiter.api.Assertions

internal open class RecordingConnectionListener(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )

  fun newChain(call: RealCall): RealInterceptorChain =
    RealInterceptorChain(
      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
    )

  fun newRoutePlanner(
    client: OkHttpClient,
    address: Address = newAddress(),

import okhttp3.CallEvent.Canceled
import org.junit.jupiter.api.Assertions.fail

open class EventRecorder(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) {
  private val eventListenerAdapter =
    EventListenerAdapter()
      .apply {
        listeners += ::logEvent
      }

      }
    val interceptor2 =
      Interceptor { chain: Interceptor.Chain ->
        assertThat(chain.writeTimeoutMillis()).isEqualTo(100)
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .writeTimeout(Duration.ofSeconds(5))
        .addInterceptor(interceptor1)
        .addInterceptor(interceptor2)
        .build()
    server.enqueue(