Add OTEL_AWS_APPLICATION_SIGNALS_ENABLED check for EMF dimensions

Add Service and Environment dimensions when Application Signals is enabled
(OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true), regardless of platform.

Environment dimension can be customized via deployment.environment resource
attribute, defaulting to "lambda:default" if not set.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: syed-ahsan-ishtiaque

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

@@ -2,11 +2,15 @@
 # SPDX-License-Identifier: Apache-2.0
 from amazon.opentelemetry.distro._aws_span_processing_util import UNKNOWN_SERVICE
 from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.semconv.resource import ResourceAttributes
 
 # As per https://opentelemetry.io/docs/specs/semconv/resource/#service, if service name is not specified, SDK defaults
 # the service name to unknown_service:<process name> or just unknown_service.
 _OTEL_UNKNOWN_SERVICE_PREFIX: str = "unknown_service"
 
+# Default environment value when deployment.environment is not set
+_DEFAULT_ENVIRONMENT: str = "lambda:default"
+
 
 def get_service_attribute(resource: Resource) -> (str, bool):
     """Service is always derived from SERVICE_NAME"""
@@ -17,3 +21,23 @@ def get_service_attribute(resource: Resource) -> (str, bool):
         return UNKNOWN_SERVICE, True
 
     return service, False
+
+
+def get_environment_attribute(resource: Resource) -> str:
+    """
+    Get environment from resource's deployment.environment attribute.
+
+    Args:
+        resource: The OTel Resource to extract environment from
+
+    Returns:
+        The deployment.environment value if set, otherwise "lambda:default"
+    """
+    if resource is None:
+        return _DEFAULT_ENVIRONMENT
+
+    environment = resource.attributes.get(ResourceAttributes.DEPLOYMENT_ENVIRONMENT)
+    if environment:
+        return environment
+
+    return _DEFAULT_ENVIRONMENT

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

@@ -6,12 +6,16 @@
 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._aws_resource_attribute_configurator import (
+    get_environment_attribute,
+    get_service_attribute,
+)
 from opentelemetry.sdk.metrics import Counter
 from opentelemetry.sdk.metrics import Histogram as HistogramInstr
 from opentelemetry.sdk.metrics import ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter
@@ -33,9 +37,6 @@
 
 logger = logging.getLogger(__name__)
 
-# Constants for Lambda EMF dimensions
-LAMBDA_ENVIRONMENT_DEFAULT = "lambda:default"
-
 
 class MetricRecord:
     """The metric data unified representation of all OTel metrics for OTel to CW EMF conversion."""
@@ -193,23 +194,32 @@ def _get_dimension_names(self, attributes: Attributes) -> List[str]:
 
     def _add_lambda_dimensions(self, emf_log: Dict, dimension_names: List[str], resource: Resource) -> List[str]:
         """
-        Add Service and Environment dimensions for Lambda environments.
+        Add Service and Environment dimensions when Application Signals is enabled.
 
         Args:
             emf_log: The EMF log dictionary to add dimension values to
             dimension_names: The current list of dimension names
             resource: The OTel Resource to extract service name from
 
         Returns:
-            Updated list of dimension names with Service and Environment prepended (if Lambda)
+            Updated list of dimension names with Service and Environment prepended
         """
-        if not self._is_lambda:
+        # Only add dimensions when Application Signals is enabled
+        app_signals_enabled = (
+            os.environ.get(
+                "OTEL_AWS_APPLICATION_SIGNALS_ENABLED",
+                os.environ.get("OTEL_AWS_APP_SIGNALS_ENABLED", "false"),
+            ).lower()
+            == "true"
+        )
+        if not app_signals_enabled:
             return dimension_names
 
         service_name, _ = get_service_attribute(resource) if resource else ("UnknownService", True)
+        environment = get_environment_attribute(resource)
         # Add dimension values to the EMF log root
         emf_log["Service"] = service_name
-        emf_log["Environment"] = LAMBDA_ENVIRONMENT_DEFAULT
+        emf_log["Environment"] = environment
         # Add Service and Environment to dimension names (at the beginning for consistency)
         return ["Service", "Environment"] + dimension_names
 

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

@@ -1,8 +1,9 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+import os
 import unittest
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 from amazon.opentelemetry.distro.exporter.aws.metrics.base_emf_exporter import BaseEmfExporter, MetricRecord
 from opentelemetry.sdk.metrics.export import MetricExportResult
@@ -300,25 +301,25 @@ def test_is_lambda_initialization(self):
         exporter = ConcreteEmfExporter(is_lambda=True)
         self.assertTrue(exporter._is_lambda)
 
-    def test_create_emf_log_with_lambda_dimensions(self):
-        """Test EMF log creation includes Service and Environment dimensions in Lambda mode."""
-        # Create Lambda exporter
-        lambda_exporter = ConcreteEmfExporter(namespace="TestNamespace", is_lambda=True)
+    @patch.dict(os.environ, {"OTEL_AWS_APPLICATION_SIGNALS_ENABLED": "true"})
+    def test_create_emf_log_with_app_signals_dimensions(self):
+        """Test EMF log creation includes Service and Environment dimensions when app signals enabled."""
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
 
         # Create a simple metric record
-        record = lambda_exporter._create_metric_record("test_metric", "Count", "Test")
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
         record.value = 50.0
         record.timestamp = 1234567890
         record.attributes = {"env": "test"}
 
         records = [record]
-        resource = Resource.create({"service.name": "my-lambda-service"})
+        resource = Resource.create({"service.name": "my-service"})
 
-        result = lambda_exporter._create_emf_log(records, resource, 1234567890)
+        result = exporter._create_emf_log(records, resource, 1234567890)
 
         # Check that Service and Environment dimensions are added
         self.assertIn("Service", result)
