feat: GOFF Specificity

.swiftlint.yml

@@ -72,4 +72,5 @@ identifier_name:
     - GlobalAPIKey
     - key
     - dto
+    - ctx
 reporter: "xcode" # reporter type (xcode, json, csv, checkstyle, codeclimate, junit, html, emoji, sonarqube, markdown, github-actions-logging, summary)

Package.resolved

@@ -6,8 +6,8 @@
         "repositoryURL": "https://github.com/open-feature/swift-sdk.git",
         "state": {
           "branch": null,
-          "revision": "02b033c954766e86d5706bfc8ee5248244c11e77",
-          "version": "0.1.0"
+          "revision": "907567cf9d43aad4c015a8758a7d53d755e76213",
+          "version": "0.2.0"
         }
       }
     ]

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
             targets: ["OFREP"])
     ],
     dependencies: [
-        .package(url: "https://github.com/open-feature/swift-sdk.git", from: "0.1.0")
+        .package(url: "https://github.com/open-feature/swift-sdk.git", from: "0.2.0")
     ],
     targets: [
         .target(

Sources/GOFeatureFlag/controller/data_collector_manager.swift

@@ -0,0 +1,58 @@
+import Foundation
+import OpenFeature
+import Combine
+
+class DataCollectorManager {
+    var events: [FeatureEvent] = []
+    var hooks: [any Hook] = []
+    let queue = DispatchQueue(label: "org.gofeatureflag.feature.events", attributes: .concurrent)
+    let goffAPI: GoFeatureFlagAPI
+    let options: GoFeatureFlagProviderOptions
+    private var timer: DispatchSourceTimer?
+
+    init(goffAPI: GoFeatureFlagAPI, options: GoFeatureFlagProviderOptions) {
+        self.goffAPI = goffAPI
+        self.options = options
+    }
+
+    func start() {
+        timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global())
+        timer?.schedule(deadline: .now(), repeating: self.options.dataCollectorInterval, leeway: .milliseconds(100))
+        timer?.setEventHandler { [weak self] in
+            guard let weakSelf = self else { return }
+            Task {
+                await weakSelf.pushEvents()
+            }
+        }
+        timer?.resume()
+    }
+
+    func appendFeatureEvent(event: FeatureEvent) {
+        self.queue.async(flags:.barrier) {
+            self.events.append(event)
+        }
+    }
+
+    func pushEvents() async {
+        self.queue.async(flags:.barrier) {
+            Task {
+                do {
+                    if !self.events.isEmpty {
+                        (_,_) = try await self.goffAPI.postDataCollector(events: self.events)
+                        self.events = []
+                    }
+                } catch {
+                    NSLog("data collector error: \(error)")
+                }
+            }
+        }
+    }
+
+    func getHooks() -> [any Hook] {
+        return self.hooks
+    }
+
+    func stop() async {
+        await self.pushEvents()
+    }
+}

Sources/GOFeatureFlag/controller/goff_api.swift

@@ -0,0 +1,65 @@
+import Foundation
+import OpenFeature
+import OFREP
+
+class GoFeatureFlagAPI {
+    private let networkingService: NetworkingService
+    private let options: GoFeatureFlagProviderOptions
+    private let metadata: [String:String] = ["provider": "openfeature-swift"]
+
+    init(networkingService: NetworkingService, options: GoFeatureFlagProviderOptions) {
+        self.networkingService = networkingService
+        self.options = options
+    }
+
+    func postDataCollector(events: [FeatureEvent]?) async throws -> (DataCollectorResponse, HTTPURLResponse) {
+        guard let events = events else {
+            throw GoFeatureFlagError.noEventToSend
+        }
+        if events.isEmpty {
+            throw GoFeatureFlagError.noEventToSend
+        }
+
+        guard let url = URL(string: options.endpoint) else {
+            throw InvalidOptions.invalidEndpoint(message: "endpoint [" + options.endpoint + "] is not valid")
+        }
+
+        let dataCollectorURL = url.appendingPathComponent("v1/data/collector")
+        var request = URLRequest(url: dataCollectorURL)
+        request.httpMethod = "POST"
+
+        let requestBody = DataCollectorRequest(meta: metadata, events: events)
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .prettyPrinted
+        request.httpBody = try encoder.encode(requestBody)
+        request.setValue(
+            "application/json",
+            forHTTPHeaderField: "Content-Type"
+        )
+        if let apiKey = self.options.apiKey {
+            request.setValue("Bearer \(apiKey)", forHTTPHeaderField:"Authorization")
+        }
+
+        let (data, response) = try await networkingService.doRequest(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw GoFeatureFlagError.httpResponseCastError
+        }
+
+        if httpResponse.statusCode == 401 {
+            throw GoFeatureFlagError.apiUnauthorizedError(response: httpResponse)
+        }
+        if httpResponse.statusCode == 403 {
+            throw GoFeatureFlagError.forbiddenError(response: httpResponse)
+        }
+        if httpResponse.statusCode >= 400 {
+            throw GoFeatureFlagError.unexpectedResponseError(response: httpResponse)
+        }
+
+        do {
+            let response = try JSONDecoder().decode(DataCollectorResponse.self, from: data)
+            return (response, httpResponse)
+        } catch {
+            throw GoFeatureFlagError.unmarshallError(error: error)
+        }
+    }
+}

Sources/GOFeatureFlag/exception/goff_errors.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+enum GoFeatureFlagError: Error, Equatable {
+    static func == (left: GoFeatureFlagError, right: GoFeatureFlagError) -> Bool {
+        return type(of: left) == type(of: right)
+    }
+
+    case httpResponseCastError
+    case noEventToSend
+    case unmarshallError(error: Error)
+    case apiUnauthorizedError(response: HTTPURLResponse)
+    case forbiddenError(response: HTTPURLResponse)
+    case unexpectedResponseError(response: HTTPURLResponse)
+}

Sources/GOFeatureFlag/hook/data_collector_bool_hook.swift

@@ -0,0 +1,72 @@
+import Foundation
+import OpenFeature
+import OFREP
+
+class BooleanHook: Hook {
+    typealias HookValue = Bool
+    let dataCollectorMngr: DataCollectorManager
+
+    init(dataCollectorMngr: DataCollectorManager) {
+        self.dataCollectorMngr = dataCollectorMngr
+    }
+
+    func before<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+
+    func after<HookValue>(
+        ctx: HookContext<HookValue>,
+        details: FlagEvaluationDetails<HookValue>,
+        hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+        guard let value = details.value as? Bool else {
+            NSLog("Default value is not of type Bool")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: details.variant ?? "SdkDefault",
+            value: JSONValue.bool(value),
+            default: false,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func error<HookValue>(
+        ctx: HookContext<HookValue>,
+        error: Error,
+        hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+        guard let value = ctx.defaultValue as? Bool else {
+            NSLog("Default value is not of type Bool")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: "SdkDefault",
+            value: JSONValue.bool(value),
+            default: true,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func finallyAfter<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+}

Sources/GOFeatureFlag/hook/data_collector_double_hook.swift

@@ -0,0 +1,73 @@
+import Foundation
+import OpenFeature
+import OFREP
+
+class DoubleHook: Hook {
+    typealias HookValue = Double
+    let dataCollectorMngr: DataCollectorManager
+
+    init(dataCollectorMngr: DataCollectorManager) {
+        self.dataCollectorMngr = dataCollectorMngr
+    }
+
+    func before<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+
+    func after<HookValue>(
+        ctx: HookContext<HookValue>,
+        details: FlagEvaluationDetails<HookValue>,
+        hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+        guard let value = details.value as? Double else {
+            NSLog("Default value is not of type Double")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: details.variant ?? "SdkDefault",
+            value: JSONValue.double(value),
+            default: false,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func error<HookValue>(
+        ctx: HookContext<HookValue>,
+        error: Error,
+        hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+
+        guard let value = ctx.defaultValue as? Double else {
+            NSLog("Default value is not of type Double")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: "SdkDefault",
+            value: JSONValue.double(value),
+            default: true,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func finallyAfter<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+}

Sources/GOFeatureFlag/hook/data_collector_integer_hook.swift

@@ -0,0 +1,69 @@
+import Foundation
+import OpenFeature
+import OFREP
+
+class IntegerHook: Hook {
+    typealias HookValue = Int64
+    let dataCollectorMngr: DataCollectorManager
+
+    init(dataCollectorMngr: DataCollectorManager) {
+        self.dataCollectorMngr = dataCollectorMngr
+    }
+
+    func before<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+
+    func after<HookValue>(
+        ctx: HookContext<HookValue>,
+        details: FlagEvaluationDetails<HookValue>,
+        hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+        guard let value = details.value as? Int64 else {
+            NSLog("Default value is not of type Integer")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: details.variant ?? "SdkDefault",
+            value: JSONValue.integer(value),
+            default: false,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func error<HookValue>(ctx: HookContext<HookValue>, error: Error, hints: [String: Any]) {
+        let contextKind = "user"
+        let userKey = ctx.ctx?.getTargetingKey() ?? ""
+        let key = ctx.flagKey
+        guard let value = ctx.defaultValue as? Int64 else {
+            NSLog("Default value is not of type Integer")
+            return
+        }
+
+        let event = FeatureEvent(
+            kind: "feature",
+            contextKind: contextKind,
+            userKey: userKey,
+            creationDate: Int64(Date().timeIntervalSince1970),
+            key: key,
+            variation: "SdkDefault",
+            value: JSONValue.integer(value),
+            default: true,
+            source: "PROVIDER_CACHE"
+        )
+        self.dataCollectorMngr.appendFeatureEvent(event: event)
+    }
+
+    func finallyAfter<HookValue>(ctx: HookContext<HookValue>, hints: [String: Any]) {
+        return
+    }
+}