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

* tests

* helper method

* bump version + changelog

Author: dmarticus

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.3.2
+
+* [Full Changelog](https://github.com/PostHog/posthog-go/compare/v1.3.1...v1.3.2)
+
 ## 1.3.1
 
 * [Full Changelog](https://github.com/PostHog/posthog-go/compare/v1.3.0...v1.3.1)

featureflags.go

@@ -106,6 +106,7 @@ type DecideRequestData struct {
 type DecideResponse struct {
 	FeatureFlags        map[string]interface{} `json:"featureFlags"`
 	FeatureFlagPayloads map[string]string      `json:"featureFlagPayloads"`
+	QuotaLimited        *[]string              `json:"quota_limited"`
 }
 
 type InconclusiveMatchError struct {
@@ -175,14 +176,28 @@ func (poller *FeatureFlagsPoller) fetchNewFeatureFlags() {
 	headers := [][2]string{{"Authorization", "Bearer " + personalApiKey + ""}}
 	res, cancel, err := poller.localEvaluationFlags(headers)
 	defer cancel()
-	if err != nil || res.StatusCode != http.StatusOK {
-		if err != nil {
-			poller.Errorf("Unable to fetch feature flags: %s", err)
-		} else {
-			poller.Errorf("Unable to fetch feature flags, status: %s", res.Status)
-		}
+	if err != nil {
+		poller.Errorf("Unable to fetch feature flags: %s", err)
 		return
 	}
+
+	// Handle quota limit response (HTTP 402)
+	if res.StatusCode == http.StatusPaymentRequired {
+		// Clear existing flags when quota limited
+		poller.mutex.Lock()
+		poller.featureFlags = []FeatureFlag{}
+		poller.cohorts = map[string]PropertyGroup{}
+		poller.groups = map[string]string{}
+		poller.mutex.Unlock()
+		poller.Errorf("[FEATURE FLAGS] PostHog feature flags quota limited, resetting feature flag data. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts")
+		return
+	}
+
+	if res.StatusCode != http.StatusOK {
+		poller.Errorf("Unable to fetch feature flags, status: %s", res.Status)
+		return
+	}
+
 	defer res.Body.Close()
 	resBody, err := ioutil.ReadAll(res.Body)
 	if err != nil {

posthog.go

@@ -723,13 +723,30 @@ func (c *client) makeRemoteConfigRequest(flagKey string) (string, error) {
 	}
 	return responseData, nil
 }
-	
+
+// isFeatureFlagsQuotaLimited checks if feature flags are quota limited in the decide response
+func (c *client) isFeatureFlagsQuotaLimited(decideResponse *DecideResponse) bool {
+	if decideResponse.QuotaLimited != nil {
+		for _, limitedFeature := range *decideResponse.QuotaLimited {
+			if limitedFeature == "feature_flags" {
+				c.Errorf("[FEATURE FLAGS] PostHog feature flags quota limited. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts")
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func (c *client) getFeatureFlagFromDecide(key string, distinctId string, groups Groups, personProperties Properties, groupProperties map[string]Properties) (interface{}, error) {
 	decideResponse, err := c.makeDecideRequest(distinctId, groups, personProperties, groupProperties)
 	if err != nil {
 		return nil, err
 	}
 
+	if c.isFeatureFlagsQuotaLimited(decideResponse) {
+		return false, nil
+	}
+
 	if value, ok := decideResponse.FeatureFlags[key]; ok {
 		return value, nil
 	}
@@ -743,6 +760,10 @@ func (c *client) getFeatureFlagPayloadFromDecide(key string, distinctId string,
 		return "", err
 	}
 
+	if c.isFeatureFlagsQuotaLimited(decideResponse) {
+		return "", nil
+	}
+
 	if value, ok := decideResponse.FeatureFlagPayloads[key]; ok {
 		return value, nil
 	}
@@ -756,5 +777,9 @@ func (c *client) getAllFeatureFlagsFromDecide(distinctId string, groups Groups,
 		return nil, err
 	}
 
+	if c.isFeatureFlagsQuotaLimited(decideResponse) {
+		return map[string]interface{}{}, nil
+	}
+
 	return decideResponse.FeatureFlags, nil
 }

posthog_test.go

@@ -256,57 +256,6 @@ func TestCaptureNoProperties(t *testing.T) {
 	})
 }
 
-func ExampleHistoricalMigrationCapture() {
-	body, server := mockServer()
-	defer server.Close()
-
-	client, _ := NewWithConfig("Csyjlnlun3OzyNJAafdlv", Config{
-		Endpoint:            server.URL,
-		BatchSize:           1,
-		now:                 mockTime,
-		HistoricalMigration: true,
-	})
-	defer client.Close()
-
-	client.Enqueue(Capture{
-		Event:      "Download",
-		DistinctId: "123456",
-		Properties: Properties{
-			"application": "PostHog Go",
-			"version":     "1.0.0",
-			"platform":    "macos", // :)
-		},
-		SendFeatureFlags: false,
-	})
-
-	fmt.Printf("%s\n", <-body)
-	// Output:
-	// {
-	//   "api_key": "Csyjlnlun3OzyNJAafdlv",
-	//   "batch": [
-	//     {
-	//       "distinct_id": "123456",
-	//       "event": "Download",
-	//       "library": "posthog-go",
-	//       "library_version": "1.0.0",
-	//       "properties": {
-	//         "$lib": "posthog-go",
-	//         "$lib_version": "1.0.0",
-	//         "application": "PostHog Go",
-	//         "platform": "macos",
-	//         "version": "1.0.0"
-	//       },
-	//       "send_feature_flags": false,
-	//       "timestamp": "2009-11-10T23:00:00Z",
-	//       "type": "capture",
-	//       "uuid": ""
-	//     }
-	//   ],
-	//   "historical_migration": true
-	// }
-
-}
-
 func TestEnqueue(t *testing.T) {
 	tests := map[string]struct {
 		ref string
@@ -1780,3 +1729,121 @@ func TestCaptureSendFlags(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestFeatureFlagQuotaLimits(t *testing.T) {
+	t.Run("decide endpoint quota limited", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if strings.HasPrefix(r.URL.Path, "/decide") {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte(`{
+					"featureFlags": {"test-flag": true},
+					"featureFlagPayloads": {"test-flag": "test-payload"},
+					"quota_limited": ["feature_flags"]
+				}`))
+			}
+		}))
+		defer server.Close()
+
+		client, _ := NewWithConfig("test-api-key", Config{
+			Endpoint: server.URL,
+		})
+		defer client.Close()
+
+		// Test GetFeatureFlag
+		value, err := client.GetFeatureFlag(FeatureFlagPayload{
+			Key:        "test-flag",
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if value != false {
+			t.Error("Expected false when quota limited, got", value)
+		}
+
+		// Test GetFeatureFlagPayload
+		payload, err := client.GetFeatureFlagPayload(FeatureFlagPayload{
+			Key:        "test-flag",
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if payload != "" {
+			t.Error("Expected empty string when quota limited, got", payload)
+		}
+
+		// Test GetAllFlags
+		flags, err := client.GetAllFlags(FeatureFlagPayloadNoKey{
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if len(flags) != 0 {
+			t.Error("Expected empty map when quota limited, got", flags)
+		}
+	})
+
+	t.Run("local evaluation endpoint quota limited", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if strings.HasPrefix(r.URL.Path, "/api/feature_flag/local_evaluation") {
+				w.WriteHeader(http.StatusPaymentRequired)
+				w.Write([]byte(`{
+					"type": "quota_limited",
+					"detail": "You have exceeded your feature flag request quota",
+					"code": "payment_required"
+				}`))
+			} else if strings.HasPrefix(r.URL.Path, "/decide") {
+				// Mock the decide endpoint as well since it's used as fallback
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte(`{
+					"featureFlags": {},
+					"featureFlagPayloads": {}
+				}`))
+			}
+		}))
+		defer server.Close()
+
+		client, _ := NewWithConfig("test-api-key", Config{
+			PersonalApiKey: "test-personal-key",
+			Endpoint:       server.URL,
+		})
+		defer client.Close()
+
+		// Test GetFeatureFlag
+		value, err := client.GetFeatureFlag(FeatureFlagPayload{
+			Key:        "test-flag",
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if value != false {
+			t.Error("Expected false when quota limited, got", value)
+		}
+
+		// Test GetFeatureFlagPayload
+		payload, err := client.GetFeatureFlagPayload(FeatureFlagPayload{
+			Key:        "test-flag",
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if payload != "" {
+			t.Error("Expected empty string when quota limited, got", payload)
+		}
+
+		// Test GetAllFlags
+		flags, err := client.GetAllFlags(FeatureFlagPayloadNoKey{
+			DistinctId: "user123",
+		})
+		if err != nil {
+			t.Error("Expected no error, got", err)
+		}
+		if len(flags) != 0 {
+			t.Error("Expected empty map when quota limited, got", flags)
+		}
+	})
+}

version.go

@@ -3,7 +3,7 @@ package posthog
 import "flag"
 
 // Version of the client.
-const Version = "1.3.1"
+const Version = "1.3.2"
 
 // make tests easier by using a constant version
 func getVersion() string {