datadog-checks-base 37.8.0__tar.gz → 37.10.0__tar.gz

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datadog-checks-base
-Version: 37.8.0
+Version: 37.10.0
 Summary: The Datadog Check Toolkit
 Project-URL: Source, https://github.com/DataDog/integrations-core
 Author-email: Datadog <packages@datadoghq.com>
@@ -17,33 +17,34 @@ Requires-Dist: mmh3==5.1.0; extra == 'db'
 Provides-Extra: deps
 Requires-Dist: binary==1.0.1; extra == 'deps'
 Requires-Dist: cachetools==5.5.2; extra == 'deps'
-Requires-Dist: cryptography==44.0.1; extra == 'deps'
-Requires-Dist: ddtrace==2.10.6; extra == 'deps'
+Requires-Dist: cryptography==44.0.2; extra == 'deps'
+Requires-Dist: ddtrace==2.21.4; extra == 'deps'
 Requires-Dist: jellyfish==1.1.3; extra == 'deps'
 Requires-Dist: lazy-loader==0.4; extra == 'deps'
 Requires-Dist: prometheus-client==0.21.1; extra == 'deps'
-Requires-Dist: protobuf==5.29.3; extra == 'deps'
-Requires-Dist: pydantic==2.10.6; extra == 'deps'
+Requires-Dist: protobuf==6.30.2; extra == 'deps'
+Requires-Dist: pydantic==2.11.1; extra == 'deps'
 Requires-Dist: python-dateutil==2.9.0.post0; extra == 'deps'
-Requires-Dist: pywin32==308; (sys_platform == 'win32') and extra == 'deps'
+Requires-Dist: pywin32==310; (sys_platform == 'win32') and extra == 'deps'
 Requires-Dist: pyyaml==6.0.2; extra == 'deps'
 Requires-Dist: requests-toolbelt==1.0.0; extra == 'deps'
 Requires-Dist: requests-unixsocket2==0.4.2; extra == 'deps'
 Requires-Dist: requests==2.32.3; extra == 'deps'
 Requires-Dist: simplejson==3.20.1; extra == 'deps'
+Requires-Dist: urllib3==2.3.0; 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.26; extra == 'http'
+Requires-Dist: botocore==1.37.23; extra == 'http'
 Requires-Dist: oauthlib==3.2.2; extra == 'http'
 Requires-Dist: pyjwt==2.10.1; extra == 'http'
-Requires-Dist: pyopenssl==24.3.0; extra == 'http'
+Requires-Dist: pyopenssl==25.0.0; extra == 'http'
 Requires-Dist: pysocks==1.7.1; extra == 'http'
 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.15; extra == 'json'
+Requires-Dist: orjson==3.10.16; extra == 'json'
 Provides-Extra: kube
 Requires-Dist: kubernetes==32.0.1; extra == 'kube'
 Requires-Dist: requests-oauthlib==2.0.0; extra == 'kube'

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.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.8.0"
+__version__ = "37.10.0"

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/datadog_checks/base/checks/base.py

@@ -57,11 +57,6 @@ else:
 
 init_logging()
 
-if datadog_agent.get_config('disable_unsafe_yaml'):
-    from ..ddyaml import monkey_patch_pyyaml
-
-    monkey_patch_pyyaml()
-
 if datadog_agent.get_config('integration_tracing'):
     from ddtrace import patch
 
@@ -386,17 +381,6 @@ class AgentCheck(object):
 
         return limit
 
