Support AppSignals metrics transport protocol configuration. (#70)

*Issue #, if available:*

This PR is matching the [aws-otel-java-instrumentation PR
](aws-observability/aws-otel-java-instrumentation#752)
to support both http and grpc protocol according the environment
variables.

Testing:
I test the change on EC2 instance using the CWAgent receiving the
metrics and traces by running on two sets of environment variables:
1. http:
```
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
export OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
```
2. grpc:
```
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4315
export OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4315
```

I has been confirmed that both the traces and metrics are received
successfully, logs and service map shows up in the console:
![Screenshot 2024-02-23 at 11 35
39 AM](https://github.com/aws-observability/aws-otel-python-instrumentation/assets/146124015/200af747-772a-46de-931e-dee96d5f6f57)

![Screenshot 2024-02-23 at 11 36
11 AM](https://github.com/aws-observability/aws-otel-python-instrumentation/assets/146124015/287575b4-6bb1-453a-a54a-9bd3b74e6e9d)

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

Author: wangzlei

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

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 import os
 from logging import Logger, getLogger
-from typing import Dict, Type
+from typing import ClassVar, Dict, Type
 
 from typing_extensions import override
 
@@ -15,7 +15,8 @@
 )
 from amazon.opentelemetry.distro.aws_span_metrics_processor_builder import AwsSpanMetricsProcessorBuilder
 from amazon.opentelemetry.distro.sampler.aws_xray_remote_sampler import AwsXRayRemoteSampler
-from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter as OTLPGrpcOTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter as OTLPHttpOTLPMetricExporter
 from opentelemetry.sdk._configuration import (
     _get_exporter_names,
     _get_id_generator,
@@ -29,6 +30,8 @@
 )
 from opentelemetry.sdk.environment_variables import (
     _OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED,
+    OTEL_EXPORTER_OTLP_METRICS_PROTOCOL,
+    OTEL_EXPORTER_OTLP_PROTOCOL,
     OTEL_TRACES_SAMPLER_ARG,
 )
 from opentelemetry.sdk.extension.aws.resource.ec2 import AwsEc2ResourceDetector
@@ -55,6 +58,7 @@
 OTEL_AWS_APP_SIGNALS_ENABLED = "OTEL_AWS_APP_SIGNALS_ENABLED"
 OTEL_METRIC_EXPORT_INTERVAL = "OTEL_METRIC_EXPORT_INTERVAL"
 OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT = "OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT"
+OTEL_AWS_SMP_EXPORTER_ENDPOINT = "OTEL_AWS_SMP_EXPORTER_ENDPOINT"
 DEFAULT_METRIC_EXPORT_INTERVAL = 60000.0
 
 _logger: Logger = getLogger(__name__)
@@ -172,41 +176,28 @@ def _custom_import_sampler(sampler_name: str, resource: Resource) -> Sampler:
 
 
 def _customize_sampler(sampler: Sampler) -> Sampler:
-    if not is_smp_enabled():
+    if not is_app_signals_enabled():
         return sampler
     return AlwaysRecordSampler(sampler)
 
 
 def _customize_exporter(span_exporter: SpanExporter, resource: Resource) -> SpanExporter:
-    if not is_smp_enabled():
+    if not is_app_signals_enabled():
         return span_exporter
     return AwsMetricAttributesSpanExporterBuilder(span_exporter, resource).build()
 
 
 def _customize_span_processors(provider: TracerProvider, resource: Resource) -> None:
-    if not is_smp_enabled():
+    if not is_app_signals_enabled():
         return
 
     # Construct and set local and remote attributes span processor
     provider.add_span_processor(AttributePropagatingSpanProcessorBuilder().build())
 
     # Construct meterProvider
-    temporality_dict: Dict[type, AggregationTemporality] = {}
-    for typ in [
-        Counter,
-        UpDownCounter,
-        ObservableCounter,
-        ObservableCounter,
-        ObservableUpDownCounter,
-        ObservableGauge,
-        Histogram,
-    ]:
-        temporality_dict[typ] = AggregationTemporality.DELTA
-    _logger.info("Span Metrics Processor enabled")
-    smp_endpoint = os.environ.get(OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT, "http://localhost:4315")
-    otel_metric_exporter = OTLPMetricExporter(endpoint=smp_endpoint, preferred_temporality=temporality_dict)
+    _logger.info("AWS AppSignals enabled")
+    otel_metric_exporter = AppSignalsExporterProvider().create_exporter()
     export_interval_millis = float(os.environ.get(OTEL_METRIC_EXPORT_INTERVAL, DEFAULT_METRIC_EXPORT_INTERVAL))
-    _logger.debug("Span Metrics endpoint: %s", smp_endpoint)
     _logger.debug("Span Metrics export interval: %s", export_interval_millis)
     # Cap export interval to 60 seconds. This is currently required for metrics-trace correlation to work correctly.
     if export_interval_millis > DEFAULT_METRIC_EXPORT_INTERVAL:
@@ -216,11 +207,53 @@ def _customize_span_processors(provider: TracerProvider, resource: Resource) ->
         exporter=otel_metric_exporter, export_interval_millis=export_interval_millis
     )
     meter_provider: MeterProvider = MeterProvider(resource=resource, metric_readers=[periodic_exporting_metric_reader])
-    # Construct and set span metrics processor
+    # Construct and set AppSignals metrics processor
     provider.add_span_processor(AwsSpanMetricsProcessorBuilder(meter_provider, resource).build())
 
     return
 
 
-def is_smp_enabled():
+def is_app_signals_enabled():
     return os.environ.get(OTEL_AWS_APP_SIGNALS_ENABLED, False)
+
+
+class AppSignalsExporterProvider:
+    _instance: ClassVar["AppSignalsExporterProvider"] = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    # pylint: disable=no-self-use
+    def create_exporter(self):
+        protocol = os.environ.get(
+            OTEL_EXPORTER_OTLP_PROTOCOL, os.environ.get(OTEL_EXPORTER_OTLP_METRICS_PROTOCOL, "grpc")
+        )
+        _logger.debug("AppSignals export protocol: %s", protocol)
+
+        app_signals_endpoint = os.environ.get(
+            OTEL_AWS_APP_SIGNALS_EXPORTER_ENDPOINT,
+            os.environ.get(OTEL_AWS_SMP_EXPORTER_ENDPOINT, "http://localhost:4315"),
+        )
+
+        _logger.debug("AppSignals export endpoint: %s", app_signals_endpoint)
+
+        temporality_dict: Dict[type, AggregationTemporality] = {}
+        for typ in [
+            Counter,
+            UpDownCounter,
+            ObservableCounter,
+            ObservableCounter,
+            ObservableUpDownCounter,
+            ObservableGauge,
+            Histogram,
+        ]:
+            temporality_dict[typ] = AggregationTemporality.DELTA
+
+        if protocol == "http/protobuf":
+            return OTLPHttpOTLPMetricExporter(endpoint=app_signals_endpoint, preferred_temporality=temporality_dict)
+        if protocol == "grpc":
+            return OTLPGrpcOTLPMetricExporter(endpoint=app_signals_endpoint, preferred_temporality=temporality_dict)
+
+        raise RuntimeError(f"Unsupported AppSignals export protocol: {protocol} ")