fix: include group context in $feature_flag_called dedupe key (#625)

* fix: include group context in $feature_flag_called dedupe key

In `_capture_feature_flag_called_if_needed`, the per-distinct_id dedupe key only included the flag key and response. For group-scoped flags, this meant that when the same user was evaluated under a different group, no new `$feature_flag_called` event was fired — causing per-group exposure undercount for experiments scoped to a group key.

Include the sorted `groups` map in the dedupe key so that the same (distinct_id, flag, response) combination fires once per distinct group context. Repeated calls under the same group context still dedupe, and calls that pass the same map in a different key order still dedupe (the groups are canonicalized via `sorted(groups.items())`).

Mirrors the posthog-node fix in PostHog/posthog-js#3658.

Generated-By: PostHog Code
Task-Id: d94308d9-7655-4bac-8f15-c61478b5fca1

* chore: add changeset



Generated-By: PostHog Code
Task-Id: d94308d9-7655-4bac-8f15-c61478b5fca1

* refactor: use tuple for feature_flag_reported_key and parameterize dedupe tests

Author: gustavohstrassburger

.sampo/changesets/include-group-context-in-flag-called-dedupe.md

@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Include group context in the `$feature_flag_called` dedupe key so group-scoped flags fire a separate event for each group a user is evaluated under, instead of being dedup-ed against the first group context the same `(distinct_id, flag, response)` was seen under.

posthog/client.py

@@ -2250,14 +2250,17 @@ def _capture_feature_flag_called_if_needed(
         groups: Optional[Dict[str, str]] = None,
         disable_geoip: Optional[bool] = None,
     ) -> None:
-        """Fire a ``$feature_flag_called`` event if the (distinct_id, flag, response)
-        triple hasn't already been reported on this client. Shared by the single-flag
-        evaluation path and ``FeatureFlagEvaluations.is_enabled() / get_flag()`` so
-        both paths dedupe identically.
+        """Fire a ``$feature_flag_called`` event if the (distinct_id, flag, response,
+        groups) tuple hasn't already been reported on this client. Group context is
+        included so that group-scoped flags fire a separate event for each group a
+        user is evaluated under. Shared by the single-flag evaluation path and
+        ``FeatureFlagEvaluations.is_enabled() / get_flag()`` so both paths dedupe
+        identically.
         """
-        feature_flag_reported_key = (
-            f"{key}_{'::null::' if response is None else str(response)}"
+        groups_key = (
+            tuple(sorted((str(k), str(v)) for k, v in groups.items())) if groups else ()
         )
+        feature_flag_reported_key = (key, response, groups_key)
 
         reported_flags = self.distinct_ids_feature_flags_reported.get(distinct_id)
         if reported_flags is None:

posthog/test/test_feature_flags.py

@@ -5271,6 +5271,81 @@ def test_disable_geoip_get_flag_capture_call(self, patch_flags, patch_capture):
             disable_geoip=False,
         )
 
+    @mock.patch.object(Client, "capture")
+    @mock.patch("posthog.client.flags")
+    def test_capture_fires_per_group_context(self, patch_flags, patch_capture):
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Group flag",
+                "key": "group-scoped-flag",
+                "active": True,
+                "filters": {
+                    "groups": [{"properties": [], "rollout_percentage": 100}],
+                },
+            }
+        ]
+
+        # Same user, same flag, same response — but two different group contexts.
+        client.get_feature_flag(
+            "group-scoped-flag", "user-1", groups={"company": "org-a"}
+        )
+        client.get_feature_flag(
+            "group-scoped-flag", "user-1", groups={"company": "org-b"}
+        )
+
+        flag_called_groups = [
+            call.kwargs.get("groups")
+            for call in patch_capture.call_args_list
+            if call.args and call.args[0] == "$feature_flag_called"
+        ]
+        self.assertEqual(len(flag_called_groups), 2)
+        self.assertIn({"company": "org-a"}, flag_called_groups)
+        self.assertIn({"company": "org-b"}, flag_called_groups)
+
+    @parameterized.expand(
+        [
+            (
+                "same_context",
+                {"company": "org-a"},
+                {"company": "org-a"},
+            ),
+            (
+                "different_key_order",
+                {"company": "org-a", "team": "red"},
+                {"team": "red", "company": "org-a"},
+            ),
+        ]
+    )
+    @mock.patch.object(Client, "capture")
+    @mock.patch("posthog.client.flags")
+    def test_capture_dedupes_repeated_calls_under_same_group_context(
+        self, _name, first_groups, second_groups, patch_flags, patch_capture
+    ):
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Group flag",
+                "key": "group-scoped-flag",
+                "active": True,
+                "filters": {
+                    "groups": [{"properties": [], "rollout_percentage": 100}],
+                },
+            }
+        ]
+
+        client.get_feature_flag("group-scoped-flag", "user-1", groups=first_groups)
+        client.get_feature_flag("group-scoped-flag", "user-1", groups=second_groups)
+
+        flag_called_count = sum(
+            1
+            for call in patch_capture.call_args_list
+            if call.args and call.args[0] == "$feature_flag_called"
+        )
+        self.assertEqual(flag_called_count, 1)
+
     @mock.patch.object(Client, "capture")
     @mock.patch("posthog.client.flags")
     def test_capture_multiple_users_doesnt_out_of_memory(