redisbench-admin 0.11.39__py3-none-any.whl → 0.11.41__py3-none-any.whl

redisbench_admin/run_remote/standalone.py

@@ -13,6 +13,7 @@ from redisbench_admin.utils.remote import (
 )
 from redisbench_admin.utils.ssh import SSHSession
 from redisbench_admin.utils.utils import redis_server_config_module_part
+import tempfile
 
 
 def ensure_redis_server_available(server_public_ip, username, private_key, port=22):
@@ -148,6 +149,123 @@ def ensure_memtier_benchmark_available(
         logging.error("Failed to check memtier_benchmark availability")
 
 
+def validate_remote_host_compatibility(
+    server_public_ip, username, private_key, custom_redis_server_path=None, port=22
+):
+    """
+    Validate remote host compatibility by checking OS version, stdlib version,
+    and optionally testing a custom redis-server binary.
+
+    Args:
+        server_public_ip: IP address of the remote server
+        username: SSH username
+        private_key: Path to SSH private key
+        custom_redis_server_path: Optional path to custom redis-server binary on remote host
+        port: SSH port (default 22)
+
+    Returns:
+        tuple: (success: bool, validation_info: dict)
+    """
+    logging.info("Validating remote host compatibility...")
+
+    validation_info = {}
+    success = True
+
+    try:
+        # Check OS version
+        os_commands = [
+            "uname -a",  # System information
+            "cat /etc/os-release",  # OS release info
+            "ldd --version",  # glibc version
+        ]
+
+        os_results = execute_remote_commands(
+            server_public_ip, username, private_key, os_commands, port
+        )
+
+        # Process OS information
+        for i, (recv_exit_status, stdout, stderr) in enumerate(os_results):
+            if recv_exit_status == 0:
+                if i == 0:  # uname -a
+                    validation_info["system_info"] = "".join(stdout).strip()
+                    logging.info(f"System info: {validation_info['system_info']}")
+                elif i == 1:  # /etc/os-release
+                    os_release = "".join(stdout).strip()
+                    validation_info["os_release"] = os_release
+                    logging.info(f"OS release info: {os_release}")
+                elif i == 2:  # ldd --version (glibc)
+                    glibc_info = "".join(stdout).strip()
+                    validation_info["glibc_version"] = glibc_info
+                    logging.info(f"glibc version: {glibc_info}")
+            else:
+                logging.warning(
+                    f"Command {os_commands[i]} failed with exit code {recv_exit_status}"
+                )
+                if i == 2:  # glibc check failed, try alternative
+                    alt_result = execute_remote_commands(
+                        server_public_ip,
+                        username,
+                        private_key,
+                        ["getconf GNU_LIBC_VERSION"],
+                        port,
+                    )
+                    if alt_result and alt_result[0][0] == 0:
+                        glibc_alt = "".join(alt_result[0][1]).strip()
+                        validation_info["glibc_version"] = glibc_alt
+                        logging.info(f"glibc version (alternative): {glibc_alt}")
+
+        # Test custom redis-server binary if provided
+        if custom_redis_server_path:
+            logging.info(
+                f"Testing custom redis-server binary: {custom_redis_server_path}"
+            )
+
+            # Check if the binary exists and is executable
+            check_commands = [
+                f"test -f {custom_redis_server_path}",
+                f"test -x {custom_redis_server_path}",
+                f"{custom_redis_server_path} --version",
+            ]
+
+            check_results = execute_remote_commands(
+                server_public_ip, username, private_key, check_commands, port
+            )
+
+            for i, (recv_exit_status, stdout, stderr) in enumerate(check_results):
+                if recv_exit_status != 0:
+                    if i == 0:
+                        logging.error(
+                            f"Custom redis-server binary not found: {custom_redis_server_path}"
+                        )
+                        success = False
+                    elif i == 1:
+                        logging.error(
+                            f"Custom redis-server binary not executable: {custom_redis_server_path}"
+                        )
+                        success = False
+                    elif i == 2:
+                        logging.error(
+                            f"Custom redis-server binary --version failed: {stderr}"
+                        )
+                        success = False
+                    break
+                elif i == 2:  # --version succeeded
+                    version_output = "".join(stdout).strip()
+                    validation_info["custom_redis_version"] = version_output
+                    logging.info(f"Custom redis-server version: {version_output}")
+
+    except Exception as e:
+        logging.error(f"Remote host validation failed with exception: {e}")
+        success = False
+
+    if success:
+        logging.info("✅ Remote host validation passed")
+    else:
+        logging.error("❌ Remote host validation failed")
+
+    return success, validation_info
+
+
 def spin_up_standalone_remote_redis(
     temporary_dir,
     server_public_ip,
@@ -290,10 +408,24 @@ def generate_remote_standalone_redis_cmd(
     modules_configuration_parameters_map,
     enable_redis_7_config_directives=True,
     enable_debug_command="yes",
+    custom_redis_server_path=None,
+    custom_redis_conf_path=None,
 ):
-    initial_redis_cmd = "redis-server --save '' --logfile {} --dir {} --daemonize yes --protected-mode no ".format(
-        logfile, temporary_dir
+    # Use custom redis-server binary if provided, otherwise use default
+    redis_server_binary = (
+        custom_redis_server_path if custom_redis_server_path else "redis-server"
     )
+
+    # If custom config file is provided, use it; otherwise use command line parameters
+    if custom_redis_conf_path:
+        initial_redis_cmd = "{} {} --daemonize yes".format(
+            redis_server_binary, custom_redis_conf_path
+        )
+        logging.info(f"Using custom redis.conf: {custom_redis_conf_path}")
+    else:
+        initial_redis_cmd = "{} --save '' --logfile {} --dir {} --daemonize yes --protected-mode no ".format(
+            redis_server_binary, logfile, temporary_dir
+        )
     if enable_redis_7_config_directives:
         extra_str = " --enable-debug-command {} ".format(enable_debug_command)
         initial_redis_cmd = initial_redis_cmd + extra_str
@@ -323,3 +455,290 @@ def generate_remote_standalone_redis_cmd(
     if remote_module_files is not None:
         initial_redis_cmd += " " + " ".join(command)
     return full_logfile, initial_redis_cmd
+
+
+def spin_test_standalone_redis(
+    server_public_ip,
+    username,
+    private_key,
+    db_ssh_port=22,
+    redis_port=6379,
+    local_module_files=None,
+    redis_configuration_parameters=None,
+    modules_configuration_parameters_map=None,
+    custom_redis_conf_path=None,
+    custom_redis_server_path=None,
+):
+    """
+    Setup standalone Redis server, run INFO SERVER, print output as markdown and exit.
+
+    Args:
+        server_public_ip: IP address of the remote server
+        username: SSH username
+        private_key: Path to SSH private key
+        db_ssh_port: SSH port (default 22)
+        redis_port: Redis port (default 6379)
+        local_module_files: List of local module files to copy
+        redis_configuration_parameters: Dict of Redis configuration parameters
+        modules_configuration_parameters_map: Dict of module configuration parameters
+        custom_redis_conf_path: Path to custom redis.conf file
+        custom_redis_server_path: Path to custom redis-server binary
+    """
+    logging.info("🚀 Starting spin-test mode...")
+
+    try:
+        # Create temporary directory on remote host
+        temporary_dir = "/tmp/redisbench-spin-test"
+        create_dir_commands = [f"mkdir -p {temporary_dir}"]
+        execute_remote_commands(
+            server_public_ip, username, private_key, create_dir_commands, db_ssh_port
+        )
+
+        # Ensure Redis server is available (only if not using custom binary)
+        if custom_redis_server_path is None:
+            ensure_redis_server_available(
+                server_public_ip, username, private_key, db_ssh_port
+            )
+        else:
+            logging.info(
+                "🔧 Using custom Redis binary - skipping system Redis installation"
+            )
+
+        # Copy custom Redis files if provided
+        remote_redis_conf_path = None
+        remote_redis_server_path = None
+
+        if custom_redis_conf_path:
+            if not os.path.exists(custom_redis_conf_path):
+                logging.error(
+                    f"❌ Custom redis.conf file not found: {custom_redis_conf_path}"
+                )
+                return False
+
+            remote_redis_conf_path = f"{temporary_dir}/redis.conf"
+            logging.info(f"📁 Copying custom redis.conf to remote host...")
+
+            copy_result = copy_file_to_remote_setup(
+                server_public_ip,
+                username,
+                private_key,
+                custom_redis_conf_path,
+                remote_redis_conf_path,
+                None,
+                db_ssh_port,
+                False,  # don't continue on error
+            )
+
+            if not copy_result:
+                logging.error("❌ Failed to copy redis.conf to remote host")
+                return False
+
+        if custom_redis_server_path:
+            if not os.path.exists(custom_redis_server_path):
+                logging.error(
+                    f"❌ Custom redis-server binary not found: {custom_redis_server_path}"
+                )
+                return False
+
+            remote_redis_server_path = f"{temporary_dir}/redis-server"
+            logging.info(f"📁 Copying custom redis-server binary to remote host...")
+
+            copy_result = copy_file_to_remote_setup(
+                server_public_ip,
+                username,
+                private_key,
+                custom_redis_server_path,
+                remote_redis_server_path,
+                None,
+                db_ssh_port,
+                False,  # don't continue on error
+            )
+
+            if not copy_result:
+                logging.error("❌ Failed to copy redis-server binary to remote host")
+                return False
+
+            # Make the binary executable
+            chmod_commands = [f"chmod +x {remote_redis_server_path}"]
+            chmod_results = execute_remote_commands(
+                server_public_ip, username, private_key, chmod_commands, db_ssh_port
+            )
+
+            recv_exit_status, stdout, stderr = chmod_results[0]
+            if recv_exit_status != 0:
+                logging.warning(
+                    f"⚠️ Failed to make redis-server binary executable: {stderr}"
+                )
+            else:
+                logging.info("✅ Redis-server binary made executable")
+
+        # Copy modules if provided
+        remote_module_files = None
+        if local_module_files:
+            remote_module_file_dir = f"{temporary_dir}/modules"
+            create_module_dir_commands = [f"mkdir -p {remote_module_file_dir}"]
+            execute_remote_commands(
+                server_public_ip,
+                username,
+                private_key,
+                create_module_dir_commands,
+                db_ssh_port,
+            )
+
+            remote_module_files = remote_module_files_cp(
+                local_module_files,
+                db_ssh_port,
+                private_key,
+                remote_module_file_dir,
+                server_public_ip,
+                username,
+                continue_on_module_check_error=True,
+            )
+
+        # Generate Redis startup command
+        logfile = "redis-spin-test.log"
+        full_logfile, redis_cmd = generate_remote_standalone_redis_cmd(
+            logfile,
+            redis_configuration_parameters,
+            remote_module_files,
+            temporary_dir,
+            modules_configuration_parameters_map or {},
+            enable_redis_7_config_directives=True,
+            enable_debug_command="yes",
+            custom_redis_server_path=remote_redis_server_path,
+            custom_redis_conf_path=remote_redis_conf_path,
+        )
+
+        # Override port if specified
+        if redis_port != 6379:
+            redis_cmd += f" --port {redis_port}"
+
+        logging.info(f"🔧 Starting Redis with command: {redis_cmd}")
+
+        # Start Redis server
+        start_commands = [redis_cmd]
+        start_result = execute_remote_commands(
+            server_public_ip, username, private_key, start_commands, db_ssh_port
+        )
+
+        # Check if Redis started successfully
+        recv_exit_status, stdout, stderr = start_result[0]
+        if recv_exit_status != 0:
+            logging.error(
+                f"❌ Failed to start Redis server. Exit code: {recv_exit_status}"
+            )
+            logging.error(f"STDOUT: {stdout}")
+            logging.error(f"STDERR: {stderr}")
+            return False
+
+        # Wait a moment for Redis to fully start
+        import time
+
+        time.sleep(2)
+
+        # Collect system information
+        logging.info("📊 Collecting system information...")
+        system_commands = [
+            "uname -a",  # System information
+            "cat /etc/os-release",  # OS release info
+            "ldd --version 2>/dev/null || getconf GNU_LIBC_VERSION 2>/dev/null || echo 'glibc version not available'",  # glibc version
+            "cat /proc/version",  # Kernel version
+            "cat /proc/cpuinfo | grep 'model name' | head -1",  # CPU info
+            "free -h",  # Memory info
+            "df -h /",  # Disk space
+        ]
+
+        system_results = execute_remote_commands(
+            server_public_ip, username, private_key, system_commands, db_ssh_port
+        )
+
+        # Run INFO SERVER command
+        info_commands = [f"redis-cli -p {redis_port} INFO SERVER"]
+        info_result = execute_remote_commands(
+            server_public_ip, username, private_key, info_commands, db_ssh_port
+        )
+
+        recv_exit_status, stdout, stderr = info_result[0]
+        if recv_exit_status != 0:
+            logging.error(
+                f"❌ Failed to run INFO SERVER. Exit code: {recv_exit_status}"
+            )
+            logging.error(f"STDOUT: {stdout}")
+            logging.error(f"STDERR: {stderr}")
+            return False
+
+        # Format output as markdown
+        info_output = "".join(stdout).strip()
+
+        print("\n" + "=" * 80)
+        print("🎯 REDIS SPIN-TEST RESULTS")
+        print("=" * 80)
+        print()
+
+        # Display system information
+        print("## 🖥️  System Information")
+        print()
+
+        system_labels = [
+            "System Info",
+            "OS Release",
+            "glibc Version",
+            "Kernel Version",
+            "CPU Model",
+            "Memory",
+            "Disk Space",
+        ]
+
+        for i, (label, (recv_exit_status, stdout, stderr)) in enumerate(
+            zip(system_labels, system_results)
+        ):
+            if recv_exit_status == 0 and stdout:
+                output = "".join(stdout).strip()
+                if output:
+                    print(f"**{label}:**")
+                    print("```")
+                    print(output)
+                    print("```")
+                    print()
+            else:
+                print(f"**{label}:** ⚠️ Not available")
+                print()
+
+        # Display Redis information
+        print("## 🔴 Redis Server Information")
+        print()
+        print("```")
+        print(info_output)
+        print("```")
+        print()
+        print("✅ Spin-test completed successfully!")
+        print("=" * 80)
+
+        # Cleanup: Stop Redis server
+        cleanup_commands = [
+            f"redis-cli -p {redis_port} shutdown nosave",
+            f"rm -rf {temporary_dir}",
+        ]
+        execute_remote_commands(
+            server_public_ip, username, private_key, cleanup_commands, db_ssh_port
+        )
+
+        logging.info("🧹 Cleanup completed")
+        return True
+
+    except Exception as e:
+        logging.error(f"❌ Spin-test failed with error: {e}")
+
+        # Attempt cleanup on error
+        try:
+            cleanup_commands = [
+                f"redis-cli -p {redis_port} shutdown nosave",
+                f"rm -rf {temporary_dir}",
+            ]
+            execute_remote_commands(
+                server_public_ip, username, private_key, cleanup_commands, db_ssh_port
+            )
+        except:
+            pass  # Ignore cleanup errors
+
+        return False

redisbench_admin/run_remote/terraform.py

@@ -32,7 +32,11 @@ def terraform_spin_or_reuse_env(
     tf_folder_path=None,
     architecture="x86_64",
 ):
-    (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
+    (
+        remote_setup,
+        deployment_type,
+        remote_id,
+    ) = fetch_remote_setup_from_config(
         benchmark_config["remote"],
         "https://github.com/redis-performance/testing-infrastructure.git",
         "master",

redisbench_admin/utils/remote.py

@@ -629,6 +629,15 @@ def push_data_to_redistimeseries(rts, time_series_dict: dict, expire_msecs=0):
         )
         for timeseries_name, time_series in time_series_dict.items():
             try:
+                arch = "x86_64"
+                if "arch" in time_series["labels"]:
+                    arch = time_series["labels"]["arch"]
+                if arch == "aarch64" and "aarch64" not in timeseries_name:
+                    original_timeseries_name = timeseries_name
+                    timeseries_name = f"{timeseries_name}/arch/{arch}"
+                    logging.warning(
+                        f"overriding key named {original_timeseries_name} given it does not contain arch and it's not x86_64. new key={timeseries_name}"
+                    )
                 exporter_create_ts(rts, time_series, timeseries_name)
                 for timestamp, value in time_series["data"].items():
                     try:
@@ -771,7 +780,10 @@ def extract_perversion_timeseries_from_results(
 ):
     break_by_key = "version"
     break_by_str = "by.{}".format(break_by_key)
-    (branch_time_series_dict, target_tables,) = common_timeseries_extraction(
+    (
+        branch_time_series_dict,
+        target_tables,
+    ) = common_timeseries_extraction(
         break_by_key,
         break_by_str,
         datapoints_timestamp,
@@ -942,9 +954,9 @@ def from_metric_kv_to_timeserie(
 
         target_table_dict[target_name] = target_value
 
-        target_table_dict[
-            "{}:percent {}".format(target_name, comparison_type)
-        ] = target_value_pct_str
+        target_table_dict["{}:percent {}".format(target_name, comparison_type)] = (
+            target_value_pct_str
+        )
     return target_table_keyname, target_table_dict
 
 
@@ -1186,3 +1198,31 @@ def check_ec2_env():
         logging.error(error_message)
 
     return status, error_message
+
+
+def perform_connectivity_test(redis_conns, test_description=""):
+    """Perform PING test on all Redis connections"""
+    logging.info(f"🔍 Performing connectivity test: {test_description}")
+
+    success_count = 0
+    total_count = len(redis_conns)
+
+    for i, conn in enumerate(redis_conns):
+        try:
+            result = conn.ping()
+            if result:
+                logging.info(f"✅ Connection {i}: PING successful")
+                success_count += 1
+            else:
+                logging.error(f"❌ Connection {i}: PING returned False")
+        except Exception as e:
+            logging.error(f"❌ Connection {i}: PING failed - {e}")
+
+    if success_count == total_count:
+        logging.info(f"🎉 All {total_count} connectivity tests passed!")
+        return True
+    else:
+        logging.error(
+            f"💥 {total_count - success_count}/{total_count} connectivity tests failed!"
+        )
+        return False

{redisbench_admin-0.11.39.dist-info → redisbench_admin-0.11.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.39
+Version: 0.11.41
 Summary: Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... ).
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com
@@ -154,7 +154,13 @@ $ tox
 
 To run a specific test:
 ```sh
-$ tox -- tests/test_redistimeseries.py
+$ tox -- tests/test_defaults_purpose_built_env.py
+```
+
+To run a specific test and persist the docker container used for timeseries:
+
+```
+tox  --docker-dont-stop=rts_datasink  -- -vv --log-cli-level=INFO  tests/test_defaults_purpose_built_env.py 
 ```
 
 To run a specific test with verbose logging:

{redisbench_admin-0.11.39.dist-info → redisbench_admin-0.11.41.dist-info}/RECORD

@@ -3,19 +3,19 @@ redisbench_admin/cli.py,sha256=LAS5qnqScXKhxHYfXWB0mvAYaUYrSurIwadhexEa9g4,7740
 redisbench_admin/commands/__init__.py,sha256=mzVrEtqefFdopyzR-W6xx3How95dyZfToGKm1-_YzeY,95
 redisbench_admin/commands/commands.json.py,sha256=mzVrEtqefFdopyzR-W6xx3How95dyZfToGKm1-_YzeY,95
 redisbench_admin/compare/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
-redisbench_admin/compare/args.py,sha256=Wy0An7bAcqUO06a2_cNeAS2ighL1zFRqbgGZIK1eKHs,6178
-redisbench_admin/compare/compare.py,sha256=KJ8jBiQ8WSlcFeal82xEg3-FkhY5SeXQa_ubuyC7zmw,103180
+redisbench_admin/compare/args.py,sha256=rOP8td_GYPYsZiYN4olyYmUsku-oizggEZNRTB_fVro,6336
+redisbench_admin/compare/compare.py,sha256=NvC7RbQUJUKlPdJQj9TjUmk2k8UtiA9wnZWNDV7IM_Q,103315
 redisbench_admin/deploy/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/deploy/args.py,sha256=neLUcQqI__HkJItkQg2C293hl5g3yHG40t171r7-E5Y,1732
-redisbench_admin/deploy/deploy.py,sha256=c1srxDMaUHuyh6wGdgLqzTz3ljZFtGqiumtAmguVyuk,3791
+redisbench_admin/deploy/deploy.py,sha256=MtfJbsL97DLrbBYut6zRCzyEMebX4xWoZE-m4-JDRB8,3885
 redisbench_admin/environments/__init__.py,sha256=cD7zfXt0VEmy0b7452HvcAxX_9kVj6Vm213yNdUHP20,95
-redisbench_admin/environments/oss_cluster.py,sha256=lUOG6oN8VXAnDXFK7Xns-ag-hSOSxxxL8jZ4Mh03hQY,6681
+redisbench_admin/environments/oss_cluster.py,sha256=yYOvDRcEJxG9dkzd-lvaKTrt71MNeMdAV0G6TjHxsX8,8142
 redisbench_admin/environments/oss_standalone.py,sha256=Sl38rUpwJ3wNOl9zn38iK8q2iJi2pRFmaJAZJbuT_SQ,2474
 redisbench_admin/export/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/export/args.py,sha256=v_WjJCNz_LeIFMNwSN6XwRmvSx1K2ys8XS1gK50EM_4,3508
 redisbench_admin/export/common/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/export/common/common.py,sha256=LnvXjMLlJRzMTxiFIjrfRFfDx9JJm88OZHu7lnTOpFA,4331
-redisbench_admin/export/export.py,sha256=ozt3WmCMbttJoY6Ac2CAdA_5DuhKNaImun4BEdf_1f0,11228
+redisbench_admin/export/export.py,sha256=u00NjaCbWhCJ319leVlP4ZkqiqZt5FN4Gbag4Poo23M,11274
 redisbench_admin/export/google_benchmark/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/export/google_benchmark/google_benchmark_json_format.py,sha256=OuMaMmmma5VvXA0rcLIQSMxIq81oa5I3xYDFhbWj-IA,1804
 redisbench_admin/export/memtier_benchmark/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
@@ -35,7 +35,7 @@ redisbench_admin/grafana_api/grafana_api.py,sha256=dG17GCYmWRILmy7h3-OiBeGzuNGnR
 redisbench_admin/profilers/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/profilers/daemon.py,sha256=Y4ZbbH-cRHJk9cvpsb60UZFq_HVHWXtatb7T2vtlRKo,12973
 redisbench_admin/profilers/flamegraph.pl,sha256=Za5XE-1gb_U-nzqwoyRwfe1TB182c64gITa-2klWTTA,35898
-redisbench_admin/profilers/perf.py,sha256=OjHI9iKqCx9vZDqRqz0xOGoeKLTRps-ikBKVxSJqwC4,27756
+redisbench_admin/profilers/perf.py,sha256=HtzzMVsXEJa1H7tOAfKlbFYDn2KnxAG_IU9yKPKZB7w,27772
 redisbench_admin/profilers/perf_daemon_caller.py,sha256=nD97cXmX3JytyafvNMmhUBq40uYrf6vtjdJ1TXZbvVY,4948
 redisbench_admin/profilers/pprof.py,sha256=g7oNC3AtNDTUOBIh_mIi5bFl_b0mL8tqBu6qKvAOrKw,3949
 redisbench_admin/profilers/profilers.py,sha256=4C1xaPyLoPydJ3eBAxW7IlSHG-3qj3A3BAKejiZXEK0,510
@@ -176,14 +176,14 @@ redisbench_admin/run/ann/pkg/test/test-jaccard.py,sha256=oIhaQCQKrQokwv3fvgLSwPl
 redisbench_admin/run/ann/pkg/test/test-metrics.py,sha256=vJdS8Kuk8bAnpB65Uqb-9rUUI35XrHwaO3cNwKX5gxc,3057
 redisbench_admin/run/args.py,sha256=tevHZrezJ4RreHp6K-MGHko3e1Gi_IdsS2Q0jD2ZSoU,8173
 redisbench_admin/run/cluster.py,sha256=_Y6a8Dbu1cJ7OxhgymKQSZcCmV8cZ3UpGEWL6b6O84Y,6363
-redisbench_admin/run/common.py,sha256=u1XM87EsqAa4pE8IMY_Pq1DaiwvcTG79xcv9IVaYMj0,28218
+redisbench_admin/run/common.py,sha256=5TAxmHbUti7S3nzPzn7f-L4ls6gpStU2C4yvkiii7m4,28410
 redisbench_admin/run/ftsb/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/run/ftsb/ftsb.py,sha256=NP-K_hCEagmX5ayN0pQVtOdQxDTwgxKrnzz9_MLT9qQ,2492
 redisbench_admin/run/git.py,sha256=6UYGcTN0MPzf4QDVoJnFkou0yZasLF6jLG7f0zoySq8,3064
 redisbench_admin/run/grafana.py,sha256=iMDgMyJKinpZMTD43rZ1IcRGkadjFjCxaB48mYWkvG4,9421
 redisbench_admin/run/memtier_benchmark/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/run/memtier_benchmark/memtier_benchmark.py,sha256=wTd2olovvFBZ98mOSr6DM5BJsdaiuPteEZzBqeSgbkE,4246
-redisbench_admin/run/metrics.py,sha256=uOOwOC9vTC97y2hxSKwt_RJqxpkLJmSR3oOv_WWnS9o,7630
+redisbench_admin/run/metrics.py,sha256=8EQdcZbCiFB_kIR1WtUQNOPV8y74bZ8Dj51Cv0aR4nk,7556
 redisbench_admin/run/modules.py,sha256=9To85oDw2tmUNmTDxOgvKls_46oZRcd2cCt6xNjIWiA,1691
 redisbench_admin/run/redis_benchmark/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/run/redis_benchmark/redis_benchmark.py,sha256=e-Az2uTlt3z2W4uzlUsdxeT8GITpxpGb-Mjb6JxrSWc,6848
@@ -199,19 +199,19 @@ redisbench_admin/run/ycsb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 redisbench_admin/run/ycsb/ycsb.py,sha256=cs5saVH7C4YpDvzhoa15PwEho59qTVR1E90v_FYjMVw,6873
 redisbench_admin/run_async/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/run_async/async_env.py,sha256=tE1turaaZNHfOaSpGxh62EJWp88zoQFUf3sMbaS7JRA,2408
-redisbench_admin/run_async/async_terraform.py,sha256=fRzhUq9kIPs0EjQxrpctkoNiI2Q4fKTdNlVbBDpG1Ys,11223
+redisbench_admin/run_async/async_terraform.py,sha256=ngOQnECUuC20pZwiJItaiBnzlwT2DiKciPTHtqLURe4,11299
 redisbench_admin/run_async/benchmark.py,sha256=S-dsaWGjgsPQxj8sXAACnbtNw5zlJnRFoo53ULbrMEY,1630
 redisbench_admin/run_async/log.py,sha256=cD7zfXt0VEmy0b7452HvcAxX_9kVj6Vm213yNdUHP20,95
-redisbench_admin/run_async/render_files.py,sha256=OMPy3-GnU14tQ4HNlF5utOnmzpRAXURwG_h8UDkTmYs,2674
+redisbench_admin/run_async/render_files.py,sha256=NMagmx-2hsMET_XN8tkmQz55g-azqW7SjAqaq4GL8F0,2676
 redisbench_admin/run_async/run_async.py,sha256=g2ZOQqj9vXZYaRyNpJZtgfYyY9tMuRmEv3Hh3qWOUs8,14525
 redisbench_admin/run_local/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
-redisbench_admin/run_local/args.py,sha256=9Qr-IVQJ3TMqFkn9Jp597KjU2AGq3u0X5Eb82CWD7wk,1504
+redisbench_admin/run_local/args.py,sha256=LPpqtx1cH1dkkeHjYlaFnAp_TijxnzPZFO2CmYD9ikU,1906
 redisbench_admin/run_local/local_client.py,sha256=gwawMDOBrf7m--uyxu8kMZC5LBiLjbUBSKvzVOdOAas,124
 redisbench_admin/run_local/local_db.py,sha256=9vINqKOs-wDMFEuEHT0I8KO9YnEo_h4NWNk5da3LwSY,7518
 redisbench_admin/run_local/local_helpers.py,sha256=JyqLW2-Sbm35BXjxxfOB1yK7ADdLfcVrq08NLNdIwac,7026
-redisbench_admin/run_local/run_local.py,sha256=j3FvRPP6ROk5COX7j5bCizXa7UOHd-A8EnxIxR6gQHU,31176
+redisbench_admin/run_local/run_local.py,sha256=QHnGfVAaVuct7t0WrWyQpbirC3MWX7fQF5-kXU_pJBs,34834
 redisbench_admin/run_remote/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
-redisbench_admin/run_remote/args.py,sha256=vhV87avBwXL8c2QLqrAkIyWD53MYhN06F-3wRv3l5xE,3829
+redisbench_admin/run_remote/args.py,sha256=Ef32mg1yNYYHL5g59SzIWZqFB__RNLLriPqiucVyoNg,4826
 redisbench_admin/run_remote/consts.py,sha256=bCMkwyeBD-EmOpoHKni7LjWy5WuaxGJhGhqpi4AL0RQ,386
 redisbench_admin/run_remote/log.py,sha256=cD7zfXt0VEmy0b7452HvcAxX_9kVj6Vm213yNdUHP20,95
 redisbench_admin/run_remote/notifications.py,sha256=-W9fLaftEFNfplBl2clHk37jbYxliDbHftQ62khN31k,2157
@@ -219,24 +219,24 @@ redisbench_admin/run_remote/remote_client.py,sha256=rRmDro1weto01wzqYpId8NMPoizE
 redisbench_admin/run_remote/remote_db.py,sha256=EEDeiOZk-godr5EINscEkOJLGWUN3gFfH6RaBzAKbak,14566
 redisbench_admin/run_remote/remote_env.py,sha256=Ux_0QT1unNRlKl3cakzjG5Px1uuxOOfBoF_pnalx_T8,4936
 redisbench_admin/run_remote/remote_failures.py,sha256=IOo6DyxarcwwMPCeN4gWB2JrhuC9iBLwq0nCROqr5ak,1567
-redisbench_admin/run_remote/remote_helpers.py,sha256=A3oyMg3PcXluB2g746jgfnVpq4_WIsDw0o_6-okAh4E,10552
-redisbench_admin/run_remote/run_remote.py,sha256=s4GEqNU-hyBVCrSJCb4Tg9jZXe6EymcZcZ7-p9viKE4,70198
-redisbench_admin/run_remote/standalone.py,sha256=BT_3ojr6w84FZGwTkFxDLnSGMth24FyaoXedKLhf5h4,12629
-redisbench_admin/run_remote/terraform.py,sha256=FCkE69h2nYK6ehfHGkoQqE-e2tPh2FWSYX1AoAei4GA,3988
+redisbench_admin/run_remote/remote_helpers.py,sha256=skWeGyDJBmyx_UwUekT3N3_nOJvF2-Hvu-E7vKlO9gg,10598
+redisbench_admin/run_remote/run_remote.py,sha256=tZqCu1fTfB5gWooVIEsSDoaVfnVRfxeCpn-RLmYI3IM,75476
+redisbench_admin/run_remote/standalone.py,sha256=OGau_7MpQihbn0U4qa0QmGZnwQ_gJhuxuWiQm9zpp7M,27970
+redisbench_admin/run_remote/terraform.py,sha256=vV3eWXNwj7vsnFNqUgCir5ueZS4VYopEyzWiTtoSq0Q,4018
 redisbench_admin/utils/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redisbench_admin/utils/benchmark_config.py,sha256=bC2C6rnj89wkkSlOXyyfe0N15unn_M1t1zfskfVkb98,21387
 redisbench_admin/utils/local.py,sha256=zUvyVI9LZMT3qyxs1pO3mXL6Bt_1z9EZUGppaRcWNRA,3890
 redisbench_admin/utils/redisearch.py,sha256=lchUEzpt0zB1rHwlDlw9LLifAnxFWcLP-PePw7TjL-0,1602
 redisbench_admin/utils/redisgraph_benchmark_go.py,sha256=os7EJt6kBxsFJLKkSoANbjMT7-cEq4-Ns-49alk2Tf8,2048
-redisbench_admin/utils/remote.py,sha256=e9N1poTODH1zcrmyscOco9jdxHxOBZYpW00FBGWGfQY,40670
+redisbench_admin/utils/remote.py,sha256=RAQ2VxfmlK7swN7ujCuwSI2soGSycjnxbQw_IrLxIFE,42205
 redisbench_admin/utils/results.py,sha256=uKk3uNJ--bSXlUj_HGQ2OaV6MVqmXJVM8xTzFV6EOw4,3267
 redisbench_admin/utils/ssh.py,sha256=QW4AwlocMHJt05QMdN_4f8WeDmxiEwR80ny8VBThq6k,6533
 redisbench_admin/utils/utils.py,sha256=XVSvo1_DdcYwk2jOxL3VPVPbnDnhGYt8ieYfANo6rTo,15085
 redisbench_admin/watchdog/__init__.py,sha256=cD7zfXt0VEmy0b7452HvcAxX_9kVj6Vm213yNdUHP20,95
 redisbench_admin/watchdog/args.py,sha256=nKsG1G6ATOZlAMHMtT9u3kXxduKCbejSZ5x8oB_ynZ8,1312
 redisbench_admin/watchdog/watchdog.py,sha256=0wWYge3x_OMxWrzazNhJif2NK4tKsI963HVZqjczRag,6189
-redisbench_admin-0.11.39.dist-info/LICENSE,sha256=AAMtfs82zOOvmG68vILivm6lxi2rcOlGObmA8jzxQvw,10768
-redisbench_admin-0.11.39.dist-info/METADATA,sha256=apkZr_qljuPHiCPAH3iWj8TBAYvEQHKgrW0pNSzlCOw,5389
-redisbench_admin-0.11.39.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redisbench_admin-0.11.39.dist-info/entry_points.txt,sha256=UUawXk_AS-PlieKJ1QxPQXGsRLb6OW_F0MtmA1W0KE8,113
-redisbench_admin-0.11.39.dist-info/RECORD,,
+redisbench_admin-0.11.41.dist-info/LICENSE,sha256=AAMtfs82zOOvmG68vILivm6lxi2rcOlGObmA8jzxQvw,10768
+redisbench_admin-0.11.41.dist-info/METADATA,sha256=doOixz08d09LZGCuGz9OsIuNdcP_1fYqxaiLwUacBCY,5596
+redisbench_admin-0.11.41.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redisbench_admin-0.11.41.dist-info/entry_points.txt,sha256=UUawXk_AS-PlieKJ1QxPQXGsRLb6OW_F0MtmA1W0KE8,113
+redisbench_admin-0.11.41.dist-info/RECORD,,