redisbench-admin 0.11.40__py3-none-any.whl → 0.11.42__py3-none-any.whl

redisbench_admin/compare/args.py

@@ -131,6 +131,7 @@ def create_compare_arguments(parser):
     parser.add_argument("--simple-table", type=bool, default=False)
     parser.add_argument("--use_metric_context_path", type=bool, default=False)
     parser.add_argument("--testname_regex", type=str, default=".*", required=False)
+    parser.add_argument("--test-regex", type=str, default=".*", required=False)
     parser.add_argument(
         "--regressions-percent-lower-limit",
         type=float,

redisbench_admin/compare/compare.py

@@ -254,7 +254,9 @@ def compare_command_logic(args, project_name, project_version):
     uid = args.grafana_uid
     if tf_github_repo.lower() in grafana_dashboards_uids and uid is None:
         uid = grafana_dashboards_uids[tf_github_repo.lower()]
-        logging.info(f"Using uid from grafana_dashboards_uids. {grafana_dashboards_uids}. uid={uid}")
+        logging.info(
+            f"Using uid from grafana_dashboards_uids. {grafana_dashboards_uids}. uid={uid}"
+        )
     else:
         logging.info(f"Using uid from args. uid={uid}")
     grafana_link_base = None
@@ -324,9 +326,7 @@ def compare_command_logic(args, project_name, project_version):
         comparison_summary = "In summary:\n"
         if total_stable > 0:
             comparison_summary += (
-                "- Detected a total of {} stable tests between versions.\n".format(
-                    total_stable,
-                )
+                f"- Detected a total of {total_stable} stable tests between versions.\n"
             )
 
         if total_unstable > 0:
@@ -388,13 +388,10 @@ def compare_command_logic(args, project_name, project_version):
 
                             comparison_summary += f"  - {test_display_name}: {', '.join(commands_info)}{confidence_indicator}\n"
         if total_improvements > 0:
-            comparison_summary += "- Detected a total of {} improvements above the improvement water line.\n".format(
-                total_improvements
-            )
+            comparison_summary += f"- Detected a total of {total_improvements} improvements above the improvement water line.\n"
         if total_regressions > 0:
-            comparison_summary += "- Detected a total of {} regressions bellow the regression water line {}.\n".format(
-                total_regressions, args.regressions_percent_lower_limit
-            )
+            comparison_summary += f"- Detected a total of {total_regressions} regressions bellow the regression water line {args.regressions_percent_lower_limit}%.\n"
+        comparison_summary += "\n"
 
         comment_body += comparison_summary
         comment_body += "\n"

redisbench_admin/run_remote/args.py

@@ -130,5 +130,32 @@ def create_run_remote_arguments(parser):
         action="store_true",
         help="Continue running benchmarks even if module check failed",
     )
+    parser.add_argument(
+        "--redis-conf",
+        required=False,
+        default=None,
+        type=str,
+        help="Path to custom redis.conf file to copy to remote host",
+    )
+    parser.add_argument(
+        "--redis-server-binary",
+        required=False,
+        default=None,
+        type=str,
+        help="Path to custom redis-server binary to copy to remote host",
+    )
+    parser.add_argument(
+        "--spin-test",
+        default=False,
+        action="store_true",
+        help="Setup standalone Redis server, run INFO SERVER, print output as markdown and exit",
+    )
+    parser.add_argument(
+        "--spin-test-config",
+        required=False,
+        default=None,
+        type=str,
+        help="Optional benchmark configuration file for spin-test mode (to execute install_steps)",
+    )
 
     return parser

redisbench_admin/run_remote/run_remote.py

@@ -51,6 +51,7 @@ from redisbench_admin.run_remote.remote_db import (
     remote_db_spin,
     db_error_artifacts,
 )
