rename storageResolution as per naming convention

Author: Meshwa Savalia

README.md

@@ -39,7 +39,8 @@ from aws_embedded_metrics import metric_scope
 @metric_scope
 def my_handler(metrics):
     metrics.put_dimensions({"Foo": "Bar"})
-    metrics.put_metric("ProcessingLatency", 100, "Milliseconds", 60)
+    metrics.put_metric("ProcessingLatency", 100, "Milliseconds", StorageResolution.STANDARD)
+    metrics.put_metric("Memory.HeapUsed", 1600424.0, "Bytes", StorageResolution.HIGH)
     metrics.set_property("AccountId", "123456789012")
     metrics.set_property("RequestId", "422b1569-16f6-4a03")
     metrics.set_property("DeviceId", "61270781-c6ac-46f1")
@@ -53,7 +54,7 @@ def my_handler(metrics):
 
 The `MetricsLogger` is the interface you will use to publish embedded metrics.
 
-- **put_metric**(key: str, value: float, unit: str = "None", storageResolution: int = 60) -> MetricsLogger
+- **put_metric**(key: str, value: float, unit: str = "None", storage_resolution: int = 60) -> MetricsLogger
 
 Adds a new metric to the current logger context. Multiple metrics using the same key will be appended to an array of values. Multiple metrics cannot have same key and different storage resolution. The Embedded Metric Format supports a maximum of 100 values per key. If more metric values are added than are supported by the format, the logger will be flushed to allow for new metric values to be captured.
 
@@ -64,10 +65,18 @@ Requirements:
 - Values must be in the range of 8.515920e-109 to 1.174271e+108. In addition, special values (for example, NaN, +Infinity, -Infinity) are not supported.
 - Metrics must meet CloudWatch Metrics requirements, otherwise a `InvalidMetricError` will be thrown. See [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html) for valid values.
 
+- ##### Storage Resolution
+An OPTIONAL value representing the storage resolution for the corresponding metric. Setting this to `High` specifies this metric as a high-resolution metric, so that CloudWatch stores the metric with sub-minute resolution down to one second. Setting this to `Standard` specifies this metric as a standard-resolution metric, which CloudWatch stores at 1-minute resolution. If a value is not provided, then a default value of `Standard` is assumed. See [Cloud Watch High-Resolution metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#high-resolution-metrics)
+
 Examples:
 
 ```py
-put_metric("Latency", 200, "Milliseconds", 60)
+# Standard Resolution example
+put_metric("Latency", 200, "Milliseconds")
+put_metric("Latency", 201, "Milliseconds", StorageResolution.STANDARD)
+
+# High Resolution example
+put_metric("Memory.HeapUsed", 1600424.0, Unit.BYTES, StorageResolution.HIGH)
 ```
 
 - **set_property**(key: str, value: Any) -> MetricsLogger

aws_embedded_metrics/logger/metric.py

@@ -10,14 +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
+from aws_embedded_metrics.storage_resolution import StorageResolution
 
 
 class Metric(object):
-    def __init__(self, value: float, unit: str = None, storageResolution: StorageResolution = StorageResolution.STANDARD):
+    def __init__(self, value: float, unit: str = None, storage_resolution: StorageResolution = StorageResolution.STANDARD):
         self.values = [value]
         self.unit = unit or "None"
-        self.storageResolution = storageResolution or StorageResolution.STANDARD
+        self.storage_resolution = storage_resolution or StorageResolution.STANDARD
 
     def add_value(self, value: float) -> None:
         self.values.append(value)

aws_embedded_metrics/logger/metrics_context.py

@@ -16,7 +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 aws_embedded_metrics.storage_resolution import StorageResolution
 from typing import List, Dict, Any, Set
 
 
@@ -40,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, StorageResolution] = {}
+        self.metric_name_and_resolution_map: Dict[str, StorageResolution] = {}
 
-    def put_metric(self, key: str, value: float, unit: str = None, storageResolution: StorageResolution = StorageResolution.STANDARD) -> None:
+    def put_metric(self, key: str, value: float, unit: str = None, storage_resolution: StorageResolution = StorageResolution.STANDARD) -> None:
         """
         Adds a metric measurement to the context.
         Multiple calls using the same key will be stored as an
@@ -51,14 +51,14 @@ def put_metric(self, key: str, value: float, unit: str = None, storageResolution
         context.put_metric("Latency", 100, "Milliseconds")
         ```
         """
-        validate_metric(key, value, unit, storageResolution, self.metricNameAndResolutionMap)
+        validate_metric(key, value, unit, storage_resolution, self.metric_name_and_resolution_map)
         metric = self.metrics.get(key)
         if metric:
             # TODO: we should log a warning if the unit has been changed
             metric.add_value(value)
         else:
