traced_execution_async` in `opentelemetry-instrumentation-dbapi` ignores instrumentation suppression

[jameswatters1]

Describe your environment

• opentelemetry-instrumentation-dbapi 0.62b1
• opentelemetry-instrumentation-psycopg 0.62b1
• psycopg 3 with AsyncConnection / AsyncConnectionPool
• Python 3.14

What happened?

Spans are still created (and exported) for queries executed inside
opentelemetry.instrumentation.utils.suppress_instrumentation() when the
cursor is async. The sync path correctly suppresses.

Steps to Reproduce

from opentelemetry.instrumentation.psycopg import PsycopgInstrumentor
from opentelemetry.instrumentation.utils import suppress_instrumentation
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from psycopg import AsyncConnection

exporter = InMemorySpanExporter()
provider = TracerProvider()
provider.add_span_processor(SimpleSpanProcessor(exporter))
PsycopgInstrumentor().instrument(tracer_provider=provider)

async def main():
    async with await AsyncConnection.connect(DSN) as conn:
        async with conn.cursor() as cur:
            with suppress_instrumentation():
                await cur.execute("SELECT 1")

# after running main():
assert exporter.get_finished_spans() == ()   # FAILS — one span was exported

The same code with a sync psycopg.connect() passes.

Expected Result

No span — the async path should honor suppression exactly as the sync path
does.

Actual Result

One span was created and exported for the SELECT 1 executed inside suppress_instrumentation() — exporter.get_finished_spans() returns a span named SELECT with db.statement = "SELECT 1", and the final assertion in the reproducer fails.
Running the identical code with a sync psycopg.connect() connection produces no span — the sync path honors suppression, the async path does not.

Additional context

The common use of suppress_instrumentation() around background polls
(outbox sweeps, health/metric COUNT queries) silently stops working the day a
codebase migrates from sync to async connections — every poll becomes a root
span again, with no error and no signal that suppression is inert. Tests that
assert is_instrumentation_enabled() inside the block keep passing, because
the flag is set correctly; it is simply never read.

Would you like to implement a fix?

None

Tip

_{React with 👍 to help prioritize this issue. Please use comments to provide useful context, avoiding +1 or me too, to help us triage it. Learn more here.}

[xrmx]

We have a test in dbapi for suppress_instrumentation wrapping async code. Tried adding another one but still is green.

diff --git a/instrumentation/opentelemetry-instrumentation-dbapi/tests/test_dbapi_integration.py b/instrumentation/opentelemetry-instrumentation-dbapi/tests/test_dbapi_integration.py
index 826edad23..e50ed74d9 100644
--- a/instrumentation/opentelemetry-instrumentation-dbapi/tests/test_dbapi_integration.py
+++ b/instrumentation/opentelemetry-instrumentation-dbapi/tests/test_dbapi_integration.py
@@ -8,7 +8,7 @@ import contextlib
 import logging
 import re
 import sys
-from unittest import mock
+from unittest import IsolatedAsyncioTestCase, mock
 
 import pytest
 
@@ -1703,3 +1703,20 @@ class MockCursor:
             # pylint: disable=broad-exception-raised
             raise Exception("Test Exception")
         self.rowcount = rowcount
+
+
+class TestDBApiAsync(TestBase, IsolatedAsyncioTestCase):
+    async def test_suppress_instrumentation(self):
+        execute = mock.AsyncMock(return_value="result")
+        db_integration = dbapi.DatabaseApiIntegration(
+            "instrumenting_module_test_name",
+            "testcomponent",
+        )
+
+        with suppress_instrumentation():
+            result = await dbapi.CursorTracer(db_integration).traced_execution_async(MockCursor(), execute, "SELECT 1")
+
+        self.assertEqual(result, "result")
+        execute.assert_awaited_once_with("SELECT 1")
+        self.assertEqual(len(self.memory_exporter.get_finished_spans()), 0)

Also your reproducer works fine for me with uv run repro-suppression-async.py on opentelemetry-python-contrib.

Please reproduce with latest release.