Change configuration for adding Application Signals Dimensions to EMF exporter (#552)

*Description of changes:*
- Ports changes from:
aws-observability/aws-otel-java-instrumentation#1264

- Adds new `OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS` environment
variable. When enabled, the exporters automatically add Service and
Environment dimensions. Defaults to `UnknownService` and
`generic:default` respectively based on resource attributes and cloud
platform.

- Application Signals dimensions are enabled by default when
OTEL_METRICS_EXPORTER is set to awsemf. Users can opt out or disable
this feature by explicitly setting
OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS to false.

- Disable Application Signals Dimensions for Agent Observability path


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

Author: liustve

CHANGELOG.md

@@ -17,6 +17,8 @@ If your change does not need a CHANGELOG entry, add the "skip changelog" label t
   ([#547](https://github.com/aws-observability/aws-otel-python-instrumentation/pull/547))
 - Add Service and Environment dimensions to EMF metrics when Application Signals EMF export is enabled
   ([#548](https://github.com/aws-observability/aws-otel-python-instrumentation/pull/548))
+- Refactor configuration for adding Application Signals Dimensions to EMF exporter
+  ([#552](https://github.com/aws-observability/aws-otel-python-instrumentation/pull/552))
 - Fix CVE-2025-66471. No associated PR since `urllib3` dependency will auto-bump to `2.6.x` upon release.
 
 ## v0.14.0 - 2025-11-19

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

@@ -11,6 +11,7 @@
 _logger: Logger = getLogger(__name__)
 
 AGENT_OBSERVABILITY_ENABLED = "AGENT_OBSERVABILITY_ENABLED"
+OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS = "OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS"
 
 
 def is_installed(req: str) -> bool:
@@ -38,6 +39,11 @@ def is_agent_observability_enabled() -> bool:
     return os.environ.get(AGENT_OBSERVABILITY_ENABLED, "false").lower() == "true"
 
 
+def should_add_application_signals_dimensions() -> bool:
+    """Should Service and Environment Application Signals dimensions be added to EMF logs?"""
+    return os.environ.get(OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS, "true").lower() == "true"
+
+
 IS_BOTOCORE_INSTALLED: bool = is_installed("botocore")
 
 

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

@@ -16,7 +16,12 @@
 import sys
 from logging import ERROR, Logger, getLogger
 
-from amazon.opentelemetry.distro._utils import get_aws_region, is_agent_observability_enabled, is_installed
+from amazon.opentelemetry.distro._utils import (
+    OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS,
+    get_aws_region,
+    is_agent_observability_enabled,
+    is_installed,
+)
 from amazon.opentelemetry.distro.aws_opentelemetry_configurator import (
     APPLICATION_SIGNALS_ENABLED_CONFIG,
     OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
@@ -158,6 +163,7 @@ def _configure(self, **kwargs):
 
             # Disable AWS Application Signals by default
             os.environ.setdefault(APPLICATION_SIGNALS_ENABLED_CONFIG, "false")
+            os.environ.setdefault(OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS, "false")
 
         super(AwsOpenTelemetryDistro, self)._configure()
 

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/exporter/aws/metrics/base_emf_exporter.py

@@ -6,13 +6,12 @@
 import json
 import logging
 import math
-import os
 import time
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Tuple
 
-from amazon.opentelemetry.distro._aws_resource_attribute_configurator import get_service_attribute
+from amazon.opentelemetry.distro._utils import should_add_application_signals_dimensions
 from opentelemetry.sdk.metrics import Counter
 from opentelemetry.sdk.metrics import Histogram as HistogramInstr
 from opentelemetry.sdk.metrics import ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter
@@ -30,6 +29,7 @@
 )
 from opentelemetry.sdk.metrics.view import ExponentialBucketHistogramAggregation
 from opentelemetry.sdk.resources import Resource
+from opentelemetry.semconv._incubating.attributes.cloud_attributes import CloudPlatformValues
 from opentelemetry.semconv.resource import ResourceAttributes
 from opentelemetry.util.types import Attributes
 
@@ -39,9 +39,19 @@
 SERVICE_DIMENSION_NAME: str = "Service"
 ENVIRONMENT_DIMENSION_NAME: str = "Environment"
 
+# Resource attribute constant for deployment.environment.name
+# deployment.environment is deprecated in favor of deployment.environment.name
+# but not yet available in current OTel Python version
+# https://github.com/open-telemetry/opentelemetry.io/commit/b04507d7be1e916f6705126c56d66dbe9536503e
+DEPLOYMENT_ENVIRONMENT_NAME: str = "deployment.environment.name"
+
 # Constants
-LAMBDA_DEFAULT: str = "lambda:default"
 UNKNOWN_SERVICE: str = "UnknownService"
+UNKNOWN_ENVIRONMENT: str = "generic:default"
+EC2_DEFAULT: str = "ec2:default"
+ECS_DEFAULT: str = "ecs:default"
+EKS_DEFAULT: str = "eks:default"
+LAMBDA_DEFAULT: str = "lambda:default"
 
 
 class MetricRecord:
@@ -195,52 +205,58 @@ def _get_dimension_names(self, attributes: Attributes) -> List[str]:
         # For now, use all attributes as dimensions
         return list(attributes.keys())
 
-    def _has_dimension_case_insensitive(self, dimension_names: List[str], dimension_to_check: str) -> bool:
-        """Check if dimension already exists (case-insensitive match)."""
-        dimension_lower = dimension_to_check.lower()
-        return any(dim.lower() == dimension_lower for dim in dimension_names)
-
-    @staticmethod
-    def _is_application_signals_emf_export_enabled() -> bool:
-        """Check if Application Signals EMF export is enabled.
-
-        Returns True only if BOTH:
-        - OTEL_AWS_APPLICATION_SIGNALS_ENABLED is true
-        - OTEL_AWS_APPLICATION_SIGNALS_EMF_EXPORT_ENABLED is true
-        """
-        app_signals_enabled = os.environ.get("OTEL_AWS_APPLICATION_SIGNALS_ENABLED", "false").lower() == "true"
-        emf_export_enabled = (
-            os.environ.get("OTEL_AWS_APPLICATION_SIGNALS_EMF_EXPORT_ENABLED", "false").lower() == "true"
-        )
-        return app_signals_enabled and emf_export_enabled
-
     def _add_application_signals_dimensions(
-        self, dimension_names: List[str], emf_log: Dict, resource: Resource
+        self, dimension_names: List[str], emf_log: Dict, resource_attributes: Optional[Attributes]
     ) -> None:
-        """Add Service and Environment dimensions if not already present (case-insensitive)."""
-        if not self._is_application_signals_emf_export_enabled():
+        """Add Service and Environment dimensions if not already present."""
+        if not should_add_application_signals_dimensions():
             return
 
-        # Add Service dimension if not already set by user
         if not self._has_dimension_case_insensitive(dimension_names, SERVICE_DIMENSION_NAME):
-            if resource:
-                service_name, _ = get_service_attribute(resource)
-            else:
+            service_name = resource_attributes.get(ResourceAttributes.SERVICE_NAME) if resource_attributes else None
+            service_name_str = str(service_name) if service_name else ""
+            # https://github.com/open-telemetry/opentelemetry-python/blob/102fec2be1fe9d0a8e299598a21ad6ec3b96dcca/opentelemetry-semantic-conventions/src/opentelemetry/semconv/attributes/service_attributes.py#L20
+            if (
+                not service_name
+                or service_name_str == "unknown_service"
+                or service_name_str.startswith("unknown_service:")
+            ):
                 service_name = UNKNOWN_SERVICE
-            dimension_names.insert(0, SERVICE_DIMENSION_NAME)
-            emf_log[SERVICE_DIMENSION_NAME] = str(service_name)
+            dimension_names.append(SERVICE_DIMENSION_NAME)
+            emf_log[SERVICE_DIMENSION_NAME] = service_name
 
-        # Add Environment dimension if not already set by user
         if not self._has_dimension_case_insensitive(dimension_names, ENVIRONMENT_DIMENSION_NAME):
-            environment_value = None
-            if resource and resource.attributes:
-                environment_value = resource.attributes.get(ResourceAttributes.DEPLOYMENT_ENVIRONMENT)
-            if not environment_value:
-                environment_value = LAMBDA_DEFAULT
-            # Insert after Service if it exists, otherwise at the beginning
-            insert_pos = 1 if SERVICE_DIMENSION_NAME in dimension_names else 0
-            dimension_names.insert(insert_pos, ENVIRONMENT_DIMENSION_NAME)
-            emf_log[ENVIRONMENT_DIMENSION_NAME] = str(environment_value)
+            environment_name = self._get_deployment_environment(resource_attributes)
+            dimension_names.append(ENVIRONMENT_DIMENSION_NAME)
+            emf_log[ENVIRONMENT_DIMENSION_NAME] = environment_name
+
+    def _has_dimension_case_insensitive(self, dimension_names: List[str], dimension_to_check: str) -> bool:
+        """Check if dimension already exists."""
+        dimension_lower = dimension_to_check.lower()
+        return any(dim.lower() == dimension_lower for dim in dimension_names)
+
+    def _get_deployment_environment(self, resource_attributes: Optional[Attributes]) -> str:
+        """Get deployment environment from resource attributes or cloud platform."""
+        if not resource_attributes:
+            return UNKNOWN_ENVIRONMENT
+
+        environment_name = resource_attributes.get(DEPLOYMENT_ENVIRONMENT_NAME)
+        if not environment_name:
+            environment_name = resource_attributes.get(ResourceAttributes.DEPLOYMENT_ENVIRONMENT)
+
+        if environment_name:
+            return str(environment_name)
+
+        platform = resource_attributes.get(ResourceAttributes.CLOUD_PLATFORM)
+        if platform:
+            platform_defaults = {
+                CloudPlatformValues.AWS_EC2.value: EC2_DEFAULT,
+                CloudPlatformValues.AWS_ECS.value: ECS_DEFAULT,
+                CloudPlatformValues.AWS_EKS.value: EKS_DEFAULT,
+                CloudPlatformValues.AWS_LAMBDA.value: LAMBDA_DEFAULT,
+            }
+            return platform_defaults.get(str(platform), UNKNOWN_ENVIRONMENT)
+        return UNKNOWN_ENVIRONMENT
 
     def _get_attributes_key(self, attributes: Attributes) -> str:
         """
@@ -552,7 +568,8 @@ def _create_emf_log(
             emf_log[name] = str(value)
 
         # Add Service and Environment dimensions if Application Signals EMF export is enabled
-        self._add_application_signals_dimensions(dimension_names, emf_log, resource)
+        resource_attributes = resource.attributes if resource else {}
+        self._add_application_signals_dimensions(dimension_names, emf_log, resource_attributes)
 
         # Add CloudWatch Metrics if we have metrics, include dimensions only if they exist
         if metric_definitions:

aws-opentelemetry-distro/tests/amazon/opentelemetry/distro/exporter/aws/metrics/test_aws_cloudwatch_emf_exporter.py

@@ -358,8 +358,10 @@ def test_create_emf_log(self):
         # Check that the result is JSON serializable
         json.dumps(result)  # Should not raise exception
 
+    @patch.dict("os.environ", {"OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS": "false"})
     def test_create_emf_log_with_resource(self):
         """Test EMF log creation with resource attributes."""
+
         # Create test records
         gauge_record = self.exporter._create_metric_record("gauge_metric", "Count", "Gauge")
         gauge_record.value = 50.0
@@ -395,8 +397,10 @@ def test_create_emf_log_with_resource(self):
         self.assertEqual(set(cw_metrics["Dimensions"][0]), {"env", "service"})
         self.assertEqual(cw_metrics["Metrics"][0]["Name"], "gauge_metric")
 
+    @patch.dict("os.environ", {"OTEL_METRICS_ADD_APPLICATION_SIGNALS_DIMENSIONS": "false"})
     def test_create_emf_log_without_dimensions(self):
         """Test EMF log creation with metrics but no dimensions."""
+
         # Create test record without attributes (no dimensions)
         gauge_record = self.exporter._create_metric_record("gauge_metric", "Count", "Gauge")
         gauge_record.value = 75.0