add disable to flush

Author: anafalcao

aws_lambda_powertools/metrics/functions.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import logging
+import os
 from datetime import datetime
 
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.exceptions import (
@@ -8,6 +10,9 @@
 )
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.metric_properties import MetricResolution, MetricUnit
 from aws_lambda_powertools.shared import constants
+from aws_lambda_powertools.shared.functions import resolve_truthy_env_var_choice
+
+logger = logging.getLogger(__name__)
 
 
 def extract_cloudwatch_metric_resolution_value(metric_resolutions: list, resolution: int | MetricResolution) -> int:
@@ -134,3 +139,27 @@ def convert_timestamp_to_emf_format(timestamp: int | datetime) -> int:
         # Returning zero represents the initial date of epoch time,
         # which will be skipped by Amazon CloudWatch.
         return 0
+
+
+def is_metrics_disabled() -> bool:
+    """Checks if metrics have been disabled via POWERTOOLS_METRICS_DISABLED or POWERTOOLS_DEV
+
+    Returns:
+        bool: True if metrics are disabled, False otherwise
+    """
+    # First check POWERTOOLS_METRICS_DISABLED as it should take precedence
+    if constants.METRICS_DISABLED_ENV in os.environ:
+        env_value = os.getenv(constants.METRICS_DISABLED_ENV)
+        is_disabled = resolve_truthy_env_var_choice(env=env_value or "false")
+        if is_disabled:
+            logger.debug("Metrics have been disabled via env var POWERTOOLS_METRICS_DISABLED")
+        return bool(is_disabled)
+
+    # Then check if POWERTOOLS_DEV is enabled
+    dev_mode_value = os.getenv(constants.POWERTOOLS_DEV_ENV)
+    dev_mode = resolve_truthy_env_var_choice(env=dev_mode_value or "false")
+    if dev_mode:
+        logger.debug("Metrics have been disabled via env var POWERTOOLS_DEV")
+        return True
+
+    return False

aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py

@@ -15,13 +15,14 @@
     convert_timestamp_to_emf_format,
     extract_cloudwatch_metric_resolution_value,
     extract_cloudwatch_metric_unit_value,
+    is_metrics_disabled,
     validate_emf_timestamp,
 )
 from aws_lambda_powertools.metrics.provider.base import BaseProvider
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.constants import MAX_DIMENSIONS, MAX_METRICS
 from aws_lambda_powertools.metrics.provider.cloudwatch_emf.metric_properties import MetricResolution, MetricUnit
 from aws_lambda_powertools.shared import constants
-from aws_lambda_powertools.shared.functions import resolve_env_var_choice, resolve_truthy_env_var_choice
+from aws_lambda_powertools.shared.functions import resolve_env_var_choice
 from aws_lambda_powertools.warnings import PowertoolsUserWarning
 
 if TYPE_CHECKING:
