feat: add timeout to fetchAndActivate

Sources/Confidence/Confidence.swift

@@ -272,7 +272,8 @@ public class Confidence: ConfidenceEventSender {
             storage: storage,
             context: context,
             parent: self,
-            debugLogger: debugLogger)
+            debugLogger: debugLogger
+        )
     }
 }
 
@@ -288,6 +289,7 @@ extension Confidence {
         internal var region: ConfidenceRegion = .global
         internal var metadata: ConfidenceMetadata?
         internal var initialContext: ConfidenceStruct = [:]
+        internal var timeout: Double = 10
 
         // Injectable for testing
         internal var flagApplier: FlagApplier?
@@ -337,6 +339,15 @@ extension Confidence {
             return self
         }
 
+        /**
+         Sets the timeout for the network requests to the Confidence backend.
+         The default is 10 seconds.
+         */
+        public func withTimeout(timeout: Double) -> Builder {
+            self.timeout = timeout
+            return self
+        }
+
         public func build() -> Confidence {
             var debugLogger: DebugLogger?
             if loggerLevel != LoggerLevel.NONE {
@@ -347,15 +358,19 @@ extension Confidence {
             }
             let options = ConfidenceClientOptions(
                 credentials: ConfidenceClientCredentials.clientSecret(secret: clientSecret),
-                region: region)
+                region: region,
+                timeoutIntervalForRequest: timeout)
             let metadata = ConfidenceMetadata(
                 name: sdkId,
                 version: "0.2.4") // x-release-please-version
             let uploader = RemoteConfidenceClient(
                 options: options,
                 metadata: metadata
             )
-            let httpClient = NetworkClient(baseUrl: BaseUrlMapper.from(region: options.region))
+            let httpClient = NetworkClient(
+                baseUrl: BaseUrlMapper.from(region: options.region),
+                timeoutIntervalForRequests: options.timeoutIntervalForRequest
+            )
             let flagApplier = flagApplier ?? FlagApplierWithRetries(
                 httpClient: httpClient,
                 storage: DefaultStorage(filePath: "confidence.flags.apply"),

Sources/Confidence/ConfidenceClientOptions.swift

@@ -4,15 +4,18 @@ struct ConfidenceClientOptions {
     public var credentials: ConfidenceClientCredentials
     public var region: ConfidenceRegion
     public var initializationStrategy: InitializationStrategy
+    public var timeoutIntervalForRequest: Double
 
     public init(
         credentials: ConfidenceClientCredentials,
         region: ConfidenceRegion? = nil,
-        initializationStrategy: InitializationStrategy = .fetchAndActivate
+        initializationStrategy: InitializationStrategy = .fetchAndActivate,
+        timeoutIntervalForRequest: Double = 0
     ) {
         self.credentials = credentials
         self.region = region ?? .global
         self.initializationStrategy = initializationStrategy
+        self.timeoutIntervalForRequest = timeoutIntervalForRequest
     }
 }
 

Sources/Confidence/Http/NetworkClient.swift

@@ -5,12 +5,14 @@ final class NetworkClient: HttpClient {
     private let retry: Retry
     private let session: URLSession
     private let baseUrl: String
+    private var timeoutIntervalForRequests: Double
 
     public init(
         session: URLSession? = nil,
         baseUrl: String,
         defaultHeaders: [String: String] = [:],
-        retry: Retry = .none
+        retry: Retry = .none,
+        timeoutIntervalForRequests: Double
     ) {
         self.session =
         session
@@ -24,6 +26,7 @@ final class NetworkClient: HttpClient {
         self.headers = defaultHeaders
         self.retry = retry
         self.baseUrl = baseUrl
+        self.timeoutIntervalForRequests = timeoutIntervalForRequests
     }
 
     public func post<T: Decodable>(

Sources/Confidence/RemoteConfidenceClient.swift

@@ -23,7 +23,11 @@ public class RemoteConfidenceClient: ConfidenceClient {
         case .usa:
             self.baseUrl = "https://events.us.confidence.dev/v1/events"
         }
-        self.httpClient = NetworkClient(session: session, baseUrl: baseUrl)
+        self.httpClient = NetworkClient(
+            session: session,
+            baseUrl: baseUrl,
+            timeoutIntervalForRequests: options.timeoutIntervalForRequest
+        )
         self.metadata = metadata
         self.debugLogger = debugLogger
     }

Sources/Confidence/RemoteResolveConfidenceClient.swift

@@ -19,7 +19,8 @@ class RemoteConfidenceResolveClient: ConfidenceResolveClient {
         self.metadata = metadata
         self.httpClient = NetworkClient(
             session: session,
-            baseUrl: BaseUrlMapper.from(region: options.region))
+            baseUrl: BaseUrlMapper.from(region: options.region),
+            timeoutIntervalForRequests: options.timeoutIntervalForRequest)
     }
 
     // MARK: Resolver
@@ -34,24 +35,24 @@ class RemoteConfidenceResolveClient: ConfidenceResolveClient {
         )
 
         do {
-            let result: HttpClientResult<ResolveFlagsResponse> =
-            try await self.httpClient.post(path: ":resolve", data: request)
-            switch result {
-            case .success(let successData):
-                guard successData.response.status == .ok else {
-                    throw successData.response.mapStatusToError(error: successData.decodedError)
+                    let result: HttpClientResult<ResolveFlagsResponse> =
+                    try await self.httpClient.post(path: ":resolve", data: request)
+                    switch result {
+                    case .success(let successData):
+                        guard successData.response.status == .ok else {
+                            throw successData.response.mapStatusToError(error: successData.decodedError)
+                        }
+                        guard let response = successData.decodedData else {
+                            throw ConfidenceError.parseError(message: "Unable to parse request response")
+                        }
+                        let resolvedValues = try response.resolvedFlags.map { resolvedFlag in
+                            try convert(resolvedFlag: resolvedFlag)
+                        }
+                        return ResolvesResult(resolvedValues: resolvedValues, resolveToken: response.resolveToken)
+                    case .failure(let errorData):
+                        throw handleError(error: errorData)
+                    }
                 }
-                guard let response = successData.decodedData else {
-                    throw ConfidenceError.parseError(message: "Unable to parse request response")
-                }
-                let resolvedValues = try response.resolvedFlags.map { resolvedFlag in
-                    try convert(resolvedFlag: resolvedFlag)
-                }
-                return ResolvesResult(resolvedValues: resolvedValues, resolveToken: response.resolveToken)
-            case .failure(let errorData):
-                throw handleError(error: errorData)
-            }
-        }
     }
 
     public func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {

Tests/ConfidenceTests/ConfidenceTest.swift

@@ -581,6 +581,45 @@ class ConfidenceTest: XCTestCase {
             XCTAssertEqual(error as? ConfidenceError, ConfidenceError.invalidContextInMessage)
         }
     }
+
+    func testRequestTimedOut() async throws {
+        class FakeClient: ConfidenceResolveClient {
+            var resolvedValues: [ResolvedValue] = []
+            func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {
+                try await Task.sleep(nanoseconds: 5000000000)
+                return .init(resolvedValues: resolvedValues, resolveToken: "token")
+            }
+        }
+
+        let client = FakeClient()
+        client.resolvedValues = [
+            ResolvedValue(
+                variant: "default",
+                value: .init(structure: ["size": .init(integer: 3)]),
+                flag: "flag",
+                resolveReason: .match)
+        ]
+
+        let confidence = Confidence.Builder(clientSecret: "test")
+            .withContext(initialContext: ["targeting_key": .init(string: "user2")])
+            .withFlagResolverClient(flagResolver: client)
+            .withFlagApplier(flagApplier: flagApplier)
+            .withTimeout(timeout: 1)
+            .build()
+
+        try await confidence.fetchAndActivate()
+        let evaluation = try confidence.getEvaluation(
+            key: "flag.size",
+            defaultValue: 0)
+
+        XCTAssertEqual(evaluation.value, 3)
+        XCTAssertNil(evaluation.errorCode)
+        XCTAssertNil(evaluation.errorMessage)
+        XCTAssertEqual(evaluation.reason, .match)
+        XCTAssertEqual(evaluation.variant, "default")
+        await fulfillment(of: [flagApplier.applyExpectation], timeout: 1)
+        XCTAssertEqual(flagApplier.applyCallCount, 1)
+    }
 }
 
 final class DispatchQueueFake: DispatchQueueType {