+from redisbench_admin.run_remote.standalone import spin_test_standalone_redis
 from redisbench_admin.run_remote.remote_env import remote_env_setup
 from redisbench_admin.run_remote.remote_failures import failed_remote_run_artifact_store
 from redisbench_admin.run_remote.terraform import (
@@ -122,12 +123,15 @@ def run_remote_command_logic(args, project_name, project_version):
     tf_setup_name_sufix = "{}-{}".format(args.setup_name_sufix, tf_github_sha)
     s3_bucket_name = args.s3_bucket_name
     local_module_files = args.module_path
-    for pos, module_file in enumerate(local_module_files):
-        if " " in module_file:
-            logging.info(
-                "Detected multiple files in single module path {}".format(module_file)
-            )
-            local_module_files[pos] = module_file.split(" ")
+    if local_module_files is not None:
+        for pos, module_file in enumerate(local_module_files):
+            if " " in module_file:
+                logging.info(
+                    "Detected multiple files in single module path {}".format(
+                        module_file
+                    )
+                )
+                local_module_files[pos] = module_file.split(" ")
     dbdir_folder = args.dbdir_folder
     private_key = args.private_key
     grafana_profile_dashboard = args.grafana_profile_dashboard
@@ -238,6 +242,63 @@ def run_remote_command_logic(args, project_name, project_version):
 
     ssh_pem_check(EC2_PRIVATE_PEM, private_key)
 
+    # Handle spin-test mode
+    if args.spin_test:
+        logging.info(
+            "🚀 Spin-test mode detected - setting up standalone Redis and running INFO SERVER"
+        )
+
+        # Parse inventory to get server details
+        if args.inventory is None:
+            logging.error(
+                "❌ --spin-test requires --inventory to specify the remote server"
+            )
+            exit(1)
+
+        # Parse inventory string
+        inventory_parts = args.inventory.split(",")
+        server_public_ip = None
+
+        for part in inventory_parts:
+            if "=" in part:
+                key, value = part.split("=", 1)
+                if key.strip() == "server_public_ip":
+                    server_public_ip = value.strip()
+                    break
+
+        if server_public_ip is None:
+            logging.error("❌ --spin-test requires server_public_ip in --inventory")
+            exit(1)
+
+        # Load benchmark config if provided
+        benchmark_config = None
+        if args.spin_test_config:
+            try:
+                import yaml
+                with open(args.spin_test_config, 'r') as config_file:
+                    benchmark_config = yaml.safe_load(config_file)
+                    logging.info(f"📋 Loaded benchmark config from {args.spin_test_config}")
+            except Exception as e:
+                logging.error(f"❌ Failed to load benchmark config: {e}")
+                exit(1)
+
+        # Run spin test
+        success = spin_test_standalone_redis(
+            server_public_ip=server_public_ip,
+            username=args.user,
+            private_key=private_key,
+            db_ssh_port=args.db_ssh_port,
+            redis_port=args.db_port,
+            local_module_files=local_module_files,
+            redis_configuration_parameters=None,
+            modules_configuration_parameters_map=None,
+            custom_redis_conf_path=args.redis_conf,
+            custom_redis_server_path=args.redis_server_binary,
+            benchmark_config=benchmark_config,
+        )
+
+        exit(0 if success else 1)
+
     (
         benchmark_defs_result,
         benchmark_definitions,

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,373 @@ 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 execute_install_steps(benchmark_config, server_public_ip, username, private_key, db_ssh_port):
+    """
+    Execute install_steps from dbconfig and clientconfig sections.
+
+    Args:
+        benchmark_config: The benchmark configuration dictionary
+        server_public_ip: IP address of the remote server
+        username: SSH username
+        private_key: Path to SSH private key
+        db_ssh_port: SSH port
+    """
+    install_commands = []
+
+    # Extract install_steps from dbconfig
+    if "dbconfig" in benchmark_config:
+        dbconfig = benchmark_config["dbconfig"]
+        if isinstance(dbconfig, list):
+            for config_item in dbconfig:
+                if "install_steps" in config_item:
+                    steps = config_item["install_steps"]
+                    if isinstance(steps, list):
+                        install_commands.extend(steps)
+                        logging.info(f"📦 Found {len(steps)} install steps in dbconfig")
+        elif isinstance(dbconfig, dict):
+            if "install_steps" in dbconfig:
+                steps = dbconfig["install_steps"]
+                if isinstance(steps, list):
+                    install_commands.extend(steps)
+                    logging.info(f"📦 Found {len(steps)} install steps in dbconfig")
+
+    # Extract install_steps from clientconfig
+    if "clientconfig" in benchmark_config:
+        clientconfig = benchmark_config["clientconfig"]
+        if isinstance(clientconfig, list):
+            for config_item in clientconfig:
+                if "install_steps" in config_item:
+                    steps = config_item["install_steps"]
+                    if isinstance(steps, list):
+                        install_commands.extend(steps)
+                        logging.info(f"📦 Found {len(steps)} install steps in clientconfig")
+        elif isinstance(clientconfig, dict):
+            if "install_steps" in clientconfig:
+                steps = clientconfig["install_steps"]
+                if isinstance(steps, list):
+                    install_commands.extend(steps)
+                    logging.info(f"📦 Found {len(steps)} install steps in clientconfig")
+
+    # Execute all install commands
+    if install_commands:
+        logging.info(f"🔧 Executing {len(install_commands)} installation commands...")
+        for i, command in enumerate(install_commands, 1):
+            logging.info(f"📋 Step {i}/{len(install_commands)}: {command}")
+
+        install_result = execute_remote_commands(
+            server_public_ip, username, private_key, install_commands, db_ssh_port
+        )
+
+        # Check results
+        for i, (recv_exit_status, stdout, stderr) in enumerate(install_result):
+            if recv_exit_status != 0:
+                logging.warning(
+                    f"⚠️ Install step {i+1} returned exit code {recv_exit_status}"
+                )
+                logging.warning(f"Command: {install_commands[i]}")
+                if stderr:
+                    logging.warning(f"STDERR: {''.join(stderr).strip()}")
+                if stdout:
+                    logging.warning(f"STDOUT: {''.join(stdout).strip()}")
+            else:
+                logging.info(f"✅ Install step {i+1} completed successfully")
+
+        logging.info("🎯 All installation steps completed")
+    else:
+        logging.info("📦 No install_steps found in configuration")
+
+
+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,
+    benchmark_config=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
+        )
+
+        # Execute install_steps from dbconfig and clientconfig if present
+        if benchmark_config is not None:
+            execute_install_steps(
+                benchmark_config, server_public_ip, username, private_key, 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"
+        _, 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 label, (recv_exit_status, stdout, stderr) in 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/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:

{redisbench_admin-0.11.40.dist-info → redisbench_admin-0.11.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.40
+Version: 0.11.42
 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

{redisbench_admin-0.11.40.dist-info → redisbench_admin-0.11.42.dist-info}/RECORD

@@ -3,8 +3,8 @@ 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=qyOgo0CBE3NdDRTa5dqgNV_0eZJ0jkGBliGTasHuWls,6256
-redisbench_admin/compare/compare.py,sha256=ZE6j5T8SIiyW6mpUCkVWRvo5xT4Tkf-SnOnYSSQ9zt4,103382
+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=MtfJbsL97DLrbBYut6zRCzyEMebX4xWoZE-m4-JDRB8,3885
@@ -211,7 +211,7 @@ redisbench_admin/run_local/local_db.py,sha256=9vINqKOs-wDMFEuEHT0I8KO9YnEo_h4NWN
 redisbench_admin/run_local/local_helpers.py,sha256=JyqLW2-Sbm35BXjxxfOB1yK7ADdLfcVrq08NLNdIwac,7026
 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=VnZ20gqpk-NMzNxaaUHgedgl3B6fZm3Fewj6cPZ1iCg,4231
+redisbench_admin/run_remote/args.py,sha256=gJux_1udR6d5BUMMnIewl62hS0b2WnQ_7WQF4hElX7c,5051
 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
@@ -220,23 +220,23 @@ redisbench_admin/run_remote/remote_db.py,sha256=EEDeiOZk-godr5EINscEkOJLGWUN3gFf
 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=skWeGyDJBmyx_UwUekT3N3_nOJvF2-Hvu-E7vKlO9gg,10598
-redisbench_admin/run_remote/run_remote.py,sha256=_K7Bx9CWarf6UOUjt9CDKGJBqu-qgLjGYzPs80jOwnU,73789
-redisbench_admin/run_remote/standalone.py,sha256=BT_3ojr6w84FZGwTkFxDLnSGMth24FyaoXedKLhf5h4,12629
+redisbench_admin/run_remote/run_remote.py,sha256=7B-x-AI1pVon8ccfRio8q6EXTXaqPPMj_PxytpiICUs,76045
+redisbench_admin/run_remote/standalone.py,sha256=Or2GaSccxEyIl0z833RWi-fylSQ71Z6E1R2vbN0rHMM,31593
 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=qlO49qdJh96rOEXnFMgFcpiwYjmrG0K060bEc3nyHD0,41643
+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.40.dist-info/LICENSE,sha256=AAMtfs82zOOvmG68vILivm6lxi2rcOlGObmA8jzxQvw,10768
-redisbench_admin-0.11.40.dist-info/METADATA,sha256=olR0Y3plqHRTgl01WGkXOkyV5Iz_veIrpEG6vYaQksg,5596
-redisbench_admin-0.11.40.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redisbench_admin-0.11.40.dist-info/entry_points.txt,sha256=UUawXk_AS-PlieKJ1QxPQXGsRLb6OW_F0MtmA1W0KE8,113
-redisbench_admin-0.11.40.dist-info/RECORD,,
+redisbench_admin-0.11.42.dist-info/LICENSE,sha256=AAMtfs82zOOvmG68vILivm6lxi2rcOlGObmA8jzxQvw,10768
+redisbench_admin-0.11.42.dist-info/METADATA,sha256=s_waYOA4L1z-YQOS-p7DPaW8QWK2zzr2rsMSEAIVD7Y,5596
+redisbench_admin-0.11.42.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redisbench_admin-0.11.42.dist-info/entry_points.txt,sha256=UUawXk_AS-PlieKJ1QxPQXGsRLb6OW_F0MtmA1W0KE8,113
+redisbench_admin-0.11.42.dist-info/RECORD,,