Add Service and Environment dimensions to EMF metrics for Lambda

When running on AWS Lambda, EMF metrics now include "Service" and
"Environment" dimensions to enable better metric filtering and
correlation in CloudWatch.

- Service: Uses service.name from OTel Resource (set via OTEL_SERVICE_NAME)
- Environment: Hardcoded to "lambda:default"

This change only applies when using ConsoleEmfExporter in Lambda
environments, ensuring non-Lambda deployments are unaffected.

🤖 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_opentelemetry_configurator.py

@@ -835,7 +835,7 @@ def _create_emf_exporter():
             # pylint: disable=import-outside-toplevel
             from amazon.opentelemetry.distro.exporter.aws.metrics.console_emf_exporter import ConsoleEmfExporter
 
-            return ConsoleEmfExporter(namespace=log_header_setting.namespace)
+            return ConsoleEmfExporter(namespace=log_header_setting.namespace, is_lambda=True)
 
         # For non-Lambda environment or Lambda with valid headers - use CloudWatch EMF exporter
         session = get_aws_session()

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

@@ -30,8 +30,13 @@
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.util.types import Attributes
 
+from amazon.opentelemetry.distro._aws_resource_attribute_configurator import get_service_attribute
+
 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."""
@@ -121,6 +126,7 @@ def __init__(
         namespace: str = "default",
         preferred_temporality: Optional[Dict[type, AggregationTemporality]] = None,
         preferred_aggregation: Optional[Dict[type, Any]] = None,
+        is_lambda: bool = False,
     ):
         """
         Initialize the base EMF exporter.
@@ -129,7 +135,9 @@ def __init__(
             namespace: CloudWatch namespace for metrics
             preferred_temporality: Optional dictionary mapping instrument types to aggregation temporality
             preferred_aggregation: Optional dictionary mapping instrument types to preferred aggregation
+            is_lambda: Whether the exporter is running in AWS Lambda environment
         """
+        self._is_lambda = is_lambda
         # Set up temporality preference default to DELTA if customers not set
         if preferred_temporality is None:
             preferred_temporality = {
@@ -493,6 +501,15 @@ def _create_emf_log(
         for name, value in all_attributes.items():
             emf_log[name] = str(value)
 
+        # Add Service and Environment dimensions for Lambda
+        if self._is_lambda:
+            service_name, _ = get_service_attribute(resource) if resource else ("UnknownService", True)
+            # Add Service and Environment to dimension names (at the beginning for consistency)
+            dimension_names = ["Service", "Environment"] + dimension_names
+            # Add dimension values to the EMF log root
+            emf_log["Service"] = service_name
+            emf_log["Environment"] = LAMBDA_ENVIRONMENT_DEFAULT
+
         # Add CloudWatch Metrics if we have metrics, include dimensions only if they exist
         if metric_definitions:
             cloudwatch_metric = {"Namespace": self.namespace, "Metrics": metric_definitions}

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

@@ -30,6 +30,7 @@ def __init__(
         namespace: str = "default",
         preferred_temporality: Optional[Dict[type, AggregationTemporality]] = None,
         preferred_aggregation: Optional[Dict[type, Any]] = None,
+        is_lambda: bool = False,
         **kwargs: Any,
     ) -> None:
         """
@@ -39,12 +40,13 @@ def __init__(
             namespace: CloudWatch namespace for metrics (defaults to "default")
             preferred_temporality: Optional dictionary mapping instrument types to aggregation temporality
             preferred_aggregation: Optional dictionary mapping instrument types to preferred aggregation
+            is_lambda: Whether the exporter is running in AWS Lambda environment
             **kwargs: Additional arguments (unused, kept for compatibility)
         """
         # No need to check for None since namespace has a default value
         if namespace is None:
             namespace = "default"
-        super().__init__(namespace, preferred_temporality, preferred_aggregation)
+        super().__init__(namespace, preferred_temporality, preferred_aggregation, is_lambda=is_lambda)
 
     def _export(self, log_event: Dict[str, Any]) -> None:
         """

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

@@ -286,6 +286,113 @@ def test_export_failure_handling(self):
         result = self.exporter.export(metrics_data)
         self.assertEqual(result, MetricExportResult.FAILURE)
 
+    def test_is_lambda_initialization(self):
+        """Test is_lambda parameter initialization."""
+        # Default should be False
+        exporter = ConcreteEmfExporter()
+        self.assertFalse(exporter._is_lambda)
+
+        # Explicit False
+        exporter = ConcreteEmfExporter(is_lambda=False)
+        self.assertFalse(exporter._is_lambda)
+
+        # Explicit True
+        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)
+
+        # Create a simple metric record
+        record = lambda_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"})
+
+        result = lambda_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.assertIn("Environment", result)
+        self.assertEqual(result["Environment"], "lambda:default")
+
+        # Check that dimensions include Service and Environment
+        cw_metrics = result["_aws"]["CloudWatchMetrics"][0]
+        dimensions = cw_metrics["Dimensions"][0]
+        self.assertIn("Service", dimensions)
+        self.assertIn("Environment", dimensions)
+        # Service and Environment should be at the beginning
+        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)
+
+        # Create a simple metric record
+        record = non_lambda_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)
+
+        # Check that Service and Environment dimensions are NOT added
+        self.assertNotIn("Service", result)
+        self.assertNotIn("Environment", result)
+
+        # Check that dimensions do NOT include Service and Environment
+        cw_metrics = result["_aws"]["CloudWatchMetrics"][0]
+        dimensions = cw_metrics["Dimensions"][0]
+        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)
+
+        record = lambda_exporter._create_metric_record("test_metric", "Count", "Test")
+        record.value = 50.0
+        record.timestamp = 1234567890
+        record.attributes = {}
+
+        records = [record]
+        # Resource with unknown_service prefix
+        resource = Resource.create({"service.name": "unknown_service:python"})
+
+        result = lambda_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)
+
+        record = lambda_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)
+
+        # Should handle None resource gracefully
+        self.assertEqual(result["Service"], "UnknownService")
+        self.assertEqual(result["Environment"], "lambda:default")
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -52,6 +52,25 @@ def test_initialization_with_parameters(self):
         exporter = ConsoleEmfExporter(namespace="TestNamespace", extra_param="ignored")  # Should be ignored
         self.assertEqual(exporter.namespace, "TestNamespace")
 
+    def test_is_lambda_initialization(self):
+        """Test is_lambda parameter initialization."""
+        # Default should be False
+        exporter = ConsoleEmfExporter()
+        self.assertFalse(exporter._is_lambda)
+
+        # Explicit False
+        exporter = ConsoleEmfExporter(is_lambda=False)
+        self.assertFalse(exporter._is_lambda)
+
+        # Explicit True
+        exporter = ConsoleEmfExporter(is_lambda=True)
+        self.assertTrue(exporter._is_lambda)
+
+        # With other parameters
+        exporter = ConsoleEmfExporter(namespace="TestNamespace", is_lambda=True)
+        self.assertEqual(exporter.namespace, "TestNamespace")
+        self.assertTrue(exporter._is_lambda)
+
     def test_export_log_event_success(self):
         """Test that log events are properly sent to console output."""
         # Create a simple log event with EMF-formatted message

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

@@ -1327,7 +1327,7 @@ def test_create_emf_exporter_lambda_without_valid_headers(
             result = _create_emf_exporter()
 
             self.assertEqual(result, mock_exporter_instance)
-            mock_console_exporter.assert_called_once_with(namespace="test-namespace")
+            mock_console_exporter.assert_called_once_with(namespace="test-namespace", is_lambda=True)
 
     @patch("amazon.opentelemetry.distro.aws_opentelemetry_configurator._fetch_logs_header")
     @patch("amazon.opentelemetry.distro.aws_opentelemetry_configurator._is_lambda_environment")
@@ -1474,7 +1474,7 @@ def test_create_emf_exporter_lambda_without_valid_headers_none_namespace(
             result = _create_emf_exporter()
 
             self.assertEqual(result, mock_exporter_instance)
-            mock_console_exporter.assert_called_once_with(namespace=None)
+            mock_console_exporter.assert_called_once_with(namespace=None, is_lambda=True)
 
     @patch("amazon.opentelemetry.distro.aws_opentelemetry_configurator._fetch_logs_header")
     @patch("amazon.opentelemetry.distro.aws_opentelemetry_configurator._is_lambda_environment")