class OpenTelemetryBase(unittest.TestCase):
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 tearDown(self):
if HAS_OPENTELEMETRY_INSTALLED:
trace_api.set_tracer_provider(self.original_tracer_provider)
def assertNoSpans(self):
if HAS_OPENTELEMETRY_INSTALLED:
span_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 0)
def assertSpanAttributes(self,
name,
status=StatusCanonicalCode.OK,
attributes=None,
span=None):
if HAS_OPENTELEMETRY_INSTALLED:
if not span:
span_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 1)
span = span_list[0]
self.assertEqual(span.name, name)
self.assertEqual(span.status.canonical_code, status)
self.assertEqual(dict(span.attributes), attributes)
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 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)
class TestAsyncio(unittest.TestCase):
async def task(self, name):
with self.tracer.start_as_current_span(name):
context.set_value("say", "bar")
def submit_another_task(self, name):
self.loop.create_task(self.task(name))
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.SimpleSpanProcessor(self.memory_exporter)
self.tracer_provider.add_span_processor(span_processor)
self.loop = asyncio.get_event_loop()
def tearDown(self):
context.detach(self.token)
@patch(
"opentelemetry.context._RUNTIME_CONTEXT", ContextVarsRuntimeContext()
)
def test_with_asyncio(self):
with self.tracer.start_as_current_span("asyncio_test"):
for name in _SPAN_NAMES:
self.submit_another_task(name)
stop_loop_when(
self.loop,
lambda: len(self.memory_exporter.get_finished_spans()) >= 5,
timeout=5.0,
)
self.loop.run_forever()
span_list = self.memory_exporter.get_finished_spans()
span_names_list = [span.name for span in span_list]
expected = [
"test_span1",
"test_span2",
"test_span3",
"test_span4",
"test_span5",
"asyncio_test",
]
self.assertCountEqual(span_names_list, expected)
span_names_list.sort()
expected.sort()
self.assertListEqual(span_names_list, expected)
expected_parent = next(
span for span in span_list if span.name == "asyncio_test"
)
for span in span_list:
if span is expected_parent:
continue
self.assertEqual(span.parent, expected_parent.context)
def setUp(self):
"""
Create a tracer with running workers, while spying the ``_put()`` method to
keep trace of triggered API calls.
"""
self.exporter = InMemorySpanExporter()
api = APIOtel(exporter=self.exporter)
# create a new tracer
self.tracer = Tracer()
self.tracer.configure(api=api)
# spy the send() method
self.api = self.tracer.writer.api
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_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 configure_inmemory_span_exporter(agent):
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
return memoryExporter
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.SimpleSpanProcessor(_MEMORY_EXPORTER)
tracer_provider.add_span_processor(span_processor)
def setUpClass(cls):
global _MEMORY_EXPORTER # pylint:disable=global-statement
trace_api.set_preferred_tracer_provider_implementation(
lambda T: TracerProvider())
tracer_provider = trace_api.tracer_provider()
_MEMORY_EXPORTER = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(_MEMORY_EXPORTER)
tracer_provider.add_span_processor(span_processor)
def setup():
reload_module(opentelemetry_tracing)
tracer_provider = TracerProvider()
memory_exporter = InMemorySpanExporter()
span_processor = SimpleExportSpanProcessor(memory_exporter)
tracer_provider.add_span_processor(span_processor)
trace.set_tracer_provider(tracer_provider)
yield memory_exporter
def __init__(self):
tracer_provider = trace.TracerProvider()
oteltracer = tracer_provider.get_tracer(__name__)
super().__init__(oteltracer)
exporter = InMemorySpanExporter()
span_processor = SimpleSpanProcessor(exporter)
tracer_provider.add_span_processor(span_processor)
self.exporter = exporter
def test_batch_span_processor_fork(self):
# pylint: disable=invalid-name
tracer_provider = trace.TracerProvider()
tracer = tracer_provider.get_tracer(__name__)
exporter = InMemorySpanExporter()
span_processor = export.BatchSpanProcessor(
exporter,
max_queue_size=256,
max_export_batch_size=64,
schedule_delay_millis=10,
)
tracer_provider.add_span_processor(span_processor)
with tracer.start_as_current_span("foo"):
pass
time.sleep(0.5) # give some time for the exporter to upload spans
self.assertTrue(span_processor.force_flush())
self.assertEqual(len(exporter.get_finished_spans()), 1)
exporter.clear()
def child(conn):
def _target():
with tracer.start_as_current_span("span") as s:
s.set_attribute("i", "1")
with tracer.start_as_current_span("temp"):
pass
self.run_with_many_threads(_target, 100)
time.sleep(0.5)
spans = exporter.get_finished_spans()
conn.send(len(spans) == 200)
conn.close()
parent_conn, child_conn = multiprocessing.Pipe()
p = multiprocessing.Process(target=child, args=(child_conn, ))
p.start()
self.assertTrue(parent_conn.recv())
p.join()
span_processor.shutdown()
def init_otel():
"""Init the OpenTelemetry settings"""
global tracer, session_name, service_name, insecure, otel_exporter
LOGGER.debug("Init Otel : {}".format(service_name))
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({SERVICE_NAME:
service_name}), ))
if in_memory_span_exporter:
otel_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(otel_exporter))
otel_exporter.clear()
else:
otel_exporter = OTLPSpanExporter()
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(otel_exporter))
tracer = trace.get_tracer(session_name)
def setUpClass(cls):
cls._tracer_source = TracerSource()
cls._tracer = Tracer(cls._tracer_source, None)
cls._span_exporter = InMemorySpanExporter()
cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
cls._tracer_source.add_span_processor(cls._span_processor)
trace_integration(cls._tracer)
client = MongoClient(MONGODB_HOST,
MONGODB_PORT,
serverSelectionTimeoutMS=2000)
db = client[MONGODB_DB_NAME]
cls._collection = db[MONGODB_COLLECTION_NAME]
def test_send_traces(self):
def return_same(span):
return span
exporter = InMemorySpanExporter()
api = APIOtel(exporter=exporter)
# we don't care about _span_to_otel_span() here
api._span_to_otel_span = return_same
traces = (
(MockSpan(), ),
(MockSpan(), MockSpan()),
(MockSpan(), MockSpan(), MockSpan()),
)
api.send_traces(traces)
# flat traces to 1 dimension tuple
traces_tuple = tuple([item for sublist in traces for item in sublist])
self.assertEqual(traces_tuple, exporter.get_finished_spans())
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)
class TestInMemorySpanExporter(unittest.TestCase):
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 exec_scenario(self):
with self.tracer.start_as_current_span("foo"):
with self.tracer.start_as_current_span("bar"):
with self.tracer.start_as_current_span("xxx"):
pass
def test_get_finished_spans(self):
span_list = self.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):
self.memory_exporter.clear()
span_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 0)
def test_shutdown(self):
span_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 3)
self.memory_exporter.shutdown()
# after shutdown no new spans are accepted
self.exec_scenario()
span_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(span_list), 3)
def test_return_code(self):
span = trace._Span("name", mock.Mock(spec=trace_api.SpanContext))
span_list = (span, )
memory_exporter = InMemorySpanExporter()
ret = memory_exporter.export(span_list)
self.assertEqual(ret, export.SpanExportResult.SUCCESS)
memory_exporter.shutdown()
# after shutdown export should fail
ret = memory_exporter.export(span_list)
self.assertEqual(ret, export.SpanExportResult.FAILURE)
def setUpClass(cls):
cls._connection = None
cls._cursor = None
cls._tracer_provider = TracerProvider()
cls._tracer = Tracer(cls._tracer_provider, None)
cls._span_exporter = InMemorySpanExporter()
cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
cls._tracer_provider.add_span_processor(cls._span_processor)
trace_integration(cls._tracer)
cls._connection = mysql.connector.connect(
user=MYSQL_USER,
password=MYSQL_PASSWORD,
host=MYSQL_HOST,
port=MYSQL_PORT,
database=MYSQL_DB_NAME,
)
cls._cursor = cls._connection.cursor()
def create_tracer_provider(**kwargs):
"""Helper to create a configured tracer provider.
Creates and configures a `TracerProvider` with a
`SimpleSpanProcessor` 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.SimpleSpanProcessor(memory_exporter)
tracer_provider.add_span_processor(span_processor)
return tracer_provider, memory_exporter
def setUpClass(cls):
cls._connection = None
cls._cursor = None
cls._tracer_provider = TracerProvider()
cls._tracer = Tracer(cls._tracer_provider, None)
cls._span_exporter = InMemorySpanExporter()
cls._span_processor = SimpleExportSpanProcessor(cls._span_exporter)
cls._tracer_provider.add_span_processor(cls._span_processor)
trace_integration(cls._tracer)
cls._connection = psycopg2.connect(
dbname=POSTGRES_DB_NAME,
user=POSTGRES_USER,
password=POSTGRES_PASSWORD,
host=POSTGRES_HOST,
port=POSTGRES_PORT,
)
cls._connection.set_session(autocommit=True)
cls._cursor = cls._connection.cursor()
def test_return_code(self):
span = trace._Span("name", mock.Mock(spec=trace_api.SpanContext))
span_list = (span, )
memory_exporter = InMemorySpanExporter()
ret = memory_exporter.export(span_list)
self.assertEqual(ret, export.SpanExportResult.SUCCESS)
memory_exporter.shutdown()
# after shutdown export should fail
ret = memory_exporter.export(span_list)
self.assertEqual(ret, export.SpanExportResult.FAILURE)
def test_run():
logger = setup_custom_logger(__name__)
agent = Agent()
agent.instrument(None)
# Setup In-Memory Span Exporter
logger.info('Agent initialized.')
logger.info('Adding in-memory span exporter.')
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
logger.info('Added in-memory span exporter')
logger.info('Running test calls.')
try:
session = botocore.session.get_session()
session.set_credentials(access_key="access-key",
secret_key="secret-key")
region = "us-west-2"
client = session.create_client("lambda", region_name=region)
iam_client = session.create_client("iam", region_name=region)
arn = _create_role_and_get_arn(iam_client)
result = _create_lambda_function('some_function',
return_headers_lambda_str(), client,
arn)
memoryExporter.clear()
response = client.invoke(
Payload=json.dumps({}),
FunctionName=result['FunctionArn'],
InvocationType="RequestResponse",
)
spans = memoryExporter.get_finished_spans()
invoke_span = spans[-1]
assert invoke_span.attributes['faas.invoked_name'] == 'some_function'
assert invoke_span.attributes['http.status_code'] == 200
assert invoke_span.attributes['rpc.service'] == 'Lambda'
memoryExporter.clear()
return 0
except:
logger.error(
'Failed to test boto instrumentation wrapper: exception=%s, stacktrace=%s',
sys.exc_info()[0], traceback.format_exc())
raise sys.exc_info()[0]
def init_otel():
"""Init the OpenTelemetry settings"""
global tracer, session_name, service_name, insecure, otel_exporter, errors_counter, failed_counter, skipped_counter, total_counter, controller # noqa: E501
LOGGER.debug("Init Otel : {}".format(service_name))
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({SERVICE_NAME:
service_name}), ))
if in_memory_span_exporter:
otel_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(otel_exporter))
# metrics_exporter = ConsoleMetricsExporter()
else:
otel_exporter = OTLPSpanExporter()
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(otel_exporter))
# metrics_exporter = CollectorMetricsExporter()
tracer = trace.get_tracer(session_name)
def memory_exporter():
memory_exporter = InMemorySpanExporter()
return memory_exporter
class MockLambdaContext:
pass
lambdaContext = MockLambdaContext()
lambdaContext.invoked_function_arn = "arn://mock-lambda-function-arn"
lambdaContext.aws_request_id = "mock_aws_request_id"
# TODO: does not work, need upstream fix
resource = Resource.create().merge(AwsLambdaResourceDetector().detect())
trace.set_tracer_provider(TracerProvider(resource=resource, ))
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter()), )
in_memory_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(in_memory_exporter))
def test_lambda_instrument():
in_memory_exporter.clear()
lambda_handler("mock", lambdaContext)
spans = in_memory_exporter.get_finished_spans()
assert len(spans) == 1
span = spans[0]
assert span.name == "mock_lambda.handler"
parent_context = span.parent
assert parent_context.trace_id == 0x5FB7331105E8BB83207FA31D4D9CDB4C
import threading
import mysql.connector
from flask import Flask
import requests
from opentelemetry import trace
from opentelemetry.instrumentation.flask import FlaskInstrumentor, get_default_span_name
from opentelemetry.sdk.trace import TracerProvider, export
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor, ConsoleSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.instrumentation.requests import RequestsInstrumentor
server = Flask(__name__)
FlaskInstrumentor().instrument_app(server)
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
tracerProvider = TracerProvider(
resource=Resource.create({
'service.name': 'otel-python-agent',
'service.instance.id': os.getpid(),
}))
#consoleExporter = ConsoleSpanExporter()
#simpleExportSpanProcessor2 = SimpleSpanProcessor(consoleExporter)
trace.set_tracer_provider(tracerProvider)
trace.get_tracer_provider().add_span_processor(simpleExportSpanProcessor)
#trace.get_tracer_provider().add_span_processor(simpleExportSpanProcessor2)
requestsInstrumentor = RequestsInstrumentor()
def get_test_ot_exporter():
global _TEST_OT_EXPORTER
if _TEST_OT_EXPORTER is None:
_TEST_OT_EXPORTER = InMemorySpanExporter()
return _TEST_OT_EXPORTER
class TestWorkers(TestCase):
"""
Ensures that a workers interacts correctly with the main thread. These are part
of integration tests so real calls are triggered.
"""
def setUp(self):
"""
Create a tracer with running workers, while spying the ``_put()`` method to
keep trace of triggered API calls.
"""
self.exporter = InMemorySpanExporter()
api = APIOtel(exporter=self.exporter)
# create a new tracer
self.tracer = Tracer()
self.tracer.configure(api=api)
# spy the send() method
self.api = self.tracer.writer.api
def tearDown(self):
"""
Stop running worker
"""
self._wait_thread_flush()
def _wait_thread_flush(self):
"""
Helper that waits for the thread flush
"""
self.tracer.writer.stop()
self.tracer.writer.join(None)
def test_worker_single_trace(self):
# create a trace block and send it using the transport system
tracer = self.tracer
tracer.trace('client.testing').finish()
# one send is expected
self._wait_thread_flush()
spans = self.exporter.get_finished_spans()
self.assertEqual(len(spans), 1)
self.assertEqual(spans[0].name, 'client.testing')
def test_worker_single_trace_multiple_spans(self):
# make a single send() if a single trace with multiple spans is created before the flush
tracer = self.tracer
parent = tracer.trace('client.testing.parent')
tracer.trace('client.testing.child').finish()
parent.finish()
# one send is expected
self._wait_thread_flush()
spans = self.exporter.get_finished_spans()
self.assertEqual(len(spans), 2)
self.assertEqual(spans[0].name, 'client.testing.parent')
self.assertEqual(spans[1].name, 'client.testing.child')
def test_worker_filter_request(self):
self.tracer.configure(
settings={FILTERS_KEY: [FilterRequestsOnUrl(r'http://example\.com/health')]},
api=self.api,
)
span = self.tracer.trace('testing.filteredurl')
span.set_tag(http.URL, 'http://example.com/health')
span.finish()
span = self.tracer.trace('testing.nonfilteredurl')
span.set_tag(http.URL, 'http://example.com/api/resource')
span.finish()
self._wait_thread_flush()
spans = self.exporter.get_finished_spans()
self.assertEqual(len(spans), 1)
self.assertEqual(spans[0].name, 'testing.nonfilteredurl')
