datadog-checks-base 37.5.0__tar.gz → 37.6.0__tar.gz

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datadog-checks-base
-Version: 37.5.0
+Version: 37.6.0
 Summary: The Datadog Check Toolkit
 Project-URL: Source, https://github.com/DataDog/integrations-core
 Author-email: Datadog <packages@datadoghq.com>
@@ -13,16 +13,16 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
 Provides-Extra: db
-Requires-Dist: mmh3==5.0.1; extra == 'db'
+Requires-Dist: mmh3==5.1.0; extra == 'db'
 Provides-Extra: deps
 Requires-Dist: binary==1.0.1; extra == 'deps'
-Requires-Dist: cachetools==5.5.0; extra == 'deps'
+Requires-Dist: cachetools==5.5.1; extra == 'deps'
 Requires-Dist: cryptography==43.0.1; extra == 'deps'
 Requires-Dist: ddtrace==2.10.6; extra == 'deps'
 Requires-Dist: jellyfish==1.1.3; extra == 'deps'
 Requires-Dist: prometheus-client==0.21.1; extra == 'deps'
 Requires-Dist: protobuf==5.29.3; extra == 'deps'
-Requires-Dist: pydantic==2.10.5; extra == 'deps'
+Requires-Dist: pydantic==2.10.6; extra == 'deps'
 Requires-Dist: python-dateutil==2.9.0.post0; extra == 'deps'
 Requires-Dist: pywin32==308; (sys_platform == 'win32') and extra == 'deps'
 Requires-Dist: pyyaml==6.0.2; extra == 'deps'
@@ -34,7 +34,7 @@ Requires-Dist: uptime==3.0.1; extra == 'deps'
 Requires-Dist: wrapt==1.17.2; extra == 'deps'
 Provides-Extra: http
 Requires-Dist: aws-requests-auth==0.4.3; extra == 'http'
-Requires-Dist: botocore==1.36.1; extra == 'http'
+Requires-Dist: botocore==1.36.16; extra == 'http'
 Requires-Dist: oauthlib==3.2.2; extra == 'http'
 Requires-Dist: pyjwt==2.10.1; extra == 'http'
 Requires-Dist: pyopenssl==24.2.1; extra == 'http'
@@ -43,9 +43,9 @@ Requires-Dist: requests-kerberos==0.15.0; extra == 'http'
 Requires-Dist: requests-ntlm==1.3.0; extra == 'http'
 Requires-Dist: requests-oauthlib==2.0.0; extra == 'http'
 Provides-Extra: json
-Requires-Dist: orjson==3.10.14; extra == 'json'
+Requires-Dist: orjson==3.10.15; extra == 'json'
 Provides-Extra: kube
-Requires-Dist: kubernetes==31.0.0; extra == 'kube'
+Requires-Dist: kubernetes==32.0.0; extra == 'kube'
 Requires-Dist: requests-oauthlib==2.0.0; extra == 'kube'
 Description-Content-Type: text/markdown
 

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/datadog_checks/base/__about__.py

@@ -1,4 +1,4 @@
 # (C) Datadog, Inc. 2018-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-__version__ = "37.5.0"
+__version__ = "37.6.0"

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/datadog_checks/base/checks/base.py

@@ -164,6 +164,8 @@ class AgentCheck(object):
     # See https://github.com/DataDog/integrations-core/pull/2093 for more information.
     DEFAULT_METRIC_LIMIT = 0
 
+    HA_SUPPORTED = False
+
     # Allow tracing for classic integrations
     def __init_subclass__(cls, *args, **kwargs):
         try:
@@ -312,6 +314,14 @@ class AgentCheck(object):
         if os.environ.get("GOFIPS", "0") == "1":
             enable_fips()
 
+        ha_enabled_init = self.init_config.get('ha_enabled', False) if self.init_config else False
+        ha_enabled_instance = self.instance.get('ha_enabled', False) if self.instance else False
+
+        if not self.HA_SUPPORTED and (ha_enabled_init or ha_enabled_instance):
+            raise ConfigurationError(
+                f"High Availability is enabled for check {self.name} but this integration does not support it"
+            )
+
     def _create_metrics_pattern(self, metric_patterns, option_name):
         all_patterns = metric_patterns.get(option_name, [])
 

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/datadog_checks/base/checks/openmetrics/v2/labels.py

