refactor: use native python validation over JSON Schema

Author: heitorlessa

aws_lambda_powertools/metrics/base.py

@@ -9,14 +9,12 @@
 
 from ..shared import constants
 from ..shared.functions import resolve_env_var_choice
-from ..shared.lazy_import import LazyLoader
 from .exceptions import MetricUnitError, MetricValueError, SchemaValidationError
-from .schema import CLOUDWATCH_EMF_SCHEMA
 
-fastjsonschema = LazyLoader("fastjsonschema", globals(), "fastjsonschema")
 logger = logging.getLogger(__name__)
 
 MAX_METRICS = 100
+MAX_DIMENSIONS = 9
 
 
 class MetricUnit(Enum):
@@ -138,9 +136,7 @@ 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, validate_metrics: bool = True
-    ) -> Dict:
+    def serialize_metric_set(self, metrics: Dict = None, dimensions: Dict = None, metadata: Dict = None) -> Dict:
         """Serializes metric and dimensions set
 
         Parameters
@@ -151,8 +147,6 @@ def serialize_metric_set(
             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
         -------
@@ -184,6 +178,12 @@ def serialize_metric_set(
         if self.service and not self.dimension_set.get("service"):
             self.dimension_set["service"] = self.service
 
+        if len(metrics) == 0:
+            raise SchemaValidationError("Must contain at least one metric.")
+
+        if self.namespace is None:
+            raise SchemaValidationError("Must contain a metric namespace.")
+
         logger.debug({"details": "Serializing metrics", "metrics": metrics, "dimensions": dimensions})
 
         metric_names_and_units: List[Dict[str, str]] = []  # [ { "Name": "metric_name", "Unit": "Count" } ]
@@ -213,20 +213,8 @@ def serialize_metric_set(
             **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=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)
-
     def add_dimension(self, name: str, value: str):
         """Adds given dimension to all metrics
 
@@ -244,7 +232,10 @@ def add_dimension(self, name: str, value: str):
             Dimension value
         """
         logger.debug(f"Adding dimension: {name}:{value}")
-
+        if len(self.dimension_set) == 9:
+            raise SchemaValidationError(
+                f"Maximum number of dimensions exceeded ({MAX_DIMENSIONS}): Unable to add dimension {name}."
+            )
         # Cast value to str according to EMF spec
         # Majority of values are expected to be string already, so
         # checking before casting improves performance in most cases
@@ -305,7 +296,7 @@ def __extract_metric_unit_value(self, unit: Union[str, MetricUnit]) -> str:
             if unit in self._metric_unit_options:
                 unit = MetricUnit[unit].value
 
-            if unit not in self._metric_units:  # str correta
+            if unit not in self._metric_units:
                 raise MetricUnitError(
                     f"Invalid metric unit '{unit}', expected either option: {self._metric_unit_options}"
                 )

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, validate_metrics: bool = True):
+def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = None):
     """Context manager to simplify creation of a single metric
 
     Example
@@ -94,8 +94,6 @@ 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
     -------
@@ -116,6 +114,6 @@ def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = No
         metric: SingleMetric = SingleMetric(namespace=namespace)
         metric.add_metric(name=name, unit=unit, value=value)
         yield metric
-        metric_set: Dict = metric.serialize_metric_set(validate_metrics=validate_metrics)
+        metric_set: Dict = metric.serialize_metric_set()
     finally:
-        print(json.dumps(metric_set))
+        print(json.dumps(metric_set, separators=(",", ":")))

aws_lambda_powertools/metrics/metrics.py

@@ -61,8 +61,6 @@ def do_something():
         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
     ------
@@ -78,13 +76,12 @@ def do_something():
     _dimensions = {}
     _metadata = {}
 
-    def __init__(self, service: str = None, namespace: str = None, validate_metrics: bool = True):
+    def __init__(self, service: str = None, namespace: str = None):
         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,
@@ -159,7 +156,7 @@ def decorate(event, context):
                 else:
                     metrics = self.serialize_metric_set()
                     self.clear_metrics()
-                    print(json.dumps(metrics))
+                    print(json.dumps(metrics, separators=(",", ":")))
 
             return response
 

