Report combined errors when both errors_while_computing and flag_missing

When the server returns errorsWhileComputingFlags=true AND the requested
flag is not in the response, report both conditions as a comma-separated
string: "errors_while_computing_flags,flag_missing"

This provides better debugging context when both conditions occur.

Author: haacked

posthog/client.py

@@ -1590,10 +1590,13 @@ def _get_feature_flag_result(
                         disable_geoip,
                     )
                 )
+                errors = []
                 if errors_while_computing:
-                    feature_flag_error = "errors_while_computing_flags"
-                elif flag_details is None:
-                    feature_flag_error = "flag_missing"
+                    errors.append("errors_while_computing_flags")
+                if flag_details is None:
+                    errors.append("flag_missing")
+                if errors:
+                    feature_flag_error = ",".join(errors)
 
                 flag_result = FeatureFlagResult.from_flag_details(
                     flag_details, override_match_value

posthog/test/test_feature_flag_result.py

@@ -544,6 +544,42 @@ def test_get_feature_flag_result_flag_not_in_response(
             disable_geoip=None,
         )
 
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_get_feature_flag_result_errors_computing_and_flag_missing(
+        self, patch_capture, patch_flags
+    ):
+        """Test that both errors are reported when errorsWhileComputingFlags=true AND flag is missing.
+
+        This can happen when the server encounters errors computing flags AND the requested
+        flag is not in the response. Both conditions should be reported for debugging.
+        """
+        patch_flags.return_value = {
+            "flags": {},  # Flag is missing
+            "requestId": "test-request-id-999",
+            "errorsWhileComputingFlags": True,  # But errors also occurred
+        }
+
+        flag_result = self.client.get_feature_flag_result(
+            "missing-flag", "some-distinct-id"
+        )
+
+        self.assertIsNone(flag_result)
+        patch_capture.assert_called_with(
+            "$feature_flag_called",
+            distinct_id="some-distinct-id",
+            properties={
+                "$feature_flag": "missing-flag",
+                "$feature_flag_response": None,
+                "locally_evaluated": False,
+                "$feature/missing-flag": None,
+                "$feature_flag_request_id": "test-request-id-999",
+                "$feature_flag_error": "errors_while_computing_flags,flag_missing",
+            },
+            groups={},
+            disable_geoip=None,
+        )
+
     @mock.patch("posthog.client.flags")
     @mock.patch.object(Client, "capture")
     def test_get_feature_flag_result_unknown_error(self, patch_capture, patch_flags):