featureflip 2.3.0__tar.gz → 2.3.1__tar.gz

{featureflip-2.3.0 → featureflip-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featureflip
-Version: 2.3.0
+Version: 2.3.1
 Summary: Python SDK for Featureflip - a feature flag SaaS platform
 Project-URL: Homepage, https://featureflip.io
 Project-URL: Documentation, https://featureflip.io/docs/sdks/python/

{featureflip-2.3.0 → featureflip-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "featureflip"
-version = "2.3.0"
+version = "2.3.1"
 description = "Python SDK for Featureflip - a feature flag SaaS platform"
 readme = "README.md"
 license = "Apache-2.0"

{featureflip-2.3.0 → featureflip-2.3.1}/src/featureflip/_core.py

@@ -37,6 +37,19 @@ logger = structlog.get_logger()
 T = TypeVar("T")
 
 
+def _resolve_user_id(context: dict[str, Any]) -> str | None:
+    """Resolve the built-in user id from a raw context dict.
+
+    Honors the ``user_id`` / ``userId`` alias (universal across the engine and
+    every SDK) so a caller passing either spelling gets the same top-level
+    ``userId`` on analytics events. Returns ``None`` when neither is present.
+    """
+    raw = context.get("user_id")
+    if raw is None:
+        raw = context.get("userId")
+    return str(raw) if raw is not None else None
+
+
 class _SharedFeatureflipCore:
     """Internal shared core owning all expensive resources of a FeatureflipClient.
 
@@ -373,10 +386,13 @@ class _SharedFeatureflipCore:
         """Queue a custom event."""
         if self._test_mode_values is not None or self._event_processor is None:
             return
+        # Send the backend SdkEventDto shape: top-level userId, no `context`.
+        # See apps/evaluation-api Controllers/SdkController.RecordEvents — the
+        # backend has no context/value/reason field, so anything else is dropped.
         event = {
             "type": "Custom",
             "flagKey": event_name,
-            "context": context or {},
+            "userId": _resolve_user_id(context or {}),
             "metadata": metadata or {},
             "timestamp": datetime.now(timezone.utc).isoformat(),
         }
@@ -386,10 +402,19 @@ class _SharedFeatureflipCore:
         """Send user attributes for segment building."""
         if self._test_mode_values is not None or self._event_processor is None:
             return
+        # Promote the user id to the top-level userId field and put the remaining
+        # attributes in metadata (stripping both alias spellings so the identity
+        # isn't duplicated inside the metadata bag).
+        attributes = {
+            k: v
+            for k, v in (context or {}).items()
+            if k not in ("user_id", "userId")
+        }
         event = {
             "type": "Identify",
             "flagKey": "$identify",
-            "context": context or {},
+            "userId": _resolve_user_id(context or {}),
+            "metadata": attributes,
             "timestamp": datetime.now(timezone.utc).isoformat(),
         }
         self._event_processor.queue_event(event)
@@ -402,24 +427,25 @@ class _SharedFeatureflipCore:
     def queue_evaluation_event(
         self,
         key: str,
-        value: Any,
         context: dict[str, Any],
-        reason: EvaluationReason,
-        rule_id: str | None = None,
+        variation_key: str | None,
     ) -> None:
-        """Queue an evaluation event (called by the handle's variation() method)."""
+        """Queue an evaluation event (called by the handle's variation() method).
+
+        Emits the backend SdkEventDto shape — top-level ``userId`` and
+        ``variation`` — mirroring the JS SDK. The backend has no context/value/
+        reason/ruleId fields, so they are not sent (System.Text.Json would drop
+        them and bind UserId/Variation to null; see #1920).
+        """
         if self._event_processor is None:
             return
         event: dict[str, Any] = {
             "type": "Evaluation",
             "flagKey": key,
-            "value": value,
-            "context": context,
-            "reason": reason.value,
+            "userId": _resolve_user_id(context or {}),
+            "variation": variation_key,
             "timestamp": datetime.now(timezone.utc).isoformat(),
         }
-        if rule_id is not None:
-            event["ruleId"] = rule_id
         self._event_processor.queue_event(event)
 
     # --- Shutdown ---

{featureflip-2.3.0 → featureflip-2.3.1}/src/featureflip/client.py

@@ -103,10 +103,8 @@ class FeatureflipClient:
             if track:
                 self._core.queue_evaluation_event(
                     key=key,
-                    value=value,
                     context=context or {},
-                    reason=detail.reason,
-                    rule_id=detail.rule_id,
+                    variation_key=detail.variation_key,
                 )
             return cast("T", value)
         except Exception as e:
@@ -254,20 +252,15 @@ class FeatureflipClient:
     def _queue_evaluation_event(
         self,
         key: str,
-        value: Any,
         context: dict[str, Any],
-        reason: EvaluationReason,
-        rule_id: str | None = None,
+        variation_key: str | None = None,
     ) -> None:
         """Queue an evaluation event. Delegates to the shared core.
 
-        Preserved for backwards compatibility with existing tests that call
-        this method directly on the client.
+        Preserved for tests that call this method directly on the client.
         """
         self._core.queue_evaluation_event(
             key=key,
-            value=value,
             context=context,
-            reason=reason,
-            rule_id=rule_id,
+            variation_key=variation_key,
         )

{featureflip-2.3.0 → featureflip-2.3.1}/tests/integration/test_api.py

@@ -7,6 +7,7 @@ and update mechanisms (polling).
 
 from __future__ import annotations
 
+import json
 import time
 
 import httpx
@@ -458,6 +459,112 @@ class TestEventTracking:
             client.flush()  # Should not raise
 
 
+class TestEventWireShape:
+    """Events must be sent in the backend SdkEventDto shape (top-level userId /
+    variation), matching the JS SDK. The backend has no context/value/reason/ruleId
+    fields, so those keys are silently dropped and UserId/Variation bind to null
+    unless the SDK populates them client-side. Regression guard for #1920.
+    """
+
+    @staticmethod
+    def _first_event(events_route: respx.Route) -> dict:
+        payload = json.loads(events_route.calls[0].request.read())
+        assert isinstance(payload, dict)
+        assert isinstance(payload["events"], list)
+        return payload["events"][0]
+
+    @respx.mock
+    def test_evaluation_event_has_top_level_userid_and_variation(
+        self, test_config: Config
+    ) -> None:
+        respx.get("https://eval.featureflip.io/v1/sdk/flags").mock(
+            return_value=httpx.Response(200, json=MOCK_FLAGS_RESPONSE)
+        )
+        events_route = respx.post("https://eval.featureflip.io/v1/sdk/events").mock(
+            return_value=httpx.Response(202)
+        )
+
+        with FeatureflipClient(sdk_key="test-sdk-key", config=test_config) as client:
+            client.variation("test-flag", {"user_id": "123"}, default=False)
+            client.flush()
+
+        event = self._first_event(events_route)
+        assert event["type"] == "Evaluation"
+        assert event["flagKey"] == "test-flag"
+        assert event["userId"] == "123"
+        # served variation of the boolean fallthrough ("on")
+        assert event["variation"] == "on"
+        # backend DTO has no such fields — must not be sent
+        assert "context" not in event
+        assert "value" not in event
+        assert "reason" not in event
+        assert "ruleId" not in event
+
+    @respx.mock
+    def test_evaluation_event_resolves_userid_camelcase_alias(
+        self, test_config: Config
+    ) -> None:
+        respx.get("https://eval.featureflip.io/v1/sdk/flags").mock(
+            return_value=httpx.Response(200, json=MOCK_FLAGS_RESPONSE)
+        )
+        events_route = respx.post("https://eval.featureflip.io/v1/sdk/events").mock(
+            return_value=httpx.Response(202)
+        )
+
+        with FeatureflipClient(sdk_key="test-sdk-key", config=test_config) as client:
+            # camelCase alias — a documented-valid keyed context
+            client.variation("test-flag", {"userId": "alice"}, default=False)
+            client.flush()
+
+        event = self._first_event(events_route)
+        assert event["userId"] == "alice"
+
+    @respx.mock
+    def test_track_event_has_top_level_userid(self, test_config: Config) -> None:
+        respx.get("https://eval.featureflip.io/v1/sdk/flags").mock(
+            return_value=httpx.Response(200, json=MOCK_FLAGS_RESPONSE)
+        )
+        events_route = respx.post("https://eval.featureflip.io/v1/sdk/events").mock(
+            return_value=httpx.Response(202)
+        )
+
+        with FeatureflipClient(sdk_key="test-sdk-key", config=test_config) as client:
+            client.track("signup", {"userId": "alice"}, metadata={"plan": "pro"})
+            client.flush()
+
+        event = self._first_event(events_route)
+        assert event["type"] == "Custom"
+        assert event["flagKey"] == "signup"
+        assert event["userId"] == "alice"
+        assert event["metadata"] == {"plan": "pro"}
+        assert "context" not in event
+
+    @respx.mock
+    def test_identify_promotes_userid_and_strips_it_from_metadata(
+        self, test_config: Config
+    ) -> None:
+        respx.get("https://eval.featureflip.io/v1/sdk/flags").mock(
+            return_value=httpx.Response(200, json=MOCK_FLAGS_RESPONSE)
+        )
+        events_route = respx.post("https://eval.featureflip.io/v1/sdk/events").mock(
+            return_value=httpx.Response(202)
+        )
+
+        with FeatureflipClient(sdk_key="test-sdk-key", config=test_config) as client:
+            client.identify({"userId": "alice", "plan": "pro"})
+            client.flush()
+
+        event = self._first_event(events_route)
+        assert event["type"] == "Identify"
+        assert event["flagKey"] == "$identify"
+        assert event["userId"] == "alice"
+        # identity is promoted to userId, not buried in metadata
+        assert event["metadata"] == {"plan": "pro"}
+        assert "userId" not in event["metadata"]
+        assert "user_id" not in event["metadata"]
+        assert "context" not in event
+
+
 class TestPollingUpdates:
     """Tests for polling-based flag updates."""
 

{featureflip-2.3.0 → featureflip-2.3.1}/tests/test_client.py

@@ -331,8 +331,11 @@ class TestIdentify:
             client._core._event_processor.queue_event.assert_called_once()
             event = client._core._event_processor.queue_event.call_args[0][0]
             assert event["type"] == "Identify"
-            assert event["context"]["user_id"] == "123"
-            assert event["context"]["email"] == "test@example.com"
+            # user id is promoted to the top-level backend DTO field; the
+            # remaining attributes land in metadata (see #1920)
+            assert event["userId"] == "123"
+            assert event["metadata"]["email"] == "test@example.com"
+            assert "context" not in event
             client.close()
 
     def test_identify_event_includes_flagkey(self) -> None:
@@ -702,13 +705,21 @@ class TestEvaluationEventKeys:
             assert "flagKey" in event, f"Event should use 'flagKey' but has keys: {list(event.keys())}"
             assert "flag_key" not in event, "Event should not use snake_case 'flag_key'"
             assert event["flagKey"] == "test-flag"
+            # user id is promoted to the top-level backend DTO field
+            assert event["userId"] == "123"
             client.close()
 
-    def test_evaluation_event_uses_camelcase_rule_id(self) -> None:
-        """_queue_evaluation_event must use 'ruleId' not 'rule_id'."""
+    def test_evaluation_event_matches_backend_dto_shape(self) -> None:
+        """Evaluation events carry only the backend SdkEventDto fields.
+
+        The backend maps SdkEventDto -> SdkEvent with type/flagKey/userId/variation/
+        timestamp/metadata/prerequisiteKey and nothing else (see
+        Evaluation.Api Controllers/SdkController.RecordEvents). Sending context/value/
+        reason/ruleId is dead weight silently dropped by System.Text.Json. Regression
+        guard for #1920.
+        """
         with patch("featureflip._core.HttpClient") as mock_http:
-            flag = create_test_flag()
-            mock_http.return_value.get_flags.return_value = ([flag], [])
+            mock_http.return_value.get_flags.return_value = ([create_test_flag()], [])
 
             client = FeatureflipClient(
                 sdk_key="test-key",
@@ -716,17 +727,19 @@ class TestEvaluationEventKeys:
             )
             client._core._event_processor = MagicMock()
 
-            # Call _queue_evaluation_event directly with a rule_id
             client._queue_evaluation_event(
                 key="test-flag",
-                value=True,
                 context={"user_id": "123"},
-                reason=EvaluationReason.RULE_MATCH,
-                rule_id="rule-abc",
+                variation_key="on",
             )
 
             event = client._core._event_processor.queue_event.call_args[0][0]
-            assert "ruleId" in event, f"Event should use 'ruleId' but has keys: {list(event.keys())}"
-            assert "rule_id" not in event, "Event should not use snake_case 'rule_id'"
-            assert event["ruleId"] == "rule-abc"
+            assert event["type"] == "Evaluation"
+            assert event["flagKey"] == "test-flag"
+            assert event["userId"] == "123"
+            assert event["variation"] == "on"
+            assert "timestamp" in event
+            # non-DTO fields must not be sent
+            for dead in ("context", "value", "reason", "ruleId", "rule_id"):
+                assert dead not in event, f"Event should not carry '{dead}'"
             client.close()