Pass storageResolution as enum in putMetric

Author: Meshwa Savalia

aws_embedded_metrics/logger/metric.py

@@ -10,13 +10,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from aws_embedded_metrics.storageResolution import StorageResolution
 
 
 class Metric(object):
-    def __init__(self, value: float, unit: str = None, storageResolution: int = 60):
+    def __init__(self, value: float, unit: str = None, storageResolution: StorageResolution = StorageResolution.STANDARD):
         self.values = [value]
         self.unit = unit or "None"
-        self.storageResolution = storageResolution
+        self.storageResolution = storageResolution or StorageResolution.STANDARD
 
     def add_value(self, value: float) -> None:
         self.values.append(value)

aws_embedded_metrics/logger/metrics_context.py

@@ -16,6 +16,7 @@
 from aws_embedded_metrics.config import get_config
 from aws_embedded_metrics.logger.metric import Metric
 from aws_embedded_metrics.validator import validate_dimension_set, validate_metric
+from aws_embedded_metrics.storageResolution import StorageResolution
 from typing import List, Dict, Any, Set
 
 
@@ -39,9 +40,9 @@ def __init__(
         self.metrics: Dict[str, Metric] = {}
         self.should_use_default_dimensions = True
         self.meta: Dict[str, Any] = {"Timestamp": utils.now()}
-        self.metricNameAndResolutionMap: Dict[str, int] = {}
+        self.metricNameAndResolutionMap: Dict[str, StorageResolution] = {}
 
-    def put_metric(self, key: str, value: float, unit: str = None, storageResolution: int = 60) -> None:
+    def put_metric(self, key: str, value: float, unit: str = None, storageResolution: StorageResolution = StorageResolution.STANDARD) -> None:
         """
         Adds a metric measurement to the context.
         Multiple calls using the same key will be stored as an

aws_embedded_metrics/logger/metrics_logger.py

@@ -15,6 +15,7 @@
 from aws_embedded_metrics.logger.metrics_context import MetricsContext
 from aws_embedded_metrics.validator import validate_namespace
 from aws_embedded_metrics.config import get_config
+from aws_embedded_metrics.storageResolution import StorageResolution
 from typing import Any, Awaitable, Callable, Dict, Tuple
 import sys
 import traceback
@@ -78,7 +79,9 @@ def set_namespace(self, namespace: str) -> "MetricsLogger":
         self.context.namespace = namespace
         return self
 
-    def put_metric(self, key: str, value: float, unit: str = "None", storageResolution: int = 60) -> "MetricsLogger":
+    def put_metric(
+        self, key: str, value: float, unit: str = "None", storageResolution: StorageResolution = StorageResolution.STANDARD
+    ) -> "MetricsLogger":
         self.context.put_metric(key, value, unit, storageResolution)
         return self
 

aws_embedded_metrics/serializers/log_serializer.py

@@ -18,6 +18,7 @@
     MAX_DIMENSION_SET_SIZE, MAX_METRICS_PER_EVENT, MAX_DATAPOINTS_PER_METRIC
 )
 from aws_embedded_metrics.exceptions import DimensionSetExceededError
+from aws_embedded_metrics.storageResolution import StorageResolution
 import json
 from typing import Any, Dict, List
 
@@ -88,8 +89,8 @@ def create_body() -> Dict[str, Any]:
                         remaining_data = True
 
                 metricBody = {"Name": metric_name, "Unit": metric.unit}
-                if metric.storageResolution == 1:
-                    metricBody["StorageResolution"] = metric.storageResolution  # type: ignore
+                if metric.storageResolution == StorageResolution.HIGH:
+                    metricBody["StorageResolution"] = metric.storageResolution.value  # type: ignore
                 if not config.disable_metric_extraction:
                     current_body["_aws"]["CloudWatchMetrics"][0]["Metrics"].append(metricBody)
                 num_metrics_in_current_body += 1

aws_embedded_metrics/validator.py

@@ -58,7 +58,7 @@ def validate_dimension_set(dimension_set: Dict[str, str]) -> None:
             raise InvalidDimensionError("Dimension name cannot start with ':'")
 
 
-def validate_metric(name: str, value: float, unit: Optional[str], storageResolution: Optional[int], metricNameAndResolutionMap: dict) -> None:  # noqa: E501
+def validate_metric(name: str, value: float, unit: Optional[str], storageResolution: StorageResolution, metricNameAndResolutionMap: dict) -> None:  # noqa: E501
     """
     Validates a metric
 
@@ -90,7 +90,7 @@ def validate_metric(name: str, value: float, unit: Optional[str], storageResolut
     if metricNameAndResolutionMap and name in metricNameAndResolutionMap:
         if metricNameAndResolutionMap.get(name) is not storageResolution:
             raise InvalidMetricError(
-                f"Resolution for metrics ${name} is already set. A single log event cannot have a metric with two different resolutions.")
+                "Resolution for metrics ${name} is already set. A single log event cannot have a metric with two different resolutions.")
 
 
 def validate_namespace(namespace: str) -> None:

examples/ec2/app.py

@@ -1,4 +1,5 @@
 from aws_embedded_metrics import metric_scope
+from aws_embedded_metrics.storageResolution import StorageResolution
 
 import logging
 
@@ -10,7 +11,7 @@
 def my_handler(metrics):
     metrics.put_dimensions({"Foo": "Bar"})
     metrics.put_metric("ProcessingLatency", 100, "Milliseconds")
-    metrics.put_metric("CPU Utilization", 87, "Percent", 1)
+    metrics.put_metric("CPU Utilization", 87, "Percent", StorageResolution.HIGH)
     metrics.set_property("AccountId", "123456789012")
     metrics.set_property("RequestId", "422b1569-16f6-4a03-b8f0-fe3fd9b100f8")
     metrics.set_property("DeviceId", "61270781-c6ac-46f1-baf7-22c808af8162")

examples/lambda/function.py

@@ -1,11 +1,12 @@
 from aws_embedded_metrics import metric_scope
+from aws_embedded_metrics.storageResolution import StorageResolution
 
 
 @metric_scope
 def my_handler(event, context, metrics):
     metrics.put_dimensions({"Foo": "Bar"})
     metrics.put_metric("ProcessingLatency", 100, "Milliseconds")
-    metrics.put_metric("CPU Utilization", 87, "Percent", 1)
+    metrics.put_metric("CPU Utilization", 87, "Percent", StorageResolution.HIGH)
     metrics.set_property("AccountId", "123456789012")
     metrics.set_property("RequestId", "422b1569-16f6-4a03-b8f0-fe3fd9b100f8")
     metrics.set_property("DeviceId", "61270781-c6ac-46f1-baf7-22c808af8162")

tests/canary/agent/canary.py

@@ -2,6 +2,7 @@
 import aws_embedded_metrics
 from aws_embedded_metrics import metric_scope
 from aws_embedded_metrics.config import get_config
+from aws_embedded_metrics.storageResolution import StorageResolution
 from getversion import get_module_version
 import os
 import psutil
@@ -26,7 +27,7 @@ async def app(init, last_run_duration, metrics):
     metrics.set_dimensions({"Runtime": 'Python', "Platform": 'ECS', "Agent": 'CloudWatchAgent', "Version": version})
     metrics.put_metric('Invoke', 1, "Count")
     metrics.put_metric('Duration', last_run_duration, 'Seconds')
-    metrics.put_metric('Memory.RSS', process.memory_info().rss, 'Bytes', 1)
+    metrics.put_metric('Memory.RSS', process.memory_info().rss, 'Bytes', StorageResolution.HIGH)
 
 
 async def main():

tests/integ/agent/test_end_to_end.py

@@ -1,5 +1,6 @@
 from aws_embedded_metrics.config import get_config
 from aws_embedded_metrics import metric_scope
+from aws_embedded_metrics.storageResolution import StorageResolution
 import pytest
 import boto3
 import logging
@@ -40,7 +41,7 @@ async def test_end_to_end_tcp_multiple_flushes():
     @metric_scope
     async def do_work(metrics):
         metrics.put_dimensions({"Operation": "Agent"})
-        metrics.put_metric(metric_name, 100, "Milliseconds")
+        metrics.put_metric(metric_name, 100, "Milliseconds", StorageResolution.HIGH)
         metrics.set_property("RequestId", "422b1569-16f6-4a03-b8f0-fe3fd9b100f8")
 
     # act
@@ -70,7 +71,7 @@ async def test_end_to_end_udp():
     @metric_scope
     async def do_work(metrics):
         metrics.put_dimensions({"Operation": "Agent"})
-        metrics.put_metric(metric_name, 100, "Milliseconds")
+        metrics.put_metric(metric_name, 100, "Milliseconds", StorageResolution.HIGH)
         metrics.set_property("RequestId", "422b1569-16f6-4a03-b8f0-fe3fd9b100f8")
 
     # act

tests/logger/test_metrics_context.py

@@ -290,7 +290,7 @@ def test_put_metric_uses_none_unit_if_not_provided():
     assert metric.unit == "None"
 
 
-def test_put_metric_uses_60_storage_resolution_if_not_provided():
+def test_put_metric_uses_standard_storage_resolution_if_not_provided():
     # arrange
     context = MetricsContext()
     metric_key = fake.word()
@@ -301,22 +301,22 @@ def test_put_metric_uses_60_storage_resolution_if_not_provided():
 
     # assert
     metric = context.metrics[metric_key]
-    assert metric.storageResolution == 60
+    assert metric.storageResolution == StorageResolution.STANDARD
 
 
 @pytest.mark.parametrize(
     "name, value, unit, storageResolution",
     [
-        ("", 1, "None", 60),
-        (" ", 1, "Seconds", 60),
-        ("a" * (constants.MAX_METRIC_NAME_LENGTH + 1), 1, "None", 60),
-        ("metric", float("inf"), "Count", 60),
-        ("metric", float("-inf"), "Count", 60),
-        ("metric", float("nan"), "Count", 60),
-        ("metric", math.inf, "Seconds", 60),
-        ("metric", -math.inf, "Seconds", 60),
-        ("metric", math.nan, "Seconds", 60),
-        ("metric", 1, "Kilometers/Fahrenheit", 60),
+        ("", 1, "None", StorageResolution.STANDARD),
+        (" ", 1, "Seconds", StorageResolution.STANDARD),
+        ("a" * (constants.MAX_METRIC_NAME_LENGTH + 1), 1, "None", StorageResolution.STANDARD),
+        ("metric", float("inf"), "Count", StorageResolution.STANDARD),
+        ("metric", float("-inf"), "Count", StorageResolution.STANDARD),
+        ("metric", float("nan"), "Count", StorageResolution.STANDARD),
+        ("metric", math.inf, "Seconds", StorageResolution.STANDARD),
+        ("metric", -math.inf, "Seconds", StorageResolution.STANDARD),
+        ("metric", math.nan, "Seconds", StorageResolution.STANDARD),
+        ("metric", 1, "Kilometers/Fahrenheit", StorageResolution.STANDARD),
         ("metric", 1, "Seconds", 2),
         ("metric", 1, "Seconds", None)
     ]

tests/logger/test_metrics_logger.py

@@ -3,6 +3,7 @@
 from aws_embedded_metrics.sinks import Sink
 from aws_embedded_metrics.environment import Environment
 from aws_embedded_metrics.exceptions import InvalidNamespaceError, InvalidMetricError
+from aws_embedded_metrics.storageResolution import StorageResolution
 import aws_embedded_metrics.constants as constants
 import pytest
 from faker import Faker
@@ -58,7 +59,7 @@ async def test_can_put_metric_with_different_storage_resolution_different_flush(
     # arrange
     expected_key = fake.word()
     expected_value = fake.random.randrange(100)
-    metric_storageResolution = 1
+    metric_storageResolution = StorageResolution.HIGH
 
     logger, sink, env = get_logger_and_sink(mocker)
 
@@ -79,7 +80,7 @@ async def test_can_put_metric_with_different_storage_resolution_different_flush(
     context = sink.accept.call_args[0][0]
     assert context.metrics[expected_key].values == [expected_value]
     assert context.metrics[expected_key].unit == "None"
-    assert context.metrics[expected_key].storageResolution == 60
+    assert context.metrics[expected_key].storageResolution == StorageResolution.STANDARD
 
 
 @pytest.mark.asyncio
@@ -91,9 +92,9 @@ async def test_cannot_put_metric_with_different_storage_resolution_same_flush(mo
     logger, sink, env = get_logger_and_sink(mocker)
 
     # act
-    logger.put_metric(expected_key, expected_value, None, 1)
+    logger.put_metric(expected_key, expected_value, None, StorageResolution.HIGH)
     with pytest.raises(InvalidMetricError):
-        logger.put_metric(expected_key, expected_value, None, 60)
+        logger.put_metric(expected_key, expected_value, None, StorageResolution.STANDARD)
         await logger.flush()
 
 

tests/serializer/test_log_serializer.py

@@ -2,6 +2,7 @@
 from aws_embedded_metrics.exceptions import DimensionSetExceededError
 from aws_embedded_metrics.logger.metrics_context import MetricsContext
 from aws_embedded_metrics.serializers.log_serializer import LogSerializer
+from aws_embedded_metrics.storageResolution import StorageResolution
 from collections import Counter
 from faker import Faker
 import json
@@ -92,7 +93,30 @@ def test_serialize_metrics():
     assert_json_equality(result_json, expected)
 
 
-def test_serialize_metrics_with_storageResolution():
+def test_serialize_metrics_with_Standard_storageResolution():
+    # arrange
+    expected_key = fake.word()
+    expected_value = fake.random.randrange(0, 100)
+
+    expected_metric_definition = {"Name": expected_key, "Unit": "None"}
+
+    expected = {**get_empty_payload()}
+    expected[expected_key] = expected_value
+    expected["_aws"]["CloudWatchMetrics"][0]["Metrics"].append(
+        expected_metric_definition
+    )
+
+    context = get_context()
+    context.put_metric(expected_key, expected_value, "None", StorageResolution.STANDARD)
+
+    # act
+    result_json = serializer.serialize(context)[0]
+
+    # assert
+    assert_json_equality(result_json, expected)
+
+
+def test_serialize_metrics_with_High_storageResolution():
     # arrange
     expected_key = fake.word()
     expected_value = fake.random.randrange(0, 100)
@@ -106,7 +130,7 @@ def test_serialize_metrics_with_storageResolution():
     )
 
     context = get_context()
-    context.put_metric(expected_key, expected_value, "None", 1)
+    context.put_metric(expected_key, expected_value, "None", StorageResolution.HIGH)
 
     # act
     result_json = serializer.serialize(context)[0]