redis-benchmarks-specification 0.1.328__py3-none-any.whl → 0.1.330__py3-none-any.whl

redis_benchmarks_specification/__common__/runner.py

@@ -291,13 +291,7 @@ def export_redis_metrics(
             metric_name,
             metric_value,
         ) in overall_end_time_metrics.items():
-            tsname_metric = "{}/{}/{}/benchmark_end/{}/{}".format(
-                sprefix,
-                test_name,
-                by_variant,
-                setup_name,
-                metric_name,
-            )
+            tsname_metric = f"{sprefix}/{test_name}/{by_variant}/benchmark_end/{running_platform}/{setup_name}/{metric_name}"
 
             logging.debug(
                 "Adding a redis server side metric collected at the end of benchmark."
@@ -404,6 +398,7 @@ def exporter_datasink_common(
         running_platform,
         None,
         git_hash,
+        disable_target_tables=True,
     )
     if collect_memory_metrics:
         logging.info("Collecting memory metrics")

redis_benchmarks_specification/__common__/suppress_warnings.py

@@ -0,0 +1,20 @@
+"""
+Warning suppression module that should be imported first to suppress known warnings.
+"""
+
+import warnings
+
+# Suppress cryptography deprecation warnings from paramiko
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="paramiko")
+warnings.filterwarnings("ignore", message=".*TripleDES.*", category=DeprecationWarning)
+warnings.filterwarnings(
+    "ignore", message=".*cryptography.*", category=DeprecationWarning
+)
+
+# Also suppress the specific CryptographyDeprecationWarning if it exists
+try:
+    from cryptography.utils import CryptographyDeprecationWarning
+
+    warnings.filterwarnings("ignore", category=CryptographyDeprecationWarning)
+except ImportError:
+    pass

redis_benchmarks_specification/__common__/timeseries.py

@@ -838,34 +838,47 @@ def common_exporter_logic(
         and artifact_version != ""
         and artifact_version != "N/A"
     ):
