Add support for excluding attributes in metrics View

.changelog/5332.added

@@ -0,0 +1 @@
+`opentelemetry-sdk`: add support for parameter `exclude_attribute_keys` in `View`

opentelemetry-configuration/src/opentelemetry/configuration/_meter_provider.py

@@ -239,12 +239,10 @@ def _create_view(config: ViewConfig) -> View:
             )
 
     attribute_keys: set[str] | None = None
+    exclude_attribute_keys: set[str] | None = None
     if stream.attribute_keys is not None:
-        if stream.attribute_keys.excluded:
-            _logger.warning(
-                "attribute_keys.excluded is not supported by the Python SDK View; "
-                "the exclusion list will be ignored."
-            )
+        if stream.attribute_keys.excluded is not None:
+            exclude_attribute_keys = set(stream.attribute_keys.excluded)
         if stream.attribute_keys.included is not None:
             attribute_keys = set(stream.attribute_keys.included)
 
@@ -263,6 +261,7 @@ def _create_view(config: ViewConfig) -> View:
         description=stream.description,
         attribute_keys=attribute_keys,
         aggregation=aggregation,
+        exclude_attribute_keys=exclude_attribute_keys,
     )
 
 

opentelemetry-configuration/tests/test_meter_provider.py

@@ -876,15 +876,16 @@ def test_stream_attribute_keys_included(self):
         )
         self.assertEqual(view._attribute_keys, {"key1", "key2"})
 
-    def test_stream_attribute_keys_excluded_logs_warning(self):
+    def test_stream_attribute_keys_excluded_is_applied(self):
         config = self._make_view_config(
             stream_kwargs={"attribute_keys": IncludeExclude(excluded=["key1"])}
         )
