fix(tracer): dd_trace_methods wrapping async functions (#12337)

Resolves issue #10754

Updated` trace_wrapper` to check if the target function is async (using
`inspect.iscoroutinefunction`). If it is, the wrapper uses async/await
to keep the tracing span open until the coroutine truly finishes instead
of closing immediately when the coroutine is created.

## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [x] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

---------

Co-authored-by: Munir Abdinur <[email protected]>

Author: rachelyangdog

ddtrace/internal/tracemethods.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import List
 from typing import Tuple
 
@@ -84,6 +85,16 @@ def trace_wrapper(wrapped, instance, args, kwargs):
     if hasattr(instance, "__class__") and instance.__class__ is not type(None):  # noqa: E721
         resource = "%s.%s" % (instance.__class__.__name__, resource)
 
+    # Check for async
+    if inspect.iscoroutinefunction(wrapped):
+
+        async def async_wrapper(*a, **kw):
+            with tracer.trace("trace.annotation", resource=resource) as span:
+                span.set_tag_str("component", "trace")
+                return await wrapped(*a, **kw)
+
+        return async_wrapper(*args, **kwargs)
+
     with tracer.trace("trace.annotation", resource=resource) as span:
         span.set_tag_str("component", "trace")
         return wrapped(*args, **kwargs)

releasenotes/notes/dd-trace-methods-wrapping-async-functions-efa8599ac82c45f2.yaml

@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    tracing: Captures the execution of async functions traced via DD_TRACE_METHODS, not just coroutine creation.
+    This change increases span durations, which may affect latency-based metrics.

tests/integration/test_tracemethods.py

@@ -60,6 +60,12 @@ async def async_test_method(self):
     async def async_test_method2(self):
         await self.async_test_method()
 
+    async def _nested_async_test_method(self):
+        await asyncio.sleep(0.01)
+        # Call other async method to confirm nested spans work
+        await _async_test_method()
+        await _async_test_method2()
+
     class NestedClass:
         def test_method(self):
             pass
@@ -130,3 +136,38 @@ async def main():
     )
     assert status == 0, err
     assert out == b""
+
+
+@pytest.mark.snapshot()
+def test_ddtrace_run_trace_methods_async_nested(ddtrace_run_python_code_in_subprocess):
+    """
+    This test ensures that async spans remain open for the duration of nested awaits
+    in _Class._nested_async_test_method, which calls additional async functions.
+    """
+    import os
+
+    env = os.environ.copy()
+    env["DD_TRACE_METHODS"] = (
+        "tests.integration.test_tracemethods:_Class._nested_async_test_method,"
+        "tests.integration.test_tracemethods:_async_test_method,"
+        "tests.integration.test_tracemethods:_async_test_method2"
+    )
+
+    tests_dir = os.path.dirname(os.path.dirname(__file__))
+    env["PYTHONPATH"] = os.pathsep.join([tests_dir, env.get("PYTHONPATH", "")])
+
+    code = r"""
+import asyncio
+from tests.integration.test_tracemethods import _Class
+
+async def main():
+    c = _Class()
+    await c._nested_async_test_method()
+
+asyncio.run(main())
+"""
+
+    out, err, status, _ = ddtrace_run_python_code_in_subprocess(code, env=env)
+
+    assert status == 0, err
+    assert out == b""