-    @staticmethod
-    def load_config(yaml_str):
-        # type: (str) -> Any
-        """
-        Convenience wrapper to ease programmatic use of this class from the C API.
-        """
-        # See Performance Optimizations in this package's README.md.
-        import yaml
-
-        return yaml.safe_load(yaml_str)
-
     @property
     def http(self) -> RequestsWrapper:
         """
@@ -1485,3 +1469,28 @@ class AgentCheck(object):
 
         for m in metrics:
             self.gauge(m.name, m.value, tags=tags, raw=True)
+
+    @staticmethod
+    def load_config(yaml_str: str) -> Any:
+        """
+        Convenience wrapper to ease programmatic use of this class from the C API.
+        """
+        import subprocess
+        import sys
+
+        process = subprocess.Popen(
+            [sys.executable, '-c', 'import sys, yaml; print(yaml.safe_load(sys.stdin.read()))'],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = process.communicate(yaml_str.encode())
+        if process.returncode != 0:
+            raise ValueError(f'Failed to load config: {stderr.decode()}')
+
+        decoded = stdout.strip().decode()
+        try:
+            return eval(decoded)
+        # a single, literal unquoted string
+        except Exception:
+            return decoded

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/datadog_checks/base/checks/openmetrics/v2/scraper.py

@@ -230,13 +230,13 @@ class OpenMetricsScraper:
         self.use_process_start_time = is_affirmative(config.get('use_process_start_time'))
 
         # Used for monotonic counts
-        self.flush_first_value = False
+        self.flush_first_value = None
 
-    def scrape(self):
+    def _scrape(self):
         """
         Execute a scrape, and for each metric collected, transform the metric.
         """
-        runtime_data = {'flush_first_value': self.flush_first_value, 'static_tags': self.static_tags}
+        runtime_data = {'flush_first_value': bool(self.flush_first_value), 'static_tags': self.static_tags}
 
         # Determine which consume method to use based on target_info config
         if self.target_info:
@@ -251,7 +251,18 @@ class OpenMetricsScraper:
 
             transformer(metric, self.generate_sample_data(metric), runtime_data)
 
-        self.flush_first_value = True
+    def scrape(self):
+        try:
+            self._scrape()
+            self.flush_first_value = True
+        except:
+            # Don't flush new monotonic counts on next scrape:
+            # 1. Previous value may have expired in the aggregator, causing a spike
+            # 2. New counter itself may be too old and large when we discover it next time.
+            # If we didn't have a successful scrape yet, keep the initial value (use process_start_time to decide).
+            if self.flush_first_value:
+                self.flush_first_value = False
+            raise
 
     def consume_metrics(self, runtime_data):
         """
@@ -260,7 +271,7 @@ class OpenMetricsScraper:
 
         metric_parser = self.parse_metrics()
 
-        if not self.flush_first_value and self.use_process_start_time:
+        if self.flush_first_value is None 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)
@@ -283,7 +294,7 @@ class OpenMetricsScraper:
 
         metric_parser = self.parse_metrics()
 
-        if not self.flush_first_value and self.use_process_start_time:
+        if self.flush_first_value is None 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)

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/datadog_checks/base/stubs/aggregator.py

@@ -341,6 +341,8 @@ class AggregatorStub(object):
             if expected_tags and expected_tags != sorted(metric.tags):
                 continue
 
+            # to assert hostname is None, pass in hostname as '':
+            # https://github.com/DataDog/integrations-core/blob/7.65.x/datadog_checks_base/datadog_checks/base/checks/base.py#L760
             if hostname is not None and hostname != metric.hostname:
                 continue
 

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/datadog_checks/base/stubs/datadog_agent.py

@@ -29,7 +29,7 @@ class DatadogAgentStub(object):
         self._sent_telemetry = defaultdict(list)
 
     def get_default_config(self):
-        return {'enable_metadata_collection': True, 'disable_unsafe_yaml': True}
+        return {'enable_metadata_collection': True}
 
     def reset(self):
         self._sent_logs.clear()

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/datadog_checks/base/utils/db/statement_metrics.py

@@ -13,9 +13,7 @@ class StatementMetrics:
 
         - Postgres: pg_stat_statements
         - MySQL: performance_schema.events_statements_summary_by_digest
-        - Oracle: V$SQLAREA
         - SQL Server: sys.dm_exec_query_stats
-        - DB2: mon_db_summary
 
     These tables are monotonically increasing, so the metrics are computed from the difference
     in values between check runs.
@@ -24,7 +22,7 @@ class StatementMetrics:
     def __init__(self):
         self._previous_statements = {}
 
-    def compute_derivative_rows(self, rows, metrics, key):
+    def compute_derivative_rows(self, rows, metrics, key, execution_indicators=None):
         """
         Compute the first derivative of column-based metrics for a given set of rows. This function
         takes the difference of the previous check run's values and the current check run's values
@@ -41,10 +39,20 @@ class StatementMetrics:
         :params rows (_List[dict]_): rows from current check run
         :params metrics (_List[str]_): the metrics to compute for each row
         :params key (_callable_): function for an ID which uniquely identifies a row across runs
+        :params execution_indicators (_List[str]_): list of metrics that must change to consider a query as executed.
+            These are typically metrics that increment only when a query actually executes, such as:
+            - PostgreSQL: 'calls' from pg_stat_statements
+            - MySQL: 'exec_count' from performance_schema.events_statements_summary_by_digest
+            - SQL Server: 'execution_count' from sys.dm_exec_query_stats
+            This helps filter out cases where a normalized query was evicted then re-inserted with same call count
+            (usually 1) and slight duration change. In this case, the new normalized query entry should be treated
+            as the baseline for future diffs.
         :return (_List[dict]_): a list of rows with the first derivative of the metrics
         """
         result = []
         metrics = set(metrics)
