addressing comments

Author: liustve

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

@@ -2,13 +2,34 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import re
+import sys
+from logging import Logger, getLogger
 
+import pkg_resources
+
+_logger: Logger = getLogger(__name__)
+
+XRAY_OTLP_ENDPOINT_PATTERN = r"https://xray\.([a-z0-9-]+)\.amazonaws\.com/v1/traces$"
+
+
+def is_xray_otlp_endpoint(otlp_endpoint: str = None) -> bool:
+    """Is the given endpoint the XRay OTLP endpoint?"""
 
-def is_otlp_endpoint_cloudwatch(otlp_endpoint=None):
-    # Detects if it's the OTLP endpoint in CloudWatchs
     if not otlp_endpoint:
         return False
 
-    pattern = r"https://xray\.([a-z0-9-]+)\.amazonaws\.com/v1/traces$"
+    return bool(re.match(XRAY_OTLP_ENDPOINT_PATTERN, otlp_endpoint.lower()))
 
-    return bool(re.match(pattern, otlp_endpoint.lower()))
+
+def is_installed(req: str) -> bool:
+    """Is the given required package installed?"""
+
+    if req in sys.modules and sys.modules.get(req) != None:
+        return True
+
+    try:
+        pkg_resources.get_distribution(req)
+    except Exception as exc:  # pylint: disable=broad-except
+        _logger.debug("Skipping instrumentation patch: package %s, exception: %s", req, exc)
+        return False
+    return True

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

@@ -10,7 +10,7 @@
 
 from amazon.opentelemetry.distro._aws_attribute_keys import AWS_LOCAL_SERVICE
 from amazon.opentelemetry.distro._aws_resource_attribute_configurator import get_service_attribute
-from amazon.opentelemetry.distro._utils import is_otlp_endpoint_cloudwatch
+from amazon.opentelemetry.distro._utils import is_xray_otlp_endpoint
 from amazon.opentelemetry.distro.always_record_sampler import AlwaysRecordSampler
 from amazon.opentelemetry.distro.attribute_propagating_span_processor_builder import (
     AttributePropagatingSpanProcessorBuilder,
@@ -20,7 +20,7 @@
     AwsMetricAttributesSpanExporterBuilder,
 )
 from amazon.opentelemetry.distro.aws_span_metrics_processor_builder import AwsSpanMetricsProcessorBuilder
-from amazon.opentelemetry.distro.otlp_sigv4_exporter import OTLPAwsSigV4Exporter
+from amazon.opentelemetry.distro.otlp_aws_span_exporter import OTLPAwsSpanExporter
 from amazon.opentelemetry.distro.otlp_udp_exporter import OTLPUdpSpanExporter
 from amazon.opentelemetry.distro.sampler.aws_xray_remote_sampler import AwsXRayRemoteSampler
 from amazon.opentelemetry.distro.scope_based_exporter import ScopeBasedPeriodicExportingMetricReader
@@ -317,8 +317,10 @@ def _customize_exporter(span_exporter: SpanExporter, resource: Resource) -> Span
             traces_endpoint = os.environ.get(AWS_XRAY_DAEMON_ADDRESS_CONFIG, "127.0.0.1:2000")
             span_exporter = OTLPUdpSpanExporter(endpoint=traces_endpoint)
 
-    if is_otlp_endpoint_cloudwatch(os.environ.get(OTEL_EXPORTER_OTLP_TRACES_ENDPOINT)):
-        span_exporter = OTLPAwsSigV4Exporter(endpoint=os.getenv(OTEL_EXPORTER_OTLP_TRACES_ENDPOINT))
+    if isinstance(span_exporter, OTLPSpanExporter) and is_xray_otlp_endpoint(
+        os.environ.get(OTEL_EXPORTER_OTLP_TRACES_ENDPOINT)
+    ):
+        span_exporter = OTLPAwsSpanExporter(endpoint=os.getenv(OTEL_EXPORTER_OTLP_TRACES_ENDPOINT))
 
     if not _is_application_signals_enabled():
         return span_exporter
@@ -333,8 +335,8 @@ def _customize_span_processors(provider: TracerProvider, resource: Resource) ->
     # Construct and set local and remote attributes span processor
     provider.add_span_processor(AttributePropagatingSpanProcessorBuilder().build())
 
-    # Do not export metrics if it's CloudWatch OTLP endpoint
-    if is_otlp_endpoint_cloudwatch():
+    # Do not export Application-Signals metrics if it's XRay OTLP endpoint
+    if is_xray_otlp_endpoint():
         return
 
     # Export 100% spans and not export Application-Signals metrics if on Lambda.

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/otlp_sigv4_exporter.py renamed to aws-opentelemetry-distro/src/amazon/opentelemetry/distro/otlp_aws_span_exporter.py

@@ -4,19 +4,23 @@
 from typing import Dict, Optional
 
 import requests
-from grpc import Compression
 