@@ -1,21 +1,27 @@
 # (C) Datadog, Inc. 2020-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
+from collections import ChainMap
+
 from ....utils.functions import no_op
 
 
 class LabelAggregator:
     def __init__(self, check, config):
         share_labels = config.get('share_labels', {})
-        if not isinstance(share_labels, dict):
-            raise TypeError('Setting `share_labels` must be a mapping')
-        elif not share_labels:
+        self.target_info = config.get('target_info', False)
+        self.target_info_labels = {}
+
+        self._validate_type(share_labels, dict, "Setting `share_labels` must be a mapping")
+        self._validate_type(self.target_info, bool, "Setting `target_info` must be a boolean")
+
+        if not share_labels and not self.target_info:
             self.populate = no_op
             return
 
         self.cache_shared_labels = config.get('cache_shared_labels', True)
         self.shared_labels_cached = False
-
+        self.info_metric = {'target_info': {}}
         self.metric_config = {}
         for metric, config in share_labels.items():
             data = self.metric_config[metric] = {}
@@ -31,6 +37,7 @@ class LabelAggregator:
                     raise TypeError(f'Option `values` for metric `{metric}` of setting `share_labels` must be an array')
 
                 allowed_values = set()
+
                 for i, value in enumerate(values, 1):
                     value = str(value)
 
@@ -72,34 +79,32 @@ class LabelAggregator:
 
         self.unconditional_labels = {}
 
+    def _validate_type(self, value, expected_type, error_message):
+        if not isinstance(value, expected_type):
+            raise TypeError(error_message)
+
     def __call__(self, metrics):
         if self.cache_shared_labels:
             if self.shared_labels_cached:
                 yield from metrics
             else:
-                metric_config = self.metric_config.copy()
+                metric_config, target_info_metric = self.copy_configs()
 
                 for metric in metrics:
-                    if metric_config and metric.name in metric_config:
-                        self.collect(metric, metric_config.pop(metric.name))
-
+                    self.process_metric(metric, metric_config, target_info_metric)
                     yield metric
 
                 self.shared_labels_cached = True
         else:
             try:
-                metric_config = self.metric_config.copy()
-
-                # Cache every encountered metric until the desired labels have been collected
+                metric_config, target_info_metric = self.copy_configs()
                 cached_metrics = []
 
                 for metric in metrics:
-                    if metric.name in metric_config:
-                        self.collect(metric, metric_config.pop(metric.name))
-
+                    self.process_metric(metric, metric_config, target_info_metric)
                     cached_metrics.append(metric)
 
-                    if not metric_config:
+                    if not (metric_config or target_info_metric):
                         break
 
                 yield from cached_metrics
@@ -108,6 +113,24 @@ class LabelAggregator:
                 self.label_sets.clear()
                 self.unconditional_labels.clear()
 
+    def copy_configs(self):
+        return self.metric_config.copy(), self.info_metric.copy()
+
+    def process_metric(self, metric, *configs):
+        """
+        Collects labels from shared_labels + target_info metrics
+        """
+        for config in configs:
+            if config and metric.name in config:
+                self.collect(metric, config.pop(metric.name))
+
+    def process_target_info(self, metric):
+        """
+        Updates cached target info metrics
+        """
+        if metric.samples[0].labels != self.target_info_labels:
+            self.target_info_labels = metric.samples[0].labels
+
     def collect(self, metric, config):
         allowed_values = config.get('values')
 
@@ -147,13 +170,28 @@ class LabelAggregator:
                         if label in labels:
                             self.unconditional_labels[label] = value
             else:
-                for sample in self.allowed_samples(metric, allowed_values):
-                    for label, value in sample.labels.items():
-                        self.unconditional_labels[label] = value
+                # Store target_info metric labels to be applied to other metrics in payload
+                if metric.name == 'target_info':
+                    self.target_info_labels.update(
+                        {
+                            label: value
+                            for sample in self.allowed_samples(metric, allowed_values)
+                            for label, value in sample.labels.items()
+                        }
+                    )
+                else:
+                    # Store shared labels in a seperate attribute
+                    self.unconditional_labels.update(
+                        {
+                            label: value
+                            for sample in self.allowed_samples(metric, allowed_values)
+                            for label, value in sample.labels.items()
+                        }
+                    )
 
     def populate(self, labels):
         label_set = frozenset(labels.items())