aws_lambda_powertools/metrics/schema.py

@@ -77,7 +77,7 @@ def metadata() -> Dict[str, str]:
 
 
 @pytest.fixture
-def a_hundred_metrics(namespace=namespace) -> List[Dict[str, str]]:
+def a_hundred_metrics() -> List[Dict[str, str]]:
     return [{"name": f"metric_{i}", "unit": "Count", "value": 1} for i in range(100)]
 
 
@@ -257,7 +257,7 @@ def test_schema_validation_no_namespace(metric, dimension):
     # GIVEN we don't add any namespace
     # WHEN we attempt to serialize a valid EMF object
     # THEN it should fail namespace validation
-    with pytest.raises(SchemaValidationError, match=".*Namespace must be string"):
+    with pytest.raises(SchemaValidationError, match="Must contain a metric namespace."):
         with single_metric(**metric) as my_metric:
             my_metric.add_dimension(**dimension)
 
@@ -278,7 +278,7 @@ def test_schema_no_metrics(service, namespace):
     my_metrics = Metrics(service=service, namespace=namespace)
 
     # THEN it should fail validation and raise SchemaValidationError
-    with pytest.raises(SchemaValidationError, match=".*Metrics must contain at least 1 items"):
+    with pytest.raises(SchemaValidationError, match="Must contain at least one metric."):
         my_metrics.serialize_metric_set()
 
 
@@ -288,7 +288,7 @@ def test_exceed_number_of_dimensions(metric, namespace):
 
     # WHEN we attempt to serialize them into a valid EMF object
     # THEN it should fail validation and raise SchemaValidationError
-    with pytest.raises(SchemaValidationError, match="must contain less than or equal to 9 items"):
+    with pytest.raises(SchemaValidationError, match="Maximum number of dimensions exceeded.*"):
         with single_metric(**metric, namespace=namespace) as my_metric:
             for dimension in dimensions:
                 my_metric.add_dimension(**dimension)
@@ -328,7 +328,7 @@ def lambda_handler(evt, context):
 
     # THEN the raised exception should be SchemaValidationError
     # and specifically about the lack of Metrics
-    with pytest.raises(SchemaValidationError, match=".*Metrics must contain at least 1 items"):
+    with pytest.raises(SchemaValidationError, match="Must contain at least one metric."):
         lambda_handler({}, {})
 
 

tests/functional/test_metrics.py

@@ -1,3 +1,4 @@
+import json
 import time
 from contextlib import contextmanager
 from typing import Dict, Generator
@@ -8,8 +9,8 @@
 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
+METRICS_VALIDATION_SLA: float = 0.001
+METRICS_SERIALIZATION_SLA: float = 0.001
 
 
 @contextmanager
@@ -45,37 +46,41 @@ 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:
+def add_max_metrics_before_serialization(metrics_instance: Metrics):
     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):
+def test_metrics_large_operation_without_json_serialization_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)
+    with timing() as t:
+        add_max_metrics_before_serialization(metrics_instance=my_metrics)
+        my_metrics.serialize_metric_set()
 
     # THEN completion time should be below our validation SLA
+    elapsed = t()
     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):
+def test_metrics_large_operation_and_json_serialization_sla(namespace):
     # GIVEN Metrics is initialized with validation disabled
-    my_metrics = Metrics(namespace=namespace, validate_metrics=False)
+    my_metrics = Metrics(namespace=namespace)
+
     # WHEN we add and serialize 99 metrics
-    elapsed = time_large_metric_set_operation(metrics_instance=my_metrics, validate_metrics=False)
+    with timing() as t:
+        add_max_metrics_before_serialization(metrics_instance=my_metrics)
+        metrics = my_metrics.serialize_metric_set()
+        print(json.dumps(metrics, separators=(",", ":")))
 
     # THEN completion time should be below our serialization SLA
+    elapsed = t()
     if elapsed > METRICS_SERIALIZATION_SLA:
         pytest.fail(f"Metric serialization should be below {METRICS_SERIALIZATION_SLA}s: {elapsed}")