Added callback to override default span-name, default span name to HTTP METHOD

Signed-off-by: Emil Madsen <[email protected]>

Author: Skeen

ext/opentelemetry-ext-asgi/src/opentelemetry/ext/asgi/__init__.py

@@ -124,12 +124,8 @@ def set_status_code(span, status_code):
 
 
 def get_default_span_name(scope):
-    """Calculates a (generic) span name for an incoming HTTP request based on the ASGI scope."""
-
-    # TODO: Update once
-    #  https://github.com/open-telemetry/opentelemetry-specification/issues/270
-    #  is resolved
-    return scope.get("path", "/")
+    """Default implementation for name_callback, returns HTTP {METHOD_NAME}."""
+    return "HTTP " + scope.get("method")
 
 
 class OpenTelemetryMiddleware:
@@ -140,11 +136,15 @@ class OpenTelemetryMiddleware:
 
     Args:
         app: The ASGI application callable to forward requests to.
+        name_callback: Callback which calculates a generic span name for an
+                       incoming HTTP request based on the ASGI scope.
+                       Optional: Defaults to get_default_span_name.
     """
 
-    def __init__(self, app):
+    def __init__(self, app, name_callback=None):
         self.app = guarantee_single_callable(app)
         self.tracer = trace.tracer_source().get_tracer(__name__, __version__)
+        self.name_callback = name_callback or get_default_span_name
 
     async def __call__(self, scope, receive, send):
         """The ASGI application
@@ -156,10 +156,10 @@ async def __call__(self, scope, receive, send):
         """
 
         parent_span = propagators.extract(get_header_from_scope, scope)
-        span_name = get_default_span_name(scope)
+        span_name = self.name_callback(scope)
 
         with self.tracer.start_as_current_span(
-            span_name,
+            span_name + " (connection)",
             parent_span,
             kind=trace.SpanKind.SERVER,
             attributes=collect_request_attributes(scope),

ext/opentelemetry-ext-asgi/tests/test_asgi_middleware.py

@@ -59,7 +59,9 @@ async def error_asgi(scope, receive, send):
 
 
 class TestAsgiApplication(AsgiTestBase):
-    def validate_outputs(self, outputs, error=None):
+    def validate_outputs(self, outputs, error=None, modifiers=None):
+        # Ensure modifiers is a list
+        modifiers = modifiers or []
         # Check for expected outputs
         self.assertEqual(len(outputs), 2)
         response_start = outputs[0]
@@ -89,25 +91,25 @@ def validate_outputs(self, outputs, error=None):
         self.assertEqual(len(span_list), 4)
         expected = [
             {
-                "name": "/ (http.request)",
+                "name": "HTTP GET (http.request)",
                 "kind": trace_api.SpanKind.INTERNAL,
                 "attributes": {"type": "http.request"},
             },
             {
-                "name": "/ (http.response.start)",
+                "name": "HTTP GET (http.response.start)",
                 "kind": trace_api.SpanKind.INTERNAL,
                 "attributes": {
                     "http.status_code": 200,
                     "type": "http.response.start",
                 },
             },
             {
-                "name": "/ (http.response.body)",
+                "name": "HTTP GET (http.response.body)",
                 "kind": trace_api.SpanKind.INTERNAL,
                 "attributes": {"type": "http.response.body"},
             },
             {
-                "name": "/",
+                "name": "HTTP GET (connection)",
                 "kind": trace_api.SpanKind.SERVER,
                 "attributes": {
                     "component": "http",
@@ -124,25 +126,50 @@ def validate_outputs(self, outputs, error=None):
                 },
             },
         ]
+        # Run our expected modifiers
+        for modifier in modifiers:
+            expected = modifier(expected)
+        # Check that output matches
         for span, expected in zip(span_list, expected):
             self.assertEqual(span.name, expected["name"])
             self.assertEqual(span.kind, expected["kind"])
             self.assertEqual(span.attributes, expected["attributes"])
 
     def test_basic_asgi_call(self):
+        """Test that spans are emitted as expected."""
         app = otel_asgi.OpenTelemetryMiddleware(simple_asgi)
         self.seed_app(app)
         self.send_default_request()
         outputs = self.get_all_output()
         self.validate_outputs(outputs)
 
     def test_asgi_exc_info(self):
+        """Test that exception information is emitted as expected."""
         app = otel_asgi.OpenTelemetryMiddleware(error_asgi)
         self.seed_app(app)
         self.send_default_request()
         outputs = self.get_all_output()
         self.validate_outputs(outputs, error=ValueError)
 
+    def test_override_span_name(self):
+        """Test that span_names can be overwritten by our callback function."""
+        span_name = "Dymaxion"
+        def get_predefined_span_name(scope):
+            return span_name
+        def update_expected_span_name(expected):
+            for entry in expected:
+                entry['name'] = " ".join(
+                    [span_name] + entry['name'].split(' ')[-1:]
+                )
+            return expected
+        app = otel_asgi.OpenTelemetryMiddleware(
+            simple_asgi, name_callback=get_predefined_span_name
+        )
+        self.seed_app(app)
+        self.send_default_request()
+        outputs = self.get_all_output()
+        self.validate_outputs(outputs, modifiers=[update_expected_span_name])
+
 
 class TestAsgiAttributes(unittest.TestCase):
     def setUp(self):