Support stable http semconv - request telemetry (#39208)

Author: lzchen

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

@@ -4,6 +4,9 @@
 
 ### Features Added
 
+- Support stable http semantic conventions for breeze exporter - REQUESTS
+  ([#39208](https://github.com/Azure/azure-sdk-for-python/pull/39208))
+
 ### Breaking Changes
 
 ### Bugs Fixed

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

@@ -4,9 +4,14 @@
 import json
 import logging
 from time import time_ns
-from typing import Any, Dict, List, Sequence
+from typing import no_type_check, Any, Dict, List, Sequence
 from urllib.parse import urlparse
 
+from opentelemetry.semconv.attributes.client_attributes import CLIENT_ADDRESS
+from opentelemetry.semconv.attributes.http_attributes import (
+    HTTP_REQUEST_METHOD,
+    HTTP_RESPONSE_STATUS_CODE,
+)
 from opentelemetry.semconv.trace import DbSystemValues, SpanAttributes
 from opentelemetry.semconv._incubating.attributes import gen_ai_attributes
 from opentelemetry.sdk.resources import Resource
@@ -65,6 +70,28 @@
     "code.",
 ]
 
+_STANDARD_OPENTELEMETRY_HTTP_ATTRIBUTES = [
+    "client.address",
+    "client.port",
+    "server.address",
+    "server.port",
+    "url.full",
+    "url.path",
+    "url.query",
+    "url.scheme",
+    "url.template",
+    "error.type",
+    "network.local.address",
+    "network.local.port",
+    "network.protocol.name",
+    "network.peer.address",
+    "network.peer.port",
+    "network.protocol.version",
+    "network.transport",
+    "user_agent.original",
+    "user_agent.synthetic.type",
+]
+
 _STANDARD_AZURE_MONITOR_ATTRIBUTES = [
     _SAMPLE_RATE_KEY,
 ]
@@ -141,7 +168,7 @@ def _get_otel_resource_envelope(self, resource: Resource) -> TelemetryItem:
     def _span_to_envelope(self, span: ReadableSpan) -> TelemetryItem:
         envelope = _convert_span_to_envelope(span)
         envelope.instrumentation_key = self._instrumentation_key
-        return envelope
+        return envelope  # type: ignore
 
     def _span_events_to_envelopes(self, span: ReadableSpan) -> Sequence[TelemetryItem]:
         if not span or len(span.events) == 0:
@@ -179,6 +206,7 @@ def from_connection_string(cls, conn_str: str, **kwargs: Any) -> "AzureMonitorTr
 # pylint: disable=too-many-branches
 # pylint: disable=protected-access
 # mypy: disable-error-code="assignment,attr-defined,index,operator,union-attr"
+@no_type_check
 def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
     # Update instrumentation bitmap if span was generated from instrumentation
     _check_instrumentation_span(span)
@@ -208,8 +236,9 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
         )
         envelope.data = MonitorBase(base_data=data, base_type="RequestData")
         envelope.tags[ContextTagKeys.AI_OPERATION_NAME] = span.name
-        if SpanAttributes.NET_PEER_IP in span.attributes:
-            envelope.tags[ContextTagKeys.AI_LOCATION_IP] = span.attributes[SpanAttributes.NET_PEER_IP]
+        location_ip = trace_utils._get_location_ip(span.attributes)
+        if location_ip:
+            envelope.tags[ContextTagKeys.AI_LOCATION_IP] = location_ip
         if _AZURE_SDK_NAMESPACE_NAME in span.attributes:  # Azure specific resources
             # Currently only eventhub and servicebus are supported (kind CONSUMER)
             data.source = trace_utils._get_azure_sdk_target_source(span.attributes)
@@ -222,21 +251,19 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
                         difference = (start_time / 1000000) - enqueued_time
                         total += difference
                 data.measurements["timeSinceEnqueued"] = max(0, total / len(span.links))
-        elif SpanAttributes.HTTP_METHOD in span.attributes:  # HTTP
+        elif HTTP_REQUEST_METHOD in span.attributes or SpanAttributes.HTTP_METHOD in span.attributes:  # HTTP
             path = ""
-            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]
-            # http specific logic for ai.location.ip
-            if SpanAttributes.HTTP_CLIENT_IP in span.attributes:
-                envelope.tags[ContextTagKeys.AI_LOCATION_IP] = span.attributes[SpanAttributes.HTTP_CLIENT_IP]
+                envelope.tags["ai.user.userAgent"] = user_agent
             # url
             url = trace_utils._get_url_for_http_request(span.attributes)
             data.url = url
             # Http specific logic for ai.operation.name
             if SpanAttributes.HTTP_ROUTE in span.attributes:
                 envelope.tags[ContextTagKeys.AI_OPERATION_NAME] = "{} {}".format(
-                    span.attributes[SpanAttributes.HTTP_METHOD],
+                    span.attributes.get(HTTP_REQUEST_METHOD) or span.attributes.get(SpanAttributes.HTTP_METHOD),
                     span.attributes[SpanAttributes.HTTP_ROUTE],
                 )
             elif url:
