From 2fb4978691166708e3ac8da59752d89d3d62065d Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Sat, 9 Apr 2022 02:43:22 +0530
Subject: [PATCH 1/9] code change for issue:
https://github.com/open-telemetry/opentelemetry-python-contrib/issues/917
---
.../instrumentation/starlette/__init__.py | 51 +++
.../tests/test_starlette_instrumentation.py | 346 +++++++++++++++++-
2 files changed, 395 insertions(+), 2 deletions(-)
diff --git a/instrumentation/opentelemetry-instrumentation-starlette/src/opentelemetry/instrumentation/starlette/__init__.py b/instrumentation/opentelemetry-instrumentation-starlette/src/opentelemetry/instrumentation/starlette/__init__.py
index f468c56bf2..d5eba719a1 100644
--- a/instrumentation/opentelemetry-instrumentation-starlette/src/opentelemetry/instrumentation/starlette/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-starlette/src/opentelemetry/instrumentation/starlette/__init__.py
@@ -68,6 +68,57 @@ def client_response_hook(span: Span, message: dict):
StarletteInstrumentor().instrument(server_request_hook=server_request_hook, client_request_hook=client_request_hook, client_response_hook=client_response_hook)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in starlette are case insensitive. So, giving header name as ``CUStom-Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in starlette are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
diff --git a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
index 592f319349..c37ffb0b13 100644
--- a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
@@ -19,13 +19,24 @@
from starlette.responses import PlainTextResponse
from starlette.routing import Route
from starlette.testclient import TestClient
+from starlette.websockets import WebSocket
import opentelemetry.instrumentation.starlette as otel_starlette
from opentelemetry.sdk.resources import Resource
from opentelemetry.semconv.trace import SpanAttributes
from opentelemetry.test.test_base import TestBase
-from opentelemetry.trace import SpanKind, get_tracer
-from opentelemetry.util.http import get_excluded_urls
+from opentelemetry.test.globals_test import reset_trace_globals
+from opentelemetry.trace import (
+ SpanKind,
+ get_tracer,
+ NoOpTracerProvider,
+ set_tracer_provider,
+)
+from opentelemetry.util.http import (
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST,
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE,
+ get_excluded_urls,
+)
class TestStarletteManualInstrumentation(TestBase):
@@ -244,3 +255,334 @@ def test_mark_span_internal_in_presence_of_another_span(self):
self.assertEqual(
parent_span.context.span_id, starlette_span.parent.span_id
)
+
+
+class TestHTTPAppWithCustomHeaders(TestBase):
+ def _create_app(self):
+ app = self._create_starlette_app()
+ self._instrumentor.instrument_app(app=app)
+ return app
+
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ self._instrumentor = otel_starlette.StarletteInstrumentor()
+ self._app = self._create_app()
+ self._client = TestClient(self._app)
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ self.env_patch.stop()
+
+ @staticmethod
+ def _create_starlette_app():
+ def home(_):
+ return PlainTextResponse(
+ content="hi",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+
+ app = applications.Starlette(
+ routes=[
+ Route("/foobar", home),
+ ]
+ )
+ return app
+
+ def test_custom_request_headers_in_span_attributes(self):
+ expected = {
+ "http.request.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.request.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ resp = self._client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_custom_request_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.request.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ resp = self._client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+ def test_custom_response_headers_in_span_attributes(self):
+ expected = {
+ "http.response.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.response.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ resp = self._client.get("/foobar")
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_custom_response_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.response.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ resp = self._client.get("/foobar")
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+
+class TestWebSocketAppWithCustomHeaders(TestBase):
+ def _create_app(self):
+ app = self._create_starlette_app()
+ self._instrumentor.instrument_app(app=app)
+ return app
+
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ self._instrumentor = otel_starlette.StarletteInstrumentor()
+ self._app = self._create_app()
+ self._client = TestClient(self._app)
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ self.env_patch.stop()
+
+ @staticmethod
+ def _create_starlette_app():
+ app = applications.Starlette()
+
+ @app.websocket_route("/foobar_web")
+ async def _(websocket: WebSocket) -> None:
+ message = await websocket.receive()
+ if message.get("type") == "websocket.connect":
+ await websocket.send(
+ {
+ "type": "websocket.accept",
+ "headers": [
+ (b"custom-test-header-1", b"test-header-value-1"),
+ (b"custom-test-header-2", b"test-header-value-2"),
+ ],
+ }
+ )
+ await websocket.send_json({"message": "hello world"})
+ await websocket.close()
+ if message.get("type") == "websocket.disconnect":
+ pass
+
+ return app
+
+ def test_custom_request_headers_in_span_attributes(self):
+ expected = {
+ "http.request.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.request.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ with self._client.websocket_connect(
+ "/foobar_web",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ ) as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_custom_request_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.request.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ with self._client.websocket_connect(
+ "/foobar_web",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ ) as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+ def test_custom_response_headers_in_span_attributes(self):
+ expected = {
+ "http.response.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.response.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ with self._client.websocket_connect("/foobar_web") as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_custom_response_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.response.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ with self._client.websocket_connect("/foobar_web") as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+
+class TestNonRecordingSpanWithCustomHeaders(TestBase):
+ def _create_app(self):
+ app = self._create_starlette_app()
+ self._instrumentor.instrument_app(app=app)
+ return app
+
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ reset_trace_globals()
+ set_tracer_provider(tracer_provider=NoOpTracerProvider())
+
+ self._instrumentor = otel_starlette.StarletteInstrumentor()
+ self._app = self._create_app()
+ self._client = TestClient(self._app)
+
+ @staticmethod
+ def _create_starlette_app():
+ def home(_):
+ return PlainTextResponse(
+ content="hi",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+
+ app = applications.Starlette(
+ routes=[
+ Route("/foobar", home),
+ ]
+ )
+ return app
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ self.env_patch.stop()
+
+ def test_custom_header_not_present_in_non_recording_span(self):
+ resp = self._client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 0)
From 1adfe9cbb429a2a9ca5308e45f47924e2cb6de7d Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Sat, 9 Apr 2022 02:50:30 +0530
Subject: [PATCH 2/9] added changelog entry for startlette PR
---
CHANGELOG.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d7597561a3..fe3d4208f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,7 +15,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
([#999])(https://github.com/open-telemetry/opentelemetry-python-contrib/pull/999)
### Added
-
+- `opentelemetry-instrumentation-starlette` Capture custom request/response headers in span attributes
+ ([#1046])(https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1046)
- `opentelemetry-instrumentation-django` Capture custom request/response headers in span attributes
([#1024])(https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1024)
- `opentelemetry-instrumentation-asgi` Capture custom request/response headers in span attributes
From 8669513ec97136a29d44b60d19966c171fa76d2a Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Sat, 9 Apr 2022 02:55:14 +0530
Subject: [PATCH 3/9] solving linting issue due to generate command
---
.../tests/test_starlette_instrumentation.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
index c37ffb0b13..421066cad3 100644
--- a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
@@ -27,9 +27,9 @@
from opentelemetry.test.test_base import TestBase
from opentelemetry.test.globals_test import reset_trace_globals
from opentelemetry.trace import (
+ NoOpTracerProvider,
SpanKind,
get_tracer,
- NoOpTracerProvider,
set_tracer_provider,
)
from opentelemetry.util.http import (
From b6a5b3a32348f40a882a8265b3455ac9311ab596 Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Sat, 9 Apr 2022 02:58:09 +0530
Subject: [PATCH 4/9] resolving linting errors due to generate command
---
.../tests/test_starlette_instrumentation.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
index 421066cad3..5763b582ba 100644
--- a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
@@ -24,8 +24,8 @@
import opentelemetry.instrumentation.starlette as otel_starlette
from opentelemetry.sdk.resources import Resource
from opentelemetry.semconv.trace import SpanAttributes
-from opentelemetry.test.test_base import TestBase
from opentelemetry.test.globals_test import reset_trace_globals
+from opentelemetry.test.test_base import TestBase
from opentelemetry.trace import (
NoOpTracerProvider,
SpanKind,
From 6d2a6126cd1dc331ce4d3387abaebb5afb6e645c Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Tue, 12 Apr 2022 20:14:31 +0530
Subject: [PATCH 5/9] undo removed code from previous commits.
---
.../instrumentation/asgi/__init__.py | 54 +++
.../instrumentation/falcon/__init__.py | 51 +++
.../tests/test_fastapi_instrumentation.py | 319 +++++++++++++++++-
.../instrumentation/flask/__init__.py | 51 +++
.../instrumentation/tornado/__init__.py | 51 +++
.../instrumentation/wsgi/__init__.py | 51 +++
6 files changed, 576 insertions(+), 1 deletion(-)
diff --git a/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py b/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
index d8932da996..54656edb9f 100644
--- a/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
@@ -91,6 +91,60 @@ def client_response_hook(span: Span, message: dict):
OpenTelemetryMiddleware().(application, server_request_hook=server_request_hook, client_request_hook=client_request_hook, client_response_hook=client_response_hook)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in ASGI are case insensitive. So, giving header name as ``CUStom-Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in ASGI are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
+API
+---
+
API
---
"""
diff --git a/instrumentation/opentelemetry-instrumentation-falcon/src/opentelemetry/instrumentation/falcon/__init__.py b/instrumentation/opentelemetry-instrumentation-falcon/src/opentelemetry/instrumentation/falcon/__init__.py
index 4ee643412f..b28ac96e4c 100644
--- a/instrumentation/opentelemetry-instrumentation-falcon/src/opentelemetry/instrumentation/falcon/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-falcon/src/opentelemetry/instrumentation/falcon/__init__.py
@@ -86,6 +86,57 @@ def response_hook(span, req, resp):
FalconInstrumentation().instrument(request_hook=request_hook, response_hook=response_hook)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in falcon are case insensitive and - characters are replaced by _. So, giving header name as ``CUStom_Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in falcon are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
diff --git a/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py b/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
index ae963e4f87..46d6c55ac0 100644
--- a/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
@@ -16,6 +16,7 @@
from unittest.mock import patch
import fastapi
+from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
import opentelemetry.instrumentation.fastapi as otel_fastapi
@@ -23,8 +24,13 @@
from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware
from opentelemetry.sdk.resources import Resource
from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.test.globals_test import reset_trace_globals
from opentelemetry.test.test_base import TestBase
-from opentelemetry.util.http import get_excluded_urls
+from opentelemetry.util.http import (
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST,
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE,
+ get_excluded_urls,
+)
class TestFastAPIManualInstrumentation(TestBase):
@@ -375,3 +381,314 @@ def test_mark_span_internal_in_presence_of_span_from_other_framework(self):
self.assertEqual(
parent_span.context.span_id, span_list[3].context.span_id
)
+
+
+class TestHTTPAppWithCustomHeaders(TestBase):
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ self.app = self._create_app()
+ otel_fastapi.FastAPIInstrumentor().instrument_app(self.app)
+ self.client = TestClient(self.app)
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ self.env_patch.stop()
+ with self.disable_logging():
+ otel_fastapi.FastAPIInstrumentor().uninstrument_app(self.app)
+
+ @staticmethod
+ def _create_app():
+ app = fastapi.FastAPI()
+
+ @app.get("/foobar")
+ async def _():
+ headers = {
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ }
+ content = {"message": "hello world"}
+ return JSONResponse(content=content, headers=headers)
+
+ return app
+
+ def test_http_custom_request_headers_in_span_attributes(self):
+ expected = {
+ "http.request.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.request.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ resp = self.client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_http_custom_request_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.request.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ resp = self.client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+ def test_http_custom_response_headers_in_span_attributes(self):
+ expected = {
+ "http.response.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.response.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+ resp = self.client.get("/foobar")
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_http_custom_response_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.reponse.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+ resp = self.client.get("/foobar")
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 3)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+
+class TestWebSocketAppWithCustomHeaders(TestBase):
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ self.app = self._create_app()
+ otel_fastapi.FastAPIInstrumentor().instrument_app(self.app)
+ self.client = TestClient(self.app)
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ self.env_patch.stop()
+ with self.disable_logging():
+ otel_fastapi.FastAPIInstrumentor().uninstrument_app(self.app)
+
+ @staticmethod
+ def _create_app():
+ app = fastapi.FastAPI()
+
+ @app.websocket("/foobar_web")
+ async def _(websocket: fastapi.WebSocket):
+ message = await websocket.receive()
+ if message.get("type") == "websocket.connect":
+ await websocket.send(
+ {
+ "type": "websocket.accept",
+ "headers": [
+ (b"custom-test-header-1", b"test-header-value-1"),
+ (b"custom-test-header-2", b"test-header-value-2"),
+ ],
+ }
+ )
+ await websocket.send_json({"message": "hello world"})
+ await websocket.close()
+ if message.get("type") == "websocket.disconnect":
+ pass
+
+ return app
+
+ def test_web_socket_custom_request_headers_in_span_attributes(self):
+ expected = {
+ "http.request.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.request.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+
+ with self.client.websocket_connect(
+ "/foobar_web",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ ) as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_web_socket_custom_request_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.request.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+
+ with self.client.websocket_connect(
+ "/foobar_web",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ "custom-test-header-2": "test-header-value-2",
+ },
+ ) as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+ def test_web_socket_custom_response_headers_in_span_attributes(self):
+ expected = {
+ "http.response.header.custom_test_header_1": (
+ "test-header-value-1",
+ ),
+ "http.response.header.custom_test_header_2": (
+ "test-header-value-2",
+ ),
+ }
+
+ with self.client.websocket_connect("/foobar_web") as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ self.assertSpanHasAttributes(server_span, expected)
+
+ def test_web_socket_custom_response_headers_not_in_span_attributes(self):
+ not_expected = {
+ "http.reponse.header.custom_test_header_3": (
+ "test-header-value-3",
+ ),
+ }
+
+ with self.client.websocket_connect("/foobar_web") as websocket:
+ data = websocket.receive_json()
+ self.assertEqual(data, {"message": "hello world"})
+
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 5)
+
+ server_span = [
+ span for span in span_list if span.kind == trace.SpanKind.SERVER
+ ][0]
+
+ for key, _ in not_expected.items():
+ self.assertNotIn(key, server_span.attributes)
+
+
+class TestNonRecordingSpanWithCustomHeaders(TestBase):
+ def setUp(self):
+ super().setUp()
+ self.env_patch = patch.dict(
+ "os.environ",
+ {
+ OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
+ },
+ )
+ self.env_patch.start()
+ self.app = fastapi.FastAPI()
+
+ @self.app.get("/foobar")
+ async def _():
+ return {"message": "hello world"}
+
+ reset_trace_globals()
+ tracer_provider = trace.NoOpTracerProvider()
+ trace.set_tracer_provider(tracer_provider=tracer_provider)
+
+ self._instrumentor = otel_fastapi.FastAPIInstrumentor()
+ self._instrumentor.instrument_app(self.app)
+ self.client = TestClient(self.app)
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ with self.disable_logging():
+ self._instrumentor.uninstrument_app(self.app)
+
+ def test_custom_header_not_present_in_non_recording_span(self):
+ resp = self.client.get(
+ "/foobar",
+ headers={
+ "custom-test-header-1": "test-header-value-1",
+ },
+ )
+ self.assertEqual(200, resp.status_code)
+ span_list = self.memory_exporter.get_finished_spans()
+ self.assertEqual(len(span_list), 0)
\ No newline at end of file
diff --git a/instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py b/instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py
index 272b0d934b..9c90db0655 100644
--- a/instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py
@@ -85,6 +85,57 @@ def response_hook(span: Span, status: str, response_headers: List):
Flask Request object reference: https://flask.palletsprojects.com/en/2.0.x/api/#flask.Request
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in flask are case insensitive and - characters are replaced by _. So, giving header name as ``CUStom_Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in flask are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
diff --git a/instrumentation/opentelemetry-instrumentation-tornado/src/opentelemetry/instrumentation/tornado/__init__.py b/instrumentation/opentelemetry-instrumentation-tornado/src/opentelemetry/instrumentation/tornado/__init__.py
index 8bdf34647e..128fa56431 100644
--- a/instrumentation/opentelemetry-instrumentation-tornado/src/opentelemetry/instrumentation/tornado/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-tornado/src/opentelemetry/instrumentation/tornado/__init__.py
@@ -97,6 +97,57 @@ def client_resposne_hook(span, future):
client_response_hook=client_resposne_hook
)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in tornado are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in tornado are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
diff --git a/instrumentation/opentelemetry-instrumentation-wsgi/src/opentelemetry/instrumentation/wsgi/__init__.py b/instrumentation/opentelemetry-instrumentation-wsgi/src/opentelemetry/instrumentation/wsgi/__init__.py
index 57a0c8a4c0..5df45ac3c7 100644
--- a/instrumentation/opentelemetry-instrumentation-wsgi/src/opentelemetry/instrumentation/wsgi/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-wsgi/src/opentelemetry/instrumentation/wsgi/__init__.py
@@ -100,6 +100,57 @@ def response_hook(span: Span, environ: WSGIEnvironment, status: str, response_he
OpenTelemetryMiddleware(request_hook=request_hook, response_hook=response_hook)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in wsgi are case insensitive and - characters are replaced by _. So, giving header name as ``CUStom_Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in wsgi are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
From b575a72cc7ac06025c4a01c6c4f0f2dd316521bc Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Tue, 12 Apr 2022 20:15:01 +0530
Subject: [PATCH 6/9] undo removed code of previous commits
---
.../instrumentation/fastapi/__init__.py | 51 +++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/instrumentation/opentelemetry-instrumentation-fastapi/src/opentelemetry/instrumentation/fastapi/__init__.py b/instrumentation/opentelemetry-instrumentation-fastapi/src/opentelemetry/instrumentation/fastapi/__init__.py
index 52e1c0682c..d29749fbc3 100644
--- a/instrumentation/opentelemetry-instrumentation-fastapi/src/opentelemetry/instrumentation/fastapi/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-fastapi/src/opentelemetry/instrumentation/fastapi/__init__.py
@@ -74,6 +74,57 @@ def client_response_hook(span: Span, message: dict):
FastAPIInstrumentor().instrument(server_request_hook=server_request_hook, client_request_hook=client_request_hook, client_response_hook=client_response_hook)
+Capture HTTP request and response headers
+*****************************************
+You can configure the agent to capture predefined HTTP headers as span attributes, according to the `semantic convention <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#http-request-and-response-headers>`_.
+
+Request headers
+***************
+To capture predefined HTTP request headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="content-type,custom_request_header"
+
+will extract ``content-type`` and ``custom_request_header`` from request headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Request header names in fastapi are case insensitive. So, giving header name as ``CUStom-Header`` in environment variable will be able capture header with name ``custom-header``.
+
+The name of the added span attribute will follow the format ``http.request.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.request.header.custom_request_header = ["<value1>,<value2>"]``
+
+Response headers
+****************
+To capture predefined HTTP response headers as span attributes, set the environment variable ``OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE``
+to a comma-separated list of HTTP header names.
+
+For example,
+
+::
+
+ export OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,custom_response_header"
+
+will extract ``content-type`` and ``custom_response_header`` from response headers and add them as span attributes.
+
+It is recommended that you should give the correct names of the headers to be captured in the environment variable.
+Response header names captured in fastapi are case insensitive. So, giving header name as ``CUStomHeader`` in environment variable will be able capture header with name ``customheader``.
+
+The name of the added span attribute will follow the format ``http.response.header.<header_name>`` where ``<header_name>`` being the normalized HTTP header name (lowercase, with - characters replaced by _ ).
+The value of the attribute will be single item list containing all the header values.
+
+Example of the added span attribute,
+``http.response.header.custom_response_header = ["<value1>,<value2>"]``
+
+Note:
+ Environment variable names to caputre http headers are still experimental, and thus are subject to change.
+
API
---
"""
From f39eea9cb846240132e0495e5a047ed94792872e Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Wed, 13 Apr 2022 11:27:30 +0530
Subject: [PATCH 7/9] resolving linting errors
---
.../tests/test_fastapi_instrumentation.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py b/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
index 46d6c55ac0..e4a0960a26 100644
--- a/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py
@@ -691,4 +691,4 @@ def test_custom_header_not_present_in_non_recording_span(self):
)
self.assertEqual(200, resp.status_code)
span_list = self.memory_exporter.get_finished_spans()
- self.assertEqual(len(span_list), 0)
\ No newline at end of file
+ self.assertEqual(len(span_list), 0)
From 23ac4caae48d0c2ada2cb48f81a5d85c68365f62 Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Wed, 13 Apr 2022 12:11:28 +0530
Subject: [PATCH 8/9] removed duplicate comment
---
.../src/opentelemetry/instrumentation/asgi/__init__.py | 3 ---
1 file changed, 3 deletions(-)
diff --git a/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py b/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
index 54656edb9f..66891744e5 100644
--- a/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
+++ b/instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py
@@ -142,9 +142,6 @@ def client_response_hook(span: Span, message: dict):
Note:
Environment variable names to caputre http headers are still experimental, and thus are subject to change.
-API
----
-
API
---
"""
From edbbeaf87b4054dd9cf1f530442cc7cc1eadd545 Mon Sep 17 00:00:00 2001
From: sanket Mehta <sankmeht@cisco.com>
Date: Fri, 15 Apr 2022 21:15:46 +0530
Subject: [PATCH 9/9] created a base class "TestBaseWithCustomHeaders" for
http, websocket and no-op span test cases with custom headers
---
.../tests/test_starlette_instrumentation.py | 134 +++++-------------
1 file changed, 36 insertions(+), 98 deletions(-)
diff --git a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
index 5763b582ba..8c98feca4e 100644
--- a/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
+++ b/instrumentation/opentelemetry-instrumentation-starlette/tests/test_starlette_instrumentation.py
@@ -257,9 +257,9 @@ def test_mark_span_internal_in_presence_of_another_span(self):
)
-class TestHTTPAppWithCustomHeaders(TestBase):
- def _create_app(self):
- app = self._create_starlette_app()
+class TestBaseWithCustomHeaders(TestBase):
+ def create_app(self):
+ app = self.create_starlette_app()
self._instrumentor.instrument_app(app=app)
return app
@@ -274,16 +274,21 @@ def setUp(self):
)
self.env_patch.start()
self._instrumentor = otel_starlette.StarletteInstrumentor()
- self._app = self._create_app()
+ self._app = self.create_app()
self._client = TestClient(self._app)
def tearDown(self) -> None:
super().tearDown()
self.env_patch.stop()
+ with self.disable_logging():
+ self._instrumentor.uninstrument()
@staticmethod
- def _create_starlette_app():
- def home(_):
+ def create_starlette_app():
+ app = applications.Starlette()
+
+ @app.route("/foobar")
+ def _(request):
return PlainTextResponse(
content="hi",
headers={
@@ -292,13 +297,28 @@ def home(_):
},
)
- app = applications.Starlette(
- routes=[
- Route("/foobar", home),
- ]
- )
+ @app.websocket_route("/foobar_web")
+ async def _(websocket: WebSocket) -> None:
+ message = await websocket.receive()
+ if message.get("type") == "websocket.connect":
+ await websocket.send(
+ {
+ "type": "websocket.accept",
+ "headers": [
+ (b"custom-test-header-1", b"test-header-value-1"),
+ (b"custom-test-header-2", b"test-header-value-2"),
+ ],
+ }
+ )
+ await websocket.send_json({"message": "hello world"})
+ await websocket.close()
+ if message.get("type") == "websocket.disconnect":
+ pass
+
return app
+
+class TestHTTPAppWithCustomHeaders(TestBaseWithCustomHeaders):
def test_custom_request_headers_in_span_attributes(self):
expected = {
"http.request.header.custom_test_header_1": (
@@ -346,7 +366,7 @@ def test_custom_request_headers_not_in_span_attributes(self):
span for span in span_list if span.kind == SpanKind.SERVER
][0]
- for key, _ in not_expected.items():
+ for key in not_expected:
self.assertNotIn(key, server_span.attributes)
def test_custom_response_headers_in_span_attributes(self):
@@ -384,58 +404,11 @@ def test_custom_response_headers_not_in_span_attributes(self):
span for span in span_list if span.kind == SpanKind.SERVER
][0]
- for key, _ in not_expected.items():
+ for key in not_expected:
self.assertNotIn(key, server_span.attributes)
-class TestWebSocketAppWithCustomHeaders(TestBase):
- def _create_app(self):
- app = self._create_starlette_app()
- self._instrumentor.instrument_app(app=app)
- return app
-
- def setUp(self):
- super().setUp()
- self.env_patch = patch.dict(
- "os.environ",
- {
- OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
- OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
- },
- )
- self.env_patch.start()
- self._instrumentor = otel_starlette.StarletteInstrumentor()
- self._app = self._create_app()
- self._client = TestClient(self._app)
-
- def tearDown(self) -> None:
- super().tearDown()
- self.env_patch.stop()
-
- @staticmethod
- def _create_starlette_app():
- app = applications.Starlette()
-
- @app.websocket_route("/foobar_web")
- async def _(websocket: WebSocket) -> None:
- message = await websocket.receive()
- if message.get("type") == "websocket.connect":
- await websocket.send(
- {
- "type": "websocket.accept",
- "headers": [
- (b"custom-test-header-1", b"test-header-value-1"),
- (b"custom-test-header-2", b"test-header-value-2"),
- ],
- }
- )
- await websocket.send_json({"message": "hello world"})
- await websocket.close()
- if message.get("type") == "websocket.disconnect":
- pass
-
- return app
-
+class TestWebSocketAppWithCustomHeaders(TestBaseWithCustomHeaders):
def test_custom_request_headers_in_span_attributes(self):
expected = {
"http.request.header.custom_test_header_1": (
@@ -532,50 +505,15 @@ def test_custom_response_headers_not_in_span_attributes(self):
self.assertNotIn(key, server_span.attributes)
-class TestNonRecordingSpanWithCustomHeaders(TestBase):
- def _create_app(self):
- app = self._create_starlette_app()
- self._instrumentor.instrument_app(app=app)
- return app
-
+class TestNonRecordingSpanWithCustomHeaders(TestBaseWithCustomHeaders):
def setUp(self):
super().setUp()
- self.env_patch = patch.dict(
- "os.environ",
- {
- OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST: "Custom-Test-Header-1,Custom-Test-Header-2,Custom-Test-Header-3",
- },
- )
- self.env_patch.start()
reset_trace_globals()
set_tracer_provider(tracer_provider=NoOpTracerProvider())
- self._instrumentor = otel_starlette.StarletteInstrumentor()
- self._app = self._create_app()
+ self._app = self.create_app()
self._client = TestClient(self._app)
- @staticmethod
- def _create_starlette_app():
- def home(_):
- return PlainTextResponse(
- content="hi",
- headers={
- "custom-test-header-1": "test-header-value-1",
- "custom-test-header-2": "test-header-value-2",
- },
- )
-
- app = applications.Starlette(
- routes=[
- Route("/foobar", home),
- ]
- )
- return app
-
- def tearDown(self) -> None:
- super().tearDown()
- self.env_patch.stop()
-
def test_custom_header_not_present_in_non_recording_span(self):
resp = self._client.get(
"/foobar",