Pass selector via both header and request body for backward compatibility

- Update _create_request_args to include selector in request body
- Maintain selector in flagd-selector gRPC metadata header
- Update test to verify both header and body contain selector
- Update documentation to reflect dual transmission approach
- Ensures compatibility with both older and newer flagd versions

Co-authored-by: aepfli <[email protected]>

Author: Copilot

providers/openfeature-provider-flagd/README.md

@@ -113,7 +113,7 @@ The default options can be defined in the FlagdProvider constructor.
 
 #### Current Implementation
 
-As of this SDK version, the `selector` parameter is passed via gRPC metadata headers (`flagd-selector`) when using in-process mode. This aligns with flagd v0.11.0+ selector normalization standards.
+As of this SDK version, the `selector` parameter is passed via **both** gRPC metadata headers (`flagd-selector`) and the request body when using in-process mode. This dual approach ensures maximum compatibility with all flagd versions.
 
 **Configuration Example:**
 ```python
@@ -123,19 +123,20 @@ from openfeature.contrib.provider.flagd.config import ResolverType
 
 api.set_provider(FlagdProvider(
     resolver_type=ResolverType.IN_PROCESS,
-    selector="my-flag-source",  # Passed via flagd-selector header
+    selector="my-flag-source",  # Passed via both header and request body
 ))
 ```
 
-The selector is automatically passed via the `flagd-selector` gRPC metadata header, ensuring compatibility with flagd services that implement selector normalization.
+The selector is automatically passed via:
+- **gRPC metadata header** (`flagd-selector`) - For flagd v0.11.0+ selector normalization
+- **Request body** - For backward compatibility with older flagd versions
 
 #### Backward Compatibility
 
-flagd services maintain backward compatibility with both selector passing approaches:
-- **gRPC metadata header** (`flagd-selector`) - Current implementation (recommended)
-- **Request body selector** - Legacy approach (still supported by flagd for backward compatibility)
-
-This ensures the Python SDK works correctly with both older and newer versions of flagd services.
+This dual transmission approach ensures the Python SDK works seamlessly with all flagd service versions:
+- **Older flagd versions** read the selector from the request body
+- **Newer flagd versions (v0.11.0+)** prefer the selector from the gRPC metadata header
+- Both approaches are supported simultaneously for maximum compatibility
 
 **Related Resources:**
 - Upstream issue: [open-feature/flagd#1814](https://github.com/open-feature/flagd/issues/1814)

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/provider.py

@@ -76,7 +76,8 @@ def __init__(  # noqa: PLR0913
         :param timeout: the maximum time to wait before a request times out
         :param retry_backoff_ms: the number of milliseconds to backoff
         :param selector: filter flag configurations by source (in-process mode only)
-                         Passed via flagd-selector gRPC metadata header.
+                         Passed via both flagd-selector gRPC metadata header and request body
+                         for backward compatibility with all flagd versions.
         :param offline_flag_source_path: the path to the flag source file
         :param stream_deadline_ms: the maximum time to wait before a request times out
         :param keep_alive_time: the number of milliseconds to keep alive

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/resolvers/process/connector/grpc_watcher.py

@@ -205,8 +205,10 @@ def shutdown(self) -> None:
 
     def _create_request_args(self) -> dict:
         request_args = {}
-        # Note: selector is now passed via gRPC metadata header instead of request body
-        # This maintains compatibility with flagd v0.11.0+ selector normalization
+        # Pass selector in both request body (legacy) and metadata header (new) for backward compatibility
+        # This ensures compatibility with both older and newer flagd versions
+        if self.selector is not None:
+            request_args["selector"] = self.selector
         if self.provider_id is not None:
             request_args["provider_id"] = self.provider_id
 
@@ -216,7 +218,8 @@ def _create_metadata(self) -> typing.Optional[typing.List[typing.Tuple[str, str]
         """Create gRPC metadata headers for the request.
         
         Returns gRPC metadata as a list of tuples containing header key-value pairs.
-        The selector is passed via the 'flagd-selector' header per flagd v0.11.0+ specification.
+        The selector is passed via the 'flagd-selector' header per flagd v0.11.0+ specification,
+        while also being included in the request body for backward compatibility with older flagd versions.
         """
         if self.selector is None:
             return None

providers/openfeature-provider-flagd/tests/test_grpc_watcher.py

@@ -134,8 +134,8 @@ def test_listen_with_sync_metadata_disabled_in_config(self):
         )
         self.assertEqual(self.context, {})
 
-    def test_selector_passed_via_metadata_header(self):
-        """Test that selector is passed via gRPC metadata header, not request body"""
+    def test_selector_passed_via_both_metadata_and_body(self):
+        """Test that selector is passed via both gRPC metadata header and request body for backward compatibility"""
         self.grpc_watcher.selector = "test-selector"
         mock_stream = iter(
             [
@@ -152,11 +152,11 @@ def test_selector_passed_via_metadata_header(self):
         # Get the call arguments
         call_args = self.mock_stub.SyncFlags.call_args
 
-        # Verify the request doesn't contain selector in body
+        # Verify the request contains selector in body (backward compatibility)
         request = call_args[0][0]  # First positional argument is the request
-        self.assertFalse(hasattr(request, 'selector') and request.selector)
+        self.assertEqual(request.selector, 'test-selector')
 
-        # Verify metadata contains flagd-selector header
+        # Verify metadata also contains flagd-selector header (new approach)
         kwargs = call_args[1]
         self.assertIn('metadata', kwargs)
         metadata = kwargs['metadata']