def test_emit_succeeded(self, translate_mock, collector_mock, agent_mock): collector = collector_mock.return_value = MockTransport() agent = agent_mock.return_value = MockTransport() exporter = jaeger_exporter.JaegerExporter() translate_mock.return_value = {'test': 'mock'} exporter.emit([]) self.assertTrue(agent.export_called) self.assertTrue(collector.export_called) collector_mock.return_value = None agent = agent_mock.return_value = MockTransport() exporter = jaeger_exporter.JaegerExporter() exporter.emit([]) self.assertTrue(agent.export_called)
def main(): # create the exporter and set it in the tracer exporter = jaeger_exporter.JaegerExporter( service_name="signalfx-opencensus-jaeger-python-example", host_name="ingest.signalfx.com", username="******", password=access_token, endpoint="/v1/trace") tracer = tracer_module.Tracer(exporter=exporter) # set the tracer for this context so it can be retrieved elsewhere tracer.store_tracer() # The same result can also be achieved with # execution_context.set_opencensus_tracer(tracer) # start the span using "with", and it will automatically close and export the # span as you leave scope with tracer.span(name="main") as span_main: x = fft(gen_x()) # tag the main span with the result span_main.add_attribute("fft(x)", mag_fft(x)) # simple rectangular pulse to verify that the generated transform is correct # output should be [ 4.000 2.613 0.000 1.082 0.000 1.082 0.000 2.613 ] x = fft([1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]) span_main.add_attribute("fft(rect((x - 2)/4))", mag_fft(x))
def test_constructor_explicit(self): service = 'opencensus-jaeger' host_name = 'example1.org' agent_host_name = 'example2.org' username = '******' password = '******' port = 14268 host_name = 'localhost' thrift_url = 'http://localhost:14268/api/traces?format=jaeger.thrift' auth = (username, password) exporter = jaeger_exporter.JaegerExporter( service_name=service, host_name=host_name, agent_host_name=agent_host_name, username=username, password=password, port=port) self.assertEqual(exporter.service_name, service) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.host_name, host_name) self.assertFalse(exporter.collector is None) self.assertEqual(exporter.collector.thrift_url, thrift_url) self.assertEqual(exporter.collector.auth, auth) # property should not construct new object collector = exporter.collector self.assertEqual(exporter.collector, collector) # property should construct new object exporter._collector = None exporter.username = None exporter.password = None self.assertNotEqual(exporter.collector, collector) self.assertTrue(exporter.collector.auth is None)
def test_export(self): exporter = jaeger_exporter.JaegerExporter(service_name='my_service', transport=MockTransport) exporter.export({}) collector = jaeger_exporter.Collector(transport=MockTransport, http_transport=MockTransport) collector.export({}) agent = jaeger_exporter.AgentClientUDP(transport=MockTransport) agent.export({}) self.assertTrue(exporter.transport.export_called) self.assertTrue(collector.transport.export_called) self.assertTrue(agent.transport.export_called)
def test_constructor_default(self): service_name = 'my_service' host_name = 'localhost' thrift_port = None agent_port = 6831 agent_address = ('localhost', 6831) max_packet_size = 65000 exporter = jaeger_exporter.JaegerExporter() agent_client = exporter.agent_client self.assertEqual(exporter.service_name, service_name) self.assertEqual(exporter.host_name, None) self.assertEqual(exporter.agent_host_name, host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.port, thrift_port) self.assertEqual(exporter.endpoint, '') self.assertEqual(exporter.username, None) self.assertEqual(exporter.password, None) self.assertTrue(exporter.collector is None) self.assertTupleEqual(agent_client.address, agent_address) self.assertEqual(agent_client.max_packet_size, max_packet_size) # property should not construct new object client = exporter.agent_client self.assertEqual(agent_client, client)
def test_translate_to_jaeger(self): self.maxDiff = None trace_id_high = '6e0c63257de34c92' trace_id_low = 'bf9efcd03927272e' trace_id = trace_id_high + trace_id_low span_id = '6e0c63257de34c92' parent_span_id = '1111111111111111' span_attributes = { 'key_bool': False, 'key_string': 'hello_world', 'key_int': 3 } annotation_attributes = { 'annotation_bool': True, 'annotation_string': 'annotation_test', 'key_float': .3 } link_attributes = {'key_bool': True} import datetime s = '2017-08-15T18:02:26.071158' time = datetime.datetime.strptime(s, '%Y-%m-%dT%H:%M:%S.%f') time_events = [ time_event.TimeEvent( timestamp=time, annotation=time_event.Annotation( description='First Annotation', attributes=attributes.Attributes(annotation_attributes))), time_event.TimeEvent(timestamp=time, message_event=time_event.MessageEvent( id='message-event-id', uncompressed_size_bytes=0, )), ] time_events2 = [ time_event.TimeEvent(timestamp=time, annotation=time_event.Annotation( description='First Annotation', attributes=None)), time_event.TimeEvent(timestamp=time, message_event=time_event.MessageEvent( id='message-event-id', uncompressed_size_bytes=0, )), ] links = [ link.Link(trace_id=trace_id, span_id=span_id, type=link.Type.CHILD_LINKED_SPAN, attributes=link_attributes), link.Link(trace_id=trace_id, span_id=span_id, type=link.Type.PARENT_LINKED_SPAN, attributes=link_attributes), link.Link(trace_id=trace_id, span_id=span_id, type=link.Type.TYPE_UNSPECIFIED, attributes=link_attributes) ] span_status = status.Status(code=200, message='success') start_time = '2017-08-15T18:02:26.071158Z' end_time = '2017-08-15T18:02:36.071158Z' span_datas = [ span_data.SpanData( name='test1', context=span_context.SpanContext(trace_id=trace_id), span_id=span_id, parent_span_id=parent_span_id, attributes=span_attributes, start_time=start_time, end_time=end_time, child_span_count=0, stack_trace=None, time_events=time_events, links=links, status=span_status, same_process_as_parent_span=None, span_kind=0, ), span_data.SpanData( name='test2', context=None, span_id=span_id, parent_span_id=None, attributes=None, start_time=start_time, end_time=end_time, child_span_count=None, stack_trace=None, time_events=time_events2, links=None, status=None, same_process_as_parent_span=None, span_kind=None, ), span_data.SpanData( name='test3', context=None, span_id=span_id, parent_span_id=None, attributes=None, start_time=start_time, end_time=end_time, child_span_count=None, stack_trace=None, time_events=None, links=None, status=None, same_process_as_parent_span=None, span_kind=None, ) ] exporter = jaeger_exporter.JaegerExporter() spans = exporter.translate_to_jaeger(span_datas) expected_spans = [ jaeger.Span( traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882, parentSpanId=1229782938247303441, operationName='test1', startTime=1502820146071158, duration=10000000, flags=1, tags=[ jaeger.Tag(key='key_bool', vType=jaeger.TagType.BOOL, vBool=False), jaeger.Tag(key='key_string', vType=jaeger.TagType.STRING, vStr='hello_world'), jaeger.Tag(key='key_int', vType=jaeger.TagType.LONG, vLong=3), jaeger.Tag(key='status.code', vType=jaeger.TagType.LONG, vLong=200), jaeger.Tag(key='status.message', vType=jaeger.TagType.STRING, vStr='success') ], references=[ jaeger.SpanRef(refType=jaeger.SpanRefType.CHILD_OF, traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882), jaeger.SpanRef(refType=jaeger.SpanRefType.FOLLOWS_FROM, traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882), jaeger.SpanRef(refType=None, traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882) ], logs=[ jaeger.Log(timestamp=1502820146071158, fields=[ jaeger.Tag(key='annotation_bool', vType=jaeger.TagType.BOOL, vBool=True), jaeger.Tag(key='annotation_string', vType=jaeger.TagType.STRING, vStr='annotation_test'), jaeger.Tag(key='message', vType=jaeger.TagType.STRING, vStr='First Annotation') ]) ]), jaeger.Span(operationName="test2", traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882, parentSpanId=0, startTime=1502820146071158, duration=10000000, logs=[ jaeger.Log(timestamp=1502820146071158, fields=[ jaeger.Tag( key='message', vType=jaeger.TagType.STRING, vStr='First Annotation') ]) ]), jaeger.Span(operationName="test3", traceIdHigh=7929822056569588882, traceIdLow=-4638992594902767826, spanId=7929822056569588882, parentSpanId=0, startTime=1502820146071158, duration=10000000, logs=[]) ] spans_json = [span.format_span_json() for span in spans] expected_spans_json = [ span.format_span_json() for span in expected_spans ] span = spans_json[0] expected_span = expected_spans_json[0] try: listsEqual = self.assertCountEqual except AttributeError: listsEqual = self.assertItemsEqual log = span.get('logs')[0] expected_log = expected_span.get('logs')[0] self.assertEqual(log.get('timestamp'), expected_log.get('timestamp')) listsEqual(log.get('fields'), expected_log.get('fields')) listsEqual(span.get('tags'), expected_span.get('tags')) listsEqual(span.get('references'), expected_span.get('references')) self.assertEqual(span.get('traceIdHigh'), expected_span.get('traceIdHigh')) self.assertEqual(span.get('traceIdLow'), expected_span.get('traceIdLow')) self.assertEqual(span.get('spanId'), expected_span.get('spanId')) self.assertEqual(span.get('parentSpanId'), expected_span.get('parentSpanId')) self.assertEqual(span.get('operationName'), expected_span.get('operationName')) self.assertEqual(span.get('startTime'), expected_span.get('startTime')) self.assertEqual(span.get('duration'), expected_span.get('duration')) self.assertEqual(span.get('flags'), expected_span.get('flags')) self.assertEqual(spans_json[1], expected_spans_json[1]) self.assertEqual(spans_json[2], expected_spans_json[2])
# module='emailserver', # version='1.0.0' # ) # except: # pass # Add Jaeger tracing when following fix is released. # fix - https://github.com/census-instrumentation/opencensus-python/commit/890c19e6dc099f5674b2ee105a6c0a9ca5e81b79 # from opencensus.trace.ext.grpc import server_interceptor from opencensus.trace.samplers import always_on from opencensus.trace.exporters import jaeger_exporter try: sampler = always_on.AlwaysOnSampler() exporter = jaeger_exporter.JaegerExporter() exporter = jaeger_exporter.JaegerExporter(service_name="emailservice", agent_host_name="jaeger") tracer_interceptor = server_interceptor.OpenCensusServerInterceptor( sampler, exporter) except: tracer_interceptor = server_interceptor.OpenCensusServerInterceptor() # Loads confirmation email template from file env = Environment(loader=FileSystemLoader('templates'), autoescape=select_autoescape(['html', 'xml'])) template = env.get_template('confirmation.html') class BaseEmailService(demo_pb2_grpc.EmailServiceServicer): def Check(self, request, context):
from qubit.opencensus.trace.ext.aioredis.trace import trace_integration as aioredis_integration from qubit.opencensus.trace.ext.sanic.sanic_middleware import SanicMiddleware from qubit.opencensus.trace.propagation import jaeger_format from qubit.opencensus.trace.tracers import asyncio_context_tracer import asyncio import aiotask_context as context import aiohttp import aioredis loop = asyncio.get_event_loop() loop.set_task_factory(context.task_factory) sampler = probability.ProbabilitySampler(rate=0.5) propagator = jaeger_format.JaegerFormatPropagator() exporter = jaeger_exporter.JaegerExporter(service_name="thing") aiohttp_integration(propagator=propagator) aioredis_integration(tracer=None) app = Sanic() middleware = SanicMiddleware(app, sampler=sampler, exporter=exporter, propagator=propagator, blacklist_paths=["status", "metrics"]) @asyncio_context_tracer.span() async def somefunc(): return "yay"