fix: close OkHttp response bodies to prevent connection leaks

Confidence/src/main/java/com/spotify/confidence/Confidence.kt

@@ -1,6 +1,7 @@
 package com.spotify.confidence
 
 import android.content.Context
+import com.spotify.confidence.ConfidenceError.HttpError
 import com.spotify.confidence.ConfidenceError.ParseError
 import com.spotify.confidence.apply.FlagApplierWithRetries
 import com.spotify.confidence.cache.DiskStorage
@@ -287,6 +288,8 @@ class Confidence internal constructor(
             }
         } catch (e: ParseError) {
             throw ParseError(e.message)
+        } catch (e: HttpError) {
+            throw e
         }
     }
 

Confidence/src/main/java/com/spotify/confidence/ConfidenceError.kt

@@ -22,5 +22,10 @@ class ConfidenceError {
         val flag: String
     ) : Error(message)
 
+    data class HttpError(
+        val httpCode: Int,
+        override val message: String
+    ) : Error(message)
+
     class InvalidContextInMessage : Error("Field 'context' is not allowed in event's data")
 }

Confidence/src/main/java/com/spotify/confidence/EventSenderUploader.kt

@@ -65,19 +65,20 @@ internal class EventSenderUploaderImpl(
             .post(networkJson.encodeToString(events).toRequestBody())
             .build()
 
-        val response = httpClient.newCall(httpRequest).await()
-        if (!response.isSuccessful) {
-            debugLogger?.logError(message = "Failed to upload events. http code ${response.code}")
-        }
-        when (response.code) {
-            // clean up in case of success
-            200 -> true
-            // we shouldn't cleanup for rate limiting
-            // TODO("return retry-after")
-            429 -> false
-            // if batch couldn't be processed, we should clean it up
-            in 400..499 -> true
-            else -> false
+        httpClient.newCall(httpRequest).await().use { response ->
+            if (!response.isSuccessful) {
+                debugLogger?.logError(message = "Failed to upload events. http code ${response.code}")
+            }
+            when (response.code) {
+                // clean up in case of success
+                200 -> true
+                // we shouldn't cleanup for rate limiting
+                // TODO("return retry-after")
+                429 -> false
+                // if batch couldn't be processed, we should clean it up
+                in 400..499 -> true
+                else -> false
+            }
         }
     }
 

Confidence/src/main/java/com/spotify/confidence/RemoteFlagResolver.kt

@@ -57,8 +57,7 @@ internal class RemoteFlagResolver(
             val startTime = System.nanoTime()
             var status = Telemetry.RequestStatus.SUCCESS
             try {
-                val result = httpClient.newCall(httpRequest).await()
-                result.toResolveFlags()
+                httpClient.newCall(httpRequest).await().use { it.toResolveFlags() }
             } catch (e: SocketTimeoutException) {
                 status = Telemetry.RequestStatus.TIMEOUT
                 throw e
@@ -92,22 +91,16 @@ internal class RemoteFlagResolver(
     private fun Response.toResolveFlags(): ResolveResponse {
         if (!isSuccessful) {
             debugLogger?.logError("Failed to resolve flags. Http code: $code")
+            throw ConfidenceError.HttpError(code, "Failed to resolve flags. Http code: $code")
         }
-        body?.let { body ->
-            val bodyString = body.string()
-
-            // building the json class responsible for serializing the object
-            val networkJson = Json {
-                serializersModule = SerializersModule {
-                    ignoreUnknownKeys = true
-                }
+        val bodyString = body?.string()
+            ?: throw ConfidenceError.ParseError("Response body is null", listOf())
+        val networkJson = Json {
+            serializersModule = SerializersModule {
+                ignoreUnknownKeys = true
             }
-            try {
-                return ResolveResponse.Resolved(networkJson.decodeFromString(bodyString))
-            } finally {
-                body.close()
-            }
-        } ?: throw ConfidenceError.ParseError("Response body is null", listOf())
+        }
+        return ResolveResponse.Resolved(networkJson.decodeFromString(bodyString))
     }
 }
 

Confidence/src/main/java/com/spotify/confidence/client/FlagApplierClientImpl.kt

@@ -94,16 +94,16 @@ internal class FlagApplierClientImpl : FlagApplierClient {
             extraHeaders[Telemetry.HEADER_NAME] = headerValue
         }
 
-        val result = applyInteractor.invoke(request, extraHeaders).runCatching {
-            if (isSuccessful) {
-                Result.Success(Unit)
-            } else {
-                Result.Failure()
+        return try {
+            applyInteractor.invoke(request, extraHeaders).use { response ->
+                if (response.isSuccessful) {
+                    Result.Success(Unit)
+                } else {
+                    Result.Failure()
+                }
             }
-        }.getOrElse {
+        } catch (_: Exception) {
             Result.Failure()
         }
-
-        return result
     }
 }

Provider/src/main/java/com/spotify/confidence/openfeature/ConfidenceFeatureProvider.kt

@@ -5,6 +5,7 @@ package com.spotify.confidence.openfeature
 import com.spotify.confidence.Confidence
 import com.spotify.confidence.ConfidenceError.ErrorCode
 import com.spotify.confidence.ConfidenceError.FlagNotFoundError
+import com.spotify.confidence.ConfidenceError.HttpError
 import com.spotify.confidence.ConfidenceError.ParseError
 import com.spotify.confidence.ConfidenceValue
 import com.spotify.confidence.Evaluation
@@ -125,6 +126,8 @@ class ConfidenceFeatureProvider private constructor(
             throw OpenFeatureError.ParseError(e.message)
         } catch (e: FlagNotFoundError) {
             throw OpenFeatureError.FlagNotFoundError(e.flag)
+        } catch (e: HttpError) {
+            throw OpenFeatureError.GeneralError(e.message)
         }
     }
     companion object {