WIP

Author: ocelotl

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

@@ -19,6 +19,7 @@
 from collections.abc import MutableMapping
 from typing import Optional, Sequence, Union
 
+from opentelemetry.opentelemetry import OpenTelemetry
 from opentelemetry.util import types
 
 # bytes are accepted as a user supplied value for attributes but
@@ -126,7 +127,7 @@ def _clean_attribute_value(
     return value
 
 
-class BoundedAttributes(MutableMapping):
+class BoundedAttributes(OpenTelemetry, MutableMapping):
     """An ordered dict with a fixed max capacity.
 
     Oldest elements are dropped when the dict is full and a new element is
@@ -140,6 +141,12 @@ def __init__(
         immutable: bool = True,
         max_value_len: Optional[int] = None,
     ):
+        super().__init__(
+            maxlen=maxlen,
+            attributes=attributes,
+            immutable=immutable,
+            max_value_len=max_value_len,
+        )
         if maxlen is not None:
             if not isinstance(maxlen, int) or maxlen < 0:
                 raise ValueError(
@@ -155,11 +162,6 @@ def __init__(
                 self[key] = value
         self._immutable = immutable
 
-    def __repr__(self):
-        return (
-            f"{type(self).__name__}({dict(self._dict)}, maxlen={self.maxlen})"
-        )
-
     def __getitem__(self, key):
         return self._dict[key]
 

opentelemetry-api/src/opentelemetry/metrics/_internal/observation.py

@@ -14,10 +14,11 @@
 
 from typing import Union
 
+from opentelemetry.opentelemetry import OpenTelemetry
 from opentelemetry.util.types import Attributes
 
 
-class Observation:
+class Observation(OpenTelemetry):
     """A measurement observed in an asynchronous instrument
 
     Return/yield instances of this class from asynchronous instrument callbacks.
@@ -47,6 +48,3 @@ def __eq__(self, other: object) -> bool:
             and self.value == other.value
             and self.attributes == other.attributes
         )
-
-    def __repr__(self) -> str:
-        return f"Observation(value={self.value}, attributes={self.attributes})"

opentelemetry-api/src/opentelemetry/opentelemetry.py

@@ -0,0 +1,67 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from inspect import signature
+
+
+class OpenTelemetry:
+    def __init__(self, *args, **kwargs) -> None:
+
+        args = list(args)
+
+        object.__setattr__(self, "_repr", [])
+
+        parameters = signature(self.__init__).parameters.values()
+
+        for index, parameter in enumerate(parameters):
+            if (
+                parameter.kind is parameter.POSITIONAL_ONLY
+                or parameter.kind is parameter.POSITIONAL_OR_KEYWORD
+            ):
+                if args:
+                    self._repr.append(repr(args.pop(0)))
+                else:
+                    break
+            elif parameter.kind is parameter.VAR_POSITIONAL:
+                for _ in range(len(args)):
+                    self._repr.append(repr(args.pop(0)))
+
+        for index, parameter in enumerate(parameters):
+            if parameter.kind is parameter.KEYWORD_ONLY:
+                if args:
+                    value = args.pop(0)
+
+                    if parameter.default != value:
+                        self._repr.append(f"{parameter.name}={repr(value)}")
+                else:
+                    break
+
+        for parameter in parameters:
+            if (
+                parameter.kind is parameter.KEYWORD_ONLY
+                or parameter.kind is parameter.POSITIONAL_OR_KEYWORD
+            ) and parameter.name in kwargs.keys():
+                value = kwargs.pop(parameter.name)
+
+                if parameter.default != value:
+                    self._repr.append(f"{parameter.name}={repr(value)}")
+
+            elif parameter.kind is parameter.VAR_KEYWORD:
+                for key, value in kwargs.items():
+                    self._repr.append(f"{key}={repr(value)}")
+
+        self._repr = f"{self.__class__.__name__}({', '.join(self._repr)})"
+
+    def __repr__(self) -> str:
+        return self._repr

opentelemetry-api/src/opentelemetry/trace/span.py

@@ -5,6 +5,7 @@
 import typing
 from collections import OrderedDict
 
+from opentelemetry.opentelemetry import OpenTelemetry
 from opentelemetry.trace.status import Status, StatusCode
 from opentelemetry.util import types
 
@@ -54,7 +55,7 @@ def _is_valid_pair(key: str, value: str) -> bool:
     )
 
 
-class Span(abc.ABC):
+class Span(OpenTelemetry, abc.ABC):
     """A span represents a single operation within a trace."""
 
     @abc.abstractmethod
@@ -201,7 +202,7 @@ def sampled(self) -> bool:
 DEFAULT_TRACE_OPTIONS = TraceFlags.get_default()
 
 
-class TraceState(typing.Mapping[str, str]):
+class TraceState(OpenTelemetry, typing.Mapping[str, str]):
     """A list of key-value pairs representing vendor-specific trace info.
 
     Keys and values are strings of up to 256 printable US-ASCII characters.
@@ -218,6 +219,7 @@ def __init__(
             typing.Sequence[typing.Tuple[str, str]]
         ] = None,
     ) -> None:
+        super().__init__(entries=entries)
         self._dict = OrderedDict()  # type: OrderedDict[str, str]
         if entries is None:
             return
@@ -251,13 +253,6 @@ def __iter__(self) -> typing.Iterator[str]:
     def __len__(self) -> int:
         return len(self._dict)
 
-    def __repr__(self) -> str:
-        pairs = [
-            f"{{key={key}, value={value}}}"
-            for key, value in self._dict.items()
-        ]
-        return str(pairs)
-
     def add(self, key: str, value: str) -> "TraceState":
         """Adds a key-value pair to tracestate. The provided pair should
         adhere to w3c tracestate identifiers format.
@@ -404,7 +399,8 @@ def values(self) -> typing.ValuesView[str]:
 
 
 class SpanContext(
-    typing.Tuple[int, int, bool, "TraceFlags", "TraceState", bool]
+    OpenTelemetry,
+    typing.Tuple[int, int, bool, "TraceFlags", "TraceState", bool],
 ):
     """The state of a Span to propagate between processes.
 
@@ -437,10 +433,19 @@ def __new__(
             and INVALID_SPAN_ID < span_id <= _SPAN_ID_MAX_VALUE
         )
 
-        return tuple.__new__(
+        span_context = tuple.__new__(
             cls,
             (trace_id, span_id, is_remote, trace_flags, trace_state, is_valid),
         )
+        cls.__init__(
+            span_context,
+            trace_id,
+            span_id,
+            is_remote,
+            trace_flags=trace_flags,
+            trace_state=trace_state,
+        )
+        return span_context
 
     def __getnewargs__(
         self,
@@ -487,9 +492,6 @@ def __delattr__(self, *args: str) -> None:
             "Immutable type, ignoring call to set attribute", stack_info=True
         )
 
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}(trace_id=0x{format_trace_id(self.trace_id)}, span_id=0x{format_span_id(self.span_id)}, trace_flags=0x{self.trace_flags:02x}, trace_state={self.trace_state!r}, is_remote={self.is_remote})"
-
 
 class NonRecordingSpan(Span):
     """The Span that is used when no Span implementation is available.
@@ -544,9 +546,6 @@ def record_exception(
     ) -> None:
         pass
 
-    def __repr__(self) -> str:
-        return f"NonRecordingSpan({self._context!r})"
-
 
 INVALID_SPAN_ID = 0x0000000000000000
 INVALID_TRACE_ID = 0x00000000000000000000000000000000