Provider events

Sources/OpenFeature/Client.swift

@@ -11,4 +11,15 @@ public protocol Client: Features {
     /// Hooks are run in the order they're added in the before stage. They are run in reverse order for all
     /// other stages.
     func addHooks(_ hooks: any Hook...)
+
+    /// Add a handler for a particular provider event
+    ///  - Parameter observer: The object observing the event.
+    ///  - Parameter selector: The selector to call for this event.
+    ///  - Parameter event: The event to listen for.
+    func addHandler(observer: Any, selector: Selector, event: ProviderEvent)
+
+    /// Remove a handler for a particular provider event
+    ///  - Parameter observer: The object observing the event.
+    ///  - Parameter event: The event being listened to.
+    func removeHandler(observer: Any, event: ProviderEvent)
 }

Sources/OpenFeature/OpenFeatureAPI.swift

@@ -7,22 +7,25 @@ public class OpenFeatureAPI {
     private var _context: EvaluationContext?
     private(set) var hooks: [any Hook] = []
 
+    private let providerNotificationCentre = NotificationCenter()
+
     /// The ``OpenFeatureAPI`` singleton
     static public let shared = OpenFeatureAPI()
 
     public init() {
     }
 
-    public func setProvider(provider: FeatureProvider) async {
-        await self.setProvider(provider: provider, initialContext: nil)
+    public func setProvider(provider: FeatureProvider) {
+        self.setProvider(provider: provider, initialContext: nil)
     }
 
-    public func setProvider(provider: FeatureProvider, initialContext: EvaluationContext?) async {
+    public func setProvider(provider: FeatureProvider, initialContext: EvaluationContext?) {
         self._provider = provider
         if let context = initialContext {
             self._context = context
         }
-        await provider.initialize(initialContext: self._context)
+
+        provider.initialize(initialContext: self._context)
     }
 
     public func getProvider() -> FeatureProvider? {
@@ -33,9 +36,10 @@ public class OpenFeatureAPI {
         self._provider = nil
     }
 
-    public func setEvaluationContext(evaluationContext: EvaluationContext) async {
+    public func setEvaluationContext(evaluationContext: EvaluationContext) {
+        let oldContext = self._context
         self._context = evaluationContext
-        await getProvider()?.onContextSet(oldContext: self._context, newContext: evaluationContext)
+        getProvider()?.onContextSet(oldContext: oldContext, newContext: evaluationContext)
     }
 
     public func getEvaluationContext() -> EvaluationContext? {
@@ -62,3 +66,40 @@ public class OpenFeatureAPI {
         self.hooks.removeAll()
     }
 }
+
+// MARK: Provider Events
+
+extension OpenFeatureAPI {
+    public func addHandler(observer: Any, selector: Selector, event: ProviderEvent) {
+        providerNotificationCentre.addObserver(
+            observer,
+            selector: selector,
+            name: event.notification,
+            object: nil
+        )
+    }
+
+    public func removeHandler(observer: Any, event: ProviderEvent) {
+        providerNotificationCentre.removeObserver(observer, name: event.notification, object: nil)
+    }
+
+    public func emitEvent(
+        _ event: ProviderEvent,
+        provider: FeatureProvider,
+        error: Error? = nil,
+        details: [AnyHashable: Any]? = nil
+    ) {
+        var userInfo: [AnyHashable: Any] = [:]
+        userInfo[providerEventDetailsKeyProvider] = provider
+
+        if let error {
+            userInfo[providerEventDetailsKeyError] = error
+        }
+
+        if let details {
+            userInfo.merge(details) { $1 } // Merge, keeping value from `details` if any conflicts
+        }
+
+        providerNotificationCentre.post(name: event.notification, object: nil, userInfo: userInfo)
+    }
+}

Sources/OpenFeature/OpenFeatureClient.swift

@@ -14,11 +14,15 @@ public class OpenFeatureClient: Client {
     private var hookSupport = HookSupport()
     private var logger = Logger()
 
+    private let providerNotificationCentre = NotificationCenter()
+
     public init(openFeatureApi: OpenFeatureAPI, name: String?, version: String?) {
         self.openFeatureApi = openFeatureApi
         self.name = name
         self.version = version
         self.metadata = Metadata(name: name)
+
+        subscribeToAllProviderEvents()
     }
 
     public func addHooks(_ hooks: any Hook...) {
@@ -196,3 +200,42 @@ extension OpenFeatureClient {
         throw OpenFeatureError.generalError(message: "Unable to match default value type with flag value type")
     }
 }
+
+// MARK: Events
+
+extension OpenFeatureClient {
+    public func subscribeToAllProviderEvents() {
+        ProviderEvent.allCases.forEach { event in
+            OpenFeatureAPI.shared.addHandler(
+                observer: self,
+                selector: #selector(handleProviderEvent(notification:)),
+                event: event)
+        }
+    }
+
+    public func unsubscribeFromAllProviderEvents() {
+        ProviderEvent.allCases.forEach { event in
+            OpenFeatureAPI.shared.removeHandler(observer: self, event: event)
+        }
+    }
+
+    @objc public func handleProviderEvent(notification: Notification) {
+        var userInfo: [AnyHashable: Any] = notification.userInfo ?? [:]
+        userInfo[providerEventDetailsKeyClient] = self
+
+        providerNotificationCentre.post(name: notification.name, object: nil, userInfo: userInfo)
+    }
+
+    public func addHandler(observer: Any, selector: Selector, event: ProviderEvent) {
+        providerNotificationCentre.addObserver(
+            observer,
+            selector: selector,
+            name: event.notification,
+            object: nil
+        )
+    }
+
+    public func removeHandler(observer: Any, event: ProviderEvent) {
+        providerNotificationCentre.removeObserver(observer, name: event.notification, object: nil)
+    }
+}

Sources/OpenFeature/FeatureProvider.swift → Sources/OpenFeature/Provider/FeatureProvider.swift

@@ -6,10 +6,10 @@ public protocol FeatureProvider {
     var metadata: ProviderMetadata { get }
 
     /// Called by OpenFeatureAPI whenever the new Provider is registered
-    func initialize(initialContext: EvaluationContext?) async
+    func initialize(initialContext: EvaluationContext?)
 
     /// Called by OpenFeatureAPI whenever a new EvaluationContext is set by the application
-    func onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext) async
+    func onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext)
 
     func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws
         -> ProviderEvaluation<

Sources/OpenFeature/NoOpProvider.swift → Sources/OpenFeature/Provider/NoOpProvider.swift

@@ -4,15 +4,20 @@ import Foundation
 class NoOpProvider: FeatureProvider {
     public static let passedInDefault = "Passed in default"
 
+    public enum Mode {
+        case normal
+        case error(message: String)
+    }
+
     var metadata: ProviderMetadata = NoOpMetadata(name: "No-op provider")
     var hooks: [any Hook] = []
 
     func onContextSet(oldContext: EvaluationContext?, newContext: EvaluationContext) {
-        // no-op
+        OpenFeatureAPI.shared.emitEvent(.configurationChanged, provider: self)
     }
 
     func initialize(initialContext: EvaluationContext?) {
-        // no-op
+        OpenFeatureAPI.shared.emitEvent(.ready, provider: self)
     }
 
     func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws

Sources/OpenFeature/Provider/ProviderEvents.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+public let providerEventDetailsKeyProvider = "Provider"
+public let providerEventDetailsKeyClient = "Client"
+public let providerEventDetailsKeyError = "Error"
+
+public enum ProviderEvent: String, CaseIterable {
+    case ready = "PROVIDER_READY"
+    case error = "PROVIDER_ERROR"
+    case configurationChanged = "PROVIDER_CONFIGURATION_CHANGED"
+    case stale = "PROVIDER_STALE"
+
+    var notification: NSNotification.Name {
+        NSNotification.Name(rawValue)
+    }
+}

Tests/OpenFeatureTests/DeveloperExperienceTests.swift

@@ -11,16 +11,16 @@ final class DeveloperExperienceTests: XCTestCase {
         XCTAssertEqual(flagValue, "no-op")
     }
 
-    func testSimpleBooleanFlag() async {
-        await OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
+    func testSimpleBooleanFlag() {
+        OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
         let client = OpenFeatureAPI.shared.getClient()
 
         let flagValue = client.getValue(key: "test", defaultValue: false)
         XCTAssertFalse(flagValue)
     }
 
-    func testClientHooks() async {
-        await OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
+    func testClientHooks() {
+        OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
         let client = OpenFeatureAPI.shared.getClient()
 
         let booleanHook = BooleanHookMock()
@@ -40,8 +40,8 @@ final class DeveloperExperienceTests: XCTestCase {
         XCTAssertEqual(intHook.finallyAfterCalled, 1)
     }
 
-    func testEvalHooks() async {
-        await OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
+    func testEvalHooks() {
+        OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
         let client = OpenFeatureAPI.shared.getClient()
 
         let booleanHook = BooleanHookMock()
@@ -61,8 +61,8 @@ final class DeveloperExperienceTests: XCTestCase {
         XCTAssertEqual(intHook.finallyAfterCalled, 1)
     }
 
-    func testBrokenProvider() async {
-        await OpenFeatureAPI.shared.setProvider(provider: AlwaysBrokenProvider())
+    func testBrokenProvider() {
+        OpenFeatureAPI.shared.setProvider(provider: AlwaysBrokenProvider())
         let client = OpenFeatureAPI.shared.getClient()
 
         let details = client.getDetails(key: "test", defaultValue: false)

Tests/OpenFeatureTests/FlagEvaluationTests.swift

@@ -4,19 +4,31 @@ import XCTest
 @testable import OpenFeature
 
 final class FlagEvaluationTests: XCTestCase {
+    override func setUp() {
+        super.setUp()
+
+        OpenFeatureAPI.shared.addHandler(
+            observer: self, selector: #selector(readyEventEmitted(notification:)), event: .ready
+        )
+
+        OpenFeatureAPI.shared.addHandler(
+            observer: self, selector: #selector(errorEventEmitted(notification:)), event: .error
+        )
+    }
+
     func testSingletonPersists() {
         XCTAssertTrue(OpenFeatureAPI.shared === OpenFeatureAPI.shared)
     }
 
-    func testApiSetsProvider() async {
+    func testApiSetsProvider() {
         let provider = NoOpProvider()
-        await OpenFeatureAPI.shared.setProvider(provider: provider)
+        OpenFeatureAPI.shared.setProvider(provider: provider)
 
         XCTAssertTrue((OpenFeatureAPI.shared.getProvider() as? NoOpProvider) === provider)
     }
 
-    func testProviderMetadata() async {
-        await OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
+    func testProviderMetadata() {
+        OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
 
         XCTAssertEqual(OpenFeatureAPI.shared.getProviderMetadata()?.name, DoSomethingProvider.name)
     }
@@ -51,8 +63,10 @@ final class FlagEvaluationTests: XCTestCase {
         XCTAssertEqual(client.hooks.count, 2)
     }
 
-    func testSimpleFlagEvaluation() async {
-        await OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
+    func testSimpleFlagEvaluation() {
+        OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
+        wait(for: [readyExpectation], timeout: 5)
+
         let client = OpenFeatureAPI.shared.getClient()
         let key = "key"
 
@@ -89,7 +103,9 @@ final class FlagEvaluationTests: XCTestCase {
     }
 
     func testDetailedFlagEvaluation() async {
-        await OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
+        OpenFeatureAPI.shared.setProvider(provider: DoSomethingProvider())
+        wait(for: [readyExpectation], timeout: 5)
+
         let client = OpenFeatureAPI.shared.getClient()
         let key = "key"
 
@@ -132,7 +148,9 @@ final class FlagEvaluationTests: XCTestCase {
     }
 
     func testHooksAreFired() async {
-        await OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
+        OpenFeatureAPI.shared.setProvider(provider: NoOpProvider())
+        wait(for: [readyExpectation], timeout: 5)
+
         let client = OpenFeatureAPI.shared.getClient()
 
         let clientHook = BooleanHookMock()
@@ -148,8 +166,10 @@ final class FlagEvaluationTests: XCTestCase {
         XCTAssertEqual(invocationHook.beforeCalled, 1)
     }
 
-    func testBrokenProvider() async {
-        await OpenFeatureAPI.shared.setProvider(provider: AlwaysBrokenProvider())
+    func testBrokenProvider() {
+        OpenFeatureAPI.shared.setProvider(provider: AlwaysBrokenProvider())
+        wait(for: [errorExpectation], timeout: 5)
+
         let client = OpenFeatureAPI.shared.getClient()
 
         XCTAssertFalse(client.getValue(key: "testkey", defaultValue: false))
@@ -167,4 +187,17 @@ final class FlagEvaluationTests: XCTestCase {
         let client = OpenFeatureAPI.shared.getClient(name: "test", version: nil)
         XCTAssertEqual(client.metadata.name, "test")
     }
+
+    // MARK: Event Handlers
+    let readyExpectation = XCTestExpectation(description: "Ready")
+
+    func readyEventEmitted(notification: NSNotification) {
+        readyExpectation.fulfill()
+    }
+
+    let errorExpectation = XCTestExpectation(description: "Error")
+
+    func errorEventEmitted(notification: NSNotification) {
+        errorExpectation.fulfill()
+    }
 }

Tests/OpenFeatureTests/Helpers/AlwaysBrokenProvider.swift

@@ -7,11 +7,13 @@ class AlwaysBrokenProvider: FeatureProvider {
     var hooks: [any Hook] = []
 
     func onContextSet(oldContext: OpenFeature.EvaluationContext?, newContext: OpenFeature.EvaluationContext) {
-        // no-op
+        let error = OpenFeatureError.generalError(message: "Always Fails")
+        OpenFeatureAPI.shared.emitEvent(.error, provider: self, error: error)
     }
 
     func initialize(initialContext: OpenFeature.EvaluationContext?) {
-        // no-op
+        let error = OpenFeatureError.generalError(message: "Always Fails")
+        OpenFeatureAPI.shared.emitEvent(.error, provider: self, error: error)
     }
 
     func getBooleanEvaluation(key: String, defaultValue: Bool, context: EvaluationContext?) throws

Tests/OpenFeatureTests/Helpers/DoSomethingProvider.swift

@@ -5,11 +5,11 @@ class DoSomethingProvider: FeatureProvider {
     public static let name = "Something"
 
     func onContextSet(oldContext: OpenFeature.EvaluationContext?, newContext: OpenFeature.EvaluationContext) {
-        // no-op
+        OpenFeatureAPI.shared.emitEvent(.configurationChanged, provider: self)
     }
 
     func initialize(initialContext: OpenFeature.EvaluationContext?) {
-        // no-op
+        OpenFeatureAPI.shared.emitEvent(.ready, provider: self)
     }
 
     var hooks: [any OpenFeature.Hook] = []