opentelemetry-instrumentation-tornado 0.55b0__tar.gz → 0.56b0__tar.gz

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-tornado
-Version: 0.55b0
+Version: 0.56b0
 Summary: Tornado instrumentation for OpenTelemetry
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-tornado
 Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
@@ -18,9 +18,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.55b0
-Requires-Dist: opentelemetry-semantic-conventions==0.55b0
-Requires-Dist: opentelemetry-util-http==0.55b0
+Requires-Dist: opentelemetry-instrumentation==0.56b0
+Requires-Dist: opentelemetry-semantic-conventions==0.56b0
+Requires-Dist: opentelemetry-util-http==0.56b0
 Provides-Extra: instruments
 Requires-Dist: tornado>=5.1.1; extra == 'instruments'
 Description-Content-Type: text/x-rst

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/pyproject.toml

@@ -25,9 +25,9 @@ classifiers = [
 ]
 dependencies = [
   "opentelemetry-api ~= 1.12",
-  "opentelemetry-instrumentation == 0.55b0",
-  "opentelemetry-semantic-conventions == 0.55b0",
-  "opentelemetry-util-http == 0.55b0",
+  "opentelemetry-instrumentation == 0.56b0",
+  "opentelemetry-semantic-conventions == 0.56b0",
+  "opentelemetry-util-http == 0.56b0",
 ]
 
 [project.optional-dependencies]

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/src/opentelemetry/instrumentation/tornado/__init__.py

@@ -162,6 +162,7 @@ from timeit import default_timer
 from typing import Collection, Dict
 
 import tornado.web
+import tornado.websocket
 import wrapt
 from wrapt import wrap_function_wrapper
 
@@ -182,8 +183,19 @@ from opentelemetry.instrumentation.utils import (
 from opentelemetry.metrics import get_meter
 from opentelemetry.metrics._internal.instrument import Histogram
 from opentelemetry.propagators import textmap
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_CLIENT_IP,
+    HTTP_FLAVOR,
+    HTTP_HOST,
+    HTTP_METHOD,
+    HTTP_SCHEME,
+    HTTP_STATUS_CODE,
+    HTTP_TARGET,
+)
+from opentelemetry.semconv._incubating.attributes.net_attributes import (
+    NET_PEER_IP,
+)
 from opentelemetry.semconv.metrics import MetricInstruments
-from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.trace.status import Status, StatusCode
 from opentelemetry.util.http import (
     OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST,
@@ -351,12 +363,20 @@ def patch_handler_class(tracer, server_histograms, cls, request_hook=None):
         "prepare",
         partial(_prepare, tracer, server_histograms, request_hook),
     )
-    _wrap(cls, "on_finish", partial(_on_finish, tracer, server_histograms))
     _wrap(
         cls,
         "log_exception",
         partial(_log_exception, tracer, server_histograms),
     )
+
+    if issubclass(cls, tornado.websocket.WebSocketHandler):
+        _wrap(
+            cls,
+            "on_close",
+            partial(_websockethandler_on_close, tracer, server_histograms),
+        )
+    else:
+        _wrap(cls, "on_finish", partial(_on_finish, tracer, server_histograms))
     return True
 
 
@@ -365,8 +385,11 @@ def unpatch_handler_class(cls):
         return
 
     unwrap(cls, "prepare")
-    unwrap(cls, "on_finish")
     unwrap(cls, "log_exception")
+    if issubclass(cls, tornado.websocket.WebSocketHandler):
+        unwrap(cls, "on_close")
+    else:
+        unwrap(cls, "on_finish")
     delattr(cls, _OTEL_PATCHED_KEY)
 
 
