feat: allow metric validation to be disabled

Author: heitorlessa

aws_lambda_powertools/metrics/base.py

@@ -138,7 +138,9 @@ def add_metric(self, name: str, unit: Union[MetricUnit, str], value: float):
             # since we could have more than 100 metrics
             self.metric_set.clear()
 
-    def serialize_metric_set(self, metrics: Dict = None, dimensions: Dict = None, metadata: Dict = None) -> Dict:
+    def serialize_metric_set(
+        self, metrics: Dict = None, dimensions: Dict = None, metadata: Dict = None, validate_metrics: bool = True
+    ) -> Dict:
         """Serializes metric and dimensions set
 
         Parameters
@@ -149,6 +151,8 @@ def serialize_metric_set(self, metrics: Dict = None, dimensions: Dict = None, me
             Dictionary of dimensions to serialize, by default None
         metadata: Dict, optional
             Dictionary of metadata to serialize, by default None
+        validate_metrics: bool, optional
+            Whether to validate metrics against schema
 
         Example
         -------
@@ -209,13 +213,19 @@ def serialize_metric_set(self, metrics: Dict = None, dimensions: Dict = None, me
             **metric_names_and_values,  # "single_metric": 1.0
         }
 
+        if validate_metrics:
+            self._validate_metrics(metrics=embedded_metrics_object)
+
+        return embedded_metrics_object
+
+    @staticmethod
+    def _validate_metrics(metrics: Dict, schema: Dict = CLOUDWATCH_EMF_SCHEMA):
         try:
             logger.debug("Validating serialized metrics against CloudWatch EMF schema")
-            fastjsonschema.validate(definition=CLOUDWATCH_EMF_SCHEMA, data=embedded_metrics_object)
+            fastjsonschema.validate(definition=schema, data=metrics)
         except fastjsonschema.JsonSchemaException as e:
             message = f"Invalid format. Error: {e.message}, Invalid item: {e.name}"  # noqa: B306, E501
             raise SchemaValidationError(message)
-        return embedded_metrics_object
 
     def add_dimension(self, name: str, value: str):
         """Adds given dimension to all metrics

aws_lambda_powertools/metrics/metric.py

@@ -61,7 +61,7 @@ def add_metric(self, name: str, unit: MetricUnit, value: float):
 
 
 @contextmanager
-def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = None):
+def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = None, validate_metrics: bool = True):
     """Context manager to simplify creation of a single metric
 
     Example
@@ -94,6 +94,8 @@ def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = No
         Metric value
     namespace: str
         Namespace for metrics
+    validate_metrics: bool, optional
+        Whether to validate metrics against schema, by default True
 
     Yields
     -------
@@ -102,14 +104,18 @@ def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = No
 
     Raises
     ------
-    e
-        Propagate error received
+    MetricUnitError
+        When metric metric isn't supported by CloudWatch
+    MetricValueError
+        When metric value isn't a number
+    SchemaValidationError
+        When metric object fails EMF schema validation
     """
     metric_set = None
     try:
         metric: SingleMetric = SingleMetric(namespace=namespace)
         metric.add_metric(name=name, unit=unit, value=value)
         yield metric
-        metric_set: Dict = metric.serialize_metric_set()
+        metric_set: Dict = metric.serialize_metric_set(validate_metrics=validate_metrics)
     finally:
         print(json.dumps(metric_set))

aws_lambda_powertools/metrics/metrics.py

@@ -57,25 +57,34 @@ def do_something():
 
     Parameters
     ----------
-    MetricManager : MetricManager
-        Inherits from `aws_lambda_powertools.metrics.base.MetricManager`
+    service : str, optional
+        service name to be used as metric dimension, by default "service_undefined"
+    namespace : str
+        Namespace for metrics
+    validate_metrics: bool, optional
+        Whether to validate metrics against schema, by default True
 
     Raises
     ------
