def __init__(
self,
name: str,
context: trace_api.SpanContext,
parent: Optional[trace_api.SpanContext] = None,
sampler: Optional[sampling.Sampler] = None,
trace_config: None = None, # TODO
resource: Resource = Resource.create({}),
attributes: types.Attributes = None,
events: Sequence[Event] = None,
links: Sequence[trace_api.Link] = (),
kind: trace_api.SpanKind = trace_api.SpanKind.INTERNAL,
span_processor: SpanProcessor = SpanProcessor(),
instrumentation_info: InstrumentationInfo = None,
record_exception: bool = True,
set_status_on_exception: bool = True,
limits=_UnsetLimits,
) -> None:
super().__init__(
name=name,
context=context,
parent=parent,
kind=kind,
resource=resource,
instrumentation_info=instrumentation_info,
)
self._sampler = sampler
self._trace_config = trace_config
self._record_exception = record_exception
self._set_status_on_exception = set_status_on_exception
self._span_processor = span_processor
self._limits = limits
self._lock = threading.Lock()
self._attributes = BoundedAttributes(
self._limits.max_span_attributes,
attributes,
immutable=False,
max_value_len=self._limits.max_span_attribute_length,
)
self._events = self._new_events()
if events:
for event in events:
event._attributes = BoundedAttributes(
self._limits.max_event_attributes,
event.attributes,
max_value_len=self._limits.max_attribute_length,
)
self._events.append(event)
if links is None:
self._links = self._new_links()
else:
for link in links:
link._attributes = BoundedAttributes(
self._limits.max_link_attributes,
link.attributes,
max_value_len=self._limits.max_attribute_length,
)
self._links = BoundedList.from_seq(self._limits.max_links, links)
def test_no_limit_code(self):
bdict = BoundedAttributes(maxlen=None, immutable=False)
for num in range(100):
bdict[str(num)] = num
for num in range(100):
self.assertEqual(bdict[str(num)], num)
def __init__(
self,
context: "SpanContext",
attributes: types.Attributes = None,
) -> None:
super().__init__(context)
self._attributes = BoundedAttributes(
attributes=attributes
) # type: types.Attributes
def _generate_metric(name, point) -> Metric:
return Metric(
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
instrumentation_info=InstrumentationInfo(
"first_name", "first_version"
),
attributes=BoundedAttributes(attributes={"a": 1, "b": True}),
description="foo",
name=name,
unit="s",
point=point,
)
def test_from_map(self):
dic_len = len(self.base)
base_copy = collections.OrderedDict(self.base)
bdict = BoundedAttributes(dic_len, base_copy)
self.assertEqual(len(bdict), dic_len)
# modify base_copy and test that bdict is not changed
base_copy["name"] = "Bruno"
base_copy["age"] = 3
for key in self.base:
self.assertEqual(bdict[key], self.base[key])
# test that iter yields the correct number of elements
self.assertEqual(len(tuple(bdict)), dic_len)
# map too big
half_len = dic_len // 2
bdict = BoundedAttributes(half_len, self.base)
self.assertEqual(len(tuple(bdict)), half_len)
self.assertEqual(bdict.dropped, dic_len - half_len)
def add_event(
self,
name: str,
attributes: types.Attributes = None,
timestamp: Optional[int] = None,
) -> None:
attributes = BoundedAttributes(
self._limits.max_event_attributes,
attributes,
max_value_len=self._limits.max_attribute_length,
)
self._add_event(
Event(
name=name,
attributes=attributes,
timestamp=timestamp,
)
)
def test_bounded_dict(self):
# create empty dict
dic_len = len(self.base)
bdict = BoundedAttributes(dic_len, immutable=False)
self.assertEqual(len(bdict), 0)
# fill dict
for key in self.base:
bdict[key] = self.base[key]
self.assertEqual(len(bdict), dic_len)
self.assertEqual(bdict.dropped, 0)
for key in self.base:
self.assertEqual(bdict[key], self.base[key])
# test __iter__ in BoundedAttributes
for key in bdict:
self.assertEqual(bdict[key], self.base[key])
# updating an existing element should not drop
bdict["name"] = "Bruno"
self.assertEqual(bdict.dropped, 0)
# try to append more elements
for key in self.base:
bdict["new-" + key] = self.base[key]
self.assertEqual(len(bdict), dic_len)
self.assertEqual(bdict.dropped, dic_len)
# Invalid values shouldn't be considered for `dropped`
bdict["invalid-seq"] = [None, 1, "2"]
self.assertEqual(bdict.dropped, dic_len)
# test that elements in the dict are the new ones
for key in self.base:
self.assertEqual(bdict["new-" + key], self.base[key])
# delete an element
del bdict["new-name"]
self.assertEqual(len(bdict), dic_len - 1)
with self.assertRaises(KeyError):
_ = bdict["new-name"]
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter(insecure=True)
tracer_provider.add_span_processor(SimpleSpanProcessor(self.exporter))
self.tracer = tracer_provider.get_tracer(__name__)
self.server = server(ThreadPoolExecutor(max_workers=10))
self.server.add_insecure_port("[::]:4317")
self.server.start()
event_mock = Mock(
**{
"timestamp": 1591240820506462784,
"attributes": BoundedAttributes(
attributes={"a": 1, "b": False}
),
}
)
type(event_mock).name = PropertyMock(return_value="a")
self.span = _Span(
"a",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
attributes=BoundedAttributes(attributes={"a": 1, "b": True}),
events=[event_mock],
links=[
Mock(
**{
"context.trace_id": 1,
"context.span_id": 2,
"attributes": BoundedAttributes(
attributes={"a": 1, "b": False}
),
"kind": OTLPSpan.SpanKind.SPAN_KIND_INTERNAL, # pylint: disable=no-member
}
)
],
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
)
self.span2 = _Span(
"b",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 2), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
)
self.span3 = _Span(
"c",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
instrumentation_info=InstrumentationInfo(
name="name2", version="version2"
),
)
self.span.start()
self.span.end()
self.span2.start()
self.span2.end()
self.span3.start()
self.span3.end()
def test_immutable(self):
bdict = BoundedAttributes()
with self.assertRaises(TypeError):
bdict["should-not-work"] = "dict immutable"
def test_negative_maxlen(self):
with self.assertRaises(ValueError):
BoundedAttributes(-1)