@@ -394,13 +417,21 @@ def _prepare(
 
 
 def _on_finish(tracer, server_histograms, func, handler, args, kwargs):
-    response = func(*args, **kwargs)
-
-    _record_on_finish_metrics(server_histograms, handler)
+    try:
+        return func(*args, **kwargs)
+    finally:
+        _record_on_finish_metrics(server_histograms, handler)
+        _finish_span(tracer, handler)
 
-    _finish_span(tracer, handler)
 
-    return response
+def _websockethandler_on_close(
+    tracer, server_histograms, func, handler, args, kwargs
+):
+    try:
+        func()
+    finally:
+        _record_on_finish_metrics(server_histograms, handler)
+        _finish_span(tracer, handler)
 
 
 def _log_exception(tracer, server_histograms, func, handler, args, kwargs):
@@ -442,23 +473,21 @@ def _collect_custom_response_headers_attributes(response_headers):
 
 def _get_attributes_from_request(request):
     attrs = {
-        SpanAttributes.HTTP_METHOD: request.method,
-        SpanAttributes.HTTP_SCHEME: request.protocol,
-        SpanAttributes.HTTP_HOST: request.host,
-        SpanAttributes.HTTP_TARGET: request.path,
+        HTTP_METHOD: request.method,
+        HTTP_SCHEME: request.protocol,
+        HTTP_HOST: request.host,
+        HTTP_TARGET: request.path,
     }
 
     if request.remote_ip:
         # NET_PEER_IP is the address of the network peer
         # HTTP_CLIENT_IP is the address of the client, which might be different
         # if Tornado is set to trust X-Forwarded-For headers (xheaders=True)
-        attrs[SpanAttributes.HTTP_CLIENT_IP] = request.remote_ip
+        attrs[HTTP_CLIENT_IP] = request.remote_ip
         if hasattr(request.connection, "context") and getattr(
             request.connection.context, "_orig_remote_ip", None
         ):
-            attrs[SpanAttributes.NET_PEER_IP] = (
-                request.connection.context._orig_remote_ip
-            )
+            attrs[NET_PEER_IP] = request.connection.context._orig_remote_ip
 
     return extract_attributes_from_object(
         request, _traced_request_attrs, attrs
@@ -550,7 +579,7 @@ def _finish_span(tracer, handler, error=None):
         return
 
     if ctx.span.is_recording():
-        ctx.span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code)
+        ctx.span.set_attribute(HTTP_STATUS_CODE, status_code)
         otel_status_code = http_status_to_status_code(
             status_code, server_span=True
         )
@@ -601,7 +630,7 @@ def _record_on_finish_metrics(server_histograms, handler, error=None):
     metric_attributes = _create_metric_attributes(handler)
 
     if isinstance(error, tornado.web.HTTPError):
-        metric_attributes[SpanAttributes.HTTP_STATUS_CODE] = error.status_code
+        metric_attributes[HTTP_STATUS_CODE] = error.status_code
 
     server_histograms[MetricInstruments.HTTP_SERVER_RESPONSE_SIZE].record(
         response_size, attributes=metric_attributes
@@ -621,11 +650,11 @@ def _record_on_finish_metrics(server_histograms, handler, error=None):
 
 def _create_active_requests_attributes(request):
     metric_attributes = {
-        SpanAttributes.HTTP_METHOD: request.method,
-        SpanAttributes.HTTP_SCHEME: request.protocol,
-        SpanAttributes.HTTP_FLAVOR: request.version,
-        SpanAttributes.HTTP_HOST: request.host,
-        SpanAttributes.HTTP_TARGET: request.path,
+        HTTP_METHOD: request.method,
+        HTTP_SCHEME: request.protocol,
+        HTTP_FLAVOR: request.version,
+        HTTP_HOST: request.host,
+        HTTP_TARGET: request.path,
     }
 
     return metric_attributes
@@ -633,6 +662,6 @@ def _create_active_requests_attributes(request):
 
 def _create_metric_attributes(handler):
     metric_attributes = _create_active_requests_attributes(handler.request)
-    metric_attributes[SpanAttributes.HTTP_STATUS_CODE] = handler.get_status()
+    metric_attributes[HTTP_STATUS_CODE] = handler.get_status()
 
     return metric_attributes

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/src/opentelemetry/instrumentation/tornado/client.py

@@ -20,9 +20,13 @@ from tornado.httpclient import HTTPError, HTTPRequest
 from opentelemetry import trace
 from opentelemetry.instrumentation.utils import http_status_to_status_code
 from opentelemetry.propagate import inject
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_METHOD,
+    HTTP_STATUS_CODE,
+    HTTP_URL,
+)
 from opentelemetry.trace.status import Status, StatusCode
-from opentelemetry.util.http import remove_url_credentials
+from opentelemetry.util.http import redact_url
 
 
 def _normalize_request(args, kwargs):
@@ -75,8 +79,8 @@ def fetch_async(
 
     if span.is_recording():
         attributes = {
-            SpanAttributes.HTTP_URL: remove_url_credentials(request.url),
-            SpanAttributes.HTTP_METHOD: request.method,
+            HTTP_URL: redact_url(request.url),
+            HTTP_METHOD: request.method,
         }
         for key, value in attributes.items():
             span.set_attribute(key, value)
@@ -135,7 +139,7 @@ def _finish_tracing_callback(
         )
 
     if status_code is not None:
-        span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code)
+        span.set_attribute(HTTP_STATUS_CODE, status_code)
     span.set_status(status)
 
     if response is not None:
@@ -160,9 +164,9 @@ def _finish_tracing_callback(
 
 def _create_metric_attributes(response):
     metric_attributes = {
-        SpanAttributes.HTTP_STATUS_CODE: response.code,
-        SpanAttributes.HTTP_URL: remove_url_credentials(response.request.url),
-        SpanAttributes.HTTP_METHOD: response.request.method,
+        HTTP_STATUS_CODE: response.code,
+        HTTP_URL: redact_url(response.request.url),
+        HTTP_METHOD: response.request.method,
     }
 
     return metric_attributes

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/src/opentelemetry/instrumentation/tornado/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.55b0"
+__version__ = "0.56b0"

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/tests/test_instrumentation.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 
 
+import asyncio
 from unittest.mock import Mock, patch
 
+import tornado.websocket
 from http_server_mock import HttpServerMock
 from tornado.httpclient import HTTPClientError
 from tornado.testing import AsyncHTTPTestCase
@@ -30,7 +32,18 @@ from opentelemetry.instrumentation.tornado import (
     patch_handler_class,
     unpatch_handler_class,
 )
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_CLIENT_IP,
+    HTTP_HOST,
+    HTTP_METHOD,
+    HTTP_SCHEME,
+    HTTP_STATUS_CODE,
+    HTTP_TARGET,
+    HTTP_URL,
+)
+from opentelemetry.semconv._incubating.attributes.net_attributes import (
+    NET_PEER_IP,
+)
 from opentelemetry.test.test_base import TestBase
 from opentelemetry.test.wsgitestutil import WsgiTestBase
 from opentelemetry.trace import SpanKind, StatusCode
@@ -146,13 +159,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: method,
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 201,
+                HTTP_METHOD: method,
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 201,
                 "tornado.handler": "tests.tornado_test_app.MainHandler",
             },
         )