-    e
-        Propagate error received
+    MetricUnitError
+        When metric metric isn't supported by CloudWatch
+    MetricValueError
+        When metric value isn't a number
+    SchemaValidationError
+        When metric object fails EMF schema validation
     """
 
     _metrics = {}
     _dimensions = {}
     _metadata = {}
 
-    def __init__(self, service: str = None, namespace: str = None):
+    def __init__(self, service: str = None, namespace: str = None, validate_metrics: bool = True):
         self.metric_set = self._metrics
         self.dimension_set = self._dimensions
         self.service = service
         self.namespace = namespace
         self.metadata_set = self._metadata
+        self.validate_metrics = validate_metrics
 
         super().__init__(
             metric_set=self.metric_set,

tests/performance/conftest.py

@@ -0,0 +1,18 @@
+import time
+from contextlib import contextmanager
+from typing import Generator
+
+
+@contextmanager
+def timing() -> Generator:
+    """ "Generator to quickly time operations. It can add 5ms so take that into account in elapsed time
+
+    Examples
+    --------
+
+        with timing() as t:
+            print("something")
+        elapsed = t()
+    """
+    start = time.perf_counter()
+    yield lambda: time.perf_counter() - start  # gen as lambda to calculate elapsed time

tests/performance/test_metrics.py

@@ -0,0 +1,81 @@
+import time
+from contextlib import contextmanager
+from typing import Dict, Generator
+
+import pytest
+
+from aws_lambda_powertools import Metrics
+from aws_lambda_powertools.metrics import MetricUnit
+from aws_lambda_powertools.metrics import metrics as metrics_global
+
+METRICS_VALIDATION_SLA: float = 0.01
+METRICS_SERIALIZATION_SLA: float = 0.01
+
+
+@contextmanager
+def timing() -> Generator:
+    """ "Generator to quickly time operations. It can add 5ms so take that into account in elapsed time
+
+    Examples
+    --------
+
+        with timing() as t:
+            print("something")
+        elapsed = t()
+    """
+    start = time.perf_counter()
+    yield lambda: time.perf_counter() - start  # gen as lambda to calculate elapsed time
+
+
+@pytest.fixture(scope="function", autouse=True)
+def reset_metric_set():
+    metrics = Metrics()
+    metrics.clear_metrics()
+    metrics_global.is_cold_start = True  # ensure each test has cold start
+    yield
+
+
+@pytest.fixture
+def namespace() -> str:
+    return "test_namespace"
+
+
+@pytest.fixture
+def metric() -> Dict[str, str]:
+    return {"name": "single_metric", "unit": MetricUnit.Count, "value": 1}
+
+
+def time_large_metric_set_operation(metrics_instance: Metrics, validate_metrics: bool = True) -> float:
+    metrics_instance.add_dimension(name="test_dimension", value="test")
+
+    for i in range(99):
+        metrics_instance.add_metric(name=f"metric_{i}", unit="Count", value=1)
+
+    with timing() as t:
+        metrics_instance.serialize_metric_set(validate_metrics=validate_metrics)
+
+    return t()
+
+
+@pytest.mark.perf
+def test_metrics_validation_sla(namespace):
+    # GIVEN Metrics is initialized
+    my_metrics = Metrics(namespace=namespace)
+    # WHEN we add and serialize 99 metrics
+    elapsed = time_large_metric_set_operation(metrics_instance=my_metrics)
+
+    # THEN completion time should be below our validation SLA
+    if elapsed > METRICS_VALIDATION_SLA:
+        pytest.fail(f"Metric validation should be below {METRICS_VALIDATION_SLA}s: {elapsed}")
+
+
+@pytest.mark.perf
+def test_metrics_serialization_sla(namespace):
+    # GIVEN Metrics is initialized with validation disabled
+    my_metrics = Metrics(namespace=namespace, validate_metrics=False)
+    # WHEN we add and serialize 99 metrics
+    elapsed = time_large_metric_set_operation(metrics_instance=my_metrics, validate_metrics=False)
+
+    # THEN completion time should be below our serialization SLA
+    if elapsed > METRICS_SERIALIZATION_SLA:
+        pytest.fail(f"Metric serialization should be below {METRICS_SERIALIZATION_SLA}s: {elapsed}")