spyne: rpc-server adaptation

Signed-off-by: Varsha GS <varsha.gs@ibm.com>

Author: GSVarsha

src/instana/__init__.py

@@ -188,7 +188,7 @@ def boot_agent() -> None:
             sqlalchemy,  # noqa: F401
             starlette,  # noqa: F401
             urllib3,  # noqa: F401
-            spyne,
+            spyne,  # noqa: F401
         )
         from instana.instrumentation.aiohttp import (
             client as aiohttp_client,  # noqa: F401

src/instana/instrumentation/spyne.py

@@ -3,44 +3,41 @@
 try:
     import spyne
     import wrapt
-    from typing import TYPE_CHECKING, Dict, Any, Callable, Tuple, Iterable
-    from types import SimpleNamespace
+    from typing import TYPE_CHECKING, Dict, Any, Callable, Tuple, Iterable, Type, Optional
 
-    from opentelemetry.semconv.trace import SpanAttributes
+    from types import SimpleNamespace
 
     from instana.log import logger
     from instana.singletons import agent, tracer
     from instana.propagators.format import Format
     from instana.util.secrets import strip_secrets_from_query
-    from instana.util.traceutils import extract_custom_headers
 
     if TYPE_CHECKING:
         from instana.span.span import InstanaSpan
         from spyne.application import Application
         from spyne.server.wsgi import WsgiApplication
 
     def set_span_attributes(span: "InstanaSpan", headers: Dict[str, Any]) -> None:
-        if "REQUEST_METHOD" in headers:
-            span.set_attribute(SpanAttributes.HTTP_METHOD, headers["REQUEST_METHOD"])
         if "PATH_INFO" in headers:
-            span.set_attribute(SpanAttributes.HTTP_URL, headers["PATH_INFO"])
+            span.set_attribute("rpc.call", headers["PATH_INFO"])
         if "QUERY_STRING" in headers and len(headers["QUERY_STRING"]):
             scrubbed_params = strip_secrets_from_query(
                 headers["QUERY_STRING"],
                 agent.options.secrets_matcher,
                 agent.options.secrets_list,
             )
-            span.set_attribute("http.params", scrubbed_params)
-        if "HTTP_HOST" in headers:
-            span.set_attribute("http.host", headers["HTTP_HOST"])
+            span.set_attribute("rpc.params", scrubbed_params)
+        if "REMOTE_ADDR" in headers:
+            span.set_attribute("rpc.host", headers["REMOTE_ADDR"])
+        if "SERVER_PORT" in headers:
+            span.set_attribute("rpc.port", headers["SERVER_PORT"])
 
-    def set_response_status_code(span: "InstanaSpan", response_string: str) -> None:
+    def record_error(span: "InstanaSpan", response_string: str, error: Optional[Type[Exception]]) -> None:
         resp_code = int(response_string.split()[0])
 
         if 500 <= resp_code:
-            span.mark_as_errored()
+            span.record_exception(error)
 
-        span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, int(resp_code))
 
     @wrapt.patch_function_wrapper("spyne.server.wsgi", "WsgiApplication.handle_error")
     def handle_error_with_instana(
@@ -55,22 +52,19 @@ def handle_error_with_instana(
         if ctx.udc and ctx.udc.span:
             return wrapped(*args, **kwargs)
 
-        headers = ctx.in_document
+        headers = ctx.transport.req_env
         span_context = tracer.extract(Format.HTTP_HEADERS, headers)
 
-        with tracer.start_as_current_span("spyne", span_context=span_context) as span:
-            extract_custom_headers(span, headers, format=True)
-
+        with tracer.start_as_current_span("rpc-server", span_context=span_context) as span:
             set_span_attributes(span, headers)
 
             response_headers = ctx.transport.resp_headers
 
-            extract_custom_headers(span, response_headers, format=False)
             tracer.inject(span.context, Format.HTTP_HEADERS, response_headers)
 
             response = wrapped(*args, **kwargs)
 
-            set_response_status_code(span, ctx.transport.resp_code)
+            record_error(span, ctx.transport.resp_code, ctx.in_error or ctx.out_error)
             return response
 
     @wrapt.patch_function_wrapper(
@@ -87,7 +81,7 @@ def finalize_with_instana(
 
         if ctx.udc and ctx.udc.span and response_string:
             span = ctx.udc.span
-            set_response_status_code(span, response_string)
+            record_error(span, response_string, ctx.in_error or ctx.out_error)
             if span.is_recording():
                 span.end()
 
@@ -102,22 +96,19 @@ def process_request_with_instana(
         kwargs: Dict[str, Any],
     ) -> None:
         ctx = args[0]
-        headers = ctx.in_document
+        headers = ctx.transport.req_env
         span_context = tracer.extract(Format.HTTP_HEADERS, headers)
 
         with tracer.start_as_current_span(
-            "spyne",
+            "rpc-server",
             span_context=span_context,
             end_on_exit=False,
         ) as span:
-            extract_custom_headers(span, headers, format=True)
-
             set_span_attributes(span, headers)
 
             response = wrapped(*args, **kwargs)
             response_headers = ctx.transport.resp_headers
 
-            extract_custom_headers(span, response_headers, format=False)
             tracer.inject(span.context, Format.HTTP_HEADERS, response_headers)
 
             ## Store the span in the user defined context object offered by Spyne

tests/frameworks/test_spyne.py

@@ -78,14 +78,11 @@ def test_get_request(self) -> None:
         assert spyne_span.ec is None
 
         # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/hello"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 200
-        assert spyne_span.data["http"]["error"] is None
+        assert spyne_span.n == "rpc-server"
+        assert spyne_span.data["rpc"]["host"] == "127.0.0.1"
+        assert spyne_span.data["rpc"]["call"] == "/hello"
+        assert spyne_span.data["rpc"]["port"] == str(testenv["spyne_port"])
+        assert spyne_span.data["rpc"]["error"] is None
         assert spyne_span.stack is None
 
     def test_secret_scrubbing(self) -> None:
@@ -137,161 +134,14 @@ def test_secret_scrubbing(self) -> None:
         assert spyne_span.ec is None
 
         # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/say_hello"
-        assert spyne_span.data["http"]["params"] == "name=World&times=4&secret=<redacted>"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 200
-        assert spyne_span.data["http"]["error"] is None
-        assert spyne_span.stack is None
-
-    def test_request_header_capture(self) -> None:
-        # Hack together a manual custom headers list
-        original_extra_http_headers = agent.options.extra_http_headers
-        agent.options.extra_http_headers = ["X-Capture-This-Too", "X-Capture-That-Too"]
-
-        request_headers = {
-            "X-Capture-This-Too": "this too",
-            "X-Capture-That-Too": "that too",
-        }
-
-        with tracer.start_as_current_span("test"):
-            response = self.http.request("GET", testenv["spyne_server"] + "/hello", headers=request_headers)
-
-        spans = self.recorder.queued_spans()
-
-        assert len(spans) == 3
-
-        spyne_span = spans[0]
-        urllib3_span = spans[1]
-        test_span = spans[2]
-
-        assert response.status == 200
-
-        assert "X-INSTANA-T" in response.headers
-        assert int(response.headers["X-INSTANA-T"], 16)
-        assert response.headers["X-INSTANA-T"] == hex_id(spyne_span.t)
-
-        assert "X-INSTANA-S" in response.headers
-        assert int(response.headers["X-INSTANA-S"], 16)
-        assert response.headers["X-INSTANA-S"] == hex_id(spyne_span.s)
-
-        assert "X-INSTANA-L" in response.headers
-        assert response.headers["X-INSTANA-L"] == "1"
-
-        assert "Server-Timing" in response.headers
-        server_timing_value = f"intid;desc={hex_id(spyne_span.t)}"
-        assert response.headers["Server-Timing"] == server_timing_value
-
-        # Same traceId
-        assert test_span.t == urllib3_span.t
-        assert urllib3_span.t == spyne_span.t
-
-        # Parent relationships
-        assert urllib3_span.p == test_span.s
-        assert spyne_span.p == urllib3_span.s
-
-        assert spyne_span.sy is None
-        assert urllib3_span.sy is None
-        assert test_span.sy is None
-
-        # Error logging
-        assert test_span.ec is None
-        assert urllib3_span.ec is None
-        assert spyne_span.ec is None
-
-        # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/hello"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 200
-        assert spyne_span.data["http"]["error"] is None
-        assert spyne_span.stack is None
-
-        # custom headers
-        assert "X-Capture-This-Too" in spyne_span.data["http"]["header"]
-        assert spyne_span.data["http"]["header"]["X-Capture-This-Too"] == "this too"
-        assert "X-Capture-That-Too" in spyne_span.data["http"]["header"]
-        assert spyne_span.data["http"]["header"]["X-Capture-That-Too"] == "that too"
-
-        agent.options.extra_http_headers = original_extra_http_headers
-
-    def test_response_header_capture(self) -> None:
-        # Hack together a manual custom headers list
-        original_extra_http_headers = agent.options.extra_http_headers
-        agent.options.extra_http_headers = ["X-Capture-This", "X-Capture-That"]
-
-        with tracer.start_as_current_span("test"):
-            response = self.http.request("GET", testenv["spyne_server"] + "/response_headers")
-
-        spans = self.recorder.queued_spans()
-
-        assert len(spans) == 3
-
-        spyne_span = spans[0]
-        urllib3_span = spans[1]
-        test_span = spans[2]
-
-        assert response.status == 200
-
-        assert "X-INSTANA-T" in response.headers
-        assert int(response.headers["X-INSTANA-T"], 16)
-        assert response.headers["X-INSTANA-T"] == hex_id(spyne_span.t)
-
-        assert "X-INSTANA-S" in response.headers
-        assert int(response.headers["X-INSTANA-S"], 16)
-        assert response.headers["X-INSTANA-S"] == hex_id(spyne_span.s)
-
-        assert "X-INSTANA-L" in response.headers
-        assert response.headers["X-INSTANA-L"] == "1"
-
-        assert "Server-Timing" in response.headers
-        server_timing_value = f"intid;desc={hex_id(spyne_span.t)}"
-        assert response.headers["Server-Timing"] == server_timing_value
-
-        # Same traceId
-        assert test_span.t == urllib3_span.t
-        assert urllib3_span.t == spyne_span.t
-
-        # Parent relationships
-        assert urllib3_span.p == test_span.s
-        assert spyne_span.p == urllib3_span.s
-
-        # Synthetic
-        assert spyne_span.sy is None
-        assert urllib3_span.sy is None
-        assert test_span.sy is None
-
-        # Error logging
-        assert test_span.ec is None
-        assert urllib3_span.ec is None
-        assert spyne_span.ec is None
-
-        # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/response_headers"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 200
-        assert spyne_span.data["http"]["error"] is None
+        assert spyne_span.n == "rpc-server"
+        assert spyne_span.data["rpc"]["host"] == "127.0.0.1"
+        assert spyne_span.data["rpc"]["call"] == "/say_hello"
+        assert spyne_span.data["rpc"]["params"] == "name=World&times=4&secret=<redacted>"
+        assert spyne_span.data["rpc"]["port"] == str(testenv["spyne_port"])
+        assert spyne_span.data["rpc"]["error"] is None
         assert spyne_span.stack is None
 
-        # custom headers
-        assert "X-Capture-This" in spyne_span.data["http"]["header"]
-        assert spyne_span.data["http"]["header"]["X-Capture-This"] == "this"
-        assert "X-Capture-That" in spyne_span.data["http"]["header"]
-        assert spyne_span.data["http"]["header"]["X-Capture-That"] == "that"
-
-        agent.options.extra_http_headers = original_extra_http_headers
-
     def test_custom_404(self) -> None:
         with tracer.start_as_current_span("test"):
             response = self.http.request("GET", testenv["spyne_server"] + "/custom_404?user_id=9876")
@@ -307,7 +157,7 @@ def test_custom_404(self) -> None:
         test_span = spans[3]
 
         assert response
-        assert response.status         == 404
+        assert response.status == 404
 
         assert "X-INSTANA-T" in response.headers
         assert int(response.headers["X-INSTANA-T"], 16)
@@ -343,14 +193,12 @@ def test_custom_404(self) -> None:
         assert spyne_span.ec is None
 
         # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/custom_404"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 404
-        assert spyne_span.data["http"]["error"] is None
+        assert spyne_span.n == "rpc-server"
+        assert spyne_span.data["rpc"]["host"] == "127.0.0.1"
+        assert spyne_span.data["rpc"]["call"] == "/custom_404"
+        assert spyne_span.data["rpc"]["port"] == str(testenv["spyne_port"])
+        assert spyne_span.data["rpc"]["params"] == "user_id=9876"
+        assert spyne_span.data["rpc"]["error"] is None
         assert spyne_span.stack is None
 
         # urllib3
@@ -379,7 +227,7 @@ def test_404(self) -> None:
         test_span = spans[2]
 
         assert response
-        assert response.status         == 404
+        assert response.status == 404
 
         assert "X-INSTANA-T" in response.headers
         assert int(response.headers["X-INSTANA-T"], 16)
@@ -415,14 +263,11 @@ def test_404(self) -> None:
         assert spyne_span.ec is None
 
         # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/11111"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 404
-        assert spyne_span.data["http"]["error"] is None
+        assert spyne_span.n == "rpc-server"
+        assert spyne_span.data["rpc"]["host"] == "127.0.0.1"
+        assert spyne_span.data["rpc"]["call"] == "/11111"
+        assert spyne_span.data["rpc"]["port"] == str(testenv["spyne_port"])
+        assert spyne_span.data["rpc"]["error"] is None
         assert spyne_span.stack is None
 
         # urllib3
@@ -487,12 +332,9 @@ def test_500(self) -> None:
         assert spyne_span.ec == 1
 
         # spyne
-        assert spyne_span.n == "spyne"
-        assert (
-            "127.0.0.1:" + str(testenv["spyne_port"]) == spyne_span.data["http"]["host"]
-        )
-        assert spyne_span.data["http"]["url"] == "/exception"
-        assert spyne_span.data["http"]["method"] == "GET"
-        assert spyne_span.data["http"]["status"] == 500
-        assert spyne_span.data["http"]["error"] is None
+        assert spyne_span.n == "rpc-server"
+        assert spyne_span.data["rpc"]["host"] == "127.0.0.1"
+        assert spyne_span.data["rpc"]["call"] == "/exception"
+        assert spyne_span.data["rpc"]["port"] == str(testenv["spyne_port"])        
+        assert spyne_span.data["rpc"]["error"]
         assert spyne_span.stack is None