sdk/trace/span: expose members using properties

Given that we are passing the whole Span directly to the exporters, expose
members using properties to avoid undesired updates.

Author: mauriciovasquezbernal

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

@@ -246,82 +246,111 @@ def __init__(
         span_processor: SpanProcessor = SpanProcessor(),
     ) -> None:
 
-        self.name = name
-        self.context = context
-        self.parent = parent
-        self.sampler = sampler
-        self.trace_config = trace_config
-        self.resource = resource
-        self.attributes = attributes
-        self.events = events
-        self.links = links
-        self.span_processor = span_processor
+        self._name = name
+        self._context = context
+        self._parent = parent
+        self._sampler = sampler
+        self._trace_config = trace_config
+        self._resource = resource
+        self._attributes = attributes
+        self._events = events
+        self._links = links
+        self._span_processor = span_processor
 
         if attributes is None:
-            self.attributes = Span.empty_attributes
+            self._attributes = Span.empty_attributes
         else:
-            self.attributes = BoundedDict.from_map(
+            self._attributes = BoundedDict.from_map(
                 MAX_NUM_ATTRIBUTES, attributes
             )
 
         if events is None:
-            self.events = Span.empty_events
+            self._events = Span.empty_events
         else:
-            self.events = BoundedList.from_seq(MAX_NUM_EVENTS, events)
+            self._events = BoundedList.from_seq(MAX_NUM_EVENTS, events)
 
         if links is None:
-            self.links = Span.empty_links
+            self._links = Span.empty_links
         else:
-            self.links = BoundedList.from_seq(MAX_NUM_LINKS, links)
+            self._links = BoundedList.from_seq(MAX_NUM_LINKS, links)
 
-        self.end_time = None
-        self.start_time = None
+        self._end_time = None
+        self._start_time = None
 
     def __repr__(self):
         return '{}(name="{}")'.format(type(self).__name__, self.name)
 
     def get_context(self):
-        return self.context
+        return self._context
 
     def set_attribute(
         self: "Span", key: str, value: types.AttributeValue
     ) -> None:
-        if self.attributes is Span.empty_attributes:
-            self.attributes = BoundedDict(MAX_NUM_ATTRIBUTES)
-        self.attributes[key] = value
+        if self._attributes is Span.empty_attributes:
+            self._attributes = BoundedDict(MAX_NUM_ATTRIBUTES)
+        self._attributes[key] = value
 
     def add_event(
         self: "Span", name: str, attributes: types.Attributes = None
     ) -> None:
-        if self.events is Span.empty_events:
-            self.events = BoundedList(MAX_NUM_EVENTS)
+        if self._events is Span.empty_events:
+            self._events = BoundedList(MAX_NUM_EVENTS)
         if attributes is None:
             attributes = Span.empty_attributes
-        self.events.append(Event(name, attributes))
+        self._events.append(Event(name, attributes))
 
     def add_link(
         self: "Span",
         link_target_context: "trace_api.SpanContext",
         attributes: types.Attributes = None,
     ) -> None:
-        if self.links is Span.empty_links:
-            self.links = BoundedList(MAX_NUM_LINKS)
+        if self._links is Span.empty_links:
+            self._links = BoundedList(MAX_NUM_LINKS)
         if attributes is None:
             attributes = Span.empty_attributes
-        self.links.append(Link(link_target_context, attributes))
+        self._links.append(Link(link_target_context, attributes))
 
     def start(self):
-        if self.start_time is None:
-            self.start_time = util.time_ns()
-            self.span_processor.on_start(self)
+        if self._start_time is None:
+            self._start_time = util.time_ns()
+            self._span_processor.on_start(self)
 
     def end(self):
-        if self.end_time is None:
-            self.end_time = util.time_ns()
-            self.span_processor.on_end(self)
+        if self._end_time is None:
+            self._end_time = util.time_ns()
+            self._span_processor.on_end(self)
 
     def update_name(self, name: str) -> None:
-        self.name = name
+        self._name = name
+
+    # accessors
+    @property
+    def events(self) -> Event:
+        return self._events
+
+    @property
+    def attributes(self) -> types.Attributes:
+        return self._attributes
+
+    @property
+    def links(self) -> Link:
+        return self._links
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def start_time(self) -> int:
+        return self._start_time
+
+    @property
+    def end_time(self) -> int:
+        return self._end_time
+
+    @property
+    def parent(self) -> trace_api.ParentSpan:
+        return self._parent
 
 
 def generate_span_id():