KTOR-7139 Fix exception thrown in onCallRespond makes the client wait…

ktor-io/common/src/io/ktor/utils/io/core/Closeable.kt

@@ -8,5 +8,6 @@ import kotlin.use as stdlibUse
 
 public expect interface Closeable : AutoCloseable
 
-@Deprecated("Use stdlib implementation instead. Remove import of this function", ReplaceWith("stdlibUse(block)"))
+@Suppress("DeprecatedCallableAddReplaceWith")
+@Deprecated("Use stdlib implementation instead. Remove import of this function")
 public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R = stdlibUse(block)

ktor-server/ktor-server-core/api/ktor-server-core.api

@@ -499,6 +499,7 @@ public final class io/ktor/server/engine/BaseApplicationResponse$BodyLengthIsToo
 
 public final class io/ktor/server/engine/BaseApplicationResponse$Companion {
 	public final fun getEngineResponseAttributeKey ()Lio/ktor/util/AttributeKey;
+	public final fun setupFallbackResponse (Lio/ktor/server/engine/EnginePipeline;)V
 	public final fun setupSendPipeline (Lio/ktor/server/response/ApplicationSendPipeline;)V
 }
 

ktor-server/ktor-server-core/api/ktor-server-core.klib.api

@@ -370,6 +370,7 @@ abstract class io.ktor.server.engine/BaseApplicationResponse : io.ktor.server.re
         final val EngineResponseAttributeKey // io.ktor.server.engine/BaseApplicationResponse.Companion.EngineResponseAttributeKey|{}EngineResponseAttributeKey[0]
             final fun <get-EngineResponseAttributeKey>(): io.ktor.util/AttributeKey<io.ktor.server.engine/BaseApplicationResponse> // io.ktor.server.engine/BaseApplicationResponse.Companion.EngineResponseAttributeKey.<get-EngineResponseAttributeKey>|<get-EngineResponseAttributeKey>(){}[0]
 
+        final fun setupFallbackResponse(io.ktor.server.engine/EnginePipeline) // io.ktor.server.engine/BaseApplicationResponse.Companion.setupFallbackResponse|setupFallbackResponse(io.ktor.server.engine.EnginePipeline){}[0]
         final fun setupSendPipeline(io.ktor.server.response/ApplicationSendPipeline) // io.ktor.server.engine/BaseApplicationResponse.Companion.setupSendPipeline|setupSendPipeline(io.ktor.server.response.ApplicationSendPipeline){}[0]
     }
 }

ktor-server/ktor-server-core/common/src/io/ktor/server/engine/BaseApplicationEngine.kt