-        labels.update(self.unconditional_labels)
+        labels.update(ChainMap(self.unconditional_labels, self.target_info_labels))
 
         for matching_label_set, shared_labels in self.label_sets:
             # Check for subset without incurring the cost of a `.issubset` lookup and call

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/datadog_checks/base/checks/openmetrics/v2/scraper.py

@@ -58,6 +58,7 @@ class OpenMetricsScraper:
 
         # Parse the configuration
         self.endpoint = config['openmetrics_endpoint']
+        self.target_info = config.get('target_info', False)
 
         self.metric_transformer = MetricTransformer(self.check, config)
         self.label_aggregator = LabelAggregator(self.check, config)
@@ -238,7 +239,13 @@ class OpenMetricsScraper:
         """
         runtime_data = {'flush_first_value': self.flush_first_value, 'static_tags': self.static_tags}
 
-        for metric in self.consume_metrics(runtime_data):
+        # Determine which consume method to use based on target_info config
+        if self.target_info:
+            consume_method = self.consume_metrics_w_target_info
+        else:
+            consume_method = self.consume_metrics
+
+        for metric in consume_method(runtime_data):
             transformer = self.metric_transformer.get(metric)
             if transformer is None:
                 continue
@@ -248,23 +255,52 @@ class OpenMetricsScraper:
         self.flush_first_value = True
 
     def consume_metrics(self, runtime_data):
+        """
+        Yield the processed metrics and filter out excluded metrics, without checking for target_info metrics.
+        """
+
+        metric_parser = self.parse_metrics()
+
+        if not self.flush_first_value and self.use_process_start_time:
+            metric_parser = first_scrape_handler(metric_parser, runtime_data, datadog_agent.get_process_start_time())
+        if self.label_aggregator.configured:
+            metric_parser = self.label_aggregator(metric_parser)
+
+        for metric in metric_parser:
+            # Skip excluded metrics
+            if metric.name in self.exclude_metrics or (
+                self.exclude_metrics_pattern is not None and self.exclude_metrics_pattern.search(metric.name)
+            ):
+                self.submit_telemetry_number_of_ignored_metric_samples(metric)
+                continue
+
+            yield metric
+
+    def consume_metrics_w_target_info(self, runtime_data):
         """
         Yield the processed metrics and filter out excluded metrics.
