use extended attributes everywhere

Author: Liudmila Molkova

opentelemetry-api/src/opentelemetry/attributes/__init__.py

@@ -38,86 +38,6 @@
 
 _logger = logging.getLogger(__name__)
 
-
-def _clean_attribute(
-    key: str, value: types.AttributeValue, max_len: Optional[int]
-) -> Optional[Union[types.AttributeValue, Tuple[Union[str, int, float], ...]]]:
-    """Checks if attribute value is valid and cleans it if required.
-
-    The function returns the cleaned value or None if the value is not valid.
-
-    An attribute value is valid if it is either:
-        - A primitive type: string, boolean, double precision floating
-            point (IEEE 754-1985) or integer.
-        - An array of primitive type values. The array MUST be homogeneous,
-            i.e. it MUST NOT contain values of different types.
-
-    An attribute needs cleansing if:
-        - Its length is greater than the maximum allowed length.
-        - It needs to be encoded/decoded e.g, bytes to strings.
-    """
-
-    if not (key and isinstance(key, str)):
-        _logger.warning("invalid key `%s`. must be non-empty string.", key)
-        return None
-
-    if isinstance(value, _VALID_ATTR_VALUE_TYPES):
-        return _clean_attribute_value(value, max_len)
-
-    if isinstance(value, Sequence):
-        sequence_first_valid_type = None
-        cleaned_seq = []
-
-        for element in value:
-            element = _clean_attribute_value(element, max_len)  # type: ignore
-            if element is None:
-                cleaned_seq.append(element)
-                continue
-
-            element_type = type(element)
-            # Reject attribute value if sequence contains a value with an incompatible type.
-            if element_type not in _VALID_ATTR_VALUE_TYPES:
-                _logger.warning(
-                    "Invalid type %s in attribute '%s' value sequence. Expected one of "
-                    "%s or None",
-                    element_type.__name__,
-                    key,
-                    [
-                        valid_type.__name__
-                        for valid_type in _VALID_ATTR_VALUE_TYPES
-                    ],
-                )
-                return None
-
-            # The type of the sequence must be homogeneous. The first non-None
-            # element determines the type of the sequence
-            if sequence_first_valid_type is None:
-                sequence_first_valid_type = element_type
-            # use equality instead of isinstance as isinstance(True, int) evaluates to True
-            elif element_type != sequence_first_valid_type:
-                _logger.warning(
-                    "Attribute %r mixes types %s and %s in attribute value sequence",
-                    key,
-                    sequence_first_valid_type.__name__,
-                    type(element).__name__,
-                )
-                return None
-
-            cleaned_seq.append(element)
-
-        # Freeze mutable sequences defensively
-        return tuple(cleaned_seq)
-
-    _logger.warning(
-        "Invalid type %s for attribute '%s' value. Expected one of %s or a "
-        "sequence of those types",
-        type(value).__name__,
-        key,
-        [valid_type.__name__ for valid_type in _VALID_ATTR_VALUE_TYPES],
-    )
-    return None
-
-
 def _clean_extended_attribute_value(
     value: types.AnyValue, max_len: Optional[int]
 ) -> types.AnyValue:
@@ -209,25 +129,6 @@ def _clean_extended_attribute(
         _logger.warning("Attribute %s: %s", key, exception)
         return None
 
-
-def _clean_attribute_value(
-    value: types.AttributeValue, limit: Optional[int]
-) -> Optional[types.AttributeValue]:
-    if value is None:
-        return None
-
-    if isinstance(value, bytes):
-        try:
-            value = value.decode()
-        except UnicodeDecodeError:
-            _logger.warning("Byte attribute could not be decoded.")
-            return None
-
-    if limit is not None and isinstance(value, str):
-        value = value[:limit]
-    return value
-
-
 class BoundedAttributes(MutableMapping):  # type: ignore
     """An ordered dict with a fixed max capacity.
 
@@ -251,7 +152,7 @@ def __init__(
         self.maxlen = maxlen
         self.dropped = 0
         self.max_value_len = max_value_len
-        self._extended_attributes = extended_attributes
+        self._extended_attributes = True
         # OrderedDict is not used until the maxlen is reached for efficiency.
 
         self._dict: Union[
@@ -278,14 +179,9 @@ def __setitem__(self, key: str, value: types.AnyValue) -> None:
                 self.dropped += 1
                 return
 
-            if self._extended_attributes:
-                value = _clean_extended_attribute(
-                    key, value, self.max_value_len
-                )
-            else:
-                value = _clean_attribute(key, value, self.max_value_len)  # type: ignore
-                if value is None:
-                    return
+            value = _clean_extended_attribute(
+                key, value, self.max_value_len
+            )
 
             if key in self._dict:
                 del self._dict[key]