-        self.assertEqual(result["Service"], "my-lambda-service")
+        self.assertEqual(result["Service"], "my-service")
         self.assertIn("Environment", result)
         self.assertEqual(result["Environment"], "lambda:default")
 
@@ -331,21 +332,21 @@ def test_create_emf_log_with_lambda_dimensions(self):
         self.assertEqual(dimensions[0], "Service")
         self.assertEqual(dimensions[1], "Environment")
 
-    def test_create_emf_log_without_lambda_dimensions(self):
-        """Test EMF log creation does NOT include Service and Environment dimensions when not Lambda."""
-        # Create non-Lambda exporter (default)
-        non_lambda_exporter = ConcreteEmfExporter(namespace="TestNamespace", is_lambda=False)
+    def test_create_emf_log_without_app_signals_dimensions(self):
+        """Test EMF log creation does NOT include Service and Environment dimensions when app signals disabled."""
+        # App signals not enabled (default)
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
 
         # Create a simple metric record
-        record = non_lambda_exporter._create_metric_record("test_metric", "Count", "Test")
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
         record.value = 50.0
         record.timestamp = 1234567890
         record.attributes = {"env": "test"}
 
         records = [record]
         resource = Resource.create({"service.name": "my-service"})
 
-        result = non_lambda_exporter._create_emf_log(records, resource, 1234567890)
+        result = exporter._create_emf_log(records, resource, 1234567890)
 
         # Check that Service and Environment dimensions are NOT added
         self.assertNotIn("Service", result)
@@ -357,11 +358,12 @@ def test_create_emf_log_without_lambda_dimensions(self):
         self.assertNotIn("Service", dimensions)
         self.assertNotIn("Environment", dimensions)
 
-    def test_create_emf_log_lambda_with_unknown_service(self):
-        """Test EMF log creation uses UnknownService when service.name is not set in Lambda mode."""
-        lambda_exporter = ConcreteEmfExporter(namespace="TestNamespace", is_lambda=True)
+    @patch.dict(os.environ, {"OTEL_AWS_APPLICATION_SIGNALS_ENABLED": "true"})
+    def test_create_emf_log_with_unknown_service(self):
+        """Test EMF log creation uses UnknownService when service.name is not set."""
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
 
-        record = lambda_exporter._create_metric_record("test_metric", "Count", "Test")
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
         record.value = 50.0
         record.timestamp = 1234567890
         record.attributes = {}
@@ -370,29 +372,72 @@ def test_create_emf_log_lambda_with_unknown_service(self):
         # Resource with unknown_service prefix
         resource = Resource.create({"service.name": "unknown_service:python"})
 
-        result = lambda_exporter._create_emf_log(records, resource, 1234567890)
+        result = exporter._create_emf_log(records, resource, 1234567890)
 
         # Should fall back to UnknownService
         self.assertEqual(result["Service"], "UnknownService")
         self.assertEqual(result["Environment"], "lambda:default")
 
-    def test_create_emf_log_lambda_with_none_resource(self):
-        """Test EMF log creation handles None resource in Lambda mode."""
-        lambda_exporter = ConcreteEmfExporter(namespace="TestNamespace", is_lambda=True)
+    @patch.dict(os.environ, {"OTEL_AWS_APPLICATION_SIGNALS_ENABLED": "true"})
+    def test_create_emf_log_with_none_resource(self):
+        """Test EMF log creation handles None resource gracefully."""
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
 
-        record = lambda_exporter._create_metric_record("test_metric", "Count", "Test")
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
         record.value = 50.0
         record.timestamp = 1234567890
         record.attributes = {}
 
         records = [record]
 
-        result = lambda_exporter._create_emf_log(records, None, 1234567890)
+        result = exporter._create_emf_log(records, None, 1234567890)
 
         # Should handle None resource gracefully
         self.assertEqual(result["Service"], "UnknownService")
         self.assertEqual(result["Environment"], "lambda:default")
 
+    @patch.dict(os.environ, {"OTEL_AWS_APP_SIGNALS_ENABLED": "true"})
+    def test_create_emf_log_with_deprecated_app_signals_env_var(self):
+        """Test EMF log includes dimensions when using deprecated OTEL_AWS_APP_SIGNALS_ENABLED."""
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
+
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
+        record.value = 50.0
+        record.timestamp = 1234567890
+        record.attributes = {}
+
+        records = [record]
+        resource = Resource.create({"service.name": "my-service"})
+
+        result = exporter._create_emf_log(records, resource, 1234567890)
+
+        # Should add dimensions with deprecated env var
+        self.assertIn("Service", result)
+        self.assertEqual(result["Service"], "my-service")
+        self.assertIn("Environment", result)
+        self.assertEqual(result["Environment"], "lambda:default")
+
+    @patch.dict(os.environ, {"OTEL_AWS_APPLICATION_SIGNALS_ENABLED": "true"})
+    def test_create_emf_log_with_custom_deployment_environment(self):
+        """Test EMF log uses deployment.environment from resource when set."""
+        exporter = ConcreteEmfExporter(namespace="TestNamespace")
+
+        record = exporter._create_metric_record("test_metric", "Count", "Test")
+        record.value = 50.0
+        record.timestamp = 1234567890
+        record.attributes = {}
+
+        records = [record]
+        resource = Resource.create({"service.name": "my-service", "deployment.environment": "production"})
+
+        result = exporter._create_emf_log(records, resource, 1234567890)
+
+        # Should use custom deployment.environment
+        self.assertIn("Service", result)
+        self.assertEqual(result["Service"], "my-service")
+        self.assertIn("Environment", result)
+        self.assertEqual(result["Environment"], "production")
+
 
 if __name__ == "__main__":
     unittest.main()