Logging

Ktor client provides the capability to log HTTP calls using the Logging plugin. This plugin provides different logger types for different platforms:

On JVM, Ktor uses SLF4J API as a facade for various logging frameworks (for example, Logback or Log4j).
For Native targets, the Logging plugin provides a logger that prints everything to STDOUT.
For multiplatform projects, you can specify a custom logger (for example, Napier).

Add dependencies

To enable logging, you need to include the following artifacts in the build script:

(Optional) An artifact with the required SLF4J implementation, for example, Logback:
implementation("ch.qos.logback:logback-classic:$logback_version")
implementation "ch.qos.logback:logback-classic:$logback_version"
<dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>${logback_version}</version> </dependency>
The ktor-client-logging artifact:
implementation("io.ktor:ktor-client-logging:$ktor_version")
implementation "io.ktor:ktor-client-logging:$ktor_version"
<dependency> <groupId>io.ktor</groupId> <artifactId>ktor-client-logging-jvm</artifactId> <version>${ktor_version}</version> </dependency>
You can learn more about artifacts required by the Ktor client from Adding client dependencies.

Install Logging

To install Logging, pass it to the install function inside a client configuration block:

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.logging.*
//...
val client = HttpClient(CIO) {
    install(Logging)
}

Configure Logging

The Logging plugin configuration is provided by the Logging.Config class. The example below shows a sample configuration:

The logger property is set to Logger.DEFAULT, which uses an SLF4J logging framework. For Native targets, set this property to Logger.SIMPLE.
The level property specifies the logging level. For instance, you can log only request/response headers or include their bodies.
The filter function allows you to filter log messages for requests matching the specified predicate. In the example below, only requests made to ktor.io get into the log.
The sanitizeHeader function allows you to sanitize sensitive headers to avoid their values appearing in the logs. In the example below, Authorization header value will be replaced with '***' when logged.

package com.example

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.logging.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.runBlocking

fun main() {
    runBlocking {
        val client = HttpClient(CIO) {
            install(Logging) {
                logger = Logger.DEFAULT
                level = LogLevel.HEADERS
                filter { request ->
                    request.url.host.contains("ktor.io")
                }
                sanitizeHeader { header -> header == HttpHeaders.Authorization }
            }
        }

        val response1: HttpResponse = client.get("https://ktor.io/")
        val response2: HttpResponse = client.get("https://jetbrains.com/")
    }
}

You can find the full example here: client-logging.

Provide a custom logger

To use a custom logger in your client application, you need to create a Logger instance and override the log function. The example below shows how to use the Napier library to log HTTP calls:

fun main() {
    runBlocking {
        val client = HttpClient(CIO) {
            install(Logging) {
                logger = object: Logger {
                    override fun log(message: String) {
                        Napier.v("HTTP Client", null, message)
                    }
                }
                level = LogLevel.HEADERS
            }
        }.also { Napier.base(DebugAntilog()) }

        val response: HttpResponse = client.get("https://ktor.io/")
    }
}

For the full example, see client-logging-napier.

Last modified: 02 April 2024