+        if execution_indicators:
+            execution_indicators = set(execution_indicators)
 
         merged_rows, dropped_metrics = _merge_duplicate_rows(rows, metrics, key)
         if dropped_metrics:
@@ -69,6 +77,12 @@ class StatementMetrics:
             # 2. No changes since the previous run: There is no need to store metrics of 0, since that is implied by
             #    the absence of metrics. On any given check run, most rows will have no difference so this optimization
             #    avoids having to send a lot of unnecessary metrics.
+            #
+            # 3. Execution indicators: If execution_indicators is specified, only consider a query as changed if at
+            #    least one of the execution indicator metrics has changed. This helps filter out cases where an old or
+            #    less frequently executed normalized query was evicted due to the stats table being full, and then
+            #    re-inserted to the stats table with a small call count and slight duration change. In this case,
+            #    the new normalized query entry should be treated as the baseline for future diffs.
 
             diffed_row = {k: row[k] - prev[k] if k in metric_columns else row[k] for k in row.keys()}
 
@@ -79,6 +93,12 @@ class StatementMetrics:
                 # of potentially including truncated rows that exceed previous run counts.
                 continue
 
+            # If execution_indicators is specified, check if any of the execution indicator metrics have changed
+            if execution_indicators:
+                indicator_columns = execution_indicators & metric_columns
+                if not any(diffed_row[k] > 0 for k in indicator_columns):
+                    continue
+
             # No changes to the query; no metric needed
             if all(diffed_row[k] == 0 for k in metric_columns):
                 continue

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/pyproject.toml