@@ -164,9 +176,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/"),
-                SpanAttributes.HTTP_METHOD: method,
-                SpanAttributes.HTTP_STATUS_CODE: 201,
+                HTTP_URL: self.get_url("/"),
+                HTTP_METHOD: method,
+                HTTP_STATUS_CODE: 201,
             },
         )
 
@@ -224,13 +236,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: url,
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 201,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: url,
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 201,
                 "tornado.handler": f"tests.tornado_test_app.{handler_name}",
             },
         )
@@ -242,9 +253,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url(url),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 201,
+                HTTP_URL: self.get_url(url),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 201,
             },
         )
 
@@ -263,13 +274,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/error",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 500,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/error",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 500,
                 "tornado.handler": "tests.tornado_test_app.BadHandler",
             },
         )
@@ -279,9 +289,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/error"),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 500,
+                HTTP_URL: self.get_url("/error"),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 500,
             },
         )
 
@@ -298,13 +308,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/missing-url",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 404,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/missing-url",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 404,
                 "tornado.handler": "tornado.web.ErrorHandler",
             },
         )
@@ -314,9 +323,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/missing-url"),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 404,
+                HTTP_URL: self.get_url("/missing-url"),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 404,
             },
         )
 
@@ -333,13 +342,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/raise_403",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 403,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/raise_403",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 403,
                 "tornado.handler": "tests.tornado_test_app.RaiseHTTPErrorHandler",
             },
         )
