- support for verbose logging a sanitized version of the REST API request and responses

The Coder Toolbox plugin includes comprehensive HTTP request logging capabilities to help diagnose API communication

issues with Coder deployments.

This feature allows you to monitor all HTTP requests and responses made by the plugin.

You can configure HTTP logging verbosity through the Coder Settings page:

1. Navigate to the Coder Workspaces page

2. Click on the deployment action menu (three dots)

3. Select "Settings"

4. Find the "HTTP logging level" dropdown

The plugin supports four levels of HTTP logging verbosity:

- **None**: No HTTP request/response logging (default)

- **Basic**: Logs HTTP method, URL, and response status code

- **Headers**: Logs basic information plus sanitized request and response headers

- **Body**: Logs headers plus request and response body content

HTTP logs follow this format:

HTTP logging is particularly useful for:

- **API Debugging**: Diagnosing issues with Coder API communication

- **Authentication Problems**: Troubleshooting token or certificate authentication issues

- **Network Issues**: Identifying connectivity problems with Coder deployments

- **Performance Analysis**: Monitoring request/response times and payload sizes

When reporting issues, include HTTP logs to help diagnose:

1. **Authentication Failures**: Check for 401/403 responses and token headers

2. **Network Connectivity**: Look for connection timeouts or DNS resolution issues

3. **API Compatibility**: Verify request/response formats match expected API versions

4. **Proxy Issues**: Monitor proxy authentication and routing problems

import com.coder.toolbox.sdk.convertors.LoggingConverterFactory

import com.coder.toolbox.sdk.interceptors.LoggingInterceptor

context.logger.info("proxy: ${context.proxySettings.getProxy()}")

context.logger.info("proxy selector: ${context.proxySettings.getProxySelector()}")

.addInterceptor(LoggingInterceptor(context))

.addConverterFactory(

LoggingConverterFactory.wrap(

context,

MoshiConverterFactory.create(moshi)

)

)

package com.coder.toolbox.sdk.convertors

import com.coder.toolbox.CoderToolboxContext

import okhttp3.RequestBody

import okhttp3.ResponseBody

import retrofit2.Converter

import retrofit2.Retrofit

import java.lang.reflect.Type

class LoggingConverterFactory private constructor(

private val context: CoderToolboxContext,

private val delegate: Converter.Factory,

) : Converter.Factory() {

override fun responseBodyConverter(

type: Type,

annotations: Array<Annotation>,

retrofit: Retrofit

): Converter<ResponseBody, *>? {

// Get the delegate converter

val delegateConverter = delegate.responseBodyConverter(type, annotations, retrofit)

?: return null

@Suppress("UNCHECKED_CAST")

return LoggingMoshiConverter(context, delegateConverter as Converter<ResponseBody, Any?>)

}

override fun requestBodyConverter(

type: Type,

parameterAnnotations: Array<Annotation>,

methodAnnotations: Array<Annotation>,

retrofit: Retrofit

): Converter<*, RequestBody>? {

return delegate.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit)

}

override fun stringConverter(

type: Type,

annotations: Array<Annotation>,

retrofit: Retrofit

): Converter<*, String>? {

return delegate.stringConverter(type, annotations, retrofit)

}

companion object {

fun wrap(

context: CoderToolboxContext,

delegate: Converter.Factory,

): LoggingConverterFactory {

return LoggingConverterFactory(context, delegate)

}

}

}

package com.coder.toolbox.sdk.convertors

import com.coder.toolbox.CoderToolboxContext

import okhttp3.ResponseBody

import okhttp3.ResponseBody.Companion.toResponseBody

import retrofit2.Converter

class LoggingMoshiConverter(

private val context: CoderToolboxContext,

private val delegate: Converter<ResponseBody, Any?>

) : Converter<ResponseBody, Any> {

override fun convert(value: ResponseBody): Any? {

val bodyString = value.string()

return try {

// Parse with Moshi

delegate.convert(bodyString.toResponseBody(value.contentType()))

} catch (e: Exception) {

// Log the raw content that failed to parse

context.logger.error(

"""

""".trimMargin()

)

// Re-throw so the onFailure callback still gets called

throw e

}

}

}

