datadog-checks-base 37.2.0__tar.gz → 37.3.0__tar.gz

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/.gitignore

@@ -28,7 +28,6 @@ var/
 *.egg-info/
 .installed.cfg
 *.egg
-*.zip
 # PyInstaller
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: datadog-checks-base
-Version: 37.2.0
+Version: 37.3.0
 Summary: The Datadog Check Toolkit
 Project-URL: Source, https://github.com/DataDog/integrations-core
 Author-email: Datadog <packages@datadoghq.com>
-License: BSD-3-Clause
+License-Expression: BSD-3-Clause
 Keywords: agent,checks,datadog
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.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.2.0"
+__version__ = "37.3.0"

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/datadog_checks/base/checks/base.py

@@ -6,6 +6,7 @@ import functools
 import importlib
 import inspect
 import logging
+import os
 import re
 import traceback
 import unicodedata
@@ -46,6 +47,7 @@ from ..types import (
 from ..utils.agent.utils import should_profile_memory
 from ..utils.common import ensure_bytes, to_native_string
 from ..utils.diagnose import Diagnosis
+from ..utils.fips import enable_fips
 from ..utils.http import RequestsWrapper
 from ..utils.limiter import Limiter
 from ..utils.metadata import MetadataManager
@@ -307,6 +309,9 @@ class AgentCheck(object):
         self.__formatted_tags = None
         self.__logs_enabled = None
 
+        if os.environ.get("GOFIPS", "0") == "1":
+            enable_fips()
+
     def _create_metrics_pattern(self, metric_patterns, option_name):
         all_patterns = metric_patterns.get(option_name, [])
 
@@ -1285,7 +1290,13 @@ class AgentCheck(object):
 
                     enter_pdb(self.check, line=self.init_config['set_breakpoint'], args=(instance,))
                 elif self.should_profile_memory():
-                    self.profile_memory(self.check, self.init_config, args=(instance,))
+                    # self.init_config['profile_memory'] could be `/tmp/datadog-agent-memory-profiler*`
+                    # that is generated by Datadog Agent.
+                    # If we use `--m-dir` for `agent check` command, a hidden flag, it should be same as a given value.
+                    namespaces = [self.init_config['profile_memory']]
+                    for id in self.check_id.split(":"):
+                        namespaces.append(id)
+                    self.profile_memory(func=self.check, namespaces=namespaces, args=(instance,))
                 else:
                     self.check(instance)
 

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/datadog_checks/base/checks/openmetrics/v2/metrics.py

@@ -1,6 +1,7 @@
 DEFAULT_GO_METRICS = {
     'go_gc_duration_seconds': 'go.gc.duration.seconds',
     'go_goroutines': 'go.goroutines',
+    'go_memstats_alloc_bytes': {'name': 'go.memstats.alloc_bytes', 'type': 'native_dynamic'},
     'go_memstats_buck_hash_sys_bytes': 'go.memstats.buck_hash.sys_bytes',
     'go_memstats_frees': 'go.memstats.frees',
     'go_memstats_gc_cpu_fraction': 'go.memstats.gc.cpu_fraction',
@@ -11,7 +12,10 @@ DEFAULT_GO_METRICS = {
     'go_memstats_heap_objects': 'go.memstats.heap.objects',
     'go_memstats_heap_released_bytes': 'go.memstats.heap.released_bytes',
     'go_memstats_heap_sys_bytes': 'go.memstats.heap.sys_bytes',
-    'go_memstats_last_gc_time_seconds': 'go.memstats.last_gc_time.seconds',
+    'go_memstats_last_gc_time_seconds': {
+        'name': 'go.memstats.last_gc_time_seconds',
+        'type': 'time_elapsed',
+    },
     'go_memstats_lookups': 'go.memstats.lookups',
     'go_memstats_mallocs': 'go.memstats.mallocs',
     'go_memstats_mcache_inuse_bytes': 'go.memstats.mcache.inuse_bytes',
@@ -28,7 +32,10 @@ DEFAULT_GO_METRICS = {
     'process_max_fds': 'process.max_fds',
     'process_open_fds': 'process.open_fds',
     'process_resident_memory_bytes': 'process.resident_memory.bytes',
-    'process_start_time_seconds': 'process.start_time.seconds',
+    'process_start_time_seconds': {
+        'name': 'process.start_time.seconds',
+        'type': 'time_elapsed',
+    },
     'process_virtual_memory_bytes': 'process.virtual_memory.bytes',
     'process_virtual_memory_max_bytes': 'process.virtual_memory.max_bytes',
 }

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/datadog_checks/base/stubs/similar.py

@@ -9,6 +9,62 @@ Build similar message for better test assertion failure message.
 MAX_SIMILAR_TO_DISPLAY = 15
 
 
+def dict_diff(expected, closest):
+    """
+    Returns an array of key/value pairs that are different between the two dicts.
+    """
+    diff = []
+    for key in closest.keys() | expected.keys():
+        expected_value = expected.get(key)
+        closest_value = closest.get(key)
+
+        if expected_value is not None and expected_value != closest_value:
+            diff.append((key, expected_value, closest_value))
+
+    return diff
+
+
+def tags_list_to_dict(tags):
+    return {tag.split(':', 1)[0]: (tag.split(':', 1)[1] if ":" in tag else '') for tag in tags}
+
+
+def tags_diff(expected, closest):
+    """
+    Returns an array of key/value pairs that are different between the two lists of tags.
+    """
+    diff = []
+    expected_tags_dict = tags_list_to_dict(expected)
+    closest_tags_dict = tags_list_to_dict(closest)
+    for tag in expected_tags_dict:
+        if expected_tags_dict[tag] != closest_tags_dict.get(tag):
+            diff.append((tag, expected_tags_dict[tag], closest_tags_dict.get(tag)))
+    for tag in closest_tags_dict:
+        if tag not in expected_tags_dict:
+            diff.append((tag, None, closest_tags_dict[tag]))
+    return diff
+
+
+def format_metric_stub_diff(expected, closest):
+    """
+    Return formatted difference between expected and closest metric stubs
+    """
+    diff = []
+
+    closest_dict = closest._asdict()
+    expected_dict = expected._asdict()
+    dict_diffs = dict_diff(expected_dict, closest_dict)
+    for key, expected_value, closest_value in dict_diffs:
+        if key == "tags":
+            tag_diffs = tags_diff(expected_value, closest_value)
+            for tag, expected_tag_value, closest_tag_value in tag_diffs:
+                diff.append(
+                    f"        Expected tag {tag}:{expected_tag_value}\n" + f"        Found {tag}:{closest_tag_value}"
+                )
+        else:
+            diff.append(f"        Expected {key}: {expected_value}\n        Found {closest_value}")
+    return diff
+
+
 def build_similar_elements_msg(expected, submitted_elements):
     """
     Return formatted similar elements (metrics, service checks) received compared to submitted elements
@@ -22,9 +78,17 @@ def build_similar_elements_msg(expected, submitted_elements):
             metric_stub.tags.sort()
         similar_metrics_to_print.append("{:.2f}    {}".format(score, metric_stub))
 
+    closest_diff = []
+    if similar_metrics:
+        [_, closest] = similar_metrics[0]
+        closest_diff = format_metric_stub_diff(expected, closest)
+
     return (
         "Expected:\n"
         + "        {}\n".format(expected)
+        + "Difference to closest:\n"
+        + "\n".join(closest_diff)
+        + "\n\n"
         + "Similar submitted:\n"
         + "Score   Most similar\n"
         + "\n".join(similar_metrics_to_print)

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/datadog_checks/base/utils/db/utils.py

@@ -150,6 +150,9 @@ class RateLimitingTTLCache(TTLCache):
 
 
 def resolve_db_host(db_host):
+    if db_host and db_host.endswith('.local'):
+        return db_host
+
     agent_hostname = datadog_agent.get_hostname()
     if not db_host or db_host in {'localhost', '127.0.0.1'} or db_host.startswith('/'):
         return agent_hostname

datadog_checks_base-37.3.0/datadog_checks/base/utils/fips.py

@@ -0,0 +1,32 @@
+# (C) Datadog, Inc. 2024-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+
+import os
+
+
+def enable_fips(path_to_openssl_conf=None, path_to_openssl_modules=None):
+    path_to_embedded = None
+    if os.getenv("OPENSSL_CONF") is None:
+        if path_to_openssl_conf is None:
+            path_to_embedded = _get_embedded_path() if path_to_embedded is None else path_to_embedded
+            path_to_openssl_conf = path_to_embedded / "ssl" / "openssl.cnf"
+            if not path_to_openssl_conf.exists():
+                raise RuntimeError(f'The configuration file "{path_to_openssl_conf}" does not exist')
+        os.environ["OPENSSL_CONF"] = str(path_to_openssl_conf)
+
+    if os.getenv("OPENSSL_MODULES") is None:
+        if path_to_openssl_modules is None:
+            path_to_embedded = _get_embedded_path() if path_to_embedded is None else path_to_embedded
+            path_to_openssl_modules = path_to_embedded / "lib" / "ossl-modules"
+            if not path_to_openssl_conf.exists():
+                raise RuntimeError(f'The directory "{path_to_openssl_modules}" does not exist')
+        os.environ["OPENSSL_MODULES"] = str(path_to_openssl_modules)
+
+
+def _get_embedded_path():
+    import sys
+    from pathlib import Path
+
+    embedded_dir = "embedded3" if os.name == 'nt' else "embedded"
+    return Path(sys.executable.split("embedded")[0] + embedded_dir)

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/tests/base/checks/test_agent_check.py

@@ -5,6 +5,7 @@
 # Licensed under a 3-clause BSD style license (see LICENSE)
 import json
 import logging
+import os
 from typing import Any  # noqa: F401
 
 import mock
@@ -1293,3 +1294,19 @@ def test_detect_typos_configuration_models(
         assert "Detected potential typo in configuration option" not in caplog.text
 
     assert typos == set(unknown_options)
+
+
+def test_env_var_logic_default():
+    with mock.patch.dict('os.environ', {'GOFIPS': '0'}):
+        AgentCheck()
+        assert os.getenv('OPENSSL_CONF', None) is None
+        assert os.getenv('OPENSSL_MODULES', None) is None
+
+
+def test_env_var_logic_preset():
+    preset_conf = 'path/to/openssl.cnf'
+    preset_modules = 'path/to/ossl-modules'
+    with mock.patch.dict('os.environ', {'GOFIPS': '1', 'OPENSSL_CONF': preset_conf, 'OPENSSL_MODULES': preset_modules}):
+        AgentCheck()
+        assert os.getenv('OPENSSL_CONF', None) == preset_conf
+        assert os.getenv('OPENSSL_MODULES', None) == preset_modules

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/tests/base/test_ddyaml.py

@@ -59,8 +59,8 @@ def test_load():
 
         yaml_config_safe = list(safe_yaml_load_all(stream))
         yaml_config_native = list(yaml.load_all(stream))
-        assert yaml_config_safe is not []
-        assert yaml_config_native is not []
+        assert yaml_config_safe != []
+        assert yaml_config_native != []
         assert len(yaml_config_safe) == len(yaml_config_native)
         for safe, native in zip(yaml_config_safe, yaml_config_native):
             assert safe == native

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/tests/base/utils/db/test_util.py

@@ -39,6 +39,7 @@ from datadog_checks.base.utils.serialization import json
         ("192.0.2.1", "greater-than-or-equal-to-64-characters-causes-unicode-error-----", "192.0.2.1"),
         ("192.0.2.1", "192.0.2.1", "192.0.2.1"),
         ("192.0.2.1", "192.0.2.254", "192.0.2.1"),
+        ("postgres.svc.local", "some-pod", "postgres.svc.local"),
     ],
 )
 def test_resolve_db_host(db_host, agent_hostname, want):

{datadog_checks_base-37.2.0 → datadog_checks_base-37.3.0}/tests/stubs/test_aggregator_similar.py

@@ -3,6 +3,8 @@
 # Licensed under a 3-clause BSD style license (see LICENSE)
 import difflib
 
+import pytest
+
 from datadog_checks.base import AgentCheck
 from datadog_checks.base.stubs import similar
 from datadog_checks.base.stubs.aggregator import AggregatorStub
@@ -24,6 +26,10 @@ class TestSimilarAssertionMessages(object):
         expected_msg = '''
     Expected:
         MetricStub(name='test.similar_metric', type=None, value=None, tags=None, hostname=None, device=None, flush_first_value=None)
+Difference to closest:
+        Expected name: test.similar_metric
+        Found test.most_similar_metric
+
 Similar submitted:
 Score   Most similar
 0.88    MetricStub(name='test.most_similar_metric', type=0, value=0.0, tags=[], hostname='', device=None, flush_first_value=False)
@@ -214,3 +220,33 @@ Score   Most similar
         assert similar_histogram_bucket[3][1].name == 'histogram.bucket4'  # value/monotonic/tag match
         assert similar_histogram_bucket[4][1].name == 'histogram.bucket5'  # value/monotonic match
         assert similar_histogram_bucket[5][1].name == 'histogram.bucket0'  # no match
+
+    @pytest.mark.parametrize(
+        "expected, closest, diff",
+        [
+            pytest.param({'a': 1, 'b': 2}, {'a': 1, 'b': 3}, [('b', 2, 3)], id="different value in closest"),
+            pytest.param({'a': 1}, {'b': 3}, [('a', 1, None)], id="missing key in closest"),
+            pytest.param({'a': 1}, {'a': 1}, [], id="no difference"),
+            pytest.param({'a': 1}, {}, [('a', 1, None)], id="missing key in empty closest"),
+            pytest.param({}, {'a': 1}, [], id="empty expected and extra key in closest"),
+            pytest.param({}, {}, [], id="empty"),
+        ],
+    )
+    def test_dict_diff(self, expected, closest, diff):
+        assert similar.dict_diff(expected, closest) == diff
+
+    @pytest.mark.parametrize(
+        "expected, closest, diff",
+        [
+            pytest.param(
+                ['a:1', 'b:2'], ['a:1', 'c:2'], [('b', '2', None), ('c', None, '2')], id="missing tag and extra tag"
+            ),
+            pytest.param(['a:1', 'b:2'], ['a:2', 'b:2'], [('a', '1', '2')], id="different value in closest"),
+            pytest.param(['a:1'], ['a:1'], [], id="no difference"),
+            pytest.param([], [], [], id="empty lists"),
+            pytest.param(['a:1'], [], [("a", "1", None)], id="missing tag in empty closest"),
+            pytest.param([], ['a:1'], [("a", None, "1")], id="empty expected extra tag in closest"),
+        ],
+    )
+    def test_tags_diff(self, expected, closest, diff):
+        assert similar.tags_diff(expected, closest) == diff