fix EnvironmentGetter carrier normalization

Assisted-by: ChatGPT 5

Author: pellared

.changelog/5221.fixed

@@ -0,0 +1 @@
+`opentelemetry-api`: normalize `EnvironmentGetter` carrier keys

opentelemetry-api/src/opentelemetry/propagators/_envcarrier.py

@@ -39,19 +39,36 @@ def __init__(self):
             _normalize_key(k): v for k, v in os.environ.items()
         }
 
+    def _carrier(
+        self, carrier: typing.Mapping[str, str]
+    ) -> typing.Mapping[str, str]:
+        return carrier or self.carrier
+
     def get(
         self, carrier: typing.Mapping[str, str], key: str
     ) -> list[str] | None:
         """Get a value from the environment carrier for the given key.
 
         Args:
-            carrier: Not used; maintained for interface compatibility with Getter[CarrierT]
-            key: The key to look up (case-insensitive)
+            carrier: Mapping to read from. If empty, uses the environment
+                snapshot captured at initialization.
+            key: The key to look up (normalized before lookup)
 
         Returns:
             A list with a single string value if the key exists, None otherwise.
         """
-        val = self.carrier.get(_normalize_key(key))
+        source = self._carrier(carrier)
+        normalized_key = _normalize_key(key)
+        val = source.get(normalized_key)
+        if val is None:
+            val = next(
+                (
+                    carrier_value
+                    for carrier_key, carrier_value in source.items()
+                    if _normalize_key(carrier_key) == normalized_key
+                ),
+                None,
+            )
         if val is None:
             return None
         return [val]
@@ -60,12 +77,13 @@ def keys(self, carrier: typing.Mapping[str, str]) -> list[str]:
         """Get all keys from the environment carrier.
 
         Args:
-            carrier: Not used; maintained for interface compatibility with Getter[CarrierT]
+            carrier: Mapping to read from. If empty, uses the environment
+                snapshot captured at initialization.
 
         Returns:
             List of all environment variable keys (normalized).
         """
-        return list(self.carrier.keys())
+        return [_normalize_key(key) for key in self._carrier(carrier)]
 
 
 class EnvironmentSetter(Setter[MutableMapping[str, str]]):

opentelemetry-api/tests/propagators/test__envcarrier.py

@@ -93,27 +93,51 @@ def test_keys(self):
             expected_keys = {"KEY1", "KEY2", "KEY3"}
             self.assertEqual(set(keys), expected_keys)
 
+    def test_get_normalizes_carrier_keys(self):
+        """Test lookup when the carrier stores non-normalized keys."""
+        with patch.dict(os.environ, {}, clear=True):
+            getter = EnvironmentGetter()
+            carrier = {"x-b3-traceid": "abc123"}
+
+            result = getter.get(carrier, "x-b3-traceid")
+
+            self.assertEqual(result, ["abc123"])
+
+    def test_get_uses_carrier_before_environment_snapshot(self):
+        """Test that explicit carriers take precedence over the snapshot."""
+        with patch.dict(os.environ, {"X_B3_TRACEID": "from_env"}):
+            getter = EnvironmentGetter()
+            carrier = {"x-b3-traceid": "from_carrier"}
+
+            result = getter.get(carrier, "x-b3-traceid")
+
+            self.assertEqual(result, ["from_carrier"])
+
+    def test_keys_normalizes_carrier_keys(self):
+        """Test getting normalized keys from an explicit carrier."""
+        with patch.dict(os.environ, {}, clear=True):
+            getter = EnvironmentGetter()
+            keys = getter.keys(
+                {"x-b3-traceid": "value1", "BAGGAGE": "value2"}
+            )
+
+            self.assertEqual(set(keys), {"X_B3_TRACEID", "BAGGAGE"})
+
     def test_keys_empty_environment(self):
         """Test getting keys when environment is empty."""
         with patch.dict(os.environ, {}, clear=True):
             getter = EnvironmentGetter()
             keys = getter.keys({})
             self.assertEqual(keys, [])
 
-    def test_uses_snapshot_not_carrier_parameter(self):
-        """Test that getter uses internal snapshot, not carrier parameter.
-
-        The carrier parameter exists for interface compatibility with
-        Getter[CarrierT], but EnvironmentGetter reads from os.environ at
-        initialization, creating an immutable snapshot.
-        """
+    def test_uses_snapshot_when_carrier_is_empty(self):
+        """Test that getter uses its internal snapshot for an empty carrier."""
         with patch.dict(os.environ, {"TEST_KEY": "test_value"}):
             getter = EnvironmentGetter()
-            # Both return same value from snapshot, carrier is ignored
-            result1 = getter.get({}, "test_key")
-            result2 = getter.get({"test_key": "different"}, "test_key")
-            self.assertEqual(result1, ["test_value"])
-            self.assertEqual(result2, ["test_value"])
+
+            result = getter.get({}, "test_key")
+
+            self.assertEqual(result, ["test_value"])
 
     def test_snapshot_immutability(self):
         """Test that getter snapshot doesn't see changes after initialization."""