@@ -349,9 +357,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/raise_403"),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 403,
+                HTTP_URL: self.get_url("/raise_403"),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 403,
             },
         )
 
@@ -378,13 +386,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/dyna",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 202,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/dyna",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 202,
                 "tornado.handler": "tests.tornado_test_app.DynamicHandler",
             },
         )
@@ -396,9 +403,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/dyna"),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 202,
+                HTTP_URL: self.get_url("/dyna"),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 202,
             },
         )
 
@@ -419,13 +426,12 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             server,
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/on_finish",
-                SpanAttributes.HTTP_CLIENT_IP: "127.0.0.1",
-                SpanAttributes.HTTP_STATUS_CODE: 200,
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/on_finish",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 200,
                 "tornado.handler": "tests.tornado_test_app.FinishedHandler",
             },
         )
@@ -437,9 +443,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: self.get_url("/on_finish"),
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 200,
+                HTTP_URL: self.get_url("/on_finish"),
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 200,
             },
         )
 
@@ -450,6 +456,53 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
 
         self.assertEqual(auditor.kind, SpanKind.INTERNAL)
 
+    @tornado.testing.gen_test()
+    async def test_websockethandler(self):
+        ws_client = await tornado.websocket.websocket_connect(
+            f"ws://127.0.0.1:{self.get_http_port()}/echo_socket"
+        )
+
+        await ws_client.write_message("world")
+        resp = await ws_client.read_message()
+        self.assertEqual(resp, "hello world")
+
+        ws_client.close()
+        await asyncio.sleep(0.5)
+
+        spans = self.sorted_spans(self.memory_exporter.get_finished_spans())
+        self.assertEqual(len(spans), 3)
+        close_span, msg_span, req_span = spans
+
+        self.assertEqual(req_span.name, "GET /echo_socket")
+        self.assertEqual(req_span.context.trace_id, msg_span.context.trace_id)
+        self.assertIsNone(req_span.parent)
+        self.assertEqual(req_span.kind, SpanKind.SERVER)
+        self.assertSpanHasAttributes(
+            req_span,
+            {
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: f"127.0.0.1:{self.get_http_port()}",
+                HTTP_TARGET: "/echo_socket",
+                HTTP_CLIENT_IP: "127.0.0.1",
+                HTTP_STATUS_CODE: 101,
+                "tornado.handler": "tests.tornado_test_app.EchoWebSocketHandler",
+            },
+        )
+
+        self.assertEqual(msg_span.name, "audit_message")
+        self.assertFalse(msg_span.context.is_remote)
+        self.assertEqual(msg_span.kind, SpanKind.INTERNAL)
+        self.assertEqual(msg_span.parent.span_id, req_span.context.span_id)
+
+        self.assertEqual(close_span.name, "audit_on_close")
+        self.assertFalse(close_span.context.is_remote)
+        self.assertEqual(close_span.parent.span_id, req_span.context.span_id)
+        self.assertEqual(
+            close_span.context.trace_id, msg_span.context.trace_id
+        )
+        self.assertEqual(close_span.kind, SpanKind.INTERNAL)
+
     def test_exclude_lists(self):
         def test_excluded(path):
             self.fetch(path)