-        # extract per-version datapoints
-        total_hs_ts = len(per_hash_time_series_dict.keys())
-        logging.info(
-            f"Extending the by.hash {git_hash} timeseries ({total_hs_ts}) with version info {artifact_version}"
-        )
-        for hash_timeserie in per_hash_time_series_dict.values():
-            hash_timeserie["labels"]["version"] = artifact_version
-        (
-            _,
-            per_version_time_series_dict,
-            version_target_tables,
-        ) = extract_perversion_timeseries_from_results(
-            used_ts,
-            metrics,
-            results_dict,
-            artifact_version,
-            tf_github_org,
-            tf_github_repo,
-            deployment_name,
-            deployment_type,
-            test_name,
-            tf_triggering_env,
-            metadata_tags,
-            build_variant_name,
-            running_platform,
-            testcase_metric_context_paths,
-        )
-        total_break_by_added += 1
+        # Check if version 255.255.255 should only be pushed for unstable branch
+        should_push_version = True
+        if artifact_version == "255.255.255":
+            if tf_github_branch != "unstable":
+                logging.info(
+                    f"Skipping version 255.255.255 data push for branch '{tf_github_branch}' "
+                    f"(only pushing for 'unstable' branch)"
+                )
+                should_push_version = False
+            else:
+                logging.info(f"Pushing version 255.255.255 data for unstable branch")
+
+        if should_push_version:
+            # extract per-version datapoints
+            total_hs_ts = len(per_hash_time_series_dict.keys())
+            logging.info(
+                f"Extending the by.hash {git_hash} timeseries ({total_hs_ts}) with version info {artifact_version}"
+            )
+            for hash_timeserie in per_hash_time_series_dict.values():
+                hash_timeserie["labels"]["version"] = artifact_version
+            (
+                _,
+                per_version_time_series_dict,
+                version_target_tables,
+            ) = extract_perversion_timeseries_from_results(
+                used_ts,
+                metrics,
+                results_dict,
+                artifact_version,
+                tf_github_org,
+                tf_github_repo,
+                deployment_name,
+                deployment_type,
+                test_name,
+                tf_triggering_env,
+                metadata_tags,
+                build_variant_name,
+                running_platform,
+                testcase_metric_context_paths,
+            )
+            total_break_by_added += 1
     else:
         logging.warning(
             "there was no git VERSION information to push data brokedown by VERSION"
@@ -1118,6 +1131,7 @@ def add_standardized_metric_byversion(
             tf_triggering_env,
             metadata_tags,
             build_variant_name,
+            running_platform,
         )
         labels["version"] = artifact_version
         labels["deployment_name+version"] = "{} {}".format(
@@ -1169,6 +1183,7 @@ def timeseries_test_sucess_flow(
     running_platform=None,
     timeseries_dict=None,
     git_hash=None,
+    disable_target_tables=False,
 ):
     testcase_metric_context_paths = []
     version_target_tables = None
@@ -1205,7 +1220,7 @@ def timeseries_test_sucess_flow(
             )
         )
         push_data_to_redistimeseries(rts, timeseries_dict)
-        if version_target_tables is not None:
+        if not disable_target_tables and version_target_tables is not None:
             logging.info(
                 "There are a total of {} distinct target tables by version".format(
                     len(version_target_tables.keys())
@@ -1225,7 +1240,12 @@ def timeseries_test_sucess_flow(
                 rts.hset(
                     version_target_table_keyname, None, None, version_target_table_dict
                 )
-        if branch_target_tables is not None:
+        elif disable_target_tables:
+            logging.info(
+                "Target tables disabled - skipping version target table creation"
+            )
+
+        if not disable_target_tables and branch_target_tables is not None:
             logging.info(
                 "There are a total of {} distinct target tables by branch".format(
                     len(branch_target_tables.keys())
@@ -1246,6 +1266,10 @@ def timeseries_test_sucess_flow(
                 rts.hset(
                     branch_target_table_keyname, None, None, branch_target_table_dict
                 )
+        elif disable_target_tables:
+            logging.info(
+                "Target tables disabled - skipping branch target table creation"
+            )
         if test_name is not None:
             if type(test_name) is str:
                 update_secondary_result_keys(

redis_benchmarks_specification/__runner__/runner.py

@@ -1,3 +1,6 @@
+# Import warning suppression first
+from redis_benchmarks_specification.__common__.suppress_warnings import *
+
 import datetime
 import json
 import logging
@@ -19,15 +22,11 @@ from docker.models.containers import Container
 from pytablewriter import CsvTableWriter, MarkdownTableWriter
 from redisbench_admin.profilers.profilers_local import (
     check_compatible_system_and_kernel_and_prepare_profile,
-    local_profilers_platform_checks,
-    profilers_start_if_required,
-    profilers_stop_if_required,
 )
 from redisbench_admin.run.common import (
     get_start_time_vars,
     merge_default_and_config_metrics,
     prepare_benchmark_parameters,
-    dbconfig_keyspacelen_check,
 )
 
 from redis_benchmarks_specification.__common__.runner import (
@@ -158,6 +157,83 @@ def parse_redis_uri(uri):
         return {}
 
 
+def validate_benchmark_metrics(
+    results_dict, test_name, benchmark_config=None, default_metrics=None
+):
+    """
+    Validate benchmark metrics to ensure they contain reasonable values.
+    Fails the test if critical metrics indicate something is wrong.
+
+    Args:
+        results_dict: Dictionary containing benchmark results
+        test_name: Name of the test being validated
+        benchmark_config: Benchmark configuration (unused, for compatibility)
+        default_metrics: Default metrics configuration (unused, for compatibility)
+
+    Returns:
+        tuple: (is_valid, error_message)
+    """
+    try:
+        # Define validation rules
+        throughput_patterns = [
+            "ops/sec",
+            "qps",
+            "totals.ops/sec",
+            "all_stats.totals.ops/sec",
+        ]
+
+        latency_patterns = ["latency", "p50", "p95", "p99", "p999", "usec", "msec"]
+
+        validation_errors = []
+
+        def check_nested_dict(data, path=""):
+            """Recursively check nested dictionary for metrics"""
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    current_path = f"{path}.{key}" if path else key
+                    check_nested_dict(value, current_path)
+            elif isinstance(data, (int, float)):
+                metric_path_lower = path.lower()
+
+                # Check throughput metrics
+                for pattern in throughput_patterns:
+                    if pattern in metric_path_lower:
+                        if data <= 10:  # Below 10 QPS threshold
+                            validation_errors.append(
+                                f"Throughput metric '{path}' has invalid value: {data} "
+                                f"(below 10 QPS threshold)"
+                            )
+                        break
+
+                # Check latency metrics
+                for pattern in latency_patterns:
+                    if pattern in metric_path_lower:
+                        if data <= 0.0:  # Invalid latency
+                            validation_errors.append(
+                                f"Latency metric '{path}' has invalid value: {data} "
+                                f"(should be > 0.0)"
+                            )
+                        break
+
+        # Validate the results dictionary
+        check_nested_dict(results_dict)
+
+        if validation_errors:
+            error_msg = f"Test {test_name} failed metric validation:\n" + "\n".join(
+                validation_errors
+            )
+            logging.error(error_msg)
+            return False, error_msg
+
+        logging.info(f"Test {test_name} passed metric validation")
+        return True, None
+
+    except Exception as e:
+        logging.warning(f"Error during metric validation for test {test_name}: {e}")
+        # Don't fail the test if validation itself fails
+        return True, None
+
+
 def run_local_command_with_timeout(command_str, timeout_seconds, description="command"):
     """
     Run a local command with timeout support.
@@ -2753,6 +2829,23 @@ def process_self_contained_coordinator_stream(
                             "Using aggregated JSON results from multi-client execution"
                         )
                         results_dict = json.loads(client_container_stdout)
+
+                        # Validate benchmark metrics
+                        is_valid, validation_error = validate_benchmark_metrics(
+                            results_dict, test_name, benchmark_config, default_metrics
+                        )
+                        if not is_valid:
+                            logging.error(
+                                f"Test {test_name} failed metric validation: {validation_error}"
+                            )
+                            test_result = False
+                            delete_temporary_files(
+                                temporary_dir_client=temporary_dir_client,
+                                full_result_path=full_result_path,
+                                benchmark_tool_global=benchmark_tool_global,
+                            )
+                            continue
+
                         # Print results table for multi-client
                         print_results_table_stdout(
                             benchmark_config,
@@ -2815,6 +2908,23 @@ def process_self_contained_coordinator_stream(
                                 "r",
                             ) as json_file:
                                 results_dict = json.load(json_file)
+
+                        # Validate benchmark metrics
+                        is_valid, validation_error = validate_benchmark_metrics(
+                            results_dict, test_name, benchmark_config, default_metrics
+                        )
+                        if not is_valid:
+                            logging.error(
+                                f"Test {test_name} failed metric validation: {validation_error}"
+                            )
+                            test_result = False
+                            delete_temporary_files(
+                                temporary_dir_client=temporary_dir_client,
+                                full_result_path=full_result_path,
+                                benchmark_tool_global=benchmark_tool_global,
+                            )
+                            continue
+
                         print_results_table_stdout(
                             benchmark_config,
                             default_metrics,

redis_benchmarks_specification/__self_contained_coordinator__/args.py

@@ -28,6 +28,12 @@ def create_self_contained_coordinator_args(project_name):
         description=project_name,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=project_name,
+        help="Show version information and exit",
+    )
     parser.add_argument("--event_stream_host", type=str, default=GH_REDIS_SERVER_HOST)
     parser.add_argument("--event_stream_port", type=int, default=GH_REDIS_SERVER_PORT)
     parser.add_argument("--event_stream_pass", type=str, default=GH_REDIS_SERVER_AUTH)
@@ -171,4 +177,28 @@ def create_self_contained_coordinator_args(project_name):
         default="",
         help="Filter tests to run only with the specified topology (e.g. oss-standalone)",
     )
+    parser.add_argument(
+        "--exclusive-hardware",
+        default=False,
+        action="store_true",
+        help="Enable exclusive hardware mode. Kills all memtier processes and stops all docker containers before and after each test.",
+    )
+    parser.add_argument(
+        "--http-port",
+        type=int,
+        default=8080,
+        help="Port for HTTP server endpoints (/ping health check and /reset-queue POST endpoint).",
+    )
+    parser.add_argument(
+        "--http-auth-username",
+        type=str,
+        default=None,
+        help="Username for HTTP endpoint authentication. HTTP server is disabled if not provided.",
+    )
+    parser.add_argument(
+        "--http-auth-password",
+        type=str,
+        default=None,
+        help="Password for HTTP endpoint authentication. HTTP server is disabled if not provided.",
+    )
     return parser

redis_benchmarks_specification/__self_contained_coordinator__/runners.py

@@ -615,6 +615,9 @@ def process_self_contained_coordinator_stream(
                                 metadata,
                                 build_variant_name,
                                 running_platform,
+                                None,
+                                None,
+                                disable_target_tables=True,
                             )
                             test_result = True
                             total_test_suite_runs = total_test_suite_runs + 1

redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -1,9 +1,14 @@
+# Import warning suppression first
+from redis_benchmarks_specification.__common__.suppress_warnings import *
+
 import datetime
 import json
 import logging
 import pathlib
 import shutil
+import subprocess
 import tempfile
+import threading
 import traceback
 import re
 import docker
@@ -13,6 +18,9 @@ import os
 from pathlib import Path
 import sys
 import time
+import base64
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
 
 from docker.models.containers import Container
 from redis_benchmarks_specification.__self_contained_coordinator__.post_processing import (
@@ -59,6 +67,7 @@ from redis_benchmarks_specification.__compare__.compare import (
 from redis_benchmarks_specification.__runner__.runner import (
     print_results_table_stdout,
     prepare_memtier_benchmark_parameters,
+    validate_benchmark_metrics,
 )
 from redis_benchmarks_specification.__self_contained_coordinator__.args import (
     create_self_contained_coordinator_args,
@@ -108,6 +117,192 @@ from redis_benchmarks_specification.__self_contained_coordinator__.build_info im
     extract_build_info_from_streamdata,
 )
 
+# Global variables for HTTP server control
+_reset_queue_requested = False
+_exclusive_hardware = False
+_http_auth_username = None
+_http_auth_password = None
+
+
+class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
+    """HTTP request handler for coordinator endpoints"""
+
+    def log_message(self, format, *args):
+        """Override to use our logging system"""
+        logging.info(f"HTTP {format % args}")
+
+    def _authenticate(self):
+        """Check if the request is authenticated"""
+        global _http_auth_username, _http_auth_password
+
+        # Check for Authorization header
+        auth_header = self.headers.get("Authorization")
+        if not auth_header:
+            return False
+
+        # Parse Basic auth
+        try:
+            if not auth_header.startswith("Basic "):
+                return False
+
+            # Decode base64 credentials
+            encoded_credentials = auth_header[6:]  # Remove 'Basic ' prefix
+            decoded_credentials = base64.b64decode(encoded_credentials).decode("utf-8")
+            username, password = decoded_credentials.split(":", 1)
+
+            # Verify credentials
+            return username == _http_auth_username and password == _http_auth_password
+
+        except Exception as e:
+            logging.warning(f"Authentication error: {e}")
+            return False
+
+    def _send_auth_required(self):
+        """Send 401 Unauthorized response"""
+        self.send_response(401)
+        self.send_header(
+            "WWW-Authenticate", 'Basic realm="Redis Benchmarks Coordinator"'
+        )
+        self.send_header("Content-type", "application/json")
+        self.end_headers()
+        response = {
+            "error": "Authentication required",
+            "message": "Please provide valid credentials using Basic authentication",
+        }
+        self.wfile.write(json.dumps(response).encode())
+
+    def do_GET(self):
+        """Handle GET requests"""
+        # Check authentication
+        if not self._authenticate():
+            self._send_auth_required()
+            return
+
+        parsed_path = urlparse(self.path)
+
+        if parsed_path.path == "/ping":
+            self.send_response(200)
+            self.send_header("Content-type", "application/json")
+            self.end_headers()
+            response = {
+                "status": "healthy",
+                "timestamp": datetime.datetime.utcnow().isoformat(),
+                "service": "redis-benchmarks-self-contained-coordinator",
+            }
+            self.wfile.write(json.dumps(response).encode())
+        else:
+            self.send_response(404)
+            self.send_header("Content-type", "application/json")
+            self.end_headers()
+            self.wfile.write(json.dumps({"error": "Not found"}).encode())
+
+    def do_POST(self):
+        """Handle POST requests"""
+        # Check authentication
+        if not self._authenticate():
+            self._send_auth_required()
+            return
+
+        global _reset_queue_requested
+
+        parsed_path = urlparse(self.path)
+
+        if parsed_path.path == "/reset-queue":
+            try:
+                # Read request body
+                content_length = int(self.headers.get("Content-Length", 0))
+                if content_length > 0:
+                    post_data = self.rfile.read(content_length)
+                    try:
+                        request_data = json.loads(post_data.decode())
+                    except json.JSONDecodeError:
+                        request_data = {}
+                else:
+                    request_data = {}
+
+                # Set the reset flag
+                _reset_queue_requested = True
+                logging.info("Queue reset requested via HTTP endpoint")
+
+                self.send_response(200)
+                self.send_header("Content-type", "application/json")
+                self.end_headers()
+                response = {
+                    "status": "success",
+                    "message": "Queue reset requested",
+                    "timestamp": datetime.datetime.utcnow().isoformat(),
+                }
+                self.wfile.write(json.dumps(response).encode())
+
+            except Exception as e:
+                logging.error(f"Error handling reset-queue request: {e}")
+                self.send_response(500)
+                self.send_header("Content-type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": str(e)}).encode())
+        else:
+            self.send_response(404)
+            self.send_header("Content-type", "application/json")
+            self.end_headers()
+            self.wfile.write(json.dumps({"error": "Not found"}).encode())
+
+
+def start_http_server(port=8080):
+    """Start the HTTP server in a separate thread"""
+
+    def run_server():
+        try:
+            server = HTTPServer(("0.0.0.0", port), CoordinatorHTTPHandler)
+            logging.info(f"Starting HTTP server on port {port}")
+            logging.info(f"Available endpoints:")
+            logging.info(f"  GET  /ping - Health check")
+            logging.info(
+                f"  POST /reset-queue - Reset pending streams and skip running tests"
+            )
+            server.serve_forever()
+        except Exception as e:
+            logging.error(f"HTTP server error: {e}")
+
+    server_thread = threading.Thread(target=run_server, daemon=True)
+    server_thread.start()
+    return server_thread
+
+
+def cleanup_system_processes():
+    """Clean up memtier processes and docker containers for exclusive hardware mode"""
+    global _exclusive_hardware
+
+    if not _exclusive_hardware:
+        return
+
+    logging.info("Exclusive hardware mode: Cleaning up system processes")
+
+    try:
+        # Kill all memtier_benchmark processes
+        logging.info("Killing all memtier_benchmark processes")
+        subprocess.run(["pkill", "-f", "memtier_benchmark"], check=False)
+
+        # Stop all docker containers
+        logging.info("Stopping all docker containers")
+        docker_client = docker.from_env()
+        containers = docker_client.containers.list()
+        for container in containers:
+            try:
+                logging.info(
+                    f"Stopping container: {container.name} ({container.id[:12]})"
+                )
+                container.stop(timeout=10)
+                container.remove(force=True)
+            except Exception as e:
+                logging.warning(f"Error stopping container {container.id[:12]}: {e}")
+
+        # Wait a moment for cleanup to complete
+        time.sleep(2)
+        logging.info("System cleanup completed")
+
+    except Exception as e:
+        logging.error(f"Error during system cleanup: {e}")
+
 
 def print_directory_logs(directory_path, description=""):
     """Print all .log files in a directory for debugging purposes."""
@@ -157,6 +352,8 @@ from redis_benchmarks_specification.__self_contained_coordinator__.docker import
 
 
 def main():
+    global _exclusive_hardware, _http_auth_username, _http_auth_password
+
     _, _, project_version = populate_with_poetry_data()
     project_name = "redis-benchmarks-spec runner(self-contained)"
     parser = create_self_contained_coordinator_args(
@@ -164,6 +361,23 @@ def main():
     )
     args = parser.parse_args()
 
+    # Set global exclusive hardware flag
+    _exclusive_hardware = args.exclusive_hardware
+    if _exclusive_hardware:
+        logging.info("Exclusive hardware mode enabled")
+
+    # Set HTTP authentication credentials and start server only if credentials are provided
+    _http_auth_username = args.http_auth_username
+    _http_auth_password = args.http_auth_password
+
+    if _http_auth_username and _http_auth_password:
+        logging.info(
+            "Starting HTTP server with authentication on port {}".format(args.http_port)
+        )
+        start_http_server(args.http_port)
+    else:
+        logging.info("HTTP server disabled - no authentication credentials provided")
+
     if args.logname is not None:
         print("Writting log to {}".format(args.logname))
         logging.basicConfig(
@@ -750,7 +964,7 @@ def process_self_contained_coordinator_stream(
                     github_event_conn.expire(
                         stream_test_list_pending, REDIS_BINS_EXPIRE_SECS
                     )
-                    logging.info(
+                    logging.debug(
                         f"Added test named {test_name} to the pending test list in key {stream_test_list_pending}"
                     )
 
@@ -781,6 +995,22 @@ def process_self_contained_coordinator_stream(
                         )
 
                 for test_file in filtered_test_files:
+                    # Check if queue reset was requested
+                    global _reset_queue_requested
+                    if _reset_queue_requested:
+                        logging.info(
+                            "Queue reset requested. Skipping remaining tests and clearing queues."
+                        )
+                        # Clear all pending tests from the queue
+                        github_event_conn.delete(stream_test_list_pending)
+                        github_event_conn.delete(stream_test_list_running)
+                        logging.info("Cleared pending and running test queues")
+                        _reset_queue_requested = False
+                        break
+
+                    # Clean up system processes if in exclusive hardware mode
+                    cleanup_system_processes()
+
                     redis_containers = []
                     client_containers = []
                     with open(test_file, "r") as stream:
@@ -794,8 +1024,8 @@ def process_self_contained_coordinator_stream(
                         github_event_conn.expire(
                             stream_test_list_running, REDIS_BINS_EXPIRE_SECS
                         )
-                        logging.info(
-                            f"Added test named {test_name} to the pending test list in key {stream_test_list_running}"
+                        logging.debug(
+                            f"Added test named {test_name} to the running test list in key {stream_test_list_running}"
                         )
                         (
                             _,
@@ -1250,6 +1480,23 @@ def process_self_contained_coordinator_stream(
                                     results_dict = post_process_vector_db(
                                         temporary_dir_client
                                     )
+
+                                    # Validate benchmark metrics for vector-db-benchmark
+                                    is_valid, validation_error = (
+                                        validate_benchmark_metrics(
+                                            results_dict,
+                                            test_name,
+                                            benchmark_config,
+                                            default_metrics,
+                                        )
+                                    )
+                                    if not is_valid:
+                                        logging.error(
+                                            f"Test {test_name} failed metric validation: {validation_error}"
+                                        )
+                                        test_result = False
+                                        failed_tests += 1
+                                        continue
                                 else:
                                     post_process_benchmark_results(
                                         benchmark_tool,
@@ -1276,6 +1523,24 @@ def process_self_contained_coordinator_stream(
                                         "r",
                                     ) as json_file:
                                         results_dict = json.load(json_file)
+
+                                        # Validate benchmark metrics
+                                        is_valid, validation_error = (
+                                            validate_benchmark_metrics(
+                                                results_dict,
+                                                test_name,
+                                                benchmark_config,
+                                                default_metrics,
+                                            )
+                                        )
+                                        if not is_valid:
+                                            logging.error(
+                                                f"Test {test_name} failed metric validation: {validation_error}"
+                                            )
+                                            test_result = False
+                                            failed_tests += 1
+                                            continue
+
                                         print_results_table_stdout(
                                             benchmark_config,
                                             default_metrics,
@@ -1430,6 +1695,9 @@ def process_self_contained_coordinator_stream(
 
                             overall_result &= test_result
 
+                    # Clean up system processes after test completion if in exclusive hardware mode
+                    cleanup_system_processes()
+
                     github_event_conn.lrem(stream_test_list_running, 1, test_name)
                     github_event_conn.lpush(stream_test_list_completed, test_name)
                     github_event_conn.expire(
@@ -1592,7 +1860,7 @@ def process_self_contained_coordinator_stream(
                                     e.__str__()
                                 )
                             )
-                    logging.info(
+                    logging.debug(
                         f"Added test named {test_name} to the completed test list in key {stream_test_list_completed}"
                     )
         else:

{redis_benchmarks_specification-0.1.328.dist-info → redis_benchmarks_specification-0.1.330.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.328
+Version: 0.1.330
 Summary: The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute.
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redis_benchmarks_specification-0.1.328.dist-info → redis_benchmarks_specification-0.1.330.dist-info}/RECORD

@@ -15,9 +15,10 @@ redis_benchmarks_specification/__common__/builder_schema.py,sha256=kfDpRIk7NkJrb
 redis_benchmarks_specification/__common__/env.py,sha256=kvJ8Ll-fvI_Tc0vynrzUEr22TqnJizzvJ4Lu9RjNr_M,3119
 redis_benchmarks_specification/__common__/github.py,sha256=9TZtnISsSgXTSAN_VQejo5YRPDPhlU0gjxgKGPw_sP8,10699
 redis_benchmarks_specification/__common__/package.py,sha256=4uVt1BAZ999LV2rZkq--Tk6otAVIf9YR3g3KGeUpiW4,834
-redis_benchmarks_specification/__common__/runner.py,sha256=qX2LOjlM84CEwPnSHFSCQXFFHYQNbQHelNQVZlNjlmQ,16789
+redis_benchmarks_specification/__common__/runner.py,sha256=TKMUFJ3nLSfmSU7P_ok9oM5-pI4L4tFxsWLUWaUHhbI,16733
 redis_benchmarks_specification/__common__/spec.py,sha256=D_SN48wg6NMthW_-OS1H5bydSDiuZpfd4WPPj7Vfwmc,5760
-redis_benchmarks_specification/__common__/timeseries.py,sha256=uvS3T2zdrSmW_B2S0MYTekJfHUllqU3RlD0LrF957RQ,52904
+redis_benchmarks_specification/__common__/suppress_warnings.py,sha256=xpOjJ_piGYWlGq9ITr-ZwSCl2GpreA9juZIBao4fDRs,691
+redis_benchmarks_specification/__common__/timeseries.py,sha256=P0tbmH7leEMQwvqlr4lYZgr_I6EY3chh1Kf7XWe5fDQ,54048
 redis_benchmarks_specification/__compare__/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redis_benchmarks_specification/__compare__/args.py,sha256=CNtA7pI9CJDTBJPGL2pNVfis7VDdxLautwRyka7oUCI,8911
 redis_benchmarks_specification/__compare__/compare.py,sha256=_AbuV3FZxtUZIdq4qq24LNzPNIdtQQaqrk8bUjn9blk,84327
@@ -25,9 +26,9 @@ redis_benchmarks_specification/__init__.py,sha256=YQIEx2sLPPA0JR9OuCuMNMNtm-f_gq
 redis_benchmarks_specification/__runner__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
 redis_benchmarks_specification/__runner__/args.py,sha256=K3VGmBC0-9lSv9H6VDp0N-6FGMWvc_4H0pG_TOXN5u8,11312
 redis_benchmarks_specification/__runner__/remote_profiling.py,sha256=R7obNQju8mmY9oKkcndjI4aAuxi84OCLhDSqqaYu1SU,18610
-redis_benchmarks_specification/__runner__/runner.py,sha256=z_xGRVcsk7dJTMiA0YrUIJASO-E-zN2m7NcgGbVnN9c,150939
+redis_benchmarks_specification/__runner__/runner.py,sha256=-BDFxOLgkFe4LvVX1FnqmuszuyRMR8AJZW0SvPX0utw,155496
 redis_benchmarks_specification/__self_contained_coordinator__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
-redis_benchmarks_specification/__self_contained_coordinator__/args.py,sha256=uxBjdQ78klvsVi6lOfGYQVaWIxc8OI-DwYKY16SgvCY,5952
+redis_benchmarks_specification/__self_contained_coordinator__/args.py,sha256=1LePhRkDsoMPFclM_DoXBIoMBN8zcVoQMnm9wTK5Uqw,6961
 redis_benchmarks_specification/__self_contained_coordinator__/artifacts.py,sha256=OVHqJzDgeSSRfUSiKp1ZTAVv14PvSbk-5yJsAAoUfpw,936
 redis_benchmarks_specification/__self_contained_coordinator__/build_info.py,sha256=vlg8H8Rxu2falW8xp1GvL1SV1fyBguSbz6Apxc7A2yM,2282
 redis_benchmarks_specification/__self_contained_coordinator__/clients.py,sha256=EL1V4-i-tTav1mcF_CUosqPF3Q1qi9BZL0zFajEk70c,1878
@@ -35,8 +36,8 @@ redis_benchmarks_specification/__self_contained_coordinator__/cpuset.py,sha256=s
 redis_benchmarks_specification/__self_contained_coordinator__/docker.py,sha256=09SyAfqlzs1KG9ZAajClNWtiNk4Jqzd--4-m3n1rLjU,3156
 redis_benchmarks_specification/__self_contained_coordinator__/post_processing.py,sha256=sVLKNnWdAqYY9DjVdqRC5tDaIrVSaI3Ca7w8-DQ-LRM,776
 redis_benchmarks_specification/__self_contained_coordinator__/prepopulation.py,sha256=1UeFr2T1ZQBcHCSd4W1ZtaWgXyFPfjLyDi_DgDc1eTA,2957
-redis_benchmarks_specification/__self_contained_coordinator__/runners.py,sha256=noRHn9leTfEm2fa1yHBHQd8TUGhFDoU86QQkHABnWSs,30073
-redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=UXGDzNGOMkHNTo21_ov4U-3PnRFkwgfQ39_TPNO0hSg,84156
+redis_benchmarks_specification/__self_contained_coordinator__/runners.py,sha256=F11zO_ILnpmiVwTeCQnP5nDHQk3kNnajPftwKsbhlXE,30209
+redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=9pwluITlVlucGhzQoWyJ8HVRpENgwJiqdaT6z300BBI,94834
 redis_benchmarks_specification/__setups__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis_benchmarks_specification/__setups__/topologies.py,sha256=xQ1IJkcTji_ZjLiJd3vOxZpvbNtBLZw9cPkw5hGJKHU,481
 redis_benchmarks_specification/__spec__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
@@ -281,8 +282,8 @@ redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-st
 redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-storage-1k-sessions.yml,sha256=2egtIxPxCze2jlbAfgsk4v9JSQHNMoPLbDWFEW8olDg,7006
 redis_benchmarks_specification/test-suites/template.txt,sha256=ezqGiRPOvuSDO0iG7GEf-AGXNfHbgXI89_G0RUEzL88,481
 redis_benchmarks_specification/vector-search-test-suites/vector_db_benchmark_test.yml,sha256=PD7ow-k4Ll2BkhEC3aIqiaCZt8Hc4aJIp96Lw3J3mcI,791
-redis_benchmarks_specification-0.1.328.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-redis_benchmarks_specification-0.1.328.dist-info/METADATA,sha256=ZczeKlE4rBkHFUAUCWSvmBzXLtYaA5s74c3rW-VnXZ8,22768
-redis_benchmarks_specification-0.1.328.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redis_benchmarks_specification-0.1.328.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
-redis_benchmarks_specification-0.1.328.dist-info/RECORD,,
+redis_benchmarks_specification-0.1.330.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+redis_benchmarks_specification-0.1.330.dist-info/METADATA,sha256=pvr1eZrXi04EZXbtHfLKbdYc34UFuKSP35IB70XEGKo,22768
+redis_benchmarks_specification-0.1.330.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redis_benchmarks_specification-0.1.330.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
+redis_benchmarks_specification-0.1.330.dist-info/RECORD,,