@@ -36,35 +36,38 @@ db = [
 deps = [
     "binary==1.0.1",
     "cachetools==5.5.2",
-    "cryptography==44.0.1",
-    "ddtrace==2.10.6",
+    "cryptography==44.0.2",
+    "ddtrace==2.21.4",
     "jellyfish==1.1.3",
     "lazy-loader==0.4",
     "prometheus-client==0.21.1",
-    "protobuf==5.29.3",
-    "pydantic==2.10.6",
+    "protobuf==6.30.2",
+    "pydantic==2.11.1",
     "python-dateutil==2.9.0.post0",
-    "pywin32==308; sys_platform == 'win32'",
+    "pywin32==310; sys_platform == 'win32'",
     "pyyaml==6.0.2",
     "requests-toolbelt==1.0.0",
     "requests-unixsocket2==0.4.2",
     "requests==2.32.3",
     "simplejson==3.20.1",
+    # urllib3 is a dependency of requests that we explicitly
+    # make use of in a few places
+    "urllib3==2.3.0",
     "wrapt==1.17.2",
 ]
 http = [
     "aws-requests-auth==0.4.3",
-    "botocore==1.36.26",
+    "botocore==1.37.23",
     "oauthlib==3.2.2",
     "pyjwt==2.10.1",
-    "pyopenssl==24.3.0",
+    "pyopenssl==25.0.0",
     "pysocks==1.7.1",
     "requests-kerberos==0.15.0",
     "requests-ntlm==1.3.0",
     "requests-oauthlib==2.0.0",
 ]
 json = [
-    "orjson==3.10.15",
+    "orjson==3.10.16",
 ]
 kube = [
     "kubernetes==32.0.1",

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/tests/base/checks/openmetrics/test_v2/test_first_scrape_handler.py

@@ -86,8 +86,6 @@ def test_first_scrape_handler(
     agent_start_time,
     process_start_time,
 ):
-    mock_http_response(_make_test_data(process_start_time))
-
     check = get_check(
         {
             'metrics': ['.*'],
@@ -98,53 +96,62 @@ def test_first_scrape_handler(
 
     datadog_agent.set_process_start_time(agent_start_time)
 
-    for _ in range(0, 5):
+    for idx in range(0, 10):
         aggregator.reset()
-        dd_run_check(check)
 
-        aggregator.assert_metric(
-            'test.go_memstats_alloc_bytes.count',
-            metric_type=aggregator.MONOTONIC_COUNT,
-            count=1,
-            flush_first_value=expect_first_flush,
-        )
-        aggregator.assert_metric(
-            'test.go_gc_duration_seconds.count',
-            metric_type=aggregator.MONOTONIC_COUNT,
-            count=1,
-            flush_first_value=expect_first_flush,
-        )
+        if idx != 5:
+            mock_http_response(_make_test_data(process_start_time))
+            dd_run_check(check)
 
-        if with_buckets:
-            aggregator.assert_histogram_bucket(
-                'test.skydns_skydns_dns_request_duration_seconds',
-                None,
-                None,
-                None,
-                True,
-                None,
-                None,
-                count=2,
-                flush_first_value=expect_first_flush,
-            )
-        else:
-            aggregator.assert_metric(
-                'test.skydns_skydns_dns_request_duration_seconds.count',
-                metric_type=aggregator.MONOTONIC_COUNT,
-                count=1,
-                flush_first_value=expect_first_flush,
-            )
             aggregator.assert_metric(
-                'test.skydns_skydns_dns_request_duration_seconds.sum',
+                'test.go_memstats_alloc_bytes.count',
                 metric_type=aggregator.MONOTONIC_COUNT,
                 count=1,
                 flush_first_value=expect_first_flush,
             )
             aggregator.assert_metric(
-                'test.skydns_skydns_dns_request_duration_seconds.bucket',
+                'test.go_gc_duration_seconds.count',
                 metric_type=aggregator.MONOTONIC_COUNT,
                 count=1,
                 flush_first_value=expect_first_flush,
             )
 
-        expect_first_flush = True
+            if with_buckets:
+                aggregator.assert_histogram_bucket(
+                    'test.skydns_skydns_dns_request_duration_seconds',
+                    None,
+                    None,
+                    None,
+                    True,
+                    None,
+                    None,
+                    count=2,
+                    flush_first_value=expect_first_flush,
+                )
+            else:
+                aggregator.assert_metric(
+                    'test.skydns_skydns_dns_request_duration_seconds.count',
+                    metric_type=aggregator.MONOTONIC_COUNT,
+                    count=1,
+                    flush_first_value=expect_first_flush,
+                )
+                aggregator.assert_metric(
+                    'test.skydns_skydns_dns_request_duration_seconds.sum',
+                    metric_type=aggregator.MONOTONIC_COUNT,
+                    count=1,
+                    flush_first_value=expect_first_flush,
+                )
+                aggregator.assert_metric(
+                    'test.skydns_skydns_dns_request_duration_seconds.bucket',
+                    metric_type=aggregator.MONOTONIC_COUNT,
+                    count=1,
+                    flush_first_value=expect_first_flush,
+                )
+
+            expect_first_flush = True
+        else:
+            mock_http_response("", status_code=500)
+            with pytest.raises(Exception):
+                dd_run_check(check)
+
+            expect_first_flush = False

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/tests/base/checks/test_agent_check.py

@@ -42,7 +42,12 @@ def test_check_version():
 
 
 def test_load_config():
-    assert AgentCheck.load_config("raw_foo: bar") == {'raw_foo': 'bar'}
+    assert AgentCheck.load_config('raw_foo: bar') == {'raw_foo': 'bar'}
+    assert AgentCheck.load_config('invalid:mapping') == 'invalid:mapping'
+    assert AgentCheck.load_config('') is None
+
+    with pytest.raises(ValueError, match='Failed to load config: '):
+        AgentCheck.load_config(':')
 
 
 def test_persistent_cache(datadog_agent):

{datadog_checks_base-37.8.0 → datadog_checks_base-37.10.0}/tests/base/utils/db/test_db_statements.py

@@ -303,3 +303,124 @@ class TestStatementMetrics:
     def test_compute_derivative_rows_benchmark(self, benchmark):
         sm = StatementMetrics()
         benchmark(self.__run_compute_derivative_rows, sm)
+
+    def test_compute_derivative_rows_with_execution_indicators(self):
+        sm = StatementMetrics()
+
+        def key(row):
+            return (row['query'], row['db'], row['user'])
+
+        metrics = ['calls', 'total_time', 'rows']
+        execution_indicators = ['calls']
+
+        # Initial state
+        rows1 = [
+            {'calls': 10, 'total_time': 1000, 'rows': 50, 'query': 'SELECT 1', 'db': 'test', 'user': 'user1'},
+            {'calls': 5, 'total_time': 500, 'rows': 25, 'query': 'SELECT 2', 'db': 'test', 'user': 'user1'},
+        ]
+
+        sm.compute_derivative_rows(rows1, metrics, key=key, execution_indicators=execution_indicators)
+
+        # Second run - only duration changes (should be ignored)
+        rows2 = [
+            {'calls': 10, 'total_time': 1001, 'rows': 50, 'query': 'SELECT 1', 'db': 'test', 'user': 'user1'},
+            {'calls': 5, 'total_time': 501, 'rows': 25, 'query': 'SELECT 2', 'db': 'test', 'user': 'user1'},
+        ]
+        assert [] == sm.compute_derivative_rows(rows2, metrics, key=key, execution_indicators=execution_indicators)
+
+        # Third run - calls change (should be included)
+        rows3 = [
+            {'calls': 11, 'total_time': 1002, 'rows': 51, 'query': 'SELECT 1', 'db': 'test', 'user': 'user1'},
+            {'calls': 5, 'total_time': 502, 'rows': 25, 'query': 'SELECT 2', 'db': 'test', 'user': 'user1'},
+        ]
+        result = sm.compute_derivative_rows(rows3, metrics, key=key, execution_indicators=execution_indicators)
+        assert len(result) == 1
+        assert result[0]['calls'] == 1
+        assert result[0]['total_time'] == 1
+        assert result[0]['rows'] == 1
+
+    def test_compute_derivative_rows_with_multiple_execution_indicators(self):
+        sm = StatementMetrics()
+
+        def key(row):
+            return (row['query'], row['db'], row['user'])
+
+        metrics = ['calls', 'executions', 'total_time', 'rows']
+        execution_indicators = ['calls', 'executions']
+
+        # Initial state
+        rows1 = [
+            {
+                'calls': 10,
+                'executions': 10,
+                'total_time': 1000,
+                'rows': 50,
+                'query': 'SELECT 1',
+                'db': 'test',
+                'user': 'user1',
+            },
+        ]
+
+        sm.compute_derivative_rows(rows1, metrics, key=key, execution_indicators=execution_indicators)
+
+        # Second run - only one execution indicator changes
+        rows2 = [
+            {
+                'calls': 11,
+                'executions': 10,
+                'total_time': 1001,
+                'rows': 50,
+                'query': 'SELECT 1',
+                'db': 'test',
+                'user': 'user1',
+            },
+        ]
+        result = sm.compute_derivative_rows(rows2, metrics, key=key, execution_indicators=execution_indicators)
+        assert len(result) == 1
+        assert result[0]['calls'] == 1
+        assert result[0]['executions'] == 0
+        assert result[0]['total_time'] == 1
+        assert result[0]['rows'] == 0
+
+        # Third run - both execution indicators change
+        rows3 = [
+            {
+                'calls': 12,
+                'executions': 11,
+                'total_time': 1002,
+                'rows': 51,
+                'query': 'SELECT 1',
+                'db': 'test',
+                'user': 'user1',
+            },
+        ]
+        result = sm.compute_derivative_rows(rows3, metrics, key=key, execution_indicators=execution_indicators)
+        assert len(result) == 1
+        assert result[0]['calls'] == 1
+        assert result[0]['executions'] == 1
+        assert result[0]['total_time'] == 1
+        assert result[0]['rows'] == 1
+
+    def test_compute_derivative_rows_with_invalid_execution_indicators(self):
+        sm = StatementMetrics()
+
+        def key(row):
+            return (row['query'], row['db'], row['user'])
+
+        metrics = ['calls', 'total_time', 'rows']
+
+        # Test with empty execution indicators
+        rows1 = [
+            {'calls': 10, 'total_time': 1000, 'rows': 50, 'query': 'SELECT 1', 'db': 'test', 'user': 'user1'},
+        ]
+        rows2 = [
+            {'calls': 11, 'total_time': 1001, 'rows': 51, 'query': 'SELECT 1', 'db': 'test', 'user': 'user1'},
+        ]
+
+        # Empty execution indicators should behave like no execution indicators specified
+        _ = sm.compute_derivative_rows(rows1, metrics, key=key, execution_indicators=[])
+        result = sm.compute_derivative_rows(rows2, metrics, key=key, execution_indicators=[])
+        assert len(result) == 1
+        assert result[0]['calls'] == 1
+        assert result[0]['total_time'] == 1
+        assert result[0]['rows'] == 1

datadog_checks_base-37.10.0/tests/stubs/test_assert_metric.py

@@ -0,0 +1,17 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+
+from datadog_checks.base import AgentCheck
+
+
+class TestAssertMetric:
+
+    def test_assert_metric_hostname(self, aggregator):
+        check = AgentCheck()
+
+        check.gauge('test.metric', 1, hostname=None)
+        check.gauge('test.metric_host', 1, hostname='hello')
+
+        aggregator.assert_metric('test.metric', 1, hostname='')
+        aggregator.assert_metric('test.metric_host', 1, hostname='hello')