[Django] Added support for traceresponse headers

Added opt-in support to return traceresponse headers from Django.

This allows users to configure their Django apps to inject trace context
as headers in HTTP responses. This is useful when client side apps need
to connect their spans with the server side spans e.g, in RUM products.

Today the most practical way to do this is to use the `Server-Timing`
header but in near future we might use the `traceresponse` header as
described here: https://w3c.github.io/trace-context/#trace-context-http-response-headers-format

As a result the implementation does not use a hard-coded header and
instead let's the users pick one.

This can be done by setting the `OTEL_PYTHON_TRACE_RESPONSE_HEADER` to
the header name that users want to inject in HTTP responses. The option
does not have a default value and the feature is disbaled when a env var
is not set.

Author: owais

Diff for: CHANGELOG.md

@@ -21,6 +21,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#299](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/299))
 - `opentelemetry-instrumenation-django` now supports request and response hooks.
   ([#407](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/407))
+- Add trace response header support for Django.
+  ([#395](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/395))
 
 ### Removed
 - Remove `http.status_text` from span attributes

Diff for: instrumentation/opentelemetry-instrumentation-aiohttp-client/tests/test_aiohttp_client_integration.py

@@ -17,6 +17,7 @@
 import typing
 import unittest
 import urllib.parse
+import pkg_resources
 from http import HTTPStatus
 from unittest import mock
 

Diff for: instrumentation/opentelemetry-instrumentation-django/src/opentelemetry/instrumentation/django/middleware.py

@@ -19,6 +19,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from opentelemetry.context import attach, detach
+from opentelemetry.instrumentation.propagators import get_global_back_propagator
 from opentelemetry.instrumentation.django.version import __version__
 from opentelemetry.instrumentation.utils import extract_attributes_from_object
 from opentelemetry.instrumentation.wsgi import (
@@ -28,7 +29,11 @@
 )
 from opentelemetry.propagate import extract
 from opentelemetry.trace import Span, SpanKind, get_tracer, use_span
-from opentelemetry.util.http import get_excluded_urls, get_traced_request_attrs
+from opentelemetry.util.http import (
+    get_excluded_urls,
+    get_trace_response_headers,
+    get_traced_request_attrs,
+)
 
 try:
     from django.core.urlresolvers import (  # pylint: disable=no-name-in-module
@@ -179,6 +184,19 @@ def process_response(self, request, response):
                 response,
             )
 
+            propagator = get_global_back_propagator()
+            if propagator:
+                propagator.inject(response)
+
+            # inject trace response headers
+            #for header, value in get_trace_response_headers(span):
+            #    old_value = response.get(header, "")
+            #    if old_value:
+            #        value = "{0}, {1}".format(old_value, value)
+            #    response[header] = value
+
+
+            # record any exceptions raised while processing the request
             exception = request.META.pop(self._environ_exception_key, None)
             if _DjangoMiddleware._otel_response_hook:
                 _DjangoMiddleware._otel_response_hook(  # pylint: disable=not-callable

Diff for: instrumentation/opentelemetry-instrumentation-django/tests/test_middleware.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from os import environ
 from sys import modules
 from unittest.mock import Mock, patch
 
@@ -30,7 +31,12 @@
 from opentelemetry.test.test_base import TestBase
 from opentelemetry.test.wsgitestutil import WsgiTestBase
 from opentelemetry.trace import SpanKind, StatusCode
-from opentelemetry.util.http import get_excluded_urls, get_traced_request_attrs
+from opentelemetry.util.http import (
+    ENV_HTTP_TRACE_RESPONSE_HEADER,
+    get_excluded_urls,
+    get_trace_response_headers,
+    get_traced_request_attrs,
+)
 
 # pylint: disable=import-error
 from .views import (
@@ -41,6 +47,7 @@
     route_span_name,
     traced,
     traced_template,
+    with_response_header,
 )
 
 DJANGO_2_2 = VERSION >= (2, 2)
@@ -52,6 +59,7 @@
     url(r"^excluded_arg/", excluded),
     url(r"^excluded_noarg/", excluded_noarg),
     url(r"^excluded_noarg2/", excluded_noarg2),
+    url(r"^response_header/", with_response_header),
     url(r"^span_name/([0-9]{4})/$", route_span_name),
 ]
 _django_instrumentor = DjangoInstrumentor()
@@ -309,3 +317,76 @@ def response_hook(span, request, response):
         self.assertIsInstance(response_hook_args[1], HttpRequest)
         self.assertIsInstance(response_hook_args[2], HttpResponse)
         self.assertEqual(response_hook_args[2], response)
+
+    def test_trace_response_header(self):
+        original_env_var = environ.pop(ENV_HTTP_TRACE_RESPONSE_HEADER, None)
+        response = Client().get("/span_name/1234/")
+        self.assertNotIn("Server-Timing", response._headers)
+        self.memory_exporter.clear()
+
+        for header in ["Server-Timing", "traceresponse"]:
+            environ[ENV_HTTP_TRACE_RESPONSE_HEADER] = header
+
+            response = Client().get("/span_name/1234/")
+            span = self.memory_exporter.get_finished_spans()[0]
+            headers = get_trace_response_headers(span)
+            self.assertEqual(len(headers), 2)
+
+            access_control_header = headers[0]
+            response_header = headers[1]
+
+            self.assertIn(header.lower(), response._headers)
+            self.assertEqual(
+                response._headers["access-control-expose-headers"][0],
+                access_control_header[0],
+            )
+            self.assertEqual(
+                response._headers["access-control-expose-headers"][1],
+                access_control_header[1],
+            )
+            self.assertEqual(
+                response._headers[header.lower()][0], response_header[0]
+            )
+            self.assertEqual(
+                response._headers[header.lower()][1], response_header[1]
+            )
+
+            self.memory_exporter.clear()
+            del environ[ENV_HTTP_TRACE_RESPONSE_HEADER]
+
+        if original_env_var:
+            environ[ENV_HTTP_TRACE_RESPONSE_HEADER] = original_env_var
+
+    def test_trace_response_header_pre_existing_header(self):
+        original_env_var = environ.pop(ENV_HTTP_TRACE_RESPONSE_HEADER, None)
+        environ[ENV_HTTP_TRACE_RESPONSE_HEADER] = "Server-Timing"
+        response = Client().get("/response_header/")
+
+        span = self.memory_exporter.get_finished_spans()[0]
+        headers = get_trace_response_headers(span)
+        self.assertEqual(len(headers), 2)
+        access_control_header = headers[0]
+        response_header = headers[1]
+
+        self.assertIn("server-timing", response._headers)
+        self.assertEqual(
+            response._headers["access-control-expose-headers"][0],
+            access_control_header[0],
+        )
+        self.assertEqual(
+            response._headers["access-control-expose-headers"][1],
+            "X-Test-Header, Server-Timing",
+        )
+        self.assertEqual(
+            response._headers["server-timing"][0], response_header[0]
+        )
+        self.assertEqual(
+            response._headers["server-timing"][1],
+            "abc; val=1, " + response_header[1],
+        )
+
+        self.memory_exporter.clear()
+        del environ[ENV_HTTP_TRACE_RESPONSE_HEADER]
+
+        if original_env_var:
+            environ[ENV_HTTP_TRACE_RESPONSE_HEADER] = original_env_var

Diff for: instrumentation/opentelemetry-instrumentation-django/tests/views.py

@@ -1,5 +1,7 @@
 from django.http import HttpResponse
 
+from opentelemetry.util.http import HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS
+
 
 def traced(request):  # pylint: disable=unused-argument
     return HttpResponse()
@@ -29,3 +31,10 @@ def route_span_name(
     request, *args, **kwargs
 ):  # pylint: disable=unused-argument
     return HttpResponse()
+
+
+def with_response_header(request):  # pylint: disable=unused-argument
+    response = HttpResponse()
+    response["Server-Timing"] = "abc; val=1"
+    response[HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS] = "X-Test-Header"
+    return response

Diff for: util/opentelemetry-util-http/src/opentelemetry/util/http/__init__.py

@@ -15,6 +15,14 @@
 from os import environ
 from re import compile as re_compile
 from re import search
+from typing import Callable, Collection, Optional, Tuple
+
+from opentelemetry import trace
+
+_root = r"OTEL_PYTHON_{}"
+
+HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers"
+ENV_HTTP_TRACE_RESPONSE_HEADER = "OTEL_PYTHON_HTTP_TRACE_RESPONSE_HEADER"
 
 
 class ExcludeList:
@@ -29,9 +37,6 @@ def url_disabled(self, url: str) -> bool:
         return bool(self._excluded_urls and search(self._regex, url))
 
 
-_root = r"OTEL_PYTHON_{}"
-
-
 def get_traced_request_attrs(instrumentation):
     traced_request_attrs = environ.get(
         _root.format("{}_TRACED_REQUEST_ATTRS".format(instrumentation)), []
@@ -57,3 +62,30 @@ def get_excluded_urls(instrumentation):
         ]
 
     return ExcludeList(excluded_urls)
+
+
+def get_trace_response_headers(
+    span: trace.Span,
+) -> Collection[Tuple[str, str]]:
+    header_name = environ.get(ENV_HTTP_TRACE_RESPONSE_HEADER, "").strip()
+    if not header_name:
+        return tuple()
+
+    if span is trace.INVALID_SPAN:
+        return tuple()
+
+    ctx = span.get_span_context()
+    if ctx is trace.INVALID_SPAN_CONTEXT:
+        return tuple()
+
+    return (
+        (HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, header_name),
+        (
+            header_name,
+            'traceparent;desc="00-{trace_id}-{span_id}-{sampled}"'.format(
+                trace_id=trace.format_trace_id(ctx.trace_id),
+                span_id=trace.format_span_id(ctx.span_id),
+                sampled="01" if ctx.trace_flags.sampled else "00",
+            ),
+        ),
+    )