-            self.metrics[key] = Metric(value, unit, storageResolution)
-        self.metricNameAndResolutionMap[key] = storageResolution
+            self.metrics[key] = Metric(value, unit, storage_resolution)
+        self.metric_name_and_resolution_map[key] = storage_resolution
 
     def put_dimensions(self, dimension_set: Dict[str, str]) -> None:
         """

aws_embedded_metrics/logger/metrics_logger.py

@@ -15,7 +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 aws_embedded_metrics.storage_resolution import StorageResolution
 from typing import Any, Awaitable, Callable, Dict, Tuple
 import sys
 import traceback
@@ -80,9 +80,9 @@ def set_namespace(self, namespace: str) -> "MetricsLogger":
         return self
 
     def put_metric(
-        self, key: str, value: float, unit: str = "None", storageResolution: StorageResolution = StorageResolution.STANDARD
+        self, key: str, value: float, unit: str = "None", storage_resolution: StorageResolution = StorageResolution.STANDARD
     ) -> "MetricsLogger":
-        self.context.put_metric(key, value, unit, storageResolution)
+        self.context.put_metric(key, value, unit, storage_resolution)
         return self
 
     def add_stack_trace(self, key: str, details: Any = None, exc_info: Tuple = None) -> "MetricsLogger":

aws_embedded_metrics/serializers/log_serializer.py

@@ -18,7 +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
+from aws_embedded_metrics.storage_resolution import StorageResolution
 import json
 from typing import Any, Dict, List
 
@@ -88,11 +88,11 @@ def create_body() -> Dict[str, Any]:
                     if len(metric.values) > end_index:
                         remaining_data = True
 
-                metricBody = {"Name": metric_name, "Unit": metric.unit}
-                if metric.storageResolution == StorageResolution.HIGH:
-                    metricBody["StorageResolution"] = metric.storageResolution.value  # type: ignore
+                metric_body = {"Name": metric_name, "Unit": metric.unit}
+                if metric.storage_resolution == StorageResolution.HIGH:
+                    metric_body["StorageResolution"] = metric.storage_resolution.value  # type: ignore
                 if not config.disable_metric_extraction:
-                    current_body["_aws"]["CloudWatchMetrics"][0]["Metrics"].append(metricBody)
+                    current_body["_aws"]["CloudWatchMetrics"][0]["Metrics"].append(metric_body)
                 num_metrics_in_current_body += 1
 
                 if (num_metrics_in_current_body == MAX_METRICS_PER_EVENT):

aws_embedded_metrics/storageResolution.py renamed to aws_embedded_metrics/storage_resolution.py

@@ -15,7 +15,7 @@
 import re
 from typing import Dict, Optional
 from aws_embedded_metrics.unit import Unit
-from aws_embedded_metrics.storageResolution import StorageResolution
+from aws_embedded_metrics.storage_resolution import StorageResolution
 from aws_embedded_metrics.exceptions import DimensionSetExceededError, InvalidDimensionError, InvalidMetricError, InvalidNamespaceError
 import aws_embedded_metrics.constants as constants
 
@@ -58,16 +58,16 @@ 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: StorageResolution, metricNameAndResolutionMap: dict) -> None:  # noqa: E501
+def validate_metric(name: str, value: float, unit: Optional[str], storage_resolution: StorageResolution, metric_name_and_resolution_map: dict) -> None:  # noqa: E501
     """
     Validates a metric
 
         Parameters:
             name (str): The name of the metric
             value (float): The value of the metric
             unit (Optional[str]): The unit of the metric
-            storageResolution (Optional[int]): The storage resolution of metric
-            metricNameAndResolutionMap (dict): The map used for validating metric
+            storage_resolution (Optional[int]): The storage resolution of metric
+            metric_name_and_resolution_map (dict): The map used for validating metric
 
         Raises:
             InvalidMetricError: If the metric is invalid
