Add specific error types for feature flag request failures

Replace generic "request_error" with specific error types:
- quota_limited: Rate/quota limit exceeded (QuotaLimitError)
- timeout: Request timed out (requests.exceptions.Timeout)
- connection_error: Network connectivity issue (requests.exceptions.ConnectionError)
- api_error_{status}: Server error with HTTP status code (APIError)
- unknown_error: Unexpected exceptions

Author: haacked

posthog/client.py

@@ -36,12 +36,14 @@
 from posthog.request import (
     DEFAULT_HOST,
     APIError,
+    QuotaLimitError,
     batch_post,
     determine_server_host,
     flags,
     get,
     remote_config,
 )
+import requests.exceptions
 from posthog.contexts import (
     _get_current_context,
     get_context_distinct_id,
@@ -1592,10 +1594,23 @@ def _get_feature_flag_result(
                 self.log.debug(
                     f"Successfully computed flag remotely: #{key} -> #{flag_result}"
                 )
+            except QuotaLimitError as e:
+                self.log.exception(f"[FEATURE FLAGS] Quota limit exceeded: {e}")
+                feature_flag_error = "quota_limited"
+            except requests.exceptions.Timeout as e:
+                self.log.exception(f"[FEATURE FLAGS] Request timed out: {e}")
+                feature_flag_error = "timeout"
+            except requests.exceptions.ConnectionError as e:
+                self.log.exception(f"[FEATURE FLAGS] Connection error: {e}")
+                feature_flag_error = "connection_error"
+            except APIError as e:
+                self.log.exception(f"[FEATURE FLAGS] API error: {e}")
+                feature_flag_error = f"api_error_{e.status}"
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get flag remotely: {e}")
-                feature_flag_error = "request_error"
+                feature_flag_error = "unknown_error"
 
+            if feature_flag_error:
                 # Fallback to cached value if remote evaluation fails
                 if self.flag_cache:
                     stale_result = self.flag_cache.get_stale_cached_flag(

posthog/test/test_feature_flag_result.py

@@ -533,14 +533,109 @@ def test_get_feature_flag_result_flag_not_in_response(
 
     @mock.patch("posthog.client.flags")
     @mock.patch.object(Client, "capture")
-    def test_get_feature_flag_result_request_error(self, patch_capture, patch_flags):
-        """Test that when the /flags call throws an exception, we capture it in the event.
+    def test_get_feature_flag_result_unknown_error(self, patch_capture, patch_flags):
+        """Test that unexpected exceptions are captured as unknown_error."""
+        patch_flags.side_effect = Exception("Unexpected error")
 
-        This simulates what likely happened in production: the remote evaluation failed
-        (network error, timeout, etc.), so request_id is never set, and we capture the
-        $feature_flag_called event with a null response, no request_id, and an error.
-        """
-        patch_flags.side_effect = Exception("Network timeout")
+        flag_result = self.client.get_feature_flag_result("my-flag", "some-distinct-id")
+
+        self.assertIsNone(flag_result)
+        patch_capture.assert_called_with(
+            "$feature_flag_called",
+            distinct_id="some-distinct-id",
+            properties={
+                "$feature_flag": "my-flag",
+                "$feature_flag_response": None,
+                "locally_evaluated": False,
+                "$feature/my-flag": None,
+                "$feature_flag_error": "unknown_error",
+            },
+            groups={},
+            disable_geoip=None,
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_get_feature_flag_result_timeout_error(self, patch_capture, patch_flags):
+        """Test that timeout errors are captured specifically."""
+        import requests.exceptions
+
+        patch_flags.side_effect = requests.exceptions.Timeout("Request timed out")
+
+        flag_result = self.client.get_feature_flag_result("my-flag", "some-distinct-id")
+
+        self.assertIsNone(flag_result)
+        patch_capture.assert_called_with(
+            "$feature_flag_called",
+            distinct_id="some-distinct-id",
+            properties={
+                "$feature_flag": "my-flag",
+                "$feature_flag_response": None,
+                "locally_evaluated": False,
+                "$feature/my-flag": None,
+                "$feature_flag_error": "timeout",
+            },
+            groups={},
+            disable_geoip=None,
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_get_feature_flag_result_connection_error(self, patch_capture, patch_flags):
+        """Test that connection errors are captured specifically."""
+        import requests.exceptions
+
+        patch_flags.side_effect = requests.exceptions.ConnectionError("Connection refused")
+
+        flag_result = self.client.get_feature_flag_result("my-flag", "some-distinct-id")
+
+        self.assertIsNone(flag_result)
+        patch_capture.assert_called_with(
+            "$feature_flag_called",
+            distinct_id="some-distinct-id",
+            properties={
+                "$feature_flag": "my-flag",
+                "$feature_flag_response": None,
+                "locally_evaluated": False,
+                "$feature/my-flag": None,
+                "$feature_flag_error": "connection_error",
+            },
+            groups={},
+            disable_geoip=None,
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_get_feature_flag_result_api_error(self, patch_capture, patch_flags):
+        """Test that API errors include the status code."""
+        from posthog.request import APIError
+
+        patch_flags.side_effect = APIError(500, "Internal server error")
+
+        flag_result = self.client.get_feature_flag_result("my-flag", "some-distinct-id")
+
+        self.assertIsNone(flag_result)
+        patch_capture.assert_called_with(
+            "$feature_flag_called",
+            distinct_id="some-distinct-id",
+            properties={
+                "$feature_flag": "my-flag",
+                "$feature_flag_response": None,
+                "locally_evaluated": False,
+                "$feature/my-flag": None,
+                "$feature_flag_error": "api_error_500",
+            },
+            groups={},
+            disable_geoip=None,
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_get_feature_flag_result_quota_limited(self, patch_capture, patch_flags):
+        """Test that quota limit errors are captured specifically."""
+        from posthog.request import QuotaLimitError
+
+        patch_flags.side_effect = QuotaLimitError(429, "Rate limit exceeded")
 
         flag_result = self.client.get_feature_flag_result("my-flag", "some-distinct-id")
 
@@ -553,7 +648,7 @@ def test_get_feature_flag_result_request_error(self, patch_capture, patch_flags)
                 "$feature_flag_response": None,
                 "locally_evaluated": False,
                 "$feature/my-flag": None,
-                "$feature_flag_error": "request_error",
+                "$feature_flag_error": "quota_limited",
             },
             groups={},
             disable_geoip=None,