-        with self.assertLogs(
-            "opentelemetry.configuration._meter_provider", level="WARNING"
-        ) as log:
-            create_meter_provider(config)
-        self.assertTrue(any("excluded" in msg for msg in log.output))
+        meter_provider = create_meter_provider(config)
+        views = meter_provider._sdk_config.views
+        self.assertEqual(len(views), 1)
+        view = views[0]
+        self.assertEqual(view._exclude_attribute_keys, frozenset({"key1"}))
+        self.assertIsNone(view._attribute_keys)
 
     def test_stream_aggregation_drop(self):
         view = self._get_view(

opentelemetry-sdk/src/opentelemetry/sdk/metrics/_internal/_view_instrument_match.py

@@ -98,6 +98,21 @@ def consume_measurement(
         else:
             attributes = {}
 
+        if self._view._exclude_attribute_keys:
+            attributes = {
+                key: value
+                for key, value in attributes.items()
+                if key not in self._view._exclude_attribute_keys
+            }
+
+        if self._view._attribute_keys is not None or self._view._exclude_attribute_keys:
+            measurement = Measurement(
+                value=measurement.value,
+                time_unix_nano=measurement.time_unix_nano,
+                instrument=measurement.instrument,
+                context=measurement.context,
+                attributes=attributes,
+            )
         aggr_key = frozenset(attributes.items())
 
         if aggr_key not in self._attributes_aggregation:

opentelemetry-sdk/src/opentelemetry/sdk/metrics/_internal/view.py

@@ -88,6 +88,12 @@ class View:
         instrument_unit: This is an instrument matching attribute: the unit the
             instrument must have to match the view.
 
+        exclude_attribute_keys: This is a metric stream customizing attribute: this is
+            a set of attribute keys. If not `None` then measurement attributes whose
+            keys are in ``exclude_attribute_keys`` will be removed before identifying
+            the metric stream. Applied after ``attribute_keys`` if both are provided.
+
+
     This class is not intended to be subclassed by the user.
     """
 
@@ -109,6 +115,7 @@ def __init__(
         ]
         | None = None,
         instrument_unit: str | None = None,
+        exclude_attribute_keys: set[str] | None = None,
     ):
         if (
             instrument_type
@@ -147,11 +154,18 @@ def __init__(
         self._meter_schema_url = meter_schema_url
 
         self._description = description
-        self._attribute_keys = attribute_keys
+        self._attribute_keys = (
+            frozenset(attribute_keys) if attribute_keys is not None else None
+        )
         self._aggregation = aggregation or self._default_aggregation
         self._exemplar_reservoir_factory = (
             exemplar_reservoir_factory or _default_reservoir_factory
         )
+        self._exclude_attribute_keys = (
+            frozenset(exclude_attribute_keys)
+            if exclude_attribute_keys is not None
+            else None
+        )
 
     # pylint: disable=too-many-return-statements
     # pylint: disable=too-many-branches

opentelemetry-sdk/tests/metrics/test_view_instrument_match.py

@@ -74,6 +74,125 @@ def setUpClass(cls):
             views=[],
         )
 
+    def test_view_instrument_match_exclude_attribute_keys_affects_aggregation(
+        self,
+    ):
+        instrument1 = Mock(name="instrument1")
+        instrument1.instrumentation_scope = self.mock_instrumentation_scope
+
+        mock_aggregation = MagicMock()
+        mock_aggregation._create_aggregation.return_value = MagicMock()
+
+        instrument_class_aggregation = MagicMock()
+        instrument_class_aggregation.__getitem__.return_value = (
+            mock_aggregation
+        )
+
+        view = View(
+            instrument_name="instrument1",
+            exclude_attribute_keys={"user_id"},
+        )
+        match = _ViewInstrumentMatch(
+            view,
+            instrument=instrument1,
+            instrument_class_aggregation=instrument_class_aggregation,
+        )
+        measurement1 = Measurement(
+            value=1,
+            time_unix_nano=time_ns(),
+            instrument=instrument1,
+            context=Context(),
+            attributes={"method": "GET", "user_id": "u1"},
+        )
+        measurement2 = Measurement(
+            value=2,
+            time_unix_nano=time_ns(),
+            instrument=instrument1,
+            context=Context(),
+            attributes={"method": "GET", "user_id": "u2"},
+        )
+
+        match.consume_measurement(measurement1)
+        match.consume_measurement(measurement2)
+
+        self.assertEqual(
+            len(match._attributes_aggregation),
+            1,
+        )
+
+        aggr_key = list(match._attributes_aggregation.keys())[0]
+        self.assertDictEqual(
+            dict(aggr_key),
+            {"method": "GET"},
+        )
+
+    def test_view_instrument_match_exclude_removes_attributes(self):
+        instrument1 = Mock(name="instrument1")
+        instrument1.instrumentation_scope = self.mock_instrumentation_scope
+        mock_aggregation = MagicMock()
+        mock_aggregation._create_aggregation.return_value = MagicMock()
+
+        instrument_class_aggregation = MagicMock()
+        instrument_class_aggregation.__getitem__.return_value = (
+            mock_aggregation
+        )
+        view = View(
+            instrument_name="instrument1",
+            exclude_attribute_keys={"user_id"},
+        )
+        match = _ViewInstrumentMatch(
+            view,
+            instrument=instrument1,
+            instrument_class_aggregation=instrument_class_aggregation,
+        )
+        measurement = Measurement(
+            value=1,
+            time_unix_nano=time_ns(),
+            instrument=instrument1,
+            context=Context(),
+            attributes={"method": "GET", "user_id": "u1"},
+        )
+        match.consume_measurement(measurement)
+        aggr_key = list(match._attributes_aggregation.keys())[0]
+        self.assertNotIn(
+            "user_id",
+            dict(aggr_key),
+        )
+
+    def test_view_instrument_match_include_then_exclude(self):
+        instrument1 = Mock(name="instrument1")
+        instrument1.instrumentation_scope = self.mock_instrumentation_scope
+        mock_aggregation = MagicMock()
+        mock_aggregation._create_aggregation.return_value = MagicMock()
+
+        instrument_class_aggregation = MagicMock()
+        instrument_class_aggregation.__getitem__.return_value = (
+            mock_aggregation
+        )
+        view = View(
+            instrument_name="instrument1",
+            attribute_keys={"method", "user_id"},
+            exclude_attribute_keys={"user_id"},
+        )
+        match = _ViewInstrumentMatch(
+            view,
+            instrument=instrument1,
+            instrument_class_aggregation=instrument_class_aggregation,
+        )
+        measurement = Measurement(
+            value=1,
+            time_unix_nano=time_ns(),
+            instrument=instrument1,
+            context=Context(),
+            attributes={"method": "GET", "user_id": "u1", "x": "y"},
+        )
+        match.consume_measurement(measurement)
+        aggr_key = list(match._attributes_aggregation.keys())[0]
+        self.assertDictEqual(
+            dict(aggr_key),
+            {"method": "GET"},
+        )
+
     def test_consume_measurement(self):
         instrument1 = Mock(name="instrument1")
         instrument1.instrumentation_scope = self.mock_instrumentation_scope