@@ -246,12 +273,13 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
                     if not path:
                         path = "/"
                     envelope.tags[ContextTagKeys.AI_OPERATION_NAME] = "{} {}".format(
-                        span.attributes[SpanAttributes.HTTP_METHOD],
+                        span.attributes.get(HTTP_REQUEST_METHOD) or span.attributes.get(SpanAttributes.HTTP_METHOD),
                         path,
                     )
                 except Exception:  # pylint: disable=broad-except
                     pass
-            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
@@ -263,12 +291,10 @@ def _convert_span_to_envelope(span: ReadableSpan) -> TelemetryItem:
             # Success criteria for server spans depends on span.success and the actual status code
             data.success = span.status.is_ok and status_code and status_code not in range(400, 500)
         elif SpanAttributes.MESSAGING_SYSTEM in span.attributes:  # Messaging
-            if SpanAttributes.NET_PEER_IP in span.attributes:
-                envelope.tags[ContextTagKeys.AI_LOCATION_IP] = span.attributes[SpanAttributes.NET_PEER_IP]
             if span.attributes.get(SpanAttributes.MESSAGING_DESTINATION):
-                if span.attributes.get(SpanAttributes.NET_PEER_NAME):
+                if span.attributes.get(CLIENT_ADDRESS) or span.attributes.get(SpanAttributes.NET_PEER_NAME):
                     data.source = "{}/{}".format(
-                        span.attributes.get(SpanAttributes.NET_PEER_NAME),
+                        span.attributes.get(CLIENT_ADDRESS) or span.attributes.get(SpanAttributes.NET_PEER_NAME),
                         span.attributes.get(SpanAttributes.MESSAGING_DESTINATION),
                     )
                 elif span.attributes.get(SpanAttributes.NET_PEER_IP):
@@ -515,7 +541,8 @@ def _is_standard_attribute(key: str) -> bool:
     for prefix in _STANDARD_OPENTELEMETRY_ATTRIBUTE_PREFIXES:
         if key.startswith(prefix):
             return True
-    return key in _STANDARD_AZURE_MONITOR_ATTRIBUTES
+    return key in _STANDARD_AZURE_MONITOR_ATTRIBUTES or \
+        key in _STANDARD_OPENTELEMETRY_HTTP_ATTRIBUTES
 
 
 def _get_trace_export_result(result: ExportResult) -> SpanExportResult:

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

@@ -4,6 +4,12 @@
 from typing import no_type_check, Optional, Tuple
 from urllib.parse import urlparse
 
+from opentelemetry.semconv.attributes import (
+    client_attributes,
+    server_attributes,
+    url_attributes,
+    user_agent_attributes,
+)
 from opentelemetry.semconv.trace import DbSystemValues, SpanAttributes
 from opentelemetry.util.types import Attributes
 
@@ -60,8 +66,10 @@ def _is_sql_db(db_system: str) -> bool:
 def _get_azure_sdk_target_source(attributes: Attributes) -> Optional[str]:
     # Currently logic only works for ServiceBus and EventHub
     if attributes:
-        peer_address = attributes.get("peer.address")
-        destination = attributes.get("message_bus.destination")
+        # New semconv attributes: https://github.com/Azure/azure-sdk-for-python/pull/29203
+        # TODO: Keep track of when azure-sdk supports stable semconv for these fields
+        peer_address = attributes.get("net.peer.name") or attributes.get("peer.address")
+        destination = attributes.get("messaging.destination.name") or attributes.get("message_bus.destination")
         if peer_address and destination:
             return str(peer_address) + "/" + str(destination)
     return None
