Support stable http sem conv for dependency type telemetry (Azure#39441)

Author: lzchen

sdk/monitor/azure-monitor-opentelemetry-exporter/CHANGELOG.md

@@ -8,6 +8,8 @@
   ([#39379](https://github.com/Azure/azure-sdk-for-python/pull/39379))
 - Support stable http semantic conventions for breeze exporter - REQUESTS
   ([#39208](https://github.com/Azure/azure-sdk-for-python/pull/39208))
+- Support stable http semantic conventions for breeze exporter - DEPENDENCIES
+  ([#39441](https://github.com/Azure/azure-sdk-for-python/pull/39441))
 
 ### Breaking Changes
 

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/trace/_exporter.py

@@ -336,11 +336,12 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
                 # https://github.com/Azure/azure-sdk-for-python/issues/9256
                 data.type = span.attributes[_AZURE_SDK_NAMESPACE_NAME]
                 data.target = trace_utils._get_azure_sdk_target_source(span.attributes)
-            elif SpanAttributes.HTTP_METHOD in span.attributes:  # HTTP
+            elif HTTP_REQUEST_METHOD in span.attributes or SpanAttributes.HTTP_METHOD in span.attributes:  # HTTP
                 data.type = "HTTP"
-                if SpanAttributes.HTTP_USER_AGENT in span.attributes:
+                user_agent = trace_utils._get_user_agent(span.attributes)
+                if user_agent:
                     # TODO: Not exposed in Swagger, need to update def
-                    envelope.tags["ai.user.userAgent"] = span.attributes[SpanAttributes.HTTP_USER_AGENT]
+                    envelope.tags["ai.user.userAgent"] = user_agent
                 url = trace_utils._get_url_for_http_dependency(span.attributes)
                 # data
                 if url:
@@ -353,10 +354,12 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
                 # http specific logic for name
                 if path:
                     data.name = "{} {}".format(
-                        span.attributes[SpanAttributes.HTTP_METHOD],
+                        span.attributes.get(HTTP_REQUEST_METHOD) or \
+                            span.attributes.get(SpanAttributes.HTTP_METHOD),
                         path,
                     )
-                status_code = span.attributes.get(SpanAttributes.HTTP_STATUS_CODE)
+                status_code = span.attributes.get(HTTP_RESPONSE_STATUS_CODE) or \
+                    span.attributes.get(SpanAttributes.HTTP_STATUS_CODE)
                 if status_code:
                     try:
                         status_code = int(status_code)  # type: ignore

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/trace/_utils.py

@@ -40,7 +40,8 @@ def _get_default_port_db(db_system: str) -> int:
     return 0
 
 
-def _get_default_port_http(scheme: Optional[str]) -> int:
+def _get_default_port_http(attributes: Attributes) -> int:
+    scheme = _get_http_scheme(attributes)
     if scheme == "http":
         return 80
     if scheme == "https":
@@ -77,7 +78,8 @@ def _get_azure_sdk_target_source(attributes: Attributes) -> Optional[str]:
 
 def _get_http_scheme(attributes: Attributes) -> Optional[str]:
     if attributes:
-        scheme = attributes.get(SpanAttributes.HTTP_SCHEME)
+        scheme = attributes.get(url_attributes.URL_SCHEME) or \
+            attributes.get(SpanAttributes.HTTP_SCHEME)
         if scheme:
             return str(scheme)
     return None
@@ -87,14 +89,17 @@ def _get_http_scheme(attributes: Attributes) -> Optional[str]:
 
 
 @no_type_check
-def _get_url_for_http_dependency(attributes: Attributes, scheme: Optional[str] = None) -> Optional[str]:
-    url = None
+def _get_url_for_http_dependency(attributes: Attributes) -> Optional[str]:
+    url = ""
     if attributes:
-        if not scheme:
-            scheme = _get_http_scheme(attributes)
+        # Stable sem conv only supports populating url from `url.full`
+        if url_attributes.URL_FULL in attributes:
+            return attributes[url_attributes.URL_FULL]
         if SpanAttributes.HTTP_URL in attributes:
-            url = attributes[SpanAttributes.HTTP_URL]
-        elif scheme and SpanAttributes.HTTP_TARGET in attributes:
+            return attributes[SpanAttributes.HTTP_URL]
+        # Scheme
+        scheme = _get_http_scheme(attributes)
+        if scheme and SpanAttributes.HTTP_TARGET in attributes:
             http_target = attributes[SpanAttributes.HTTP_TARGET]
             if SpanAttributes.HTTP_HOST in attributes:
                 url = "{}://{}{}".format(
@@ -138,52 +143,60 @@ def _get_target_for_dependency_from_peer(attributes: Attributes) -> Optional[str
                 port = attributes[SpanAttributes.NET_PEER_PORT]
                 # TODO: check default port for rpc
                 # This logic assumes default ports never conflict across dependency types
-                if port != _get_default_port_http(
-                    str(attributes.get(SpanAttributes.HTTP_SCHEME))
-                ) and port != _get_default_port_db(str(attributes.get(SpanAttributes.DB_SYSTEM))):
+                if port != _get_default_port_http(attributes) and \
+                    port != _get_default_port_db(str(attributes.get(SpanAttributes.DB_SYSTEM))):
                     target = "{}:{}".format(target, port)
     return target
 
 
 @no_type_check
 def _get_target_and_path_for_http_dependency(
     attributes: Attributes,
-    target: Optional[str],
-    url: Optional[str],
-    scheme: Optional[str] = None,
+    target: Optional[str] = "",
+    url: Optional[str] = "",  # Usually populated by _get_url_for_http_dependency()
 ) -> Tuple[Optional[str], str]:
-    target_from_url = None
-    path = ""
+    parsed_url = None
+    path = "/"
+    default_port = _get_default_port_http(attributes)
+    # Find path from url
+    try:
+        parsed_url = urlparse(url)
+        if parsed_url.path:
+            path = parsed_url.path
+    except Exception:  # pylint: disable=broad-except
+        pass
+    # Derive target
     if attributes:
-        if not scheme:
-            scheme = _get_http_scheme(attributes)
-        if url:
-            try:
-                parse_url = urlparse(url)
-                path = parse_url.path
-                if not path:
-                    path = "/"
-                if parse_url.port and parse_url.port == _get_default_port_http(scheme):
-                    target_from_url = parse_url.hostname
-                else:
-                    target_from_url = parse_url.netloc
-            except Exception:  # pylint: disable=broad-except
-                pass
-        if SpanAttributes.PEER_SERVICE not in attributes:
+        # Target from server.*
+        if server_attributes.SERVER_ADDRESS in attributes:
+            target = attributes[server_attributes.SERVER_ADDRESS]
+            server_port = attributes.get(server_attributes.SERVER_PORT)
+            # if not default port, include port in target
+            if server_port != default_port:
+                target = "{}:{}".format(target, server_port)
+        # We only use these values for target if not already populated by peer.service
+        elif not SpanAttributes.PEER_SERVICE in attributes:
+            # Target from http.host
             if SpanAttributes.HTTP_HOST in attributes:
                 host = attributes[SpanAttributes.HTTP_HOST]
                 try:
                     # urlparse insists on absolute URLs starting with "//"
                     # This logic assumes host does not include a "//"
                     host_name = urlparse("//" + str(host))
-                    if host_name.port == _get_default_port_http(scheme):
+                    # Ignore port from target if default port
+                    if host_name.port == default_port:
                         target = host_name.hostname
                     else:
+                        # Else include the whole host as the target
                         target = str(host)
                 except Exception:  # pylint: disable=broad-except
                     pass
-            elif target_from_url and not target:
-                target = target_from_url
+            elif parsed_url:
+                # Target from httpUrl
+                if parsed_url.port and parsed_url.port == default_port:
+                    target = parsed_url.hostname
+                else:
+                    target = parsed_url.netloc
     return (target, path)
 
 
@@ -250,7 +263,7 @@ def _get_url_for_http_request(attributes: Attributes) -> Optional[str]:
         if SpanAttributes.HTTP_URL in attributes:
             return attributes[SpanAttributes.HTTP_URL]
         # Scheme
-        scheme = attributes.get(url_attributes.URL_SCHEME) or attributes.get(SpanAttributes.HTTP_SCHEME)
+        scheme = _get_http_scheme(attributes)
         # Target
         http_target = ""
         if url_attributes.URL_PATH in attributes:

sdk/monitor/azure-monitor-opentelemetry-exporter/tests/trace/test_trace.py

@@ -362,6 +362,7 @@ def test_span_to_envelope_client_http(self):
         self.assertEqual(envelope.data.base_data.id, "a6f5d48acb4d31d9")
         self.assertEqual(envelope.data.base_data.duration, "0.00:00:01.001")
         self.assertTrue(envelope.data.base_data.success)
+        self.assertEqual(envelope.data.base_data.data, "https://www.wikipedia.org/wiki/Rabbit")
 
         self.assertEqual(envelope.data.base_type, "RemoteDependencyData")
         self.assertEqual(envelope.data.base_data.type, "HTTP")
@@ -418,6 +419,23 @@ def test_span_to_envelope_client_http(self):
         envelope = exporter._span_to_envelope(span)
         self.assertEqual(envelope.data.base_data.target, "www.wikipedia.org")
 
+        # Stable semconv
+        span._attributes = {
+            "http.request.method": "GET",
+            "server.address": "www.example.com",
+            "server.port": "1234",
+        }
+        envelope = exporter._span_to_envelope(span)
+        self.assertEqual(envelope.data.base_data.target, "www.example.com:1234")
+        span._attributes = {
+            "http.request.method": "GET",
+            "server.address": "www.example.com",
+            "server.port": 80,
+            "url.scheme": "http",
+        }
+        envelope = exporter._span_to_envelope(span)
+        self.assertEqual(envelope.data.base_data.target, "www.example.com")
+
         # url
         # spell-checker:ignore ddds
         span._attributes = {
@@ -449,6 +467,14 @@ def test_span_to_envelope_client_http(self):
         envelope = exporter._span_to_envelope(span)
         self.assertEqual(envelope.data.base_data.data, "https://192.168.0.1:8080/path/12314/?q=ddds#123")
 
+        # Stable semconv
+        span._attributes = {
+            "http.request.method": "GET",
+            "url.full": "https://www.wikipedia.org/path/12314/?q=ddds#124",
+        }
+        envelope = exporter._span_to_envelope(span)
+        self.assertEqual(envelope.data.base_data.data, "https://www.wikipedia.org/path/12314/?q=ddds#124")
+
         # result_code
         span._attributes = {
             "http.method": "GET",
@@ -477,6 +503,21 @@ def test_span_to_envelope_client_http(self):
         envelope = exporter._span_to_envelope(span)
         self.assertEqual(envelope.data.base_data.result_code, "0")
 
+        # Stable semconv
+        span._attributes = {
+            "http.request.method": "GET",
+            "http.response.status_code": "200",
+        }
+        envelope = exporter._span_to_envelope(span)
+        self.assertEqual(envelope.data.base_data.result_code, "200")
+
+        span._attributes = {
+            "http.request.method": "GET",
+            "http.response.status_code": "",
+        }
+        envelope = exporter._span_to_envelope(span)
+        self.assertEqual(envelope.data.base_data.result_code, "0")
+
     def test_span_to_envelope_client_db(self):
         exporter = self._exporter
         start_time = 1575494316027613500