+        Additionally, handle target_info metrics.
         """
 
         metric_parser = self.parse_metrics()
+
         if not self.flush_first_value and self.use_process_start_time:
             metric_parser = first_scrape_handler(metric_parser, runtime_data, datadog_agent.get_process_start_time())
         if self.label_aggregator.configured:
             metric_parser = self.label_aggregator(metric_parser)
 
         for metric in metric_parser:
+            # Skip excluded metrics
             if metric.name in self.exclude_metrics or (
                 self.exclude_metrics_pattern is not None and self.exclude_metrics_pattern.search(metric.name)
             ):
                 self.submit_telemetry_number_of_ignored_metric_samples(metric)
                 continue
 
+            # Process target_info metrics
+            if metric.name == 'target_info':
+                self.label_aggregator.process_target_info(metric)
+
             yield metric
 
     def parse_metrics(self):
@@ -312,7 +348,6 @@ class OpenMetricsScraper:
         """
         Yield a sample of processed data.
         """
-
         label_normalizer = get_label_normalizer(metric.type)
 
         for sample in metric.samples:

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/pyproject.toml

@@ -31,17 +31,17 @@ license = "BSD-3-Clause"
 
 [project.optional-dependencies]
 db = [
-    "mmh3==5.0.1",
+    "mmh3==5.1.0",
 ]
 deps = [
     "binary==1.0.1",
-    "cachetools==5.5.0",
+    "cachetools==5.5.1",
     "cryptography==43.0.1",
     "ddtrace==2.10.6",
     "jellyfish==1.1.3",
     "prometheus-client==0.21.1",
     "protobuf==5.29.3",
-    "pydantic==2.10.5",
+    "pydantic==2.10.6",
     "python-dateutil==2.9.0.post0",
     "pywin32==308; sys_platform == 'win32'",
     "pyyaml==6.0.2",
@@ -54,7 +54,7 @@ deps = [
 ]
 http = [
     "aws-requests-auth==0.4.3",
-    "botocore==1.36.1",
+    "botocore==1.36.16",
     "oauthlib==3.2.2",
     "pyjwt==2.10.1",
     "pyopenssl==24.2.1",
@@ -64,10 +64,10 @@ http = [
     "requests-oauthlib==2.0.0",
 ]
 json = [
-    "orjson==3.10.14",
+    "orjson==3.10.15",
 ]
 kube = [
-    "kubernetes==31.0.0",
+    "kubernetes==32.0.0",
     "requests-oauthlib==2.0.0",
 ]
 

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/tests/base/checks/logs/crawler/test_base.py

@@ -6,7 +6,6 @@ from datadog_checks.base.checks.logs.crawler.stream import LogRecord, LogStream
 
 
 def test_submission(dd_run_check, datadog_agent):
-
     class TestLogStream(LogStream):
         def __init__(self, start, **kwargs):
             super().__init__(**kwargs)

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/tests/base/checks/openmetrics/test_v2/test_options.py

@@ -681,6 +681,200 @@ class TestShareLabels:
 
         aggregator.assert_all_metrics_covered()
 
+    def test_target_info_tags_propagation(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_tags_propagation_unordered(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True, 'cache_shared_labels': False})
+
+        mock_http_response(
+            """
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_tags_propagation_unordered_w_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+
+        mock_http_response(
+            """
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_update_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+        check_var = check
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="stg", region="asia"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar2"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar2', 'env:stg', 'region:asia'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_w_shared_labels_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'share_labels': {'go_memstats_free_bytes': True}, 'target_info': True})
+        check_var = check
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_free_bytes Number of bytes free and available for use.
+            # TYPE go_memstats_free_bytes gauge
+            go_memstats_free_bytes{foo="bar"} 6.396288e+06
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{bar="foo"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'bar:foo', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="stg", region="asia"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo2="bar2"} 6.396288e+06
+            # HELP go_memstats_free_bytes Number of bytes free and available for use.
+            # TYPE go_memstats_free_bytes gauge
+            go_memstats_free_bytes{bar2="baz2"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'foo2:bar2', 'env:stg', 'region:asia'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_metric(
+            'test.go_memstats_free_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'env:stg', 'region:asia', 'bar2:baz2', 'foo:bar'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
 
 class TestIgnoreTags:
     def test_simple_match(self, aggregator, dd_run_check, mock_http_response):

{datadog_checks_base-37.5.0 → datadog_checks_base-37.6.0}/tests/base/checks/test_agent_check.py

@@ -11,7 +11,7 @@ from typing import Any  # noqa: F401
 import mock
 import pytest
 
-from datadog_checks.base import AgentCheck, to_native_string
+from datadog_checks.base import AgentCheck, ConfigurationError, to_native_string
 from datadog_checks.base import __version__ as base_package_version
 
 from .utils import BaseModelTest
@@ -1310,3 +1310,23 @@ def test_env_var_logic_preset():
         AgentCheck()
         assert os.getenv('OPENSSL_CONF', None) == preset_conf
         assert os.getenv('OPENSSL_MODULES', None) == preset_modules
+
+
+def test_ha_enabled_and_unsupported():
+    class TestNonHACheck(AgentCheck):
+        HA_SUPPORTED = False
+
+    TestNonHACheck('test', {}, [{}])
+    with pytest.raises(ConfigurationError):
+        TestNonHACheck('test', {'ha_enabled': True}, [{}])
+    with pytest.raises(ConfigurationError):
+        TestNonHACheck('test', {}, [{'ha_enabled': True}])
+
+
+def test_ha_enabled_and_supported():
+    class TestHACheck(AgentCheck):
+        HA_SUPPORTED = True
+
+    TestHACheck('test', {}, [{}])
+    TestHACheck('test', {'ha_enabled': True}, [{}])
+    TestHACheck('test', {}, [{'ha_enabled': True}])