@@ -77,7 +78,7 @@ def __init__(
         self.default_dimensions = default_dimensions or {}
         self.namespace = resolve_env_var_choice(choice=namespace, env=os.getenv(constants.METRICS_NAMESPACE_ENV))
         self.service = resolve_env_var_choice(choice=service, env=os.getenv(constants.SERVICE_NAME_ENV))
-        self.metrics_disabled = self.is_metrics_disabled()
+        self.metrics_disabled = is_metrics_disabled()
 
         self.metadata_set = metadata_set if metadata_set is not None else {}
         self.timestamp: int | None = None
@@ -88,25 +89,7 @@ def __init__(
 
         self.dimension_set.update(**self.default_dimensions)
 
-    @staticmethod
-    def is_metrics_disabled() -> bool:
-        """Checks if metrics have been disabled via POWERTOOLS_METRICS_DISABLED or POWERTOOLS_DEV"""
-        # First check POWERTOOLS_METRICS_DISABLED
-        if constants.METRICS_DISABLED_ENV in os.environ:
-            env_value = os.getenv(constants.METRICS_DISABLED_ENV)
-            is_disabled = resolve_truthy_env_var_choice(env=env_value or "false")
-            if is_disabled:
-                logger.debug("Metrics have been disabled via env var POWERTOOLS_METRICS_DISABLED")
-            return bool(is_disabled)
-
-        # Then check if POWERTOOLS_DEV is enabled
-        dev_mode_value = os.getenv(constants.POWERTOOLS_DEV_ENV)
-        dev_mode = resolve_truthy_env_var_choice(env=dev_mode_value or "false")
-        if dev_mode:
-            logger.debug("Metrics have been disabled via env var POWERTOOLS_DEV")
-            return True
-
-        return False
+        logger.info("im here")
 
     def add_metric(
         self,
@@ -398,7 +381,7 @@ def flush_metrics(self, raise_on_empty_metrics: bool = False) -> None:
                 "If application metrics should never be empty, consider using 'raise_on_empty_metrics'",
                 stacklevel=2,
             )
-        else:
+        elif not self.metrics_disabled:
             logger.debug("Flushing existing metrics")
             metrics = self.serialize_metric_set()
             print(json.dumps(metrics, separators=(",", ":")))

aws_lambda_powertools/metrics/provider/datadog/datadog.py

@@ -10,10 +10,11 @@
 from typing import TYPE_CHECKING, Any
 
 from aws_lambda_powertools.metrics.exceptions import MetricValueError, SchemaValidationError
+from aws_lambda_powertools.metrics.functions import is_metrics_disabled
 from aws_lambda_powertools.metrics.provider import BaseProvider
 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, resolve_truthy_env_var_choice
+from aws_lambda_powertools.shared.functions import resolve_env_var_choice
 
 if TYPE_CHECKING:
     from aws_lambda_powertools.shared.types import AnyCallableT
@@ -65,27 +66,7 @@ def __init__(
         )
         self.default_tags = default_tags or {}
         self.flush_to_log = resolve_env_var_choice(choice=flush_to_log, env=os.getenv(constants.DATADOG_FLUSH_TO_LOG))
-        self.metrics_disabled = self.is_metrics_disabled()
-
-    @staticmethod
-    def is_metrics_disabled() -> bool:
-        """Checks if metrics have been disabled via POWERTOOLS_METRICS_DISABLED or POWERTOOLS_DEV"""
-        # First check if POWERTOOLS_DEV is enabled
-        dev_mode_value = os.getenv(constants.POWERTOOLS_DEV_ENV)
-        dev_mode = resolve_truthy_env_var_choice(env=dev_mode_value or "false")
-        if dev_mode:
-            logger.debug("Metrics have been disabled via env var POWERTOOLS_DEV")
-            return True
-
-        # Then check POWERTOOLS_METRICS_DISABLED
-        if constants.METRICS_DISABLED_ENV not in os.environ:
-            return False
-
-        env_value = os.getenv(constants.METRICS_DISABLED_ENV)
-        is_disabled = resolve_truthy_env_var_choice(env=env_value or "false")
-        if is_disabled:
-            logger.debug("Metrics have been disabled via env var POWERTOOLS_METRICS_DISABLED")
-        return bool(is_disabled)
+        self.metrics_disabled = is_metrics_disabled()
 
     #  adding name,value,timestamp,tags
     def add_metric(
@@ -221,7 +202,7 @@ def flush_metrics(self, raise_on_empty_metrics: bool = False) -> None:
                         timestamp=metric_item["e"],
                         tags=metric_item["t"],
                     )
-            else:
+            elif not self.metrics_disabled:
                 # dd module not found: flush to log, this format can be recognized via datadog log forwarder
                 # https://github.com/Datadog/datadog-lambda-python/blob/main/datadog_lambda/metric.py#L77
                 for metric_item in metrics:

tests/functional/metrics/datadog/test_metrics_datadog.py

@@ -336,49 +336,68 @@ def test_namespace_env_var(monkeypatch):
     assert output[0]["m"] == f"{env_namespace}.item_sold"
 
 
-def test_metrics_disabled_with_env_var(monkeypatch):
+def test_metrics_disabled_with_env_var(monkeypatch, capsys):
     # GIVEN environment variable is set to disable metrics
     monkeypatch.setenv("POWERTOOLS_METRICS_DISABLED", "true")
 
     # WHEN metrics is initialized and adding metrics
     metrics = DatadogMetrics()
     metrics.add_metric(name="test_metric", value=1)
+    metrics.flush_metrics()
 
-    # WHEN flushing metrics
-    metrics_output = metrics.flush_metrics()
-
-    # THEN metrics output should be empty
-    assert metrics_output is None
+    # THEN no metrics should have been recorded
+    captured = capsys.readouterr()
+    assert not captured.out
 
 
-def test_metrics_disabled_persists_after_flush(monkeypatch):
+def test_metrics_disabled_persists_after_flush(monkeypatch, capsys):
     # GIVEN environment variable is set to disable metrics
     monkeypatch.setenv("POWERTOOLS_METRICS_DISABLED", "true")
     metrics = DatadogMetrics()
 
     # WHEN multiple operations are performed with flush in between
-    metrics.add_metric(name="metric1", unit="Count", value=1)
-    first_flush = metrics.flush_metrics()
+    metrics.add_metric(name="metric1", value=1)
+    metrics.flush_metrics()
+
+    # THEN first flush should not emit any metrics
+    captured = capsys.readouterr()
+    assert not captured.out
 
-    metrics.add_metric(name="metric2", unit="Count", value=2)
-    second_flush = metrics.flush_metrics()
+    # WHEN adding and flushing more metrics
+    metrics.add_metric(name="metric2", value=2)
+    metrics.flush_metrics()
 
-    # THEN all flush operations should return None
-    assert first_flush is None
-    assert second_flush is None
+    # THEN second flush should also not emit any metrics
+    captured = capsys.readouterr()
+    assert not captured.out
 
 
-def test_metrics_disabled_with_namespace(monkeypatch):
+def test_metrics_disabled_with_namespace(monkeypatch, capsys):
     # GIVEN environment variable is set to disable metrics
     monkeypatch.setenv("POWERTOOLS_METRICS_DISABLED", "true")
 
     # WHEN metrics is initialized with namespace and service
     metrics = DatadogMetrics(namespace="test_namespace")
     metrics.add_metric(name="test_metric", value=1)
-    metrics_output = metrics.flush_metrics()
+    metrics.flush_metrics()
+
+    # THEN no metrics should have been recorded
+    captured = capsys.readouterr()
+    assert not captured.out
+
+
+def test_metrics_disabled_with_dev_mode_true(monkeypatch, capsys):
+    # GIVEN dev mode is enabled
+    monkeypatch.setenv("POWERTOOLS_DEV", "true")
+
+    # WHEN metrics is initialized
+    metrics = DatadogMetrics(namespace="test")
+    metrics.add_metric(name="test_metric", value=1)
+    metrics.flush_metrics()
 
-    # THEN metrics should still be disabled
-    assert metrics_output is None
+    # THEN no metrics should have been recorded
+    captured = capsys.readouterr()
+    assert not captured.out
 
 
 def test_metrics_enabled_with_env_var_false(monkeypatch, capsys):
@@ -413,21 +432,6 @@ def test_metrics_enabled_with_env_var_not_set(monkeypatch, capsys):
     assert "test.test_metric" in metrics_output["m"]
 
 
-def test_metrics_disabled_with_dev_mode_true(monkeypatch, capsys):
-    # GIVEN dev mode is enabled
-    monkeypatch.setenv("POWERTOOLS_DEV", "true")
-
-    # WHEN metrics is initialized
-    metrics = DatadogMetrics(namespace="test")
-    metrics.add_metric(name="test_metric", value=1)
-
-    # AND flushing metrics
-    metrics_output = metrics.flush_metrics()
-
-    # THEN metrics output should be empty
-    assert metrics_output is None
-
-
 def test_metrics_enabled_with_dev_mode_false(monkeypatch, capsys):
     # GIVEN dev mode is disabled
     monkeypatch.setenv("POWERTOOLS_DEV", "false")
@@ -453,10 +457,12 @@ def test_metrics_disabled_dev_mode_overrides_metrics_disabled(monkeypatch, capsy
     metrics.add_metric(name="test_metric", value=1)
     metrics.flush_metrics()
 
-    # THEN metrics should be written to stdout (POWERTOOLS_METRICS_DISABLED takes precedence)
+    # THEN metrics should be written to stdout since POWERTOOLS_METRICS_DISABLED is false
     output = capsys.readouterr().out
+    assert output  # First verify we have output
     metrics_output = json.loads(output)
-    assert metrics_output
+    assert metrics_output  # Then verify it's valid JSON
+    assert "test.test_metric" in metrics_output["m"]  # Verify the metric is present
 
 
 def test_metrics_enabled_with_both_false(monkeypatch, capsys):
@@ -475,18 +481,16 @@ def test_metrics_enabled_with_both_false(monkeypatch, capsys):
     assert metrics_output
 
 
-def test_metrics_disabled_with_dev_mode_false_and_metrics_disabled_true(monkeypatch):
+def test_metrics_disabled_with_dev_mode_false_and_metrics_disabled_true(monkeypatch, capsys):
     # GIVEN dev mode is false but metrics disabled is true
     monkeypatch.setenv("POWERTOOLS_DEV", "false")
     monkeypatch.setenv("POWERTOOLS_METRICS_DISABLED", "true")
 
     # WHEN metrics is initialized
     metrics = DatadogMetrics(namespace="test")
-
     metrics.add_metric(name="test_metric", value=1)
+    metrics.flush_metrics()
 
-    # WHEN flushing metrics
-    metrics_output = metrics.flush_metrics()
-
-    # THEN metrics output should be empty
-    assert metrics_output is None
+    # THEN no metrics should have been recorded
+    captured = capsys.readouterr()
+    assert not captured.out