feat(profiling): Add reusable SQL profiling middleware

This commit refactors the SQL query profiling logic out of the AWX
controller's API view and into a reusable middleware in the
django-ansible-base library. This makes the feature available to all
AAP components, such as the gateway and EDA.

SQLProfilingMiddleware adds `X-API-Query-Count` and
`X-API-Query-Time` headers to API responses.

Changes include:
- A new `SQLProfilingMiddleware` class in the profiling module.
- Configuration is controlled by a new, namespaced setting,
  `ANSIBLE_BASE_SQL_PROFILING`, with a fallback to the legacy
  `SQL_DEBUG` setting for backward compatibility.
- The middleware logs a warning if it is enabled while Django's
  `DEBUG` setting is `False`, as query logging is disabled in that
  state.
- Unit tests have been added to ensure correct functionality and prevent regressions.
- The profiling documentation has been updated to include usage
  instructions for the new middleware.

Author: kdelee

ansible_base/lib/middleware/profiling/README.md

@@ -30,6 +30,38 @@ To enable cProfile support, set the following in your Django settings:
 ANSIBLE_BASE_CPROFILE_REQUESTS = True
 ```
 
+## `SQLProfilingMiddleware`
+
+This middleware provides insights into the database queries executed during a request. When enabled, it adds the following headers to the response:
+
+*   `X-API-Query-Count`: The total number of database queries executed during the request.
+*   `X-API-Query-Time`: The total time spent on database queries, in seconds.
+
+To use it, add it to your `MIDDLEWARE` list in your Django settings:
+
+```python
+# settings.py
+MIDDLEWARE = [
+    ...
+    'ansible_base.lib.middleware.profiling.profile_request.SQLProfilingMiddleware',
+    ...
+]
+```
+
+### Enabling SQL Profiling
+
+**Important:** This middleware relies on Django's `connection.queries` list, which is only populated when `settings.DEBUG` is set to `True`. Therefore, you must have `DEBUG = True` in your Django settings for this middleware to have any effect.
+
+The middleware is controlled by the `ANSIBLE_BASE_SQL_PROFILING` setting. For backwards compatibility, it will also be enabled if the standard Django `SQL_DEBUG` setting is `True`.
+
+To enable SQL profiling, set the following in your Django settings:
+
+```python
+# settings.py
+ANSIBLE_BASE_SQL_PROFILING = True
+DEBUG = True
+```
+
 ## `DABProfiler`
 
 The core profiling logic is encapsulated in the `DABProfiler` class. This class can be imported and used directly for profiling non-HTTP contexts, such as background tasks or gRPC services.

ansible_base/lib/middleware/profiling/profile_request.py

@@ -7,10 +7,13 @@
 import uuid
 from typing import Optional, Union
 
+from django.db import connection
+from django.conf import settings
 from django.utils.translation import gettext_lazy as _
 
 from ansible_base.lib.utils.settings import get_function_from_setting, get_setting
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -79,4 +82,26 @@ def __call__(self, request):
                 extra=dict(python_objects=dict(request=request, response=response, X_API_CPROFILE_FILE=response["X-API-CProfile-File"])),
             )
 
-        return response
+        return response
+
+
+class SQLProfilingMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        sql_profiling_enabled = get_setting('ANSIBLE_BASE_SQL_PROFILING', get_setting('SQL_DEBUG', False))
+        if sql_profiling_enabled:
+            if not settings.DEBUG:
+                logger.warning("ANSIBLE_BASE_SQL_PROFILING is enabled, but DEBUG is False. No SQL queries will be logged or counted.")
+                return self.get_response(request)
+
+            queries_before = len(connection.queries)
+            response = self.get_response(request)
+            q_times = [float(q['time']) for q in connection.queries[queries_before:]]
+            response['X-API-Query-Count'] = len(q_times)
+            response['X-API-Query-Time'] = '%0.3fs' % sum(q_times)
+        else:
+            response = self.get_response(request)
+
+        return response

test_app/tests/lib/middleware/test_profiling_middleware.py

@@ -1,4 +1,4 @@
-
+import uuid
 import os
 import tempfile
 from unittest.mock import patch
@@ -7,15 +7,24 @@
 from django.test import TestCase, override_settings
 from django.urls import path
 
-from ansible_base.lib.middleware.profiling.profile_request import ProfileRequestMiddleware
+from ansible_base.lib.middleware.profiling.profile_request import ProfileRequestMiddleware, SQLProfilingMiddleware
+from ansible_base.lib.utils.settings import get_setting
+from test_app.models import User
 
 # A simple view for testing middleware
 def simple_view(request):
     return HttpResponse("OK")
 
+# A view that performs a database query
+def db_view(request):
+    # Create a user with a unique username to guarantee a query.
+    User.objects.create(username=f"test-{uuid.uuid4()}")
+    return HttpResponse("OK")
+
 # Define URL patterns for the test
 urlpatterns = [
     path('test/', simple_view),
+    path('test-db/', db_view),
 ]
 
 @override_settings(ROOT_URLCONF=__name__)
@@ -65,3 +74,59 @@ def test_profile_request_middleware_cprofile_disabled(self):
         self.assertNotIn('X-API-CProfile-File', response)
 
 
+@override_settings(
+    ROOT_URLCONF=__name__,
+    MIDDLEWARE=['ansible_base.lib.middleware.profiling.profile_request.SQLProfilingMiddleware']
+)
+class SQLProfilingMiddlewareTest(TestCase):
+    def test_sql_profiling_disabled_by_default(self):
+        """
+        Test that the SQLProfilingMiddleware does not add headers when disabled.
+        """
+        response = self.client.get('/test-db/')
+        self.assertNotIn('X-API-Query-Count', response)
+        self.assertNotIn('X-API-Query-Time', response)
+
+    @override_settings(ANSIBLE_BASE_SQL_PROFILING=True, DEBUG=True)
+    def test_sql_profiling_enabled_with_new_setting(self):
+        """
+        Test that the SQLProfilingMiddleware adds headers when ANSIBLE_BASE_SQL_PROFILING is True.
+        """
+        response = self.client.get('/test-db/')
+        self.assertIn('X-API-Query-Count', response)
+        self.assertGreaterEqual(int(response['X-API-Query-Count']), 1)
+        self.assertIn('X-API-Query-Time', response)
+        self.assertTrue(response['X-API-Query-Time'].endswith('s'))
+        try:
+            float(response['X-API-Query-Time'][:-1])
+        except ValueError:
+            self.fail("X-API-Query-Time value is not a valid float")
+
+    @override_settings(SQL_DEBUG=True, DEBUG=True)
+    def test_sql_profiling_enabled_with_fallback_setting(self):
+        """
+        Test that the SQLProfilingMiddleware adds headers when SQL_DEBUG is True as a fallback.
+        """
+        response = self.client.get('/test-db/')
+        self.assertIn('X-API-Query-Count', response)
+        self.assertGreaterEqual(int(response['X-API-Query-Count']), 1)
+        self.assertIn('X-API-Query-Time', response)
+        self.assertTrue(response['X-API-Query-Time'].endswith('s'))
+        try:
+            float(response['X-API-Query-Time'][:-1])
+        except ValueError:
+            self.fail("X-API-Query-Time value is not a valid float")
+
+    @override_settings(ANSIBLE_BASE_SQL_PROFILING=True, DEBUG=False)
+    def test_sql_profiling_logs_warning_if_debug_is_false(self):
+        """
+        Test that the SQLProfilingMiddleware logs a warning and does not add headers
+        if profiling is enabled but DEBUG is False.
+        """
+        with self.assertLogs('ansible_base.lib.middleware.profiling.profile_request', level='WARNING') as cm:
+            response = self.client.get('/test-db/')
+            self.assertIn("ANSIBLE_BASE_SQL_PROFILING is enabled, but DEBUG is False", cm.output[0])
+        self.assertNotIn('X-API-Query-Count', response)
+        self.assertNotIn('X-API-Query-Time', response)
+
+