-from amazon.opentelemetry.distro._utils import is_otlp_endpoint_cloudwatch
+from amazon.opentelemetry.distro._utils import is_installed, is_xray_otlp_endpoint
+from opentelemetry.exporter.otlp.proto.http import Compression
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
 AWS_SERVICE = "xray"
 _logger = logging.getLogger(__name__)
 
-"""The OTLPAwsSigV4Exporter extends the functionality of the OTLPSpanExporter to allow SigV4 authentication if the
-   configured traces endpoint is a CloudWatch OTLP endpoint https://xray.[AWSRegion].amazonaws.com/v1/traces"""
 
+class OTLPAwsSpanExporter(OTLPSpanExporter):
+    """
+    This exporter extends the functionality of the OTLPSpanExporter to allow spans to be exported to the
+    XRay OTLP endpoint https://xray.[AWSRegion].amazonaws.com/v1/traces. Utilizes the botocore
+    library to sign and directly inject SigV4 Authentication to the exported request's headers.
 
-class OTLPAwsSigV4Exporter(OTLPSpanExporter):
+    https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-OTLPEndpoint.html
+    """
 
     def __init__(
         self,
@@ -35,34 +39,23 @@ def __init__(
 
         self._aws_region = None
 
-        if endpoint and is_otlp_endpoint_cloudwatch(endpoint):
+        if endpoint and is_xray_otlp_endpoint(endpoint):
 
-            # Defensive check to verify that the application being auto instrumented has
-            # botocore installed.
-            try:
+            if is_installed("botocore"):
                 # pylint: disable=import-outside-toplevel
                 from botocore import auth, awsrequest, session
 
                 self.boto_auth = auth
                 self.boto_aws_request = awsrequest
                 self.boto_session = session.Session()
-                self._aws_region = self._validate_exporter_endpoint(endpoint)
+                self._aws_region = endpoint.split(".")[1]
 
-            except ImportError:
+            else:
                 _logger.error(
                     "botocore is required to export traces to %s. Please install it using `pip install botocore`",
                     endpoint,
                 )
 
-        else:
-            _logger.error(
-                "Invalid XRay traces endpoint: %s. Resolving to OTLPSpanExporter to handle exporting. "
-                "The traces endpoint follows the pattern https://xray.[AWSRegion].amazonaws.com/v1/traces. "
-                "For example, for the US West (Oregon) (us-west-2) Region, the endpoint will be "
-                "https://xray.us-west-2.amazonaws.com/v1/traces.",
-                endpoint,
-            )
-
         super().__init__(
             endpoint=endpoint,
             certificate_file=certificate_file,
@@ -99,20 +92,3 @@ def _export(self, serialized_data: bytes):
                 _logger.error("Failed to get credentials to export span to OTLP CloudWatch endpoint")
 
         return super()._export(serialized_data)
-
-    def _validate_exporter_endpoint(self, endpoint: str) -> Optional[str]:
-        if not endpoint:
-            return None
-
-        region = endpoint.split(".")[1]
-        xray_regions = self.boto_session.get_available_regions(AWS_SERVICE)
-
-        if region not in xray_regions:
-
-            _logger.error(
-                "Invalid AWS region: %s. Valid regions are %s. Resolving to default endpoint.", region, xray_regions
-            )
-
-            return None
-
-        return region

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/patches/_instrumentation_patch.py

@@ -7,6 +7,7 @@
 
 import pkg_resources
 
+from amazon.opentelemetry.distro._utils import is_installed
 from amazon.opentelemetry.distro.patches._resource_detector_patches import _apply_resource_detector_patches
 
 # Env variable for determining whether we want to monkey patch gevent modules. Possible values are 'all', 'none', and
@@ -25,7 +26,7 @@ def apply_instrumentation_patches() -> None:
 
     Where possible, automated testing should be run to catch upstream changes resulting in broken patches
     """
-    if _is_installed("gevent"):
+    if is_installed("gevent"):
         try:
             gevent_patch_module = os.environ.get(AWS_GEVENT_PATCH_MODULES, "all")
 
@@ -56,7 +57,7 @@ def apply_instrumentation_patches() -> None:
         except Exception as exc:  # pylint: disable=broad-except
             _logger.info("Failed to monkey patch gevent, exception: %s", exc)
 
-    if _is_installed("botocore ~= 1.0"):
+    if is_installed("botocore ~= 1.0"):
         # pylint: disable=import-outside-toplevel
         # Delay import to only occur if patches is safe to apply (e.g. the instrumented library is installed).
         from amazon.opentelemetry.distro.patches._botocore_patches import _apply_botocore_instrumentation_patches
@@ -66,15 +67,3 @@ def apply_instrumentation_patches() -> None:
     # No need to check if library is installed as this patches opentelemetry.sdk,
     # which must be installed for the distro to work at all.
     _apply_resource_detector_patches()
-
-
-def _is_installed(req: str) -> bool:
-    if req in sys.modules:
-        return True
-
-    try:
-        pkg_resources.get_distribution(req)
-    except Exception as exc:  # pylint: disable=broad-except
-        _logger.debug("Skipping instrumentation patch: package %s, exception: %s", req, exc)
-        return False
-    return True