@@ -51,6 +51,7 @@ public abstract class BaseApplicationEngine(
         val pipeline = pipeline
 
         BaseApplicationResponse.setupSendPipeline(pipeline.sendPipeline)
+        BaseApplicationResponse.setupFallbackResponse(pipeline, environment.log)
 
         monitor.subscribe(ApplicationStarting) {
             if (!info.isFirstLoading) {
@@ -63,6 +64,7 @@ public abstract class BaseApplicationEngine(
             it.installDefaultInterceptors()
             it.installDefaultTransformationChecker()
         }
+
         monitor.subscribe(ApplicationStarted) {
             val finishedAt = getTimeMillis()
             val elapsedTimeInSeconds = (finishedAt - info.initializedStartAt) / 1_000.0
@@ -115,7 +117,7 @@ private fun Application.installDefaultTransformationChecker() {
     intercept(ApplicationCallPipeline.Plugins) {
         try {
             proceed()
-        } catch (e: CannotTransformContentToTypeException) {
+        } catch (_: CannotTransformContentToTypeException) {
             call.respond(HttpStatusCode.UnsupportedMediaType)
         }
     }

ktor-server/ktor-server-core/common/src/io/ktor/server/engine/BaseApplicationResponse.kt

@@ -13,8 +13,16 @@ import io.ktor.server.response.*
 import io.ktor.util.*
 import io.ktor.util.cio.*
 import io.ktor.util.internal.*
+import io.ktor.util.logging.Logger
 import io.ktor.utils.io.*
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CopyableThrowable
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.withContext
+
+private val ERROR_CONTENT = object : OutgoingContent.NoContent() {
+    override val status: HttpStatusCode = HttpStatusCode.InternalServerError
+}
 
 public abstract class BaseApplicationResponse(
     final override val call: PipelineCall
@@ -80,10 +88,12 @@ public abstract class BaseApplicationResponse(
                 // TODO: What should we do if TransferEncoding was set and length is present?
                 headers.append(HttpHeaders.ContentLength, contentLength.toStringFast(), safeOnly = false)
             }
+
             !transferEncodingSet -> {
                 when (content) {
                     is OutgoingContent.ProtocolUpgrade -> {
                     }
+
                     is OutgoingContent.NoContent -> headers.append(HttpHeaders.ContentLength, "0", safeOnly = false)
                     else -> headers.append(HttpHeaders.TransferEncoding, "chunked", safeOnly = false)
                 }
@@ -331,5 +341,31 @@ public abstract class BaseApplicationResponse(
                 response.respondOutgoingContent(body)
             }
         }
+
+        public fun setupFallbackResponse(application: EnginePipeline, logger: Logger) {
+            val inDevMode = application.developmentMode
+            application.intercept(EnginePipeline.Before) {
+                try {
+                    proceed()
+                } catch (cause: Throwable) {
+                    if (call.isHandled) return@intercept
+
+                    logger.error("Unhandled server error: \"${cause.message}\"", cause)
+
+                    val response = call.response as? BaseApplicationResponse
+                        ?: call.attributes[EngineResponseAttributeKey]
+
+                    val content = if (inDevMode) {
+                        ExceptionPageContent(call, cause)
+                    } else {
+                        object : OutgoingContent.NoContent() {
+                            override val status: HttpStatusCode = HttpStatusCode.InternalServerError
+                        }
+                    }
+
+                    response.respondOutgoingContent(content)
+                }
+            }
+        }
     }
 }

ktor-server/ktor-server-core/common/src/io/ktor/server/engine/DefaultEnginePipeline.kt

@@ -76,15 +76,13 @@ public suspend fun logError(call: ApplicationCall, error: Throwable) {
  *
  * [Report a problem](https://ktor.io/feedback/?fqname=io.ktor.server.engine.defaultExceptionStatusCode)
  */
-public fun defaultExceptionStatusCode(cause: Throwable): HttpStatusCode? {
-    return when (cause) {
-        is BadRequestException -> HttpStatusCode.BadRequest
-        is NotFoundException -> HttpStatusCode.NotFound
-        is UnsupportedMediaTypeException -> HttpStatusCode.UnsupportedMediaType
-        is PayloadTooLargeException -> HttpStatusCode.PayloadTooLarge
-        is TimeoutException, is TimeoutCancellationException -> HttpStatusCode.GatewayTimeout
-        else -> null
-    }
+public fun defaultExceptionStatusCode(cause: Throwable): HttpStatusCode? = when (cause) {
+    is BadRequestException -> HttpStatusCode.BadRequest
+    is NotFoundException -> HttpStatusCode.NotFound
+    is UnsupportedMediaTypeException -> HttpStatusCode.UnsupportedMediaType
+    is PayloadTooLargeException -> HttpStatusCode.PayloadTooLarge
+    is TimeoutException, is TimeoutCancellationException -> HttpStatusCode.GatewayTimeout
+    else -> null
 }
 
 private suspend fun tryRespondError(call: ApplicationCall, statusCode: HttpStatusCode) {

ktor-server/ktor-server-core/common/src/io/ktor/server/engine/internal/ExceptionPageContent.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2014-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package io.ktor.server.engine.internal
+
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.content.OutgoingContent
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.plugins.origin
+import io.ktor.server.request.httpMethod
+import io.ktor.server.request.path
+import io.ktor.utils.io.ByteReadChannel
+
+internal class ExceptionPageContent(call: ApplicationCall, cause: Throwable) : OutgoingContent.ReadChannelContent() {
+
+    override val status: HttpStatusCode?
+        get() = HttpStatusCode.InternalServerError
+
+    private val responsePage: String = buildString {
+        val request = call.request
+        append("<html><body><h1>Internal Server Error</h1><h2>Request Information:</h2><pre>")
+        append("Method: ${request.httpMethod}\n")
+        append("Path: ${request.path()}\n")
+        append("Parameters: ${request.rawQueryParameters}\n")
+        append("From origin: ${request.origin}\n")
+        append("</pre><h2>Stack Trace:</h2><pre>")
+
+        val stackTrace = cause.stackTraceToString().lines()
+        stackTrace.forEach { element ->
+            append("<span style=\"color:blue;\">$element</span><br>")
+        }
+        var currentCause = cause.cause
+        while (currentCause != null) {
+            append("<br>Caused by:<br>")
+            val causeStack = currentCause.stackTraceToString().lines()
+            causeStack.forEach { element ->
+                append("<span style=\"color:green;\">$element</span><br>")
+            }
+            currentCause = currentCause.cause
+        }
+        append("</pre></body></html>")
+    }
+
+    override fun readFrom(): ByteReadChannel = ByteReadChannel(responsePage)
+}

ktor-server/ktor-server-netty/jvm/src/io/ktor/server/netty/NettyApplicationCallHandler.kt

@@ -47,7 +47,7 @@ internal class NettyApplicationCallHandler(
                 else ->
                     try {
                         enginePipeline.execute(call)
-                    } catch (error: Exception) {
+                    } catch (error: Throwable) {
                         handleFailure(call, error)
                     }
             }

ktor-server/ktor-server-plugins/ktor-server-auth/common/test/io/ktor/tests/auth/BasicAuthTest.kt

@@ -17,7 +17,10 @@ import io.ktor.server.testing.*
 import io.ktor.util.*
 import io.ktor.utils.io.charsets.*
 import io.ktor.utils.io.core.*
-import kotlin.test.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import kotlin.test.assertNotNull
 
 class BasicAuthTest {
     @Test
@@ -213,17 +216,15 @@ class BasicAuthTest {
             }
         }
 
-        assertFailsWith<NotImplementedError> {
-            handleRequestWithBasic("/", "u", "a")
-        }
+        assertEquals(HttpStatusCode.InternalServerError, handleRequestWithBasic("/", "u", "a").status)
     }
 
     private suspend fun ApplicationTestBuilder.handleRequestWithBasic(
         url: String,
         user: String,
         pass: String,
         charset: Charset = Charsets.ISO_8859_1
-    ) = client.get(url) {
+    ): HttpResponse = client.get(url) {
         val up = "$user:$pass"
         val encoded = up.toByteArray(charset).encodeBase64()
         header(HttpHeaders.Authorization, "Basic $encoded")

ktor-server/ktor-server-plugins/ktor-server-auth/common/test/io/ktor/tests/auth/BearerAuthTest.kt

@@ -12,7 +12,8 @@ import io.ktor.server.auth.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import io.ktor.server.testing.*
-import kotlin.test.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
 
 class BearerAuthTest {
 
@@ -132,11 +133,11 @@ class BearerAuthTest {
             authenticate = { throw NotImplementedError() }
         )
 
-        assertFailsWith<NotImplementedError> {
-            client.get("/") {
-                withToken("letmein")
-            }
+        val response = client.get("/") {
+            withToken("letmein")
         }
+
+        assertEquals(HttpStatusCode.InternalServerError, response.status)
     }
 
     @Test

ktor-server/ktor-server-plugins/ktor-server-status-pages/common/test/io/ktor/server/plugins/statuspages/StatusPagesTest.kt

@@ -17,8 +17,10 @@ import io.ktor.server.routing.*
 import io.ktor.server.testing.*
 import io.ktor.utils.io.*
 import io.ktor.utils.io.charsets.*
-import kotlinx.coroutines.*
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import kotlin.test.*
 
 class StatusPagesTest {
@@ -246,9 +248,7 @@ class StatusPagesTest {
             }
         }
 
-        assertFails {
-            client.get("/")
-        }
+        assertEquals(HttpStatusCode.NotFound, client.get("/").status)
     }
 
     @Test

ktor-server/ktor-server-test-base/jvm/src/io/ktor/server/test/base/EngineTestBaseJvm.kt

@@ -334,8 +334,6 @@ actual abstract class EngineTestBase<
 
                 followRedirects = false
                 expectSuccess = false
-
-                install(HttpRequestRetry)
             }
         }
 

ktor-server/ktor-server-test-host/common/src/io/ktor/server/testing/TestApplicationEngine.kt

@@ -118,7 +118,7 @@ public class TestApplicationEngine(
 
         val throwOnException = environment.config
             .propertyOrNull(CONFIG_KEY_THROW_ON_EXCEPTION)
-            ?.getString()?.toBoolean() ?: true
+            ?.getString()?.toBoolean() != false
         tryRespondError(
             defaultExceptionStatusCode(cause)
                 ?: if (throwOnException) throw cause else HttpStatusCode.InternalServerError