Fixed requests gap 2 by parsing HTTP_URL attrib (aws-observability#43)

### Description of changes:
Updated the `_generate_remote_service` function to fallback to parsing
the `_HTTP_URL` attribute for the host and port and generate
remote_service from them. This will be the back up behavior until
`_NET_PEER*` gets populated properly.
GitHub issue:
open-telemetry/opentelemetry-python-contrib#2138.

### Testing
Tested it locally to see that the `aws_remote_service` is being
populated properly.
Tested by deploying the code changes to EKS and nodes were linking
together properly instead of the vehicle-service pointing to
UnknownRemoteService.

![Screenshot 2024-02-06 at 4 31
59 PM](https://github.com/aws-observability/aws-otel-python-instrumentation/assets/23292470/2636bad4-7eff-4be8-a98a-4457dfd3cd9d)


By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice.

Author: AsakerMohd

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/_aws_metric_attribute_generator.py

@@ -178,8 +178,8 @@ def _set_remote_service_and_operation(span: ReadableSpan, attributes: BoundedAtt
     * Attributes are confirmed to have low-cardinality values, based on code analysis.
 
     if the selected attributes are still producing the UnknownRemoteService or UnknownRemoteOperation, `net.peer.name`,
-    `net.peer.port`, `net.peer.sock.addr` and `net.peer.sock.port` will be used to derive the RemoteService. And
-    `http.method` and `http.url` will be used to derive the RemoteOperation.
+    `net.peer.port`, `net.peer.sock.addr`, `net.peer.sock.port`and 'http.url' will be used to derive the RemoteService.
+    And `http.method` and `http.url` will be used to derive the RemoteOperation.
     """
     remote_service: str = UNKNOWN_REMOTE_SERVICE
     remote_operation: str = UNKNOWN_REMOTE_OPERATION
@@ -252,6 +252,12 @@ def _generate_remote_service(span: ReadableSpan) -> str:
         if is_key_present(span, _NET_SOCK_PEER_PORT):
             port: str = str(span.attributes.get(_NET_SOCK_PEER_PORT))
             remote_service += ":" + port
+    elif is_key_present(span, _HTTP_URL):
+        http_url: str = span.attributes.get(_HTTP_URL)
+        if http_url:
+            url: ParseResult = urlparse(http_url)
+            if url and url.netloc:
+                remote_service = url.netloc
     else:
         _log_unknown_attribute(AWS_REMOTE_SERVICE, span)
 

aws-opentelemetry-distro/tests/amazon/opentelemetry/distro/test_aws_metric_attribute_generator.py

@@ -454,25 +454,49 @@ def test_remote_attributes_combinations(self):
             [SpanAttributes.NET_SOCK_PEER_ADDR, SpanAttributes.NET_SOCK_PEER_PORT], [None, None], keys, values
         )
 
-        # Validate behavior of Remote Operation from HttpTarget - with 1st api part, then remove it
+        # Validate behavior of Remote Operation from HttpTarget - with 1st api part. Also validates that
+        # RemoteService is extracted from http.url.
         keys, values = self._mock_attribute(
             [SpanAttributes.HTTP_URL], ["http://www.example.com/payment/123"], keys, values
         )
-        self._validate_expected_remote_attributes(_UNKNOWN_REMOTE_SERVICE, "/payment")
+        self._validate_expected_remote_attributes("www.example.com", "/payment")
         keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
 
         # Validate behavior of Remote Operation from HttpTarget - without 1st api part, then remove it
         keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], ["http://www.example.com"], keys, values)
+        self._validate_expected_remote_attributes("www.example.com", "/")
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
+
+        # Validate behaviour of extracting Remote Service from http.url. When url is None, it should default to
+        # _UNKNOWN_REMOTE_SERVICE
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
+        self._validate_expected_remote_attributes(_UNKNOWN_REMOTE_SERVICE, _UNKNOWN_REMOTE_OPERATION)
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
+
+        # Validate behaviour of extracting Remote Service from http.url. When url is empty, it should default to
+        # _UNKNOWN_REMOTE_SERVICE
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [""], keys, values)
         self._validate_expected_remote_attributes(_UNKNOWN_REMOTE_SERVICE, "/")
         keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
 
-        # Validate behavior of Remote Operation from HttpTarget - invalid url, then remove it
-        # We designed to let Generator return a "/" rather than UNKNOWN OPERATION when receive invalid HTTP URL
-        # We basically expect url to be well formed, both / or unknown is acceptable since it should never really happen
-        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], ["abc"], keys, values)
+        # Validate behaviour of extracting Remote Service from http.url. When url is invalid, it should default to
+        # _UNKNOWN_REMOTE_SERVICE
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], ["invalid_url"], keys, values)
         self._validate_expected_remote_attributes(_UNKNOWN_REMOTE_SERVICE, "/")
         keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
 
+        # Validate behaviour of extracting Remote Service from http.url. When url is a host name like
+        # https://www.example.com, it should extract the netaddr name as www.example.com
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], ["https://www.example.com"], keys, values)
+        self._validate_expected_remote_attributes("www.example.com", "/")
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
+
+        # Validate behaviour of extracting Remote Service from http.url. When url is an ip address with port like
+        # http://192.168.1.1:1234, it should extract the netaddr name as 192.168.1.1:1234
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], ["http://192.168.1.1:1234"], keys, values)
+        self._validate_expected_remote_attributes("192.168.1.1:1234", "/")
+        keys, values = self._mock_attribute([SpanAttributes.HTTP_URL], [None], keys, values)
+
         # Validate behaviour of Peer service attribute, then remove it.
         keys, values = self._mock_attribute([SpanAttributes.PEER_SERVICE], ["Peer service"], keys, values)
         self._validate_expected_remote_attributes("Peer service", _UNKNOWN_REMOTE_OPERATION)

contract-tests/tests/test/amazon/requests/requests_test.py

@@ -101,9 +101,7 @@ def _assert_aws_attributes(self, attributes_list: List[KeyValue], method: str, e
         # InternalOperation as OTEL does not instrument the basic server we are using, so the client span is a local
         # root.
         self._assert_str_attribute(attributes_dict, AWS_LOCAL_OPERATION, "InternalOperation")
-        # TODO: This should be "backend:8080", but isn't because requests instrumentation is not populating peer
-        #  attributes
-        self._assert_str_attribute(attributes_dict, AWS_REMOTE_SERVICE, "UnknownRemoteService")
+        self._assert_str_attribute(attributes_dict, AWS_REMOTE_SERVICE, "backend:8080")
         self._assert_str_attribute(attributes_dict, AWS_REMOTE_OPERATION, f"{method} /backend")
         # See comment above AWS_LOCAL_OPERATION
         self._assert_str_attribute(attributes_dict, AWS_SPAN_KIND, "LOCAL_ROOT")
@@ -181,8 +179,7 @@ def _assert_metric_attributes(
         self._assert_str_attribute(attribute_dict, AWS_LOCAL_SERVICE, self.get_application_otel_service_name())
         # See comment on AWS_LOCAL_OPERATION in _assert_aws_attributes
         self._assert_str_attribute(attribute_dict, AWS_LOCAL_OPERATION, "InternalOperation")
-        # See comment on AWS_REMOTE_SERVICE in _assert_aws_attributes
-        self._assert_str_attribute(attribute_dict, AWS_REMOTE_SERVICE, "UnknownRemoteService")
+        self._assert_str_attribute(attribute_dict, AWS_REMOTE_SERVICE, "backend:8080")
         self._assert_str_attribute(attribute_dict, AWS_REMOTE_OPERATION, f"{method} /backend")
         self._assert_str_attribute(attribute_dict, AWS_SPAN_KIND, "CLIENT")