velero

Author: vitkyrka

datadog_checks_dev/changelog.d/24507.added

@@ -0,0 +1 @@
+Add ``kube_discovery`` e2e test helpers, install local base code in helper Agent pods, and add a named-port discovery strategy for generated candidates.

datadog_checks_dev/datadog_checks/dev/_env.py

@@ -3,7 +3,9 @@
 # Licensed under a 3-clause BSD style license (see LICENSE)
 import json
 import os
+import re
 from base64 import urlsafe_b64decode, urlsafe_b64encode
+from typing import Any
 
 DDTRACE_OPTIONS_LIST = [
     'DD_TAGS',
@@ -110,6 +112,36 @@ def format_config(config):
     return config
 
 
+def flags_to_argv(flags: dict[str, Any]) -> list[str]:
+    """Convert ``agent check`` keyword flags (e.g. ``check_rate=True``) into CLI argv tokens."""
+    argv = []
+    for key, value in flags.items():
+        if value is not False:
+            argv.append('--{}'.format(key.replace('_', '-')))
+            if value is not True:
+                argv.append(str(value))
+
+    return argv
+
+
+JSON_COLLECTOR_PATTERN = r'((?:\{ \[|\[).*?\n(?:\} \]|\]))'
+
+
+def find_collector_blobs(output: str) -> list[str]:
+    """Pull collector JSON blobs out of ``agent check --json`` output."""
+    return re.findall(JSON_COLLECTOR_PATTERN, output, re.DOTALL)
+
+
+def replay_collector_blobs(matches: list[str], stub_aggregator: Any, stub_agent: Any) -> None:
+    """Parse and replay each collector JSON blob found by ``find_collector_blobs``."""
+    for raw_json in matches:
+        try:
+            collector = json.loads(raw_json)
+        except json.JSONDecodeError as e:
+            raise ValueError(f'Error loading json: {e}\nCollector Json Output:\n{raw_json}') from e
+        replay_check_run(collector, stub_aggregator, stub_agent)
+
+
 def replay_check_run(agent_collector, stub_aggregator, stub_agent):
     errors = []
     for collector in agent_collector:

datadog_checks_dev/datadog_checks/dev/docker.py

@@ -101,14 +101,8 @@ def assert_all_discovery_candidates_stable(
         _assert_container_stable(initial_state, current_state, index)
 
         current_stdout, current_stderr = _get_container_logs(current_container_id)
-        # Diffed separately: stdout/stderr interleaving varies across calls, breaking a combined diff.
-        new_stdout = _diff_logs(previous_stdout, current_stdout)
-        new_stderr = _diff_logs(previous_stderr, current_stderr)
-        new_logs = new_stdout + new_stderr
-        for line in new_logs.splitlines():
-            logging.debug('New log line: %s', line)
-        _assert_no_log_patterns(new_logs, log_patterns, index)
-        previous_stdout, previous_stderr = current_stdout, current_stderr
+        previous_stdout = assert_no_new_log_patterns(previous_stdout, current_stdout, log_patterns, index)
+        previous_stderr = assert_no_new_log_patterns(previous_stderr, current_stderr, log_patterns, index)
 
 
 def _get_compose_container_id(
@@ -196,11 +190,6 @@ def _get_container_logs(container_id: str) -> tuple[str, str]:
     return result.stdout, result.stderr
 
 
-def _diff_logs(previous: str, current: str) -> str:
-    """Return the portion of `current` appended since `previous`."""
-    return current[len(previous) :] if current.startswith(previous) else current
-
-
 def _assert_container_stable(
     initial_state: Mapping[str, Any], current_state: Mapping[str, Any], candidate_index: int
 ) -> None:
@@ -237,6 +226,17 @@ def _assert_no_log_patterns(logs: str, patterns: Sequence[str], candidate_index:
             )
 
 
+def assert_no_new_log_patterns(
+    previous_logs: str, current_logs: str, patterns: Sequence[str], candidate_index: int
+) -> str:
+    """Assert no dangerous pattern appears in the logs emitted since ``previous_logs``, returning the new baseline."""
+    new_logs = current_logs[len(previous_logs) :] if current_logs.startswith(previous_logs) else current_logs
+    for line in new_logs.splitlines():
+        logging.debug('New log line: %s', line)
+    _assert_no_log_patterns(new_logs, patterns, candidate_index)
+    return current_logs
+
+
 def get_e2e_discovery_metadata(
     check_root: str | os.PathLike[str] | None = None,
 ) -> dict[str, list[str]]: