feat(metrics): add cold start test

Author: heitorlessa

tests/e2e/metrics/handlers/cold_start.py

@@ -0,0 +1,12 @@
+from aws_lambda_powertools import Metrics
+
+my_metrics = Metrics()
+
+
+@my_metrics.log_metrics(capture_cold_start_metric=True)
+def lambda_handler(event, context):
+    # Maintenance: create a public method to set these explicitly
+    my_metrics.namespace = event.get("namespace")
+    my_metrics.service = event.get("service")
+
+    return "success"

tests/e2e/metrics/infrastructure.py

@@ -16,7 +16,7 @@
 class MetricsStack:
     def __init__(self, handlers_dir: Path) -> None:
         self.stack_name = f"test-metrics-{uuid4()}"
-        self.handlers_dir = handlers_dir  # hardcoded as we're not using a fixture yet
+        self.handlers_dir = handlers_dir
         self.app = App()
         self.stack = Stack(self.app, self.stack_name)
         self.session = boto3.Session()
@@ -41,7 +41,7 @@ def create_functions(self):
                 layers=[
                     LayerVersion.from_layer_version_arn(
                         self.stack,
-                        "lambda-powertools",
+                        f"{fn_name}-lambda-powertools",
                         f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPython:29",
                     )
                 ],
@@ -57,7 +57,9 @@ def create_functions(self):
 
             # CFN Outputs only support hyphen
             fn_name_camel_case = fn_name.title().replace("_", "")  # basic_handler -> BasicHandler
-            CfnOutput(self.stack, f"{fn_name_camel_case}Arn", value=function_python.function_arn)
+            self._add_resource_output(
+                name=fn_name_camel_case, value=function_python.function_name, arn_value=function_python.function_arn
+            )
 
     def deploy(self) -> Dict[str, str]:
         """Creates CloudFormation Stack and return stack outputs as dict
@@ -75,6 +77,9 @@ def deploy(self) -> Dict[str, str]:
     def delete(self):
         self.cf_client.delete_stack(StackName=self.stack_name)
 
+    def get_stack_outputs(self) -> Dict[str, str]:
+        return self.stack_outputs
+
     def _synthesize(self) -> Tuple[Dict, Path]:
         self.create_functions()
         cloud_assembly = self.app.synth()
@@ -103,5 +108,19 @@ def _deploy_stack(self, stack_name: str, template: Dict) -> Dict[str, str]:
 
         return self.stack_outputs
 
-    def get_stack_outputs(self) -> Dict[str, str]:
-        return self.stack_outputs
+    def _add_resource_output(self, name: str, value: str, arn_value: str):
+        """Add both resource value and ARN as Outputs to facilitate tests.
+
+        This will create two outputs: {Name} and {Name}Arn
+
+        Parameters
+        ----------
+        name : str
+            CloudFormation Output Key
+        value : str
+            CloudFormation Output Value
+        arn_value : str
+            CloudFormation Output Value for ARN
+        """
+        CfnOutput(self.stack, f"{name}", value=value)
+        CfnOutput(self.stack, f"{name}Arn", value=arn_value)

tests/e2e/metrics/test_metrics.py

@@ -6,8 +6,6 @@
 from tests.e2e.metrics.infrastructure import MetricsStack
 from tests.e2e.utils import helpers
 
-METRIC_NAMESPACE = "powertools-e2e-metric"
-
 
 @pytest.fixture
 def infra_outputs(infrastructure: MetricsStack):
@@ -19,6 +17,19 @@ def basic_handler_fn(infra_outputs: dict) -> str:
     return infra_outputs.get("BasicHandlerArn", "")
 
 
+@pytest.fixture
+def cold_start_fn(infra_outputs: dict) -> str:
+    return infra_outputs.get("ColdStart", "")
+
+
+@pytest.fixture
+def cold_start_fn_arn(infra_outputs: dict) -> str:
+    return infra_outputs.get("ColdStartArn", "")
+
+
+METRIC_NAMESPACE = "powertools-e2e-metric"
+
+
 def test_basic_lambda_metric_is_visible(basic_handler_fn):
     # GIVEN
     metric_name = helpers.build_metric_name()
@@ -42,6 +53,29 @@ def test_basic_lambda_metric_is_visible(basic_handler_fn):
     assert metric_data and metric_data[0] == 3.0
 
 
+def test_cold_start_metric(cold_start_fn_arn: str, cold_start_fn: str):
+    # GIVEN
+    metric_name = "ColdStart"
+    service = helpers.build_service_name()
+    dimensions = helpers.build_add_dimensions_input(function_name=cold_start_fn, service=service)
+
+    # WHEN
+    event = json.dumps({"service": service, "namespace": METRIC_NAMESPACE})
+    _, execution_time = helpers.trigger_lambda(lambda_arn=cold_start_fn_arn, payload=event)
+
+    metrics = helpers.get_metrics(
+        start_date=execution_time,
+        end_date=execution_time + datetime.timedelta(minutes=2),
+        namespace=METRIC_NAMESPACE,
+        metric_name=metric_name,
+        dimensions=dimensions,
+    )
+
+    # THEN
+    metric_data = metrics.get("Values", [])
+    assert metric_data and metric_data[0] == 1.0
+
+
 # helpers: adjust retries and wait to be much smaller
 # helpers: make retry config adjustable
 # Infra: Add temporary Powertools Layer

tests/e2e/utils/helpers.py

@@ -68,15 +68,21 @@ def get_metrics(
     namespace: str,
     start_date: datetime,
     metric_name: str,
-    service_name: str,
+    service_name: str = "",
+    dimensions: Optional[List[DimensionTypeDef]] = None,
     cw_client: Optional[CloudWatchClient] = None,
     end_date: Optional[datetime] = None,
     period: int = 60,
     stat: str = "Sum",
 ) -> MetricDataResultTypeDef:
     cw_client = cw_client or boto3.client("cloudwatch")
     metric_query = build_metric_query_data(
-        namespace=namespace, metric_name=metric_name, service_name=service_name, period=period, stat=stat
+        namespace=namespace,
+        metric_name=metric_name,
+        service_name=service_name,
+        period=period,
+        stat=stat,
+        dimensions=dimensions,
     )
 
     response = cw_client.get_metric_data(
@@ -156,27 +162,34 @@ def build_random_value(nbytes: int = 10) -> str:
 def build_metric_query_data(
     namespace: str,
     metric_name: str,
-    service_name: str,
+    service_name: str = "",
     period: int = 60,
     stat: str = "Sum",
-    dimensions: Optional[DimensionTypeDef] = None,
+    dimensions: Optional[List[DimensionTypeDef]] = None,
 ) -> List[MetricDataQueryTypeDef]:
-    metric_dimensions: List[DimensionTypeDef] = [{"Name": "service", "Value": service_name}]
-    if dimensions is not None:
-        metric_dimensions.append(dimensions)
+    dimensions = dimensions or []
 
-    return [
+    # Maintenance: get rid of service_name param to avoid future mistakes
+    if service_name:
+        dimensions.append({"Name": "service", "Value": service_name})
+
+    data_query: List[MetricDataQueryTypeDef] = [
         {
-            "Id": metric_name,
+            "Id": metric_name.lower(),
             "MetricStat": {
-                "Metric": {"Namespace": namespace, "MetricName": metric_name, "Dimensions": metric_dimensions},
+                "Metric": {"Namespace": namespace, "MetricName": metric_name},
                 "Period": period,
                 "Stat": stat,
             },
             "ReturnData": True,
         }
     ]
 
+    if dimensions:
+        data_query[0]["MetricStat"]["Metric"]["Dimensions"] = dimensions
+
+    return data_query
+
 
 def build_add_metric_input(metric_name: str, value: float, unit: str = MetricUnit.Count.value) -> Dict:
     """Create a metric input to be used with Metrics.add_metric()
@@ -220,3 +233,39 @@ def build_multiple_add_metric_input(
         List of metrics
     """
     return [{"name": metric_name, "unit": unit, "value": value} for _ in range(quantity)]
+
+
+def build_add_dimension_input(name: str, value: str) -> DimensionTypeDef:
+    """Create a dimension input to be used with either Metrics.add_dimension()
+
+    Parameters
+    ----------
+    name : str
+        dimension name
+    value : float
+        dimension value
+
+    Returns
+    -------
+    Dict
+        Metric dimension input
+    """
+    return {"Name": name, "Value": value}
+
+
+def build_add_dimensions_input(**dimensions) -> List[DimensionTypeDef]:
+    """Create dimensions input to be used with either get_metrics or Metrics.add_dimension()
+
+    Parameters
+    ----------
+    name : str
+        dimension name
+    value : float
+        dimension value
+
+    Returns
+    -------
+    Dict
+        Metric dimension input
+    """
+    return [{"Name": name, "Value": value} for name, value in dimensions.items()]