First try to implement a generic exception handler for handler functions

Author: mduesterhoeft

src/main/kotlin/com/github/mduesterhoeft/router/ApiException.kt

@@ -6,7 +6,7 @@ open class ApiException(
     val httpResponseStatus: Int,
     val details: Map<String, Any> = emptyMap(),
     cause: Throwable? = null
-) : RuntimeException("[$code] $message", cause) {
+) : RuntimeException(message, cause) {
 
     override fun toString(): String {
         return "ApiException(message='$message', code='$code', httpResponseStatus=$httpResponseStatus, details=$details, cause=$cause)"

src/main/kotlin/com/github/mduesterhoeft/router/RequestHandler.kt

@@ -18,19 +18,30 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
 
     open val objectMapper = jacksonObjectMapper()
 
+    abstract val router: Router
+
     @Suppress("UNCHECKED_CAST")
     override fun handleRequest(input: APIGatewayProxyRequestEvent, context: Context): APIGatewayProxyResponseEvent? {
-        log.info("handling request with method '${input.httpMethod}' and path '${input.path}' - Accept:${input.acceptHeader()} Content-Type:${input.contentType()} $input")
+        log.debug("handling request with method '${input.httpMethod}' and path '${input.path}' - Accept:${input.acceptHeader()} Content-Type:${input.contentType()} $input")
         val routes = router.routes as List<RouterFunction<Any, Any>>
         val matchResults: List<RequestMatchResult> = routes.map { routerFunction: RouterFunction<Any, Any> ->
             val matchResult = routerFunction.requestPredicate.match(input)
-            log.info("match result for route '$routerFunction' is '$matchResult'")
+            log.debug("match result for route '$routerFunction' is '$matchResult'")
             if (matchResult.match) {
                 val handler: HandlerFunction<Any, Any> = routerFunction.handler
                 val requestBody = deserializeRequest(handler, input)
                 val request = Request(input, requestBody, routerFunction.requestPredicate.pathPattern)
-                val response = router.filter.then(handler as HandlerFunction<*, *>).invoke(request)
-                return createResponse(input, response)
+                return try {
+                    val response = router.filter.then(handler as HandlerFunction<*, *>).invoke(request)
+                    createResponse(input, response)
+                } catch (e: RuntimeException) {
+                    when (e) {
+                        is ApiException -> createErrorResponse(input, e)
+                            .also { log.info("Caught api error while handling ${input.httpMethod} ${input.path} - $e") }
+                        else -> createInternalServerErrorResponse(input, e)
+                            .also { log.error("Caught exception handling ${input.httpMethod} ${input.path} - $e", e) }
+                    }
+                }
             }
 
             matchResult
@@ -88,8 +99,6 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
         )
     }
 
-    abstract val router: Router
-
     open fun createErrorResponse(input: APIGatewayProxyRequestEvent, ex: ApiException): APIGatewayProxyResponseEvent =
         APIGatewayProxyResponseEvent()
             .withBody(objectMapper.writeValueAsString(mapOf(
@@ -100,6 +109,15 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
             .withStatusCode(ex.httpResponseStatus)
             .withHeaders(mapOf("Content-Type" to "application/json"))
 
+    open fun createInternalServerErrorResponse(input: APIGatewayProxyRequestEvent, ex: java.lang.RuntimeException): APIGatewayProxyResponseEvent =
+        APIGatewayProxyResponseEvent()
+            .withBody(objectMapper.writeValueAsString(mapOf(
+                "message" to ex.message,
+                "code" to "INTERNAL_SERVER_ERROR"
+            )))
+            .withStatusCode(500)
+            .withHeaders(mapOf("Content-Type" to "application/json"))
+
     open fun <T> createResponse(input: APIGatewayProxyRequestEvent, response: ResponseEntity<T>): APIGatewayProxyResponseEvent {
         val accept = MediaType.parse(input.acceptHeader())
         return when {

src/test/kotlin/com/github/mduesterhoeft/router/RequestHandlerTest.kt

@@ -159,6 +159,32 @@ class RequestHandlerTest {
         assert(handler.filterInvocations).isEqualTo(2)
     }
 
+    @Test
+    fun `should handle api exception`() {
+
+        val response = testRequestHandler.handleRequest(
+            APIGatewayProxyRequestEvent()
+                .withPath("/some-api-exception")
+                .withHttpMethod("GET")
+                .withHeaders(mapOf("Accept" to "application/json")), mockk()
+        )!!
+
+        assert(response.statusCode).isEqualTo(400)
+    }
+
+    @Test
+    fun `should handle internal server error`() {
+
+        val response = testRequestHandler.handleRequest(
+            APIGatewayProxyRequestEvent()
+                .withPath("/some-internal-server-error")
+                .withHttpMethod("GET")
+                .withHeaders(mapOf("Accept" to "application/json")), mockk()
+        )!!
+
+        assert(response.statusCode).isEqualTo(500)
+    }
+
     class TestRequestHandlerWithFilter : RequestHandler() {
 
         var filterInvocations = 0
@@ -187,6 +213,12 @@ class RequestHandlerTest {
             GET("/some") { _: Request<Unit> ->
                 ResponseEntity.ok(TestResponse("Hello"))
             }
+            GET<Unit, Unit>("/some-api-exception") {
+                throw ApiException("boom", "BOOM", 400, mapOf("more" to "info"))
+            }
+            GET<Unit, Unit>("/some-internal-server-error") {
+                throw IllegalArgumentException("boom")
+            }
             GET("/some/{id}") { r: Request<Unit> ->
                 ResponseEntity.ok(TestResponse("Hello ${r.getPathParameter("id")}"))
             }