@@ -84,12 +84,12 @@ def validate_metric(name: str, value: float, unit: Optional[str], storageResolut
     if unit is not None and unit not in Unit:
         raise InvalidMetricError(f"Metric unit is not valid: {unit}")
 
-    if storageResolution is None or storageResolution not in StorageResolution:
-        raise InvalidMetricError(f"Metric storage Resolution is not valid: {storageResolution}")
+    if storage_resolution is None or storage_resolution not in StorageResolution:
+        raise InvalidMetricError(f"Metric storage resolution is not valid: {storage_resolution}")
 
-    if name in metricNameAndResolutionMap and metricNameAndResolutionMap.get(name) is not storageResolution:
+    if name in metric_name_and_resolution_map and metric_name_and_resolution_map.get(name) is not storage_resolution:
         raise InvalidMetricError(
-            "Resolution for metrics ${name} is already set. A single log event cannot have a metric with two different resolutions.")
+            f"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:

aws_embedded_metrics/validator.py

@@ -1,5 +1,5 @@
 from aws_embedded_metrics import metric_scope
-from aws_embedded_metrics.storageResolution import StorageResolution
+from aws_embedded_metrics.storage_resolution import StorageResolution
 
 import logging
 

examples/ec2/app.py

@@ -1,5 +1,5 @@
 from aws_embedded_metrics import metric_scope
-from aws_embedded_metrics.storageResolution import StorageResolution
+from aws_embedded_metrics.storage_resolution import StorageResolution
 
 
 @metric_scope

examples/lambda/function.py

@@ -2,7 +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 aws_embedded_metrics.storage_resolution import StorageResolution
 from getversion import get_module_version
 import os
 import psutil

tests/canary/agent/canary.py

@@ -3,7 +3,7 @@
 import random
 from aws_embedded_metrics import constants
 from aws_embedded_metrics.unit import Unit
-from aws_embedded_metrics.storageResolution import StorageResolution
+from aws_embedded_metrics.storage_resolution import StorageResolution
 from aws_embedded_metrics import config
 from aws_embedded_metrics.logger.metrics_context import MetricsContext
 from aws_embedded_metrics.constants import DEFAULT_NAMESPACE
@@ -264,16 +264,16 @@ def test_put_metric_adds_metrics():
     metric_key = fake.word()
     metric_value = fake.random.random()
     metric_unit = random.choice(list(Unit)).value
-    metric_storageResolution = random.choice(list(StorageResolution)).value
+    metric_storage_resolution = random.choice(list(StorageResolution)).value
 
     # act
-    context.put_metric(metric_key, metric_value, metric_unit, metric_storageResolution)
+    context.put_metric(metric_key, metric_value, metric_unit, metric_storage_resolution)
 
     # assert
     metric = context.metrics[metric_key]
     assert metric.unit == metric_unit
     assert metric.values == [metric_value]
-    assert metric.storageResolution == metric_storageResolution
+    assert metric.storage_resolution == metric_storage_resolution
 
 
 def test_put_metric_uses_none_unit_if_not_provided():
@@ -301,11 +301,11 @@ def test_put_metric_uses_standard_storage_resolution_if_not_provided():
 
     # assert
     metric = context.metrics[metric_key]
-    assert metric.storageResolution == StorageResolution.STANDARD
+    assert metric.storage_resolution == StorageResolution.STANDARD
 
 
 @pytest.mark.parametrize(
-    "name, value, unit, storageResolution",
+    "name, value, unit, storage_resolution",
     [
         ("", 1, "None", StorageResolution.STANDARD),
         (" ", 1, "Seconds", StorageResolution.STANDARD),
@@ -322,11 +322,11 @@ def test_put_metric_uses_standard_storage_resolution_if_not_provided():
         ("metric", 1, "Seconds", None)
     ]
 )
-def test_put_invalid_metric_raises_exception(name, value, unit, storageResolution):
+def test_put_invalid_metric_raises_exception(name, value, unit, storage_resolution):
     context = MetricsContext()
 
     with pytest.raises(InvalidMetricError):
-        context.put_metric(name, value, unit, storageResolution)
+        context.put_metric(name, value, unit, storage_resolution)
 
 
 def test_create_copy_with_context_creates_new_instance():

tests/logger/test_metrics_context.py

@@ -3,7 +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
+from aws_embedded_metrics.storage_resolution import StorageResolution
 import aws_embedded_metrics.constants as constants
 import pytest
 from faker import Faker
@@ -59,19 +59,18 @@ 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 = StorageResolution.HIGH
 
     logger, sink, env = get_logger_and_sink(mocker)
 
     # act
-    logger.put_metric(expected_key, expected_value, None, metric_storageResolution)
+    logger.put_metric(expected_key, expected_value, None, StorageResolution.HIGH)
     await logger.flush()
 
     # assert
     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 == metric_storageResolution
+    assert context.metrics[expected_key].storage_resolution == StorageResolution.HIGH
 
     expected_key = fake.word()
     expected_value = fake.random.randrange(100)
@@ -80,7 +79,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 == StorageResolution.STANDARD
+    assert context.metrics[expected_key].storage_resolution == StorageResolution.STANDARD
 
 
 @pytest.mark.asyncio

tests/logger/test_metrics_logger.py

@@ -2,7 +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 aws_embedded_metrics.storage_resolution import StorageResolution
 from collections import Counter
 from faker import Faker
 import json
@@ -93,7 +93,7 @@ def test_serialize_metrics():
     assert_json_equality(result_json, expected)
 
 
-def test_serialize_metrics_with_Standard_storageResolution():
+def test_serialize_metrics_with_standard_storage_resolution():
     # arrange
     expected_key = fake.word()
     expected_value = fake.random.randrange(0, 100)
@@ -116,7 +116,7 @@ def test_serialize_metrics_with_Standard_storageResolution():
     assert_json_equality(result_json, expected)
 
 
-def test_serialize_metrics_with_High_storageResolution():
+def test_serialize_metrics_with_high_storage_resolution():
     # arrange
     expected_key = fake.word()
     expected_value = fake.random.randrange(0, 100)