feat: enable sql commentor

Also, minor fixes w.r.t to profile tags

Author: adinhodovic

docs/usage.md

@@ -377,16 +377,16 @@ This requires `LOGGING = build_logging_dict()` in your settings. Without it, `se
 
 ### WebSockets (Django Channels)
 
-Add `ChannelsLoggingMiddleware` to your ASGI application. Place it outside `AuthMiddlewareStack` so `scope["user"]` is already resolved when the connection is logged:
+Add `ChannelsLoggingMiddleware` to your ASGI application. Place it inside `AuthMiddlewareStack` so `scope["user"]` is already resolved when the connection is logged:
 
 ```python
 # asgi.py
 from django_o11y.logging.middleware import ChannelsLoggingMiddleware
 
 application = ProtocolTypeRouter({
     "http": django_http_handler,
-    "websocket": ChannelsLoggingMiddleware(
-        AuthMiddlewareStack(
+    "websocket": AuthMiddlewareStack(
+        ChannelsLoggingMiddleware(
             URLRouter(websocket_urlpatterns)
         )
     ),

pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/django_o11y"]
 
 [project]
 name = "django-o11y"
-version = "0.6.0"
+version = "0.7.0"
 description = "Comprehensive OpenTelemetry observability for Django with traces, logs, metrics, and profiling"
 readme = "README.md"
 requires-python = ">=3.12"

src/django_o11y/config/setup.py

@@ -71,6 +71,7 @@ def get_config() -> dict[str, Any]:
             "SAMPLE_RATE": default_sample_rate,
             "CONSOLE_EXPORTER": False,
             "AWS_ENABLED": False,
+            "SQL_COMMENTER": True,
         },
         "LOGGING": {
             "FORMAT": "json" if not settings.DEBUG else "console",
@@ -155,6 +156,7 @@ def _apply_env_overrides(config: dict[str, Any], default_sample_rate: float) ->
     _set_float(t, "SAMPLE_RATE", "OTEL_TRACES_SAMPLER_ARG", default_sample_rate)
     _set_bool(t, "CONSOLE_EXPORTER", "DJANGO_O11Y_TRACING_CONSOLE_EXPORTER")
     _set_bool(t, "AWS_ENABLED", "DJANGO_O11Y_TRACING_AWS_ENABLED")
+    _set_bool(t, "SQL_COMMENTER", "DJANGO_O11Y_TRACING_SQL_COMMENTER", True)
 
     _set_str(lg, "FORMAT", "DJANGO_O11Y_LOGGING_FORMAT")
     _set_str(lg, "LEVEL", "DJANGO_O11Y_LOGGING_LEVEL")

src/django_o11y/profiling/setup.py

@@ -53,20 +53,25 @@ def setup_profiling(config: dict[str, Any]) -> None:
     # RESOURCE_ATTRIBUTES (including OTEL_RESOURCE_ATTRIBUTES) are the base;
     # automatic attributes override them so runtime values are always accurate.
     resource_attrs = dict(config.get("RESOURCE_ATTRIBUTES", {}))
-    tags = resource_attrs
 
-    tags.update(
-        {
-            "service_version": config["SERVICE_VERSION"],
-            "host": socket.gethostname(),
-            "process_id": str(os.getpid()),
-        }
-    )
-
-    if deployment_environment := resource_attrs.get("deployment.environment"):
-        tags["environment"] = deployment_environment
-    if service_namespace := resource_attrs.get("service.namespace"):
-        tags["service_namespace"] = service_namespace
+    # Pyroscope tag keys cannot contain dots (must match [a-zA-Z_][a-zA-Z0-9_]*).
+    # Well-known OTel attributes are mapped to their canonical Pyroscope equivalents;
+    # all other dotted keys fall back to dot→underscore replacement.
+    _OTEL_TAG_MAP = {
+        "deployment.environment": "environment",
+        "service.namespace": "service_namespace",
+        "service.version": "service_version",
+        "service.instance.id": "service_instance_id",
+    }
+    tags: dict[str, str] = {
+        "service_version": config["SERVICE_VERSION"],
+        "host": socket.gethostname(),
+        "process_id": str(os.getpid()),
+    }
+    for key, value in resource_attrs.items():
+        if value:
+            tag_key = _OTEL_TAG_MAP.get(key) or key.replace(".", "_")
+            tags[tag_key] = value
 
     try:
         pyroscope.configure(

src/django_o11y/tracing/instrumentation.py

@@ -7,7 +7,9 @@ def setup_instrumentation(config: dict[str, Any]) -> None:
     """Set up automatic tracing instrumentation for Django and dependencies."""
     from opentelemetry.instrumentation.django import DjangoInstrumentor
 
-    DjangoInstrumentor().instrument()
+    DjangoInstrumentor().instrument(
+        is_sql_commentor_enabled=config.get("TRACING", {}).get("SQL_COMMENTER", True)
+    )
     _instrument_database()
     _instrument_cache()
     _instrument_celery(config)

src/django_o11y/tracing/middleware.py

@@ -46,23 +46,20 @@ async def __acall__(self, request: HttpRequest) -> HttpResponse:
         # In ASGI mode we own the server span so it stays active in the async
         # context for the entire request — including sync_to_async calls made by
         # downstream middleware (e.g. django-structlog's handle_response).
-        carrier = {
-            k.decode("latin-1"): v.decode("latin-1")
-            for k, v in request.scope.get("headers", [])  # type: ignore[union-attr]
-        }
-        parent_context = extract(carrier)
+        parent_context = extract(request.headers)  # type: ignore[arg-type]
 
         method = request.method or "GET"
-        span_name = f"{method} {request.path}"
         with self.tracer.start_as_current_span(
-            span_name,
+            method,
             context=parent_context,
             kind=SpanKind.SERVER,
             attributes={"url.path": request.path, "http.request.method": method},
         ) as span:
             self._annotate_user(request, span)
             response = await self.get_response(request)  # type: ignore[misc]
             if span.is_recording():
+                if request.resolver_match:
+                    span.update_name(f"{method} {request.resolver_match.route}")
                 span.set_attribute("http.response.status_code", response.status_code)
             return response
 

tests/asgi.py

@@ -19,10 +19,13 @@
 application = ProtocolTypeRouter(
     {
         "http": django_http_handler,
-        # ChannelsLoggingMiddleware sits outside AuthMiddlewareStack so that
-        # scope["user"] is already resolved when connection events are logged.
-        "websocket": ChannelsLoggingMiddleware(
-            AuthMiddlewareStack(URLRouter(tests.ws_urls.websocket_urlpatterns))
+        # Middleware order (outermost → innermost):
+        #   1. AllowedHostsOriginValidator — rejects bad origins before any work
+        #   2. AuthMiddlewareStack        — resolves scope["user"]
+        #   3. ChannelsLoggingMiddleware  — logs with user context already set
+        #   4. URLRouter                  — routes to the consumer
+        "websocket": AuthMiddlewareStack(
+            ChannelsLoggingMiddleware(URLRouter(tests.ws_urls.websocket_urlpatterns))
         ),
     }
 )

tests/tracing/test_instrumentation.py

@@ -25,7 +25,55 @@ def test_setup_instrumentation_instruments_django():
     ):
         setup_instrumentation(config)
 
-    mock_inst.instrument.assert_called_once()
+    mock_inst.instrument.assert_called_once_with(is_sql_commentor_enabled=True)
+
+
+def test_setup_instrumentation_sql_commenter_enabled_by_default():
+    """SQL commenter is on by default so queries carry trace context."""
+    from django_o11y.tracing.instrumentation import setup_instrumentation
+
+    config = {"SERVICE_NAME": "test", "TRACING": {}}
+
+    mock_inst = MagicMock()
+    mock_django_module = MagicMock()
+    mock_django_module.DjangoInstrumentor.return_value = mock_inst
+
+    with (
+        patch.dict(
+            "sys.modules", {"opentelemetry.instrumentation.django": mock_django_module}
+        ),
+        patch("django_o11y.tracing.instrumentation._instrument_database"),
+        patch("django_o11y.tracing.instrumentation._instrument_cache"),
+        patch("django_o11y.tracing.instrumentation._instrument_celery"),
+        patch("django_o11y.tracing.instrumentation._instrument_http_clients"),
+    ):
+        setup_instrumentation(config)
+
+    mock_inst.instrument.assert_called_once_with(is_sql_commentor_enabled=True)
+
+
+def test_setup_instrumentation_sql_commenter_can_be_disabled():
+    """SQL commenter can be turned off via TRACING.SQL_COMMENTER=False."""
+    from django_o11y.tracing.instrumentation import setup_instrumentation
+
+    config = {"SERVICE_NAME": "test", "TRACING": {"SQL_COMMENTER": False}}
+
+    mock_inst = MagicMock()
+    mock_django_module = MagicMock()
+    mock_django_module.DjangoInstrumentor.return_value = mock_inst
+
+    with (
+        patch.dict(
+            "sys.modules", {"opentelemetry.instrumentation.django": mock_django_module}
+        ),
+        patch("django_o11y.tracing.instrumentation._instrument_database"),
+        patch("django_o11y.tracing.instrumentation._instrument_cache"),
+        patch("django_o11y.tracing.instrumentation._instrument_celery"),
+        patch("django_o11y.tracing.instrumentation._instrument_http_clients"),
+    ):
+        setup_instrumentation(config)
+
+    mock_inst.instrument.assert_called_once_with(is_sql_commentor_enabled=False)
 
 
 def test_instrument_cache_redis():