featureflip 2.4.2__tar.gz → 2.4.3__tar.gz

{featureflip-2.4.2 → featureflip-2.4.3}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2.4.3 — 2026-08-23
+
+### Fixed
+
+- An unrecognised `FlagType` no longer fails the entire config fetch. One unknown value in one flag discarded the whole payload, so a single new server-side type could blank out every flag the SDK served. ([#2401](https://github.com/canopy-labs/featureflip/issues/2401))
+- An unrecognised condition operator now fails closed instead of matching every user. The default arm returned `false`, which a negated condition then inverted to `true` — so a config naming an operator the SDK did not know could silently target everyone. ([#2262](https://github.com/canopy-labs/featureflip/issues/2262))
+- An unrecognised condition operator is tolerated at deserialization instead of discarding the whole config, matching the string-typed SDKs. ([#2372](https://github.com/canopy-labs/featureflip/issues/2372))
+- `identify()` and `track()` put the same payload on the wire as every other server SDK. The field set and shapes had drifted per language, so the same call produced different events depending on which SDK sent it. ([#2359](https://github.com/canopy-labs/featureflip/issues/2359))
+
 ## 2.4.2 — 2026-08-05
 
 ### Fixed

{featureflip-2.4.2 → featureflip-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: featureflip
-Version: 2.4.2
+Version: 2.4.3
 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/
@@ -122,7 +122,7 @@ print(detail.rule_id)  # Rule ID if reason is RULE_MATCH
 # Track custom events
 client.track("checkout-completed", {"user_id": "123"}, metadata={"total": 99.99})
 
-# Identify users for segment building
+# Record an identify event for analytics (does not affect flag evaluation)
 client.identify({"user_id": "123", "email": "user@example.com", "plan": "pro"})
 
 # Force flush pending events

{featureflip-2.4.2 → featureflip-2.4.3}/README.md

@@ -90,7 +90,7 @@ print(detail.rule_id)  # Rule ID if reason is RULE_MATCH
 # Track custom events
 client.track("checkout-completed", {"user_id": "123"}, metadata={"total": 99.99})
 
-# Identify users for segment building
+# Record an identify event for analytics (does not affect flag evaluation)
 client.identify({"user_id": "123", "email": "user@example.com", "plan": "pro"})
 
 # Force flush pending events

{featureflip-2.4.2 → featureflip-2.4.3}/pyproject.toml

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

{featureflip-2.4.2 → featureflip-2.4.3}/src/featureflip/_core.py

@@ -39,6 +39,20 @@ logger = structlog.get_logger()
 T = TypeVar("T")
 
 
+def _compact_event(event: dict[str, Any]) -> dict[str, Any]:
+    """Drop the optional wire fields when they carry nothing.
+
+    ``userId`` and ``metadata`` are both optional on the backend DTO. Every
+    server SDK omits them rather than sending ``null`` or an empty object, so
+    the same call produces the same bytes whichever SDK made it (#2359).
+    """
+    if event.get("userId") is None:
+        event.pop("userId", None)
+    if not event.get("metadata"):
+        event.pop("metadata", None)
+    return event
+
+
 def _resolve_user_id(context: dict[str, Any]) -> str | None:
     """Resolve the built-in user id from a raw context dict.
 
@@ -493,17 +507,23 @@ class _SharedFeatureflipCore:
         # 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,
-            "userId": _resolve_user_id(context or {}),
-            "metadata": metadata or {},
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
+        event = _compact_event(
+            {
+                "type": "Custom",
+                "flagKey": event_name,
+                "userId": _resolve_user_id(context or {}),
+                "metadata": metadata,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
         self._event_processor.queue_event(event)
 
     def identify(self, context: dict[str, Any]) -> None:
-        """Send user attributes for segment building."""
+        """Record an identify event for analytics.
+
+        Does not affect flag evaluation: targeting rules and segments are matched
+        against the context passed to each variation call.
+        """
         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
@@ -514,13 +534,15 @@ class _SharedFeatureflipCore:
             for k, v in (context or {}).items()
             if k not in ("user_id", "userId")
         }
-        event = {
-            "type": "Identify",
-            "flagKey": "$identify",
-            "userId": _resolve_user_id(context or {}),
-            "metadata": attributes,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
+        event = _compact_event(
+            {
+                "type": "Identify",
+                "flagKey": "$identify",
+                "userId": _resolve_user_id(context or {}),
+                "metadata": attributes,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
         self._event_processor.queue_event(event)
 
     def flush(self) -> None:
@@ -543,13 +565,15 @@ class _SharedFeatureflipCore:
         """
         if self._event_processor is None:
             return
-        event: dict[str, Any] = {
-            "type": "Evaluation",
-            "flagKey": key,
-            "userId": _resolve_user_id(context or {}),
-            "variation": variation_key,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
+        event: dict[str, Any] = _compact_event(
+            {
+                "type": "Evaluation",
+                "flagKey": key,
+                "userId": _resolve_user_id(context or {}),
+                "variation": variation_key,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
         self._event_processor.queue_event(event)
 
     # --- Shutdown ---

{featureflip-2.4.2 → featureflip-2.4.3}/src/featureflip/_http.py

@@ -163,7 +163,7 @@ class HttpClient:
         return FlagConfiguration(
             key=data["key"],
             version=data["version"],
-            type=FlagType(data["type"].lower()),
+            type=self._parse_flag_type(data["type"]),
             enabled=data["enabled"],
             variations=[
                 Variation(key=v["key"], value=v["value"])
@@ -228,13 +228,87 @@ class HttpClient:
         """
         return Condition(
             attribute=data["attribute"],
-            # The wire sends PascalCase operators (e.g. "SemverGreaterThanOrEqual");
-            # ConditionOperator._missing_ normalizes them to the snake_case members.
-            operator=ConditionOperator(data["operator"]),
+            operator=self._parse_operator(data["operator"]),
             values=data["values"],
             negate=data.get("negate", False),
         )
 
+    @staticmethod
+    def _parse_flag_type(raw: Any) -> FlagType | str:
+        """Resolve a wire flag type, tolerating one this SDK version does not know.
+
+        ``FlagType(raw)`` raises ``ValueError`` on an unrecognised name, and because the
+        throw surfaced mid-payload it failed the ENTIRE flags parse: the day a new flag
+        type ships server-side, every pinned SDK stops serving EVERY flag, not just the
+        one carrying the new type (#2395). That is the same total-outage shape #2372
+        fixed for ``ConditionOperator``, triggered by an ordinary additive server change.
+
+        Tolerating it is unconditionally safe here in a way it is NOT for ``ServeType``
+        or ``ConditionLogic``: nothing evaluates this field. It is parsed, stored and
+        re-exported, and no evaluator reads it — go, ruby and php do not even model it.
+        So there is no downstream consumer that could mis-serve on the raw string, and
+        equally none that could warn about it, which is why the diagnostic is emitted
+        here rather than left to evaluation time.
+
+        A non-string type is a DIFFERENT axis and is not tolerated, exactly as in
+        ``_parse_operator``: an integer is the server and SDK disagreeing about the wire
+        format (#2279), and coercing it with ``str()`` would turn ``0`` into the flag
+        type ``"0"`` -- indistinguishable from a genuine unknown name, and silently wrong
+        in the way #2315 exists to prevent.
+        """
+        if not isinstance(raw, str):
+            raise TypeError(
+                f"flag.type must be a string, got {type(raw).__name__}: {raw!r}"
+            )
+
+        try:
+            return FlagType(raw.lower())
+        except ValueError:
+            logger.warning(
+                "Unrecognised flag type - retaining the raw value. This SDK version "
+                "may be older than the flag configuration.",
+                flag_type=raw,
+            )
+            return raw
+
+    @staticmethod
+    def _parse_operator(raw: Any) -> ConditionOperator | str:
+        """Resolve a wire operator, tolerating one this SDK version does not know.
+
+        The wire sends PascalCase operators (e.g. ``"SemverGreaterThanOrEqual"``);
+        ``ConditionOperator._missing_`` normalizes them to the snake_case members.
+
+        An unrecognised name raises ``ValueError`` from the enum call. That used to
+        propagate out of the whole flags-payload parse, so ONE unknown operator in ONE
+        condition of ONE flag failed the ENTIRE fetch and every flag fell back to the
+        caller's defaults (#2372). The trigger is ordinary: a new operator shipped
+        server-side reaching an SDK a customer has pinned.
+
+        The raw string is returned instead of a member, which is safe because
+        ``FlagEvaluator`` fails an unrecognised operator CLOSED (#2262) — its ``case _``
+        arm returns None and ``negate`` never inverts it into a match-everyone. Keeping
+        the original text (rather than substituting a sentinel) means the evaluator's
+        ``unknown_operator`` warning names the operator actually received, which is the
+        one detail an operator debugging this needs.
+
+        A non-string operator is a DIFFERENT axis and is not tolerated. Tolerance here
+        is for an unknown *name*; an integer is the server and SDK disagreeing about the
+        wire format, and coercing it with ``str()`` would turn ``0`` into the operator
+        ``"0"`` -- indistinguishable from a genuine unknown name, and silently wrong in
+        exactly the way #2315 exists to prevent. csharp's tolerant converter had the
+        identical hole (it resolved numbers by ordinal) and closed it the same way; the
+        shared ``malformedConfigVectors`` runner pins both.
+        """
+        if not isinstance(raw, str):
+            raise TypeError(
+                f"condition.operator must be a string, got {type(raw).__name__}: {raw!r}"
+            )
+
+        try:
+            return ConditionOperator(raw)
+        except ValueError:
+            return str(raw)
+
     def _parse_serve(self, data: dict[str, Any]) -> ServeConfig:
         """Parse a serve config from JSON.
 

{featureflip-2.4.2 → featureflip-2.4.3}/src/featureflip/client.py

@@ -150,7 +150,11 @@ class FeatureflipClient:
         self._core.track(event_name, context, metadata)
 
     def identify(self, context: dict[str, Any]) -> None:
-        """Send user attributes for segment building."""
+        """Record an identify event for analytics.
+
+        Does not affect flag evaluation: targeting rules and segments are matched
+        against the context passed to each variation call.
+        """
         if self._closed:
             return
         self._core.identify(context)

{featureflip-2.4.2 → featureflip-2.4.3}/src/featureflip/evaluation.py

@@ -120,6 +120,16 @@ class FlagEvaluator:
 
         result = self._evaluate_operator(condition.operator, str_value, values)
 
+        # Issue #2262: an unrecognised operator fails CLOSED. ``not None`` is True
+        # in Python, so without this guard a negated unknown operator would match
+        # every user and roll the flag out to 100% of traffic. Every
+        # ConditionOperator member is covered above and _http.py rejects an unknown
+        # operator string at deserialization, so this is defensive here — but it
+        # keeps the contract identical to the string-typed SDKs (js/go/ruby/php),
+        # where the same input IS reachable over the wire.
+        if result is None:
+            return False
+
         return not result if condition.negate else result
 
     def _evaluate_numeric_equality(self, condition: Condition, attr_value: float) -> bool:
@@ -168,8 +178,8 @@ class FlagEvaluator:
             return False
 
     def _evaluate_operator(
-        self, operator: ConditionOperator, value: str, targets: list[str]
-    ) -> bool:
+        self, operator: ConditionOperator | str, value: str, targets: list[str]
+    ) -> bool | None:
         """Evaluate an operator against a value and targets.
 
         Args:
@@ -233,8 +243,11 @@ class FlagEvaluator:
             case ConditionOperator.SEMVER_LESS_THAN_OR_EQUAL:
                 return any(compare_semver(value, t, "<=") for t in targets)
             case _:
+                # Unrecognised operator — "cannot evaluate", not "did not match".
+                # Returning None (rather than False) keeps the two distinguishable
+                # so negate is not applied to an inability (#2262).
                 logger.warning("unknown_operator", operator=operator)
-                return False
+                return None
 
     def _compare_numeric(self, value: str, target: str, op: str) -> bool:
         """Compare two values as numbers.

{featureflip-2.4.2 → featureflip-2.4.3}/src/featureflip/models.py

@@ -125,13 +125,16 @@ class Condition:
 
     Attributes:
         attribute: The context attribute to evaluate (e.g., "country", "user_id").
-        operator: The comparison operator to use.
+        operator: The comparison operator to use. Typed to also admit a raw ``str``:
+            an operator name this SDK version does not recognise is retained
+            verbatim rather than failing the whole config parse (#2372), and the
+            evaluator fails it closed (#2262).
         values: The values to compare against.
         negate: If True, the condition result is inverted.
     """
 
     attribute: str
-    operator: ConditionOperator
+    operator: ConditionOperator | str
     values: list[Any]
     negate: bool = False
 
@@ -296,7 +299,11 @@ class FlagConfiguration:
     Attributes:
         key: Unique identifier for the flag.
         version: Version number of the configuration.
-        type: The type of value this flag returns.
+        type: The type of value this flag returns. Typed to also admit a raw
+            ``str``: a flag type this SDK version does not recognise is retained
+            verbatim rather than failing the whole config parse (#2395). Nothing
+            evaluates this field, so an unrecognised value has no effect beyond
+            the diagnostic emitted at parse time.
         enabled: Whether the flag is enabled for evaluation.
         variations: All possible variations for this flag.
         rules: Targeting rules evaluated in priority order.
@@ -308,7 +315,7 @@ class FlagConfiguration:
 
     key: str
     version: int
-    type: FlagType
+    type: FlagType | str
     enabled: bool
     variations: tuple[Variation, ...]
     rules: tuple[TargetingRule, ...]
@@ -323,7 +330,7 @@ class FlagConfiguration:
         self,
         key: str,
         version: int,
-        type: FlagType,
+        type: FlagType | str,
         enabled: bool,
         variations: list[Variation] | tuple[Variation, ...],
         rules: list[TargetingRule] | tuple[TargetingRule, ...],