Add runtime validation in setAttribute

opentelemetry-api/src/opentelemetry/util/types.py

@@ -15,5 +15,7 @@
 
 import typing
 
-AttributeValue = typing.Union[str, bool, float]
+AttributeValue = typing.Union[
+    str, bool, int, float, typing.Sequence[typing.Union[str, bool, int, float]]
+]
 Attributes = typing.Optional[typing.Dict[str, AttributeValue]]

opentelemetry-sdk/src/opentelemetry/sdk/trace/__init__.py

@@ -18,6 +18,7 @@
 import random
 import threading
 from contextlib import contextmanager
+from numbers import Number
 from types import TracebackType
 from typing import Iterator, Optional, Sequence, Tuple, Type
 
@@ -208,8 +209,38 @@ def set_attribute(self, key: str, value: types.AttributeValue) -> None:
         if has_ended:
             logger.warning("Setting attribute on ended span.")
             return
+
+        if not isinstance(value, (int, float, bool, str, list, tuple)):
+            logger.warning("invalid type for attribute value")
+            return
+        if isinstance(value, (list, tuple)) and len(value) > 0:
+            return_code = self._check_sequence(value)
+            if return_code is not None:
+                logger.warning("%s in attribute value sequence", return_code)
+                return
+
         self.attributes[key] = value
 
+    @staticmethod
+    def _check_sequence(sequence: (list, tuple)) -> Optional[str]:
+        """
+        Checks if sequence items are valid and identical
+        """
+        first_element_type = type(sequence[0])
+
+        if issubclass(type(sequence[0]), Number):
+            first_element_type = Number
+
+        for element in sequence:
+
+            if not isinstance(element, (bool, str, Number)):
+                return "invalid type"
+
+            if not isinstance(element, first_element_type):
+                return "different type"
+
+        return None
+
     def add_event(
         self,
         name: str,

opentelemetry-sdk/tests/trace/test_trace.py

@@ -368,7 +368,11 @@ def test_attributes(self):
             root.set_attribute("attr-key", "attr-value1")
             root.set_attribute("attr-key", "attr-value2")
 
-            self.assertEqual(len(root.attributes), 7)
+            root.set_attribute("empty-list", [])
+            root.set_attribute("list-of-bools", [True, True, False])
+            root.set_attribute("list-of-numerics", [123, 3.14, 0])
+
+            self.assertEqual(len(root.attributes), 10)
             self.assertEqual(root.attributes["component"], "http")
             self.assertEqual(root.attributes["http.method"], "GET")
             self.assertEqual(
@@ -379,6 +383,13 @@ def test_attributes(self):
             self.assertEqual(root.attributes["http.status_text"], "OK")
             self.assertEqual(root.attributes["misc.pi"], 3.14)
             self.assertEqual(root.attributes["attr-key"], "attr-value2")
+            self.assertEqual(root.attributes["empty-list"], [])
+            self.assertEqual(
+                root.attributes["list-of-bools"], [True, True, False]
+            )
+            self.assertEqual(
+                root.attributes["list-of-numerics"], [123, 3.14, 0]
+            )
 
         attributes = {
             "attr-key": "val",
@@ -393,6 +404,38 @@ def test_attributes(self):
             self.assertEqual(root.attributes["attr-key2"], "val2")
             self.assertEqual(root.attributes["attr-in-both"], "span-attr")
 
+    def test_invalid_attribute_values(self):
+        with self.tracer.start_as_current_span("root") as root:
+            root.set_attribute("non-primitive-data-type", dict())
+            root.set_attribute(
+                "list-of-mixed-data-types-numeric-first",
+                [123, False, "string"],
+            )
+            root.set_attribute(
+                "list-of-mixed-data-types-non-numeric-first",
+                [False, 123, "string"],
+            )
+            root.set_attribute(
+                "list-with-non-primitive-data-type", [dict(), 123]
+            )
+
+            self.assertEqual(len(root.attributes), 0)
+
+    def test_check_sequence_helper(self):
+        # pylint: disable=protected-access
+        self.assertEqual(
+            trace.Span._check_sequence([1, 2, 3.4, "ss", 4]), "different type"
+        )
+        self.assertEqual(
+            trace.Span._check_sequence([1, 2, 3.4, dict(), 4]), "invalid type"
+        )
+        self.assertEqual(
+            trace.Span._check_sequence(["sw", "lf", 3.4, "ss"]),
+            "different type",
+        )
+        self.assertIsNone(trace.Span._check_sequence([1, 2, 3.4, 5]))
+        self.assertIsNone(trace.Span._check_sequence(["ss", "dw", "fw"]))
+
     def test_sampling_attributes(self):
         decision_attributes = {
             "sampler-attr": "sample-val",