@@ -217,37 +225,77 @@ def _get_target_for_rpc_dependency(target: Optional[str], attributes: Attributes
     return target
 
 
+# Request
+
+@no_type_check
+def _get_location_ip(attributes: Attributes) -> Optional[str]:
+    return attributes.get(client_attributes.CLIENT_ADDRESS) or \
+        attributes.get(SpanAttributes.HTTP_CLIENT_IP) or \
+        attributes.get(SpanAttributes.NET_PEER_IP) # We assume non-http spans don't have http related attributes
+
+
+@no_type_check
+def _get_user_agent(attributes: Attributes) -> Optional[str]:
+    return attributes.get(user_agent_attributes.USER_AGENT_ORIGINAL) or \
+        attributes.get(SpanAttributes.HTTP_USER_AGENT)
+
+
 @no_type_check
 def _get_url_for_http_request(attributes: Attributes) -> Optional[str]:
     url = ""
     if attributes:
+        # Url
+        if url_attributes.URL_FULL in attributes:
+            return attributes[url_attributes.URL_FULL]
         if SpanAttributes.HTTP_URL in attributes:
             return attributes[SpanAttributes.HTTP_URL]
-        scheme = attributes.get(SpanAttributes.HTTP_SCHEME)
-        http_target = attributes.get(SpanAttributes.HTTP_TARGET)
+        # Scheme
+        scheme = attributes.get(url_attributes.URL_SCHEME) or attributes.get(SpanAttributes.HTTP_SCHEME)
+        # Target
+        http_target = ""
+        if url_attributes.URL_PATH in attributes:
+            http_target = attributes.get(url_attributes.URL_PATH, "")
+        if url_attributes.URL_QUERY in attributes:
+            http_target = "{}?{}".format(
+                http_target,
+                attributes.get(url_attributes.URL_QUERY, "")
+            )
+        if not http_target:
+            http_target = attributes.get(SpanAttributes.HTTP_TARGET)
         if scheme and http_target:
-            if SpanAttributes.HTTP_HOST in attributes:
+            # Host
+            http_host = ""
+            if server_attributes.SERVER_ADDRESS in attributes:
+                http_host = attributes.get(server_attributes.SERVER_ADDRESS, "")
+            if server_attributes.SERVER_PORT in attributes:
+                http_host = "{}:{}".format(
+                    http_host,
+                    attributes.get(server_attributes.SERVER_PORT, "")
+                )
+            if not http_host:
+                http_host = attributes.get(SpanAttributes.HTTP_HOST, "")
+            if http_host:
                 url = "{}://{}{}".format(
                     scheme,
-                    attributes[SpanAttributes.HTTP_HOST],
+                    http_host,
+                    http_target,
+                )
+            elif SpanAttributes.HTTP_SERVER_NAME in attributes:
+                server_name = attributes[SpanAttributes.HTTP_SERVER_NAME]
+                host_port = attributes.get(SpanAttributes.NET_HOST_PORT, "")
+                url = "{}://{}:{}{}".format(
+                    scheme,
+                    server_name,
+                    host_port,
+                    http_target,
+                )
+            elif SpanAttributes.NET_HOST_NAME in attributes:
+                host_name = attributes[SpanAttributes.NET_HOST_NAME]
+                host_port = attributes.get(SpanAttributes.NET_HOST_PORT, "")
+                url = "{}://{}:{}{}".format(
+                    scheme,
+                    host_name,
+                    host_port,
                     http_target,
                 )
-            elif SpanAttributes.NET_HOST_PORT in attributes:
-                host_port = attributes[SpanAttributes.NET_HOST_PORT]
-                if SpanAttributes.HTTP_SERVER_NAME in attributes:
-                    server_name = attributes[SpanAttributes.HTTP_SERVER_NAME]
-                    url = "{}://{}:{}{}".format(
-                        scheme,
-                        server_name,
-                        host_port,
-                        http_target,
-                    )
-                elif SpanAttributes.NET_HOST_NAME in attributes:
-                    host_name = attributes[SpanAttributes.NET_HOST_NAME]
-                    url = "{}://{}:{}{}".format(
-                        scheme,
-                        host_name,
-                        host_port,
-                        http_target,
-                    )
     return url