def test_instrumentor_create_pool(self):
AiopgInstrumentor().instrument()
pool = async_call(aiopg.create_pool(database="test"))
cnx = async_call(pool.acquire())
cursor = async_call(cnx.cursor())
query = "SELECT * FROM test"
async_call(cursor.execute(query))
spans_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
span = spans_list[0]
# Check version and name in span's instrumentation info
self.check_span_instrumentation_info(
span, opentelemetry.instrumentation.aiopg)
# check that no spans are generated after uninstrument
AiopgInstrumentor().uninstrument()
pool = async_call(aiopg.create_pool(database="test"))
cnx = async_call(pool.acquire())
cursor = async_call(cnx.cursor())
query = "SELECT * FROM test"
cursor.execute(query)
spans_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
def test_custom_tracer_provider_instrument_connection(self):
resource = resources.Resource.create(
{"service.name": "db-test-service"}
)
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
cnx = async_call(aiopg.connect(database="test"))
cnx = AiopgInstrumentor().instrument_connection(
cnx, tracer_provider=tracer_provider
)
cursor = async_call(cnx.cursor())
query = "SELECT * FROM test"
async_call(cursor.execute(query))
spans_list = exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
span = spans_list[0]
self.assertEqual(
span.resource.attributes["service.name"], "db-test-service"
)
self.assertIs(span.resource, resource)
def test_instrument_connection(self):
cnx = async_call(aiopg.connect(database="test"))
query = "SELECT * FROM test"
cursor = async_call(cnx.cursor())
async_call(cursor.execute(query))
spans_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans_list), 0)
cnx = AiopgInstrumentor().instrument_connection(cnx)
cursor = async_call(cnx.cursor())
async_call(cursor.execute(query))
spans_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
def tearDownClass(cls):
if cls._cursor:
cls._cursor.close()
if cls._connection:
cls._connection.close()
if cls._pool:
cls._pool.close()
AiopgInstrumentor().uninstrument()
def setUp(self):
super().setUp()
self._tracer = self.tracer_provider.get_tracer(__name__)
AiopgInstrumentor().instrument(tracer_provider=self.tracer_provider)
self._connection = async_call(
aiopg.connect(
dbname=POSTGRES_DB_NAME,
user=POSTGRES_USER,
password=POSTGRES_PASSWORD,
host=POSTGRES_HOST,
port=POSTGRES_PORT,
))
self._cursor = async_call(self._connection.cursor())
async def _ctx_manager_connect():
AiopgInstrumentor().instrument()
async with aiopg.connect(database="test") as cnx:
async with cnx.cursor() as cursor:
query = "SELECT * FROM test"
await cursor.execute(query)
spans_list = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
span = spans_list[0]
# Check version and name in span's instrumentation info
self.check_span_instrumentation_info(
span, opentelemetry.instrumentation.aiopg)
def setUpClass(cls):
super().setUpClass()
cls._connection = None
cls._cursor = None
cls._tracer = cls.tracer_provider.get_tracer(__name__)
AiopgInstrumentor().instrument(tracer_provider=cls.tracer_provider)
cls._pool = async_call(
aiopg.create_pool(
dbname=POSTGRES_DB_NAME,
user=POSTGRES_USER,
password=POSTGRES_PASSWORD,
host=POSTGRES_HOST,
port=POSTGRES_PORT,
))
cls._connection = async_call(cls._pool.acquire())
cls._cursor = async_call(cls._connection.cursor())
def setUp(self):
super().setUp()
self._tracer = self.tracer_provider.get_tracer(__name__)
AiopgInstrumentor().instrument(tracer_provider=self.tracer_provider)
self._dsn = (
f"dbname='{POSTGRES_DB_NAME}' user='******' password='******'"
f" host='{POSTGRES_HOST}' port='{POSTGRES_PORT}'")
self._pool = async_call(
aiopg.create_pool(
dbname=POSTGRES_DB_NAME,
user=POSTGRES_USER,
password=POSTGRES_PASSWORD,
host=POSTGRES_HOST,
port=POSTGRES_PORT,
))
self._connection = async_call(self._pool.acquire())
self._cursor = async_call(self._connection.cursor())
def test_custom_tracer_provider_create_pool(self):
resource = resources.Resource.create({})
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
AiopgInstrumentor().instrument(tracer_provider=tracer_provider)
pool = async_call(aiopg.create_pool(database="test"))
cnx = async_call(pool.acquire())
cursor = async_call(cnx.cursor())
query = "SELECT * FROM test"
async_call(cursor.execute(query))
spans_list = exporter.get_finished_spans()
self.assertEqual(len(spans_list), 1)
span = spans_list[0]
self.assertIs(span.resource, resource)
def tearDown(self):
super().tearDown()
aiopg.connect = self.origin_aiopg_connect
aiopg.create_pool = self.origin_aiopg_create_pool
with self.disable_logging():
AiopgInstrumentor().uninstrument()
def tearDown(self):
self._cursor.close()
self._connection.close()
AiopgInstrumentor().uninstrument()
super().tearDown()
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.aiopg import AiopgInstrumentor
trace_provider = TracerProvider(
resource=Resource.create({SERVICE_NAME: "my-service"}))
trace.set_tracer_provider(trace_provider)
tracer = trace.get_tracer(__name__)
jaeger_exporter = JaegerExporter(agent_host_name="127.0.0.1", agent_port=5775)
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
AiopgInstrumentor().instrument()
dsn = "dbname=test user=postgres password=postgres host=127.0.0.1"
async def init_pg(app):
pool = await aiopg.create_pool(dsn)
app["pool"] = pool
async def handle(request):
async with request.app["pool"].acquire() as conn:
async with conn.cursor() as cur:
await cur.execute("SELECT 1")
name = request.match_info.get('name', "Anonymous")
text = "Hello, " + name
