From cb41d34ea527df1b147841ccc5b20babd43075d8 Mon Sep 17 00:00:00 2001 From: dhairyakhandelwal880-dotcom Date: Sun, 15 Nov 2026 15:59:51 +0530 Subject: [PATCH 1/2] fix(metrics): reject non-finite metric values with warning (#8796) Signed-off-by: dhairyakhandelwal880-dotcom --- aws_lambda_powertools/metrics/base.py | 11 +++++ .../provider/cloudwatch_emf/cloudwatch.py | 10 +++++ .../metrics/provider/datadog/datadog.py | 11 +++++ .../metrics/datadog/test_metrics_datadog.py | 18 ++++++++ .../test_metrics_cloudwatch_emf.py | 42 +++++++++++++++++++ 5 files changed, 92 insertions(+) diff --git a/aws_lambda_powertools/metrics/base.py b/aws_lambda_powertools/metrics/base.py index 05c1fcbdfe9..18b36e73ca4 100644 --- a/aws_lambda_powertools/metrics/base.py +++ b/aws_lambda_powertools/metrics/base.py @@ -10,6 +10,7 @@ import functools import json import logging +import math import numbers import os import warnings @@ -38,6 +39,7 @@ ) from aws_lambda_powertools.shared import constants from aws_lambda_powertools.shared.functions import is_durable_context, resolve_env_var_choice +from aws_lambda_powertools.warnings import PowertoolsUserWarning if TYPE_CHECKING: from collections.abc import Callable, Generator @@ -150,6 +152,15 @@ def add_metric( if not isinstance(value, numbers.Number): raise MetricValueError(f"{value} is not a valid number") + if not math.isfinite(float(value)): + warnings.warn( + f"Skipping metric {name}: value {value} is not finite. " + "Metric values must be finite numbers; NaN and Infinity break CloudWatch EMF JSON.", + category=PowertoolsUserWarning, + stacklevel=2, + ) + return + unit = self._extract_metric_unit_value(unit=unit) resolution = self._extract_metric_resolution_value(resolution=resolution) metric: dict = self.metric_set.get(name, defaultdict(list)) diff --git a/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py b/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py index f8675018a24..a3360c188a8 100644 --- a/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py +++ b/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py @@ -3,6 +3,7 @@ import datetime as dt import json import logging +import math import numbers import os import warnings @@ -156,6 +157,15 @@ def add_metric( if not isinstance(value, numbers.Number): raise MetricValueError(f"{value} is not a valid number") + if not math.isfinite(float(value)): + warnings.warn( + f"Skipping metric {name}: value {value} is not finite. " + "Metric values must be finite numbers; NaN and Infinity break CloudWatch EMF JSON.", + category=PowertoolsUserWarning, + stacklevel=2, + ) + return + unit = extract_cloudwatch_metric_unit_value( metric_units=self._metric_units, metric_valid_options=self._metric_unit_valid_options, diff --git a/aws_lambda_powertools/metrics/provider/datadog/datadog.py b/aws_lambda_powertools/metrics/provider/datadog/datadog.py index ca6fca8a69a..f05259927aa 100644 --- a/aws_lambda_powertools/metrics/provider/datadog/datadog.py +++ b/aws_lambda_powertools/metrics/provider/datadog/datadog.py @@ -2,6 +2,7 @@ import json import logging +import math import numbers import os import re @@ -15,6 +16,7 @@ from aws_lambda_powertools.metrics.provider.datadog.warnings import DatadogDataValidationWarning from aws_lambda_powertools.shared import constants from aws_lambda_powertools.shared.functions import resolve_env_var_choice, strtobool +from aws_lambda_powertools.warnings import PowertoolsUserWarning if TYPE_CHECKING: from aws_lambda_powertools.shared.types import AnyCallableT @@ -119,6 +121,15 @@ def add_metric( if not isinstance(value, numbers.Real): raise MetricValueError(f"{value} is not a valid number") + if not math.isfinite(float(value)): + warnings.warn( + f"Skipping metric {name}: value {value} is not finite. " + "Metric values must be finite numbers; NaN and Infinity are not supported by Datadog.", + category=PowertoolsUserWarning, + stacklevel=2, + ) + return + if not timestamp: timestamp = int(time.time()) diff --git a/tests/functional/metrics/datadog/test_metrics_datadog.py b/tests/functional/metrics/datadog/test_metrics_datadog.py index b07af997e4e..872ff93b9ac 100644 --- a/tests/functional/metrics/datadog/test_metrics_datadog.py +++ b/tests/functional/metrics/datadog/test_metrics_datadog.py @@ -9,6 +9,7 @@ from aws_lambda_powertools.metrics.exceptions import MetricValueError, SchemaValidationError from aws_lambda_powertools.metrics.provider.cold_start import reset_cold_start_flag from aws_lambda_powertools.metrics.provider.datadog import DatadogMetrics, DatadogProvider +from aws_lambda_powertools.warnings import PowertoolsUserWarning def test_datadog_coldstart(capsys): @@ -125,6 +126,23 @@ def test_datadog_with_invalid_metric_value(): metrics.add_metric(name="item_sold", value="a", product="latte", order="online") +@pytest.mark.parametrize("non_finite_value", [float("nan"), float("inf"), float("-inf")]) +def test_datadog_with_non_finite_metric_value_warns_and_skips(non_finite_value): + # GIVEN DatadogMetrics is initialized with a fresh provider + provider = DatadogProvider(flush_to_log=True) + metrics = DatadogMetrics(provider=provider) + + # WHEN we add a valid metric and a non-finite metric + metrics.add_metric(name="valid_item", value=1, product="latte") + with pytest.warns(PowertoolsUserWarning, match="is not finite"): + metrics.add_metric(name="bad_item", value=non_finite_value, product="latte") + + # THEN the non-finite metric is skipped and only the valid metric remains in provider + metric_names = [m["m"] for m in provider.metric_set] + assert "valid_item" in metric_names + assert "bad_item" not in metric_names + + def test_datadog_with_invalid_metric_name(): # GIVEN DatadogMetrics is initialized metrics = DatadogMetrics() diff --git a/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py b/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py index 9d6c2cc8ee5..2433c63276d 100644 --- a/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py +++ b/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py @@ -29,6 +29,7 @@ MIN_METRIC_NAME_LENGTH, ) from aws_lambda_powertools.metrics.provider.cloudwatch_emf.exceptions import MetricNameError +from aws_lambda_powertools.warnings import PowertoolsUserWarning if TYPE_CHECKING: from aws_lambda_powertools.metrics.provider.cloudwatch_emf.types import ( @@ -490,6 +491,47 @@ def test_schema_validation_incorrect_metric_value(metric, dimension, namespace): pass +@pytest.mark.parametrize("non_finite_value", [float("nan"), float("inf"), float("-inf")]) +def test_non_finite_metric_value_warns_and_skips(namespace, non_finite_value): + # GIVEN Metrics is initialized and a non-finite value is used + my_metrics = Metrics(service="test_service", namespace=namespace) + + # WHEN we add a valid metric and a non-finite metric + my_metrics.add_metric(name="ValidMetric", unit=MetricUnit.Count, value=1) + with pytest.warns(PowertoolsUserWarning, match="is not finite"): + my_metrics.add_metric(name="BadMetric", unit=MetricUnit.Count, value=non_finite_value) + + # THEN the non-finite metric is skipped and only the valid metric remains + assert "ValidMetric" in my_metrics.metric_set + assert "BadMetric" not in my_metrics.metric_set + + +@pytest.mark.parametrize("non_finite_value", [float("nan"), float("inf"), float("-inf")]) +def test_non_finite_metric_value_emf_provider_warns_and_skips(namespace, non_finite_value): + # GIVEN AmazonCloudWatchEMFProvider is initialized + provider = AmazonCloudWatchEMFProvider(namespace=namespace, service="test_service") + + # WHEN we add a valid metric and a non-finite metric + provider.add_metric(name="ValidMetric", unit=MetricUnit.Count, value=1) + with pytest.warns(PowertoolsUserWarning, match="is not finite"): + provider.add_metric(name="BadMetric", unit=MetricUnit.Count, value=non_finite_value) + + # THEN the non-finite metric is skipped and only the valid metric remains + assert "ValidMetric" in provider.metric_set + assert "BadMetric" not in provider.metric_set + + +@pytest.mark.parametrize("non_finite_value", [float("nan"), float("inf"), float("-inf")]) +def test_non_finite_single_metric_warns_and_skips(namespace, non_finite_value, capsys): + # GIVEN single_metric context manager with a non-finite value + # WHEN we create a single metric with a non-finite value + # THEN it should warn and skip the metric, resulting in SchemaValidationError on flush + with pytest.warns(PowertoolsUserWarning, match="is not finite"): + with pytest.raises(SchemaValidationError, match="Must contain at least one metric."): + with single_metric(name="BadMetric", unit=MetricUnit.Count, value=non_finite_value, namespace=namespace): + pass + + def test_schema_no_metrics(service, namespace): # GIVEN Metrics is initialized my_metrics = Metrics(service=service, namespace=namespace) From 16d2a51d1d833379fa01f74e8d20673ebe9b1dac Mon Sep 17 00:00:00 2001 From: dhairyakhandelwal880-dotcom Date: Sun, 15 Nov 2026 16:03:14 +0530 Subject: [PATCH 2/2] test(metrics): refactor single_metric non-finite test to avoid nested assertions Signed-off-by: dhairyakhandelwal880-dotcom --- .../test_metrics_cloudwatch_emf.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py b/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py index 2433c63276d..608db02c32f 100644 --- a/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py +++ b/tests/functional/metrics/required_dependencies/test_metrics_cloudwatch_emf.py @@ -522,14 +522,16 @@ def test_non_finite_metric_value_emf_provider_warns_and_skips(namespace, non_fin @pytest.mark.parametrize("non_finite_value", [float("nan"), float("inf"), float("-inf")]) -def test_non_finite_single_metric_warns_and_skips(namespace, non_finite_value, capsys): - # GIVEN single_metric context manager with a non-finite value - # WHEN we create a single metric with a non-finite value - # THEN it should warn and skip the metric, resulting in SchemaValidationError on flush +def test_non_finite_single_metric_warns_and_skips(namespace, non_finite_value): + # GIVEN SingleMetric instance with a non-finite value + metric = SingleMetric(namespace=namespace) + + # WHEN we add a metric with a non-finite value + # THEN it should warn and skip the metric with pytest.warns(PowertoolsUserWarning, match="is not finite"): - with pytest.raises(SchemaValidationError, match="Must contain at least one metric."): - with single_metric(name="BadMetric", unit=MetricUnit.Count, value=non_finite_value, namespace=namespace): - pass + metric.add_metric(name="BadMetric", unit=MetricUnit.Count, value=non_finite_value) + + assert "BadMetric" not in metric.metric_set def test_schema_no_metrics(service, namespace):