fix(django): support async_only_middleware [backport 3.13] (#14533)

Backport 941cf9c from #14512 to 3.13.

Fixes #14506

In Python 3.13 it seems we may eagerly start a coroutine as soon as it
is created. This means in our integration when we `return func(*args,
**kwargs)` if the result is a coroutine we may start executing, then if
the caller is doing `await wrapped_func()` we'll get the `ValueError:
coroutine already executing` error being raised.

To reproduce you can follow the guide in #14521, or check the regression
middleware added to the `test_asgi_200` test function.

This only occurs with Python 3.13.


## 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: Brett Langdon <[email protected]>

Author: dd-octo-sts[bot]

ddtrace/contrib/internal/django/middleware.py

@@ -1,3 +1,4 @@
+from inspect import iscoroutinefunction
 from inspect import isfunction
 from types import FunctionType
 from typing import Any
@@ -134,17 +135,42 @@ def traced_auth_middleware_process_request(func: FunctionType, args: Tuple[Any],
 def traced_middleware_factory(func: FunctionType, args: Tuple[Any], kwargs: Dict[str, Any]) -> Any:
     middleware = func(*args, **kwargs)
 
-    if isfunction(middleware):
-        if hasattr(func, "__module__") and hasattr(func, "__qualname__"):
-            resource = f"{func.__module__}.{func.__qualname__}"
-        else:
-            resource = func_name(func)
+    if not isfunction(middleware):
+        return middleware
+
+    if hasattr(func, "__module__") and hasattr(func, "__qualname__"):
+        resource = f"{func.__module__}.{func.__qualname__}"
+    else:
+        resource = func_name(func)
+
+    if iscoroutinefunction(middleware):
+        # Handle async middleware - create async wrapper
+        async def traced_async_middleware_func(*args, **kwargs):
+            # The first argument for all middleware is the request object
+            # DEV: Do `optional=true` to avoid raising an error for middleware that don't follow the convention
+            # DEV: This is a function, so no `self` argument, so request is at position 0
+            request = get_argument_value(args, kwargs, 0, "request", optional=True)
+
+            with core.context_with_data(
+                "django.middleware.func",
+                span_name="django.middleware",
+                resource=resource,
+                tags={
+                    COMPONENT: config_django.integration_name,
+                },
+                tracer=config_django._tracer,
+                request=request,
+            ):
+                return await middleware(*args, **kwargs)
 
+        return traced_async_middleware_func
+    else:
+        # Handle sync middleware - use original wrapping approach
         def traced_middleware_func(func: FunctionType, args: Tuple[Any], kwargs: Dict[str, Any]) -> Any:
             # The first argument for all middleware is the request object
             # DEV: Do `optional=true` to avoid raising an error for middleware that don't follow the convention
             # DEV: This is a function, so no `self` argument, so request is at position 0
-            request = get_argument_value(args, kwargs, 0, "request")
+            request = get_argument_value(args, kwargs, 0, "request", optional=True)
 
             with core.context_with_data(
                 "django.middleware.func",

releasenotes/notes/fix-django-async-only-middleware-245d231d8a2384c5.yaml

@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    django: Fixes issue causing ``ValueError: coroutine already executing`` on Python 3.13+ with ``django.utils.decorators.async_only_middleware``.

tests/contrib/django/django_app/settings.py

@@ -86,6 +86,10 @@
     "tests.contrib.django.middleware.EverythingMiddleware",
 ]
 
+if os.getenv("TEST_INCLUDE_ASYNC_ONLY_MIDDLEWARE") == "1":
+    # DEV: Add to the front, since adding at the end causes it to not get called?
+    MIDDLEWARE = ["tests.contrib.django.middleware.async_only_middleware"] + MIDDLEWARE
+
 INSTALLED_APPS = [
     "django.contrib.admin",
     "django.contrib.auth",

tests/contrib/django/middleware.py

@@ -96,3 +96,18 @@ def process_view(self, request, view_func, view_args, view_kwargs):
 
     def process_template_response(self, req, resp):
         return resp
+
+
+try:
+    from django.utils.decorators import async_only_middleware
+
+    @async_only_middleware
+    def my_async_only_middleware(get_response):
+        async def handle(request):
+            raise Exception()
+            return await get_response(request)
+
+        return handle
+
+except ImportError:
+    pass

tests/contrib/django/test_django_snapshots.py

@@ -262,7 +262,8 @@ def test_psycopg3_query_default(always_create_database_spans: bool, client, snap
 )
 @pytest.mark.parametrize("django_asgi", ["application", "channels_application"])
 def test_asgi_200(django_asgi):
-    with daphne_client(django_asgi) as (client, _):
+    env = {"TEST_INCLUDE_ASYNC_ONLY_MIDDLEWARE": "1"}
+    with daphne_client(django_asgi, additional_env=env) as (client, _):
         resp = client.get("/", timeout=10)
         assert resp.status_code == 200
         assert resp.content == b"Hello, test app."