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"
