def setUpClass(cls):
global _MEMORY_EXPORTER # pylint:disable=global-statement
trace_api.set_tracer_provider(TracerProvider())
tracer_provider = trace_api.get_tracer_provider()
_MEMORY_EXPORTER = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(_MEMORY_EXPORTER)
tracer_provider.add_span_processor(span_processor)
def test_shutdown(self):
tracer = trace.Tracer()
memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
span_list = memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 3)
memory_exporter.shutdown()
# after shutdown no new spans are accepted
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
span_list = memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 3)
def setUp(self):
self.tracer_provider = trace.TracerProvider()
self.tracer = self.tracer_provider.get_tracer(__name__)
self.memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(self.memory_exporter)
self.tracer_provider.add_span_processor(span_processor)
self.exec_scenario()
def setUpClass(cls):
global _MEMORY_EXPORTER # pylint:disable=global-statement
trace_api.set_preferred_tracer_source_implementation(
lambda T: TracerSource())
tracer_source = trace_api.tracer_source()
_MEMORY_EXPORTER = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(_MEMORY_EXPORTER)
tracer_source.add_span_processor(span_processor)
def setUp(self):
self.token = context.attach(context.Context())
self.tracer_provider = trace.TracerProvider()
self.tracer = self.tracer_provider.get_tracer(__name__)
self.memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(self.memory_exporter)
self.tracer_provider.add_span_processor(span_processor)
self.loop = asyncio.get_event_loop()
def setUp(self):
if HAS_OPENTELEMETRY_INSTALLED:
self.original_tracer_provider = trace_api.get_tracer_provider()
self.tracer_provider = TracerProvider()
self.memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(
self.memory_exporter)
self.tracer_provider.add_span_processor(span_processor)
trace_api.set_tracer_provider(self.tracer_provider)
def tracer_provider(memory_exporter):
original_tracer_provider = trace_api.get_tracer_provider()
tracer_provider = TracerProvider()
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer_provider.add_span_processor(span_processor)
trace_api.set_tracer_provider(tracer_provider)
yield tracer_provider
trace_api.set_tracer_provider(original_tracer_provider)
def test_on_start_accepts_context(self):
# pylint: disable=no-self-use
tracer_provider = trace.TracerProvider()
tracer = tracer_provider.get_tracer(__name__)
exporter = MySpanExporter([])
span_processor = mock.Mock(
wraps=export.SimpleExportSpanProcessor(exporter))
tracer_provider.add_span_processor(span_processor)
context = Context()
span = tracer.start_span("foo", context=context)
span_processor.on_start.assert_called_once_with(span,
parent_context=context)
def test_get_finished_spans(self):
tracer = trace.Tracer()
memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
span_list = memory_exporter.get_finished_spans()
spans_names_list = [span.name for span in span_list]
self.assertListEqual(["xxx", "bar", "foo"], spans_names_list)
def test_clear(self):
tracer = trace.Tracer()
memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
memory_exporter.clear()
span_list = memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 0)
def test_simple_span_processor(self):
tracer = trace.Tracer()
spans_names_list = []
my_exporter = MySpanExporter(destination=spans_names_list)
span_processor = export.SimpleExportSpanProcessor(my_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_as_current_span("foo"):
with tracer.start_as_current_span("bar"):
with tracer.start_as_current_span("xxx"):
pass
self.assertListEqual(["xxx", "bar", "foo"], spans_names_list)
def test_simple_span_processor_not_sampled(self):
tracer_provider = trace.TracerProvider(
sampler=trace.sampling.ALWAYS_OFF)
tracer = tracer_provider.get_tracer(__name__)
spans_names_list = []
my_exporter = MySpanExporter(destination=spans_names_list)
span_processor = export.SimpleExportSpanProcessor(my_exporter)
tracer_provider.add_span_processor(span_processor)
with tracer.start_as_current_span("foo"):
with tracer.start_as_current_span("bar"):
with tracer.start_as_current_span("xxx"):
pass
self.assertListEqual([], spans_names_list)
def create_tracer_provider(**kwargs):
"""Helper to create a configured tracer provider.
Creates and configures a `TracerProvider` with a
`SimpleExportSpanProcessor` and a `InMemorySpanExporter`.
All the parameters passed are forwarded to the TracerProvider
constructor.
Returns:
A list with the tracer provider in the first element and the
in-memory span exporter in the second.
"""
tracer_provider = TracerProvider(**kwargs)
memory_exporter = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer_provider.add_span_processor(span_processor)
return tracer_provider, memory_exporter
def test_simple_span_processor(self):
tracer_source = trace.TracerSource()
tracer = tracer_source.get_tracer(__name__)
spans_names_list = []
my_exporter = MySpanExporter(destination=spans_names_list)
span_processor = export.SimpleExportSpanProcessor(my_exporter)
tracer_source.add_span_processor(span_processor)
with tracer.start_as_current_span("foo"):
with tracer.start_as_current_span("bar"):
with tracer.start_as_current_span("xxx"):
pass
self.assertListEqual(["xxx", "bar", "foo"], spans_names_list)
span_processor.shutdown()
self.assertTrue(my_exporter.is_shutdown)
def test_simple_span_processor_no_context(self):
"""Check that we process spans that are never made active.
SpanProcessors should act on a span's start and end events whether or
not it is ever the active span.
"""
tracer = trace.Tracer()
spans_names_list = []
my_exporter = MySpanExporter(destination=spans_names_list)
span_processor = export.SimpleExportSpanProcessor(my_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
self.assertListEqual(["xxx", "bar", "foo"], spans_names_list)
def test_custom_tracer_provider(celery_app, memory_exporter):
@celery_app.task
def fn_task():
return 42
resource = resources.Resource.create({})
tracer_provider = TracerProvider(resource=resource)
span_processor = export.SimpleExportSpanProcessor(memory_exporter)
tracer_provider.add_span_processor(span_processor)
trace_api.set_tracer_provider(tracer_provider)
CeleryInstrumentor().uninstrument()
CeleryInstrumentor().instrument(tracer_provider=tracer_provider)
fn_task.delay()
spans_list = memory_exporter.get_finished_spans()
assert len(spans_list) == 1
span = spans_list[0]
assert span.resource == resource
def test_simple_span_processor(self):
class MySpanExporter(export.SpanExporter):
def __init__(self, destination):
self.destination = destination
def export(self, spans: trace.Span) -> export.SpanExportResult:
self.destination.extend(span.name for span in spans)
return export.SpanExportResult.SUCCESS
tracer = trace.Tracer()
spans_names_list = []
my_exporter = MySpanExporter(destination=spans_names_list)
span_processor = export.SimpleExportSpanProcessor(my_exporter)
tracer.add_span_processor(span_processor)
with tracer.start_span("foo"):
with tracer.start_span("bar"):
with tracer.start_span("xxx"):
pass
self.assertListEqual(["xxx", "bar", "foo"], spans_names_list)