@@ -463,9 +516,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
             self.assertSpanHasAttributes(
                 client,
                 {
-                    SpanAttributes.HTTP_URL: self.get_url(path),
-                    SpanAttributes.HTTP_METHOD: "GET",
-                    SpanAttributes.HTTP_STATUS_CODE: 200,
+                    HTTP_URL: self.get_url(path),
+                    HTTP_METHOD: "GET",
+                    HTTP_STATUS_CODE: 200,
                 },
             )
             self.memory_exporter.clear()
@@ -496,8 +549,8 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
 
         set_global_response_propagator(orig)
 
-    def test_credential_removal(self):
-        app = HttpServerMock("test_credential_removal")
+    def test_remove_sensitive_params(self):
+        app = HttpServerMock("test_remove_sensitive_params")
 
         @app.route("/status/200")
         def index():
@@ -505,7 +558,7 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
 
         with app.run("localhost", 5000):
             response = self.fetch(
-                "http://username:password@localhost:5000/status/200"
+                "http://username:password@localhost:5000/status/200?Signature=secret"
             )
         self.assertEqual(response.code, 200)
 
@@ -518,9 +571,9 @@ class TestTornadoInstrumentation(TornadoTest, WsgiTestBase):
         self.assertSpanHasAttributes(
             client,
             {
-                SpanAttributes.HTTP_URL: "http://localhost:5000/status/200",
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_STATUS_CODE: 200,
+                HTTP_URL: "http://REDACTED:REDACTED@localhost:5000/status/200?Signature=REDACTED",
+                HTTP_METHOD: "GET",
+                HTTP_STATUS_CODE: 200,
             },
         )
 
@@ -538,14 +591,13 @@ class TestTornadoInstrumentationWithXHeaders(TornadoTest):
         self.assertSpanHasAttributes(
             spans.by_name("GET /"),
             {
-                SpanAttributes.HTTP_METHOD: "GET",
-                SpanAttributes.HTTP_SCHEME: "http",
-                SpanAttributes.HTTP_HOST: "127.0.0.1:"
-                + str(self.get_http_port()),
-                SpanAttributes.HTTP_TARGET: "/",
-                SpanAttributes.HTTP_CLIENT_IP: "12.34.56.78",
-                SpanAttributes.HTTP_STATUS_CODE: 201,
-                SpanAttributes.NET_PEER_IP: "127.0.0.1",
+                HTTP_METHOD: "GET",
+                HTTP_SCHEME: "http",
+                HTTP_HOST: "127.0.0.1:" + str(self.get_http_port()),
+                HTTP_TARGET: "/",
+                HTTP_CLIENT_IP: "12.34.56.78",
+                HTTP_STATUS_CODE: 201,
+                NET_PEER_IP: "127.0.0.1",
                 "tornado.handler": "tests.tornado_test_app.MainHandler",
             },
         )

{opentelemetry_instrumentation_tornado-0.55b0 → opentelemetry_instrumentation_tornado-0.56b0}/tests/tornado_test_app.py

@@ -2,6 +2,7 @@
 import time
 
 import tornado.web
+import tornado.websocket
 from tornado import gen
 
 
@@ -110,6 +111,16 @@ class RaiseHTTPErrorHandler(tornado.web.RequestHandler):
         raise tornado.web.HTTPError(403)
 
 
+class EchoWebSocketHandler(tornado.websocket.WebSocketHandler):
+    async def on_message(self, message):
+        with self.application.tracer.start_as_current_span("audit_message"):
+            self.write_message(f"hello {message}")
+
+    def on_close(self):
+        with self.application.tracer.start_as_current_span("audit_on_close"):
+            time.sleep(0.05)
+
+
 def make_app(tracer):
     app = tornado.web.Application(
         [
@@ -122,6 +133,7 @@ def make_app(tracer):
             (r"/ping", HealthCheckHandler),
             (r"/test_custom_response_headers", CustomResponseHeaderHandler),
             (r"/raise_403", RaiseHTTPErrorHandler),
+            (r"/echo_socket", EchoWebSocketHandler),
         ]
     )
     app.tracer = tracer