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)