def test_extract_links(self):
self.assertIsNone(_extract_links([]))
trace_id = "6e0c63257de34c92bf9efcd03927272e"
span_id1 = "95bb5edabd45950f"
span_id2 = "b6b86ad2915c9ddc"
link1 = Link(
context=SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id1, 16),
is_remote=False,
),
attributes={},
)
link2 = Link(
context=SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id1, 16),
is_remote=False,
),
attributes=self.attributes_variety_pack,
)
link3 = Link(
context=SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id2, 16),
is_remote=False,
),
attributes={
"illegal_attr_value": dict(),
"int_attr_value": 123
},
)
self.assertEqual(
_extract_links([link1, link2, link3]),
ProtoSpan.Links(link=[
{
"trace_id": trace_id,
"span_id": span_id1,
"type": "TYPE_UNSPECIFIED",
"attributes": ProtoSpan.Attributes(attribute_map={}),
},
{
"trace_id": trace_id,
"span_id": span_id1,
"type": "TYPE_UNSPECIFIED",
"attributes": self.extracted_attributes_variety_pack,
},
{
"trace_id": trace_id,
"span_id": span_id2,
"type": "TYPE_UNSPECIFIED",
"attributes": {
"attribute_map": {
"int_attr_value": AttributeValue(int_value=123)
},
"dropped_attributes_count": 1,
},
},
]),
)
def test_too_many_links(self):
link = Link(
context=SpanContext(
trace_id=int(self.example_trace_id, 16),
span_id=int(self.example_span_id, 16),
is_remote=False,
),
attributes={},
)
too_many_links = [link] * (MAX_NUM_LINKS + 5)
self.assertEqual(
_extract_links(too_many_links),
ProtoSpan.Links(
link=[
{
"trace_id": self.example_trace_id,
"span_id": self.example_span_id,
"type": "TYPE_UNSPECIFIED",
"attributes": {},
}
]
* MAX_NUM_LINKS,
dropped_links_count=len(too_many_links) - MAX_NUM_LINKS,
),
)
def test_span_to_envelope_internal(self):
exporter = self._exporter
start_time = 1575494316027613500
end_time = start_time + 1001000000
# SpanKind.INTERNAL
span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557337,
is_remote=False,
),
attributes={},
kind=SpanKind.INTERNAL,
)
span.start(start_time=start_time)
span.end(end_time=end_time)
span._status = Status(status_code=StatusCode.OK)
envelope = exporter._span_to_envelope(span)
self.assertEqual(envelope.name,
"Microsoft.ApplicationInsights.RemoteDependency")
self.assertEqual(envelope.time, "2019-12-04T21:18:36.027613Z")
self.assertEqual(envelope.data.base_data.name, "test")
self.assertEqual(envelope.data.base_data.id, "a6f5d48acb4d31d9")
self.assertEqual(envelope.data.base_data.duration, "0.00:00:01.001")
self.assertTrue(envelope.data.base_data.success)
self.assertEqual(envelope.data.base_type, "RemoteDependencyData")
self.assertEqual(envelope.data.base_data.type, "InProc")
self.assertEqual(envelope.data.base_data.result_code, "1")
def test_inject_invalid_baggage_values(self):
"""Test that invalid baggage values are not set"""
carrier = {}
self.ot_trace_propagator.inject(
carrier,
set_baggage(
"key",
"α",
context=set_span_in_context(
_Span(
"child",
SpanContext(
trace_id=int("80f198ee56343ba864fe8b2a57d3eff7",
16),
span_id=int("e457b5a2e4d86bd1", 16),
is_remote=True,
trace_flags=TraceFlags.SAMPLED,
),
)),
),
)
self.assertNotIn("".join([OT_BAGGAGE_PREFIX, "key"]), carrier.keys())
def on_message(self, message: 'InboundMessage'):
tracer = trace.get_tracer(__name__)
trace_id = str(message.get_property("trace_id"))
span_id = str(message.get_property("span_id"))
print("parentSpan trace_id on receiver side:" + trace_id)
print("parentSpan span_id on receiver side:" + span_id)
logs_file.write("parentSpan trace_id on receiver side:" + trace_id)
logs_file.write("parentSpan span_id on receiver side:" + span_id)
propagated_context = SpanContext(int(trace_id), int(span_id), True)
childSpan = tracer.start_span("RideUpdated receive",
parent=propagated_context)
topic = message.get_destination_name()
payload_str = message.get_payload_as_string()
print("\n" + f"REST CALLBACK: Message Received on Topic: {topic}.\n"
f"{int(time.time())}: {payload_str} \n")
logs_file.write("\n" +
f"REST CALLBACK: Message Received on Topic: {topic}.\n"
f"{int(time.time())}: {payload_str} \n\n")
time.sleep(1)
childSpan.end()
def test_span_to_envelope_tags(self):
exporter = self._exporter
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
envelope = exporter._span_to_envelope(test_span)
self.assertIsNotNone(envelope.tags)
self.assertIsNone(envelope.tags.get("ai.cloud.role"))
self.assertIsNone(envelope.tags.get("ai.cloud.roleInstance"))
self.assertIsNotNone(envelope.tags.get("ai.device.id"))
self.assertIsNotNone(envelope.tags.get("ai.device.locale"))
self.assertIsNotNone(envelope.tags.get("ai.device.osVersion"))
self.assertIsNotNone(envelope.tags.get("ai.device.type"))
self.assertIsNotNone(envelope.tags.get("ai.internal.sdkVersion"))
test_span.resource = resources.Resource(
{"service.name": "testServiceName",
"service.namespace": "testServiceNamespace",
"service.instance.id": "testServiceInstanceId"})
envelope = exporter._span_to_envelope(test_span)
self.assertEqual(envelope.tags.get("ai.cloud.role"), "testServiceNamespace.testServiceName")
self.assertEqual(envelope.tags.get(
"ai.cloud.roleInstance"), "testServiceInstanceId")
def test_span_envelope_server_messaging(self):
exporter = self._exporter
start_time = 1575494316027613500
end_time = start_time + 1001000000
# SpanKind.SERVER messaging
span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557337,
is_remote=False,
),
attributes={
"messaging.system": "messaging",
"net.peer.name": "test name",
"net.peer.ip": "127.0.0.1",
"messaging.destination": "celery",
},
kind=SpanKind.SERVER,
)
span._status = Status(status_code=StatusCode.OK)
span.start(start_time=start_time)
span.end(end_time=end_time)
envelope = exporter._span_to_envelope(span)
self.assertEqual(envelope.data.base_type, "RequestData")
self.assertEqual(envelope.data.base_data.name, "test")
self.assertEqual(envelope.data.base_data.id, "a6f5d48acb4d31d9")
self.assertEqual(envelope.data.base_data.duration, "0.00:00:01.001")
self.assertTrue(envelope.data.base_data.success)
def test_inject_set_baggage(self):
"""Test that baggage is set"""
carrier = {}
self.ot_trace_propagator.inject(
carrier,
set_baggage(
"key",
"value",
context=set_span_in_context(
_Span(
"child",
SpanContext(
trace_id=int("80f198ee56343ba864fe8b2a57d3eff7",
16),
span_id=int("e457b5a2e4d86bd1", 16),
is_remote=True,
trace_flags=TraceFlags.SAMPLED,
),
)),
),
)
self.assertEqual(carrier["".join([OT_BAGGAGE_PREFIX, "key"])], "value")
def test_span_to_envelope_properties(self):
exporter = self._exporter
start_time = 1575494316027613500
end_time = start_time + 1001000000
# Properties
span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557337,
is_remote=False,
),
attributes={
"test": "asd",
"http.method": "GET",
"http.url": "https://www.wikipedia.org/wiki/Rabbit",
"http.status_code": 200,
},
kind=SpanKind.CLIENT,
)
span._status = Status(status_code=StatusCode.OK)
span.start(start_time=start_time)
span.end(end_time=end_time)
envelope = exporter._span_to_envelope(span)
self.assertEqual(len(envelope.data.base_data.properties), 1)
self.assertEqual(envelope.data.base_data.properties["test"], "asd")
def test_export_success(self):
exporter = self._exporter
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
with mock.patch(
"microsoft.opentelemetry.exporter.azuremonitor.export.trace.AzureMonitorSpanExporter._transmit"
) as transmit: # noqa: E501
transmit.return_value = ExportResult.SUCCESS
storage_mock = mock.Mock()
exporter._transmit_from_storage = storage_mock
exporter.export([test_span])
self.assertEqual(len(exporter._telemetry_processors), 1)
self.assertEqual(storage_mock.call_count, 1)
try:
self.assertEqual(len(os.listdir(exporter.storage.path)), 0)
except FileNotFoundError as ex:
pass
def build_test_span_context(
trace_id=int(TRACE_ID_BASE16, 16),
span_id=int(SPAN_ID_BASE16, 16),
is_remote=True,
trace_flags=DEFAULT_TRACE_OPTIONS,
trace_state=DEFAULT_TRACE_STATE,
):
return SpanContext(trace_id, span_id, is_remote, trace_flags, trace_state,)
def test_export(self):
trace_id = "6e0c63257de34c92bf9efcd03927272e"
span_id = "95bb5edabd45950f"
span_datas = [
Span(
name="span_name",
context=SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id, 16),
is_remote=False,
),
parent=None,
kind=SpanKind.INTERNAL,
)
]
cloud_trace_spans = {
"name":
"projects/{}/traces/{}/spans/{}".format(self.project_id, trace_id,
span_id),
"span_id":
span_id,
"parent_span_id":
None,
"display_name":
TruncatableString(value="span_name", truncated_byte_count=0),
"attributes":
ProtoSpan.Attributes(
attribute_map={
"g.co/agent":
_format_attribute_value(
"opentelemetry-python {}; google-cloud-trace-exporter {}"
.format(
pkg_resources.get_distribution(
"opentelemetry-sdk").version,
cloud_trace_version,
))
}),
"links":
None,
"status":
None,
"time_events":
None,
"start_time":
None,
"end_time":
None,
}
client = mock.Mock()
exporter = CloudTraceSpanExporter(self.project_id, client=client)
exporter.export(span_datas)
client.create_span.assert_called_with(**cloud_trace_spans)
self.assertTrue(client.create_span.called)
def extract(
self,
carrier: CarrierT,
context: Optional[Context] = None,
getter: Getter = default_getter,
) -> Context:
if context is None:
context = Context()
traceid = _extract_identifier(
getter.get(carrier, OT_TRACE_ID_HEADER),
_valid_extract_traceid,
INVALID_TRACE_ID,
)
spanid = _extract_identifier(
getter.get(carrier, OT_SPAN_ID_HEADER),
_valid_extract_spanid,
INVALID_SPAN_ID,
)
sampled = _extract_first_element(
getter.get(carrier, OT_SAMPLED_HEADER)
)
if sampled == "true":
traceflags = TraceFlags.SAMPLED
else:
traceflags = TraceFlags.DEFAULT
if traceid != INVALID_TRACE_ID and spanid != INVALID_SPAN_ID:
context = set_span_in_context(
NonRecordingSpan(
SpanContext(
trace_id=traceid,
span_id=spanid,
is_remote=True,
trace_flags=TraceFlags(traceflags),
)
),
context,
)
baggage = get_all(context) or {}
for key in getter.keys(carrier):
if not key.startswith(OT_BAGGAGE_PREFIX):
continue
baggage[
key[len(OT_BAGGAGE_PREFIX) :]
] = _extract_first_element(getter.get(carrier, key))
for key, value in baggage.items():
context = set_baggage(key, value, context)
return context
def test_span_to_envelope_none(self):
exporter = self._exporter
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
def test_span_to_envelope_partA(self):
exporter = self._exporter
resource = resources.Resource({
"service.name":
"testServiceName",
"service.namespace":
"testServiceNamespace",
"service.instance.id":
"testServiceInstanceId"
})
context = SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
)
test_span = trace._Span(
name="test",
context=context,
resource=resource,
attributes={"enduser.id": "testId"},
parent=context,
)
test_span.start()
test_span.end()
envelope = exporter._span_to_envelope(test_span)
self.assertEqual(envelope.instrumentation_key,
"1234abcd-5678-4efa-8abc-1234567890ab")
self.assertIsNotNone(envelope.tags)
self.assertEqual(envelope.tags.get("ai.device.id"),
azure_monitor_context["ai.device.id"])
self.assertEqual(envelope.tags.get("ai.device.locale"),
azure_monitor_context["ai.device.locale"])
self.assertEqual(envelope.tags.get("ai.device.osVersion"),
azure_monitor_context["ai.device.osVersion"])
self.assertEqual(envelope.tags.get("ai.device.type"),
azure_monitor_context["ai.device.type"])
self.assertEqual(envelope.tags.get("ai.internal.sdkVersion"),
azure_monitor_context["ai.internal.sdkVersion"])
self.assertEqual(envelope.tags.get("ai.cloud.role"),
"testServiceNamespace.testServiceName")
self.assertEqual(envelope.tags.get("ai.cloud.roleInstance"),
"testServiceInstanceId")
self.assertEqual(envelope.tags.get("ai.internal.nodeName"),
"testServiceInstanceId")
self.assertEqual(envelope.tags.get("ai.operation.id"),
"{:032x}".format(context.trace_id))
self.assertEqual(envelope.tags.get("ai.user.id"), "testId")
self.assertEqual(envelope.tags.get("ai.operation.parentId"),
"{:016x}".format(context.span_id))
def extract(
self,
getter: Getter[TextMapPropagatorT],
carrier: TextMapPropagatorT,
context: Optional[Context] = None,
) -> Context:
traceid = _extract_first_element(
getter.get(carrier, OT_TRACE_ID_HEADER))
spanid = _extract_first_element(getter.get(carrier, OT_SPAN_ID_HEADER))
sampled = _extract_first_element(getter.get(carrier,
OT_SAMPLED_HEADER))
if sampled == "true":
traceflags = TraceFlags.SAMPLED
else:
traceflags = TraceFlags.DEFAULT
if (traceid != INVALID_TRACE_ID
and _valid_extract_traceid.fullmatch(traceid) is not None
and spanid != INVALID_SPAN_ID
and _valid_extract_spanid.fullmatch(spanid) is not None):
context = set_span_in_context(
DefaultSpan(
SpanContext(
trace_id=int(traceid, 16),
span_id=int(spanid, 16),
is_remote=True,
trace_flags=traceflags,
)),
context,
)
baggage = get_all(context) or {}
for key in getter.keys(carrier):
if not key.startswith(OT_BAGGAGE_PREFIX):
continue
baggage[key[len(OT_BAGGAGE_PREFIX):]] = _extract_first_element(
getter.get(carrier, key))
for key, value in baggage.items():
context = set_baggage(key, value, context)
return context
def test_span_to_envelope_properties(self):
exporter = self._exporter
start_time = 1575494316027613500
end_time = start_time + 1001000000
# Links
links = []
links.append(
Link(context=SpanContext(
trace_id=36873507687745823477771305566750195432,
span_id=12030755672171557338,
is_remote=False,
)))
span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557337,
is_remote=False,
),
attributes={
"http.method": "GET",
"http.url": "https://www.wikipedia.org/wiki/Rabbit",
"http.status_code": 200,
},
kind=SpanKind.CLIENT,
links=links,
)
span._status = Status(status_code=StatusCode.OK)
span.start(start_time=start_time)
span.end(end_time=end_time)
envelope = exporter._span_to_envelope(span)
self.assertEqual(len(envelope.data.base_data.properties), 1)
json_dict = json.loads(
envelope.data.base_data.properties["_MS.links"])[0]
self.assertEqual(json_dict["id"], "a6f5d48acb4d31da")
def test_span_to_envelope_client_rpc(self):
exporter = self._exporter
start_time = 1575494316027613500
end_time = start_time + 1001000000
# SpanKind.CLIENT rpc
span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557337,
is_remote=False,
),
attributes={
"peer.service": "service",
"rpc.system": "rpc",
"rpc.service": "Test service",
},
kind=SpanKind.CLIENT,
)
span.start(start_time=start_time)
span.end(end_time=end_time)
span._status = Status(status_code=StatusCode.OK)
envelope = exporter._span_to_envelope(span)
self.assertEqual(envelope.name,
"Microsoft.ApplicationInsights.RemoteDependency")
self.assertEqual(envelope.time, "2019-12-04T21:18:36.027613Z")
self.assertEqual(envelope.data.base_data.name, "test")
self.assertEqual(envelope.data.base_data.id, "a6f5d48acb4d31d9")
self.assertEqual(envelope.data.base_data.duration, "0.00:00:01.001")
self.assertTrue(envelope.data.base_data.success)
self.assertEqual(envelope.data.base_type, "RemoteDependencyData")
self.assertEqual(envelope.data.base_data.type, "rpc.system")
self.assertEqual(envelope.data.base_data.target, "service")
# target
span._attributes = {
"rpc.system": "rpc",
"rpc.service": "Test service",
}
envelope = exporter._span_to_envelope(span)
self.assertEqual(envelope.data.base_data.target, "rpc")
# TODO: data.data
# self.assertEqual(envelope.data.base_data.data, "SELECT")
self.assertEqual(envelope.data.base_data.result_code, "0")
def test_too_many_link_attributes(self):
link_attrs = {}
for attr_key in range(MAX_LINK_ATTRS + 1):
link_attrs[str(attr_key)] = 0
attr_link = Link(
context=SpanContext(
trace_id=int(self.example_trace_id, 16),
span_id=int(self.example_span_id, 16),
is_remote=False,
),
attributes=link_attrs,
)
proto_link = _extract_links([attr_link])
self.assertEqual(len(proto_link.link[0].attributes.attribute_map),
MAX_LINK_ATTRS)
def main():
otel_init()
brokers = 'timemachine:9094'
topic = 'sotest'
partitions = [0, 1, 2]
# create a consumer
consumer = KafkaConsumer(bootstrap_servers=brokers)
toppars = []
for partition in partitions:
toppars.append(TopicPartition(topic, partition))
consumer.assign(toppars)
ids_generator = trace.get_tracer_provider().ids_generator
# poll loop
for msg in consumer:
# print
print('[{}] msg:{}'.format(datetime.now(), msg))
tid = None
sid = None
for header in msg.headers:
k, v = header
print('k:{}, v_hex:{}'.format(k, v.hex()))
if k == 'traceparent':
# traceparent is a byte array like this
# b'00-0f900a88ec248149f39125cecd714909-d3f0ef64d9020f01-01'
tid = int(v[3:35], 16)
sid = int(v[36:52], 16)
print('tid:{}, sid:{}'.format(tid, sid))
parent_span_context = SpanContext(trace_id=tid,
span_id=sid,
trace_flags=1,
trace_state=0,
is_remote=True)
span = DefaultSpan(context=parent_span_context)
context = {'current-span': span}
with tracer.start_as_current_span(
"py_kc", context=context,
kind=trace_api.SpanKind.CONSUMER) as s:
print('context:{}'.format(context))
print('span:{}'.format(s))
# dummy sleep
time.sleep(0.1)
print('-' * 30)
def test_export_not_retryable(self):
exporter = self._exporter
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
with mock.patch(
"azure.monitor.opentelemetry.exporter.AzureMonitorTraceExporter._transmit"
) as transmit: # noqa: E501
transmit.return_value = ExportResult.FAILED_NOT_RETRYABLE
result = exporter.export([test_span])
self.assertEqual(result, SpanExportResult.FAILURE)
def test_export(self):
trace_id = "6e0c63257de34c92bf9efcd03927272e"
span_id = "95bb5edabd45950f"
# Create span and associated data.
resource_info = Resource(
{
"cloud.account.id": 123,
"host.id": "host",
"cloud.zone": "US",
"cloud.provider": "gcp",
"gcp.resource_type": "gce_instance",
}
)
span = Span(
name="span_name",
context=SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id, 16),
is_remote=False,
),
parent=None,
kind=SpanKind.INTERNAL,
resource=resource_info,
attributes={"attr_key": "attr_value"},
)
# pylint: disable=protected-access
span._start_time = int(time_ns() - (60 * 1e9))
span._end_time = time_ns()
span_data = [span]
# Setup the trace exporter.
channel = grpc.insecure_channel(self.address)
transport = trace_service_grpc_transport.TraceServiceGrpcTransport(
channel=channel
)
client = TraceServiceClient(transport=transport)
trace_exporter = CloudTraceSpanExporter(self.project_id, client=client)
# Export the spans and verify the results.
result = trace_exporter.export(span_data)
self.assertEqual(result, SpanExportResult.SUCCESS)
def test_span_to_envelope_partA_default(self):
exporter = self._exporter
resource = resources.Resource({"service.name": "testServiceName"})
context = SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
)
test_span = trace._Span(
name="test",
context=context,
resource=resource,
)
test_span.start()
test_span.end()
envelope = exporter._span_to_envelope(test_span)
self.assertEqual(envelope.tags.get("ai.cloud.role"), "testServiceName")
self.assertEqual(envelope.tags.get("ai.cloud.roleInstance"),
platform.node())
def carrier_inject(self, trace_id, span_id, is_remote, trace_flags):
carrier = {}
self.ot_trace_propagator.inject(
carrier,
set_span_in_context(
_Span(
"child",
context=SpanContext(
trace_id=trace_id,
span_id=span_id,
is_remote=is_remote,
trace_flags=trace_flags,
),
)),
)
return carrier
def test_export_exception(self, logger_mock):
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
exporter = self._exporter
with mock.patch(
"azure.monitor.opentelemetry.exporter.AzureMonitorTraceExporter._transmit",
throw(Exception),
): # noqa: E501
result = exporter.export([test_span])
self.assertEqual(result, SpanExportResult.FAILURE)
self.assertEqual(logger_mock.exception.called, True)
def test_export_failure(self):
exporter = self._exporter
with mock.patch(
"microsoft.opentelemetry.exporter.azuremonitor.export.trace.AzureMonitorSpanExporter._transmit"
) as transmit: # noqa: E501
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
transmit.return_value = ExportResult.FAILED_RETRYABLE
exporter.export([test_span])
self.assertEqual(len(os.listdir(exporter.storage.path)), 1)
self.assertIsNone(exporter.storage.get())
def test_export_failure(self, span_to_envelope_mock):
span_to_envelope_mock.return_value = ["bar"]
exporter = AzureMonitorSpanExporter(
storage_path=os.path.join(TEST_FOLDER, self.id()))
with mock.patch(
"azure_monitor.trace.AzureMonitorSpanExporter._transmit"
) as transmit: # noqa: E501
test_span = Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
),
)
test_span.start()
test_span.end()
transmit.return_value = ExportResult.FAILED_RETRYABLE
exporter.export([test_span])
self.assertEqual(len(os.listdir(exporter.storage.path)), 1)
self.assertIsNone(exporter.storage.get())
def test_extract_link_with_none_attribute(self):
link = Link(
context=SpanContext(
trace_id=int(self.example_trace_id, 16),
span_id=int(self.example_span_id, 16),
is_remote=False,
),
attributes=None,
)
self.assertEqual(
_extract_links([link]),
ProtoSpan.Links(link=[
{
"trace_id": self.example_trace_id,
"span_id": self.example_span_id,
"type": "TYPE_UNSPECIFIED",
"attributes": ProtoSpan.Attributes(attribute_map={}),
},
]),
)
def test_ok_request(self):
"""Test the functionality when Server Span is ended."""
span_processor = AzureMetricsSpanProcessor()
test_span = Span(
name="test",
kind=SpanKind.SERVER,
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span._start_time = 5000000
test_span._end_time = 15000000
span_processor.on_end(test_span)
self.assertEqual(span_processor.dependency_count, 0)
self.assertEqual(span_processor.dependency_duration, 0)
self.assertEqual(span_processor.failed_dependency_count, 0)
self.assertEqual(span_processor.request_count, 1)
self.assertEqual(span_processor.request_duration, 10)
self.assertEqual(span_processor.failed_request_count, 0)
def test_export_success(self):
exporter = self._exporter
test_span = trace._Span(
name="test",
context=SpanContext(
trace_id=36873507687745823477771305566750195431,
span_id=12030755672171557338,
is_remote=False,
),
)
test_span.start()
test_span.end()
with mock.patch(
"azure.monitor.opentelemetry.exporter.AzureMonitorTraceExporter._transmit"
) as transmit: # noqa: E501
transmit.return_value = ExportResult.SUCCESS
storage_mock = mock.Mock()
exporter._transmit_from_storage = storage_mock
result = exporter.export([test_span])
self.assertEqual(result, SpanExportResult.SUCCESS)
self.assertEqual(storage_mock.call_count, 1)