package com.coder.toolbox.sdk.interceptors

import com.coder.toolbox.CoderToolboxContext

import com.coder.toolbox.settings.HttpLoggingVerbosity

import okhttp3.Headers

import okhttp3.Interceptor

import okhttp3.MediaType

import okhttp3.Request

import okhttp3.RequestBody

import okhttp3.Response

import okhttp3.ResponseBody

import okio.Buffer

import java.nio.charset.StandardCharsets

private val SENSITIVE_HEADERS = setOf("Coder-Session-Token", "Proxy-Authorization")

class LoggingInterceptor(private val context: CoderToolboxContext) : Interceptor {

override fun intercept(chain: Interceptor.Chain): Response {

val logLevel = context.settingsStore.httpClientLogLevel

if (logLevel == HttpLoggingVerbosity.NONE) {

return chain.proceed(chain.request())

}

val request = chain.request()

logRequest(request, logLevel)

val response = chain.proceed(request)

logResponse(response, request, logLevel)

return response

}

private fun logRequest(request: Request, logLevel: HttpLoggingVerbosity) {

val log = buildString {

append("request --> ${request.method} ${request.url}")

if (logLevel >= HttpLoggingVerbosity.HEADERS) {

append("\n${request.headers.sanitized()}")

}

if (logLevel == HttpLoggingVerbosity.BODY) {

request.body?.let { body ->

append("\n${body.toPrintableString()}")

}

}

}

context.logger.info(log)

}

private fun logResponse(response: Response, request: Request, logLevel: HttpLoggingVerbosity) {

val log = buildString {

append("response <-- ${response.code} ${response.message} ${request.url}")

if (logLevel >= HttpLoggingVerbosity.HEADERS) {

append("\n${response.headers.sanitized()}")

}

if (logLevel == HttpLoggingVerbosity.BODY) {

response.body?.let { body ->

append("\n${body.toPrintableString()}")

}

}

}

context.logger.info(log)

}

}

private fun Headers.sanitized(): String = buildString {

this@sanitized.forEach { (name, value) ->

val displayValue = if (name in SENSITIVE_HEADERS) "<redacted>" else value

append("$name: $displayValue\n")

}

}

private fun RequestBody.toPrintableString(): String {

if (!contentType().isPrintable()) {

return "[Binary body: ${contentLength().formatBytes()}, ${contentType()}]"

}

return try {

val buffer = Buffer()

writeTo(buffer)

buffer.readString(contentType()?.charset() ?: StandardCharsets.UTF_8)

} catch (e: Exception) {

"[Error reading body: ${e.message}]"

}

}

private fun ResponseBody.toPrintableString(): String {

if (!contentType().isPrintable()) {

return "[Binary body: ${contentLength().formatBytes()}, ${contentType()}]"

}

return try {

val source = source()

source.request(Long.MAX_VALUE)

source.buffer.clone().readString(contentType()?.charset() ?: StandardCharsets.UTF_8)

} catch (e: Exception) {

"[Error reading body: ${e.message}]"

}

}

private fun MediaType?.isPrintable(): Boolean = when {

this == null -> false

type == "text" -> true

subtype == "json" || subtype.endsWith("+json") -> true

else -> false

}

private fun Long.formatBytes(): String = when {

this < 0 -> "unknown"

this < 1024 -> "${this}B"

this < 1024 * 1024 -> "${this / 1024}KB"

this < 1024 * 1024 * 1024 -> "${this / (1024 * 1024)}MB"

else -> "${this / (1024 * 1024 * 1024)}GB"

}

/**

val httpClientLogLevel: HttpLoggingVerbosity

}

enum class HttpLoggingVerbosity {

NONE,

/**

BASIC,

/**

HEADERS,

/**

BODY;

companion object {

fun fromValue(value: String?): HttpLoggingVerbosity = when (value?.lowercase(getDefault())) {

"basic" -> BASIC

"headers" -> HEADERS

"body" -> BODY

else -> NONE

}

}