feat(feature-flags): support quota limiting for feature flags

CHANGELOG.md

@@ -1,5 +1,9 @@
 ## Next
 
+## 3.20.0 - 2025-02-25
+
+- feat: add support for quota-limited feature flags ([#308](https://github.com/PostHog/posthog-ios/pull/308))
+
 ## 3.19.7 - 2025-02-20
 
 - fix: recordings not always properly masked during screen transitions ([#306](https://github.com/PostHog/posthog-ios/pull/306))

PostHog/PostHogFeatureFlags.swift

@@ -55,10 +55,8 @@ class PostHogFeatureFlags {
         var recordingActive = true
 
         // check for boolean flags
-        if let linkedFlag = sessionRecording["linkedFlag"] as? String,
-           let value = featureFlags[linkedFlag] as? Bool
-        {
-            recordingActive = value
+        if let linkedFlag = sessionRecording["linkedFlag"] as? String {
+            recordingActive = featureFlags[linkedFlag] as? Bool ?? false
             // check for specific flag variant
         } else if let linkedFlag = sessionRecording["linkedFlag"] as? [String: Any],
                   let flag = linkedFlag["flag"] as? String,
@@ -94,6 +92,21 @@ class PostHogFeatureFlags {
                    groups: groups)
         { data, _ in
             self.dispatchQueue.async {
+                // Check for quota limitation first
+                if let quotaLimited = data?["quotaLimited"] as? [String],
+                   quotaLimited.contains("feature_flags")
+                {
+                    hedgeLog("Warning: Feature flags quota limit reached - clearing all feature flags and payloads.  See https://posthog.com/docs/billing/limits-alerts for more information.")
+                    self.featureFlagsLock.withLock {
+                        // Clear both feature flags and payloads
+                        self.setCachedFeatureFlags([:])
+                        self.setCachedFeatureFlagPayload([:])
+                    }
+
+                    self.notifyAndRelease()
+                    return callback()
+                }
+
                 guard let featureFlags = data?["featureFlags"] as? [String: Any],
                       let featureFlagPayloads = data?["featureFlagPayloads"] as? [String: Any]
                 else {

PostHogTests/PostHogFeatureFlagsTest.swift

@@ -138,6 +138,40 @@ class PostHogFeatureFlagsTest: QuickSpec {
             expect(sut.isFeatureEnabled("bool-value")) == true
         }
 
+        it("clears feature flags when quota limited") {
+            let sut = self.getSut()
+            let group = DispatchGroup()
+            group.enter()
+
+            // First load some feature flags normally
+            sut.loadFeatureFlags(distinctId: "distinctId", anonymousId: "anonymousId", groups: ["group": "value"], callback: {
+                group.leave()
+            })
+
+            group.wait()
+
+            // Verify flags are loaded
+            expect(sut.isFeatureEnabled("bool-value")) == true
+            expect(sut.getFeatureFlag("string-value") as? String) == "test"
+
+            // Now set the server to return quota limited response
+            server.quotaLimitFeatureFlags = true
+
+            let group2 = DispatchGroup()
+            group2.enter()
+
+            // Load flags again, this time with quota limiting
+            sut.loadFeatureFlags(distinctId: "distinctId", anonymousId: "anonymousId", groups: ["group": "value"], callback: {
+                group2.leave()
+            })
+
+            group2.wait()
+
+            // Verify flags are cleared
+            expect(sut.isFeatureEnabled("bool-value")) == false
+            expect(sut.getFeatureFlag("string-value")).to(beNil())
+        }
+
         #if os(iOS)
             it("returns isSessionReplayFlagActive true if there is a value") {
                 let storage = PostHogStorage(self.config)
@@ -318,6 +352,35 @@ class PostHogFeatureFlagsTest: QuickSpec {
 
                 storage.reset()
             }
+
+            it("returns isSessionReplayFlagActive false if bool linked flag is missing") {
+                let storage = PostHogStorage(self.config)
+
+                let sut = self.getSut(storage: storage)
+
+                expect(sut.isSessionReplayFlagActive()) == false
+
+                let group = DispatchGroup()
+                group.enter()
+
+                server.returnReplay = true
+                server.returnReplayWithVariant = true
+                server.replayVariantName = "some-missing-flag"
+                server.flagsSkipReplayVariantName = true
+//                server.replayVariantValue = false
+
+                sut.loadFeatureFlags(distinctId: "distinctId", anonymousId: "anonymousId", groups: ["group": "value"], callback: {
+                    group.leave()
+                })
+
+                group.wait()
+
+                expect(storage.getDictionary(forKey: .sessionReplay)) != nil
+                expect(self.config.snapshotEndpoint) == "/newS/"
+                expect(sut.isSessionReplayFlagActive()) == false
+
+                storage.reset()
+            }
         #endif
     }
 }

PostHogTests/TestUtils/MockPostHogServer.swift

@@ -40,18 +40,31 @@ class MockPostHogServer {
     public var returnReplayWithVariant = false
     public var returnReplayWithMultiVariant = false
     public var replayVariantName = "myBooleanRecordingFlag"
+    public var flagsSkipReplayVariantName = false
     public var replayVariantValue: Any = true
+    public var quotaLimitFeatureFlags: Bool = false
 
     init() {
         stub(condition: pathEndsWith("/decide")) { _ in
+            if self.quotaLimitFeatureFlags {
+                return HTTPStubsResponse(
+                    jsonObject: ["quotaLimited": ["feature_flags"]],
+                    statusCode: 200,
+                    headers: nil
+                )
+            }
+
             var flags = [
                 "bool-value": true,
                 "string-value": "test",
                 "disabled-flag": false,
                 "number-value": true,
-                "recording-platform-check": "web",
-                self.replayVariantName: self.replayVariantValue,
+                "recording-platform-check": "web"
             ]
+
+            if !self.flagsSkipReplayVariantName {
+                flags[self.replayVariantName] = self.replayVariantValue
+            }
 
             if self.errorsWhileComputingFlags {
                 flags["new-flag"] = true