redisbench-admin 0.11.50__tar.gz → 0.11.51__tar.gz

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.50
+Version: 0.11.51
 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.50 → redisbench_admin-0.11.51}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redisbench-admin"
-version = "0.11.50"
+version = "0.11.51"
 description = "Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... )."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "README.md"

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/cli.py

@@ -36,15 +36,22 @@ LOG_FORMAT = "%(asctime)s %(levelname)-4s %(message)s"
 LOG_DATEFMT = "%Y-%m-%d %H:%M:%S"
 
 
-def populate_with_poetry_data():
+def populate_with_project_data():
     project_name = "redisbench-admin"
     project_version = __version__
     project_description = None
     try:
-        poetry_data = toml.load("pyproject.toml")["tool"]["poetry"]
-        project_name = poetry_data["name"]
-        project_version = poetry_data["version"]
-        project_description = poetry_data["description"]
+        pyproject_toml = toml.load("pyproject.toml")
+        if 'project' in pyproject_toml:
+            project_data = pyproject_toml["project"]
+            project_name = project_data["name"]
+            project_version = project_data["version"]
+            project_description = project_data.get("description")
+        else:
+            poetry_data = pyproject_toml["tool"]["poetry"]
+            project_name = poetry_data["name"]
+            project_version = poetry_data["version"]
+            project_description = poetry_data["description"]
     except FileNotFoundError:
         pass
 
@@ -59,7 +66,7 @@ def main():
         )
         sys.exit(1)
     requested_tool = sys.argv[1]
-    project_name, project_description, project_version = populate_with_poetry_data()
+    project_name, project_description, project_version = populate_with_project_data()
     parser = argparse.ArgumentParser(
         description=project_description,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/compare/args.py

@@ -114,26 +114,6 @@ def create_compare_arguments(parser):
         type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
         default=START_TIME_NOW_UTC,
     )
-    parser.add_argument(
-        "--from-date-baseline",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--to-date-baseline",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--from-date-comparison",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--to-date-comparison",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
     parser.add_argument(
         "--metric_mode",
         type=str,

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/compare/compare.py

@@ -314,10 +314,6 @@ def compare_command_logic(args, project_name, project_version):
         first_n_baseline,
         first_n_comparison,
         grafana_link_base,
-        args.from_date_baseline,
-        args.to_date_baseline,
-        args.from_date_comparison,
-        args.to_date_comparison,
     )
     comment_body = ""
     if total_comparison_points > 0:
@@ -597,99 +593,24 @@ def compute_regression_table(
     first_n_baseline=-1,
     first_n_comparison=-1,
     grafana_link_base=None,
-    from_date_baseline=None,
-    to_date_baseline=None,
-    from_date_comparison=None,
-    to_date_comparison=None,
 ):
     START_TIME_NOW_UTC, _, _ = get_start_time_vars()
     START_TIME_LAST_MONTH_UTC = START_TIME_NOW_UTC - datetime.timedelta(days=31)
-
-    # Handle separate baseline and comparison date ranges (takes precedence if defined)
-    if (
-        from_date_baseline is not None
-        or to_date_baseline is not None
-        or from_date_comparison is not None
-        or to_date_comparison is not None
-    ):
-        # Use separate date ranges for baseline and comparison
-        from_date_baseline = (
-            from_date_baseline
-            if from_date_baseline is not None
-            else START_TIME_LAST_MONTH_UTC
-        )
-        to_date_baseline = (
-            to_date_baseline if to_date_baseline is not None else START_TIME_NOW_UTC
-        )
-        from_date_comparison = (
-            from_date_comparison
-            if from_date_comparison is not None
-            else START_TIME_LAST_MONTH_UTC
-        )
-        to_date_comparison = (
-            to_date_comparison if to_date_comparison is not None else START_TIME_NOW_UTC
-        )
-
-        from_ts_ms_baseline = int(from_date_baseline.timestamp() * 1000)
-        to_ts_ms_baseline = int(to_date_baseline.timestamp() * 1000)
-        from_ts_ms_comparison = int(from_date_comparison.timestamp() * 1000)
-        to_ts_ms_comparison = int(to_date_comparison.timestamp() * 1000)
-
-        from_human_str_baseline = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms_baseline / 1000)
-        )
-        to_human_str_baseline = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms_baseline / 1000)
-        )
-        from_human_str_comparison = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms_comparison / 1000)
-        )
-        to_human_str_comparison = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms_comparison / 1000)
-        )
-
-        logging.info(
-            "Using separate time ranges - Baseline: {} to {}, Comparison: {} to {}".format(
-                from_human_str_baseline,
-                to_human_str_baseline,
-                from_human_str_comparison,
-                to_human_str_comparison,
-            )
-        )
-
-        # Use baseline range for legacy compatibility (will be overridden in data queries)
-        from_ts_ms = from_ts_ms_baseline
-        to_ts_ms = to_ts_ms_baseline
-
-        # Set legacy variables for table headers (show separate ranges info)
-        from_human_str = f"Baseline: {from_human_str_baseline} to {to_human_str_baseline}, Comparison: {from_human_str_comparison} to {to_human_str_comparison}"
-        to_human_str = to_human_str_baseline
-    else:
-        # Use legacy single date range for both baseline and comparison
-        if from_date is None:
-            from_date = START_TIME_LAST_MONTH_UTC
-        if to_date is None:
-            to_date = START_TIME_NOW_UTC
-        if from_ts_ms is None:
-            from_ts_ms = int(from_date.timestamp() * 1000)
-        if to_ts_ms is None:
-            to_ts_ms = int(to_date.timestamp() * 1000)
-
-        # Use same range for both baseline and comparison
-        from_ts_ms_baseline = from_ts_ms
-        to_ts_ms_baseline = to_ts_ms
-        from_ts_ms_comparison = from_ts_ms
-        to_ts_ms_comparison = to_ts_ms
-
-        from_human_str = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
-        )
-        to_human_str = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms / 1000)
-        )
-        logging.info(
-            "Using a time-delta from {} to {}".format(from_human_str, to_human_str)
-        )
+    if from_date is None:
+        from_date = START_TIME_LAST_MONTH_UTC
+    if to_date is None:
+        to_date = START_TIME_NOW_UTC
+    if from_ts_ms is None:
+        from_ts_ms = int(from_date.timestamp() * 1000)
+    if to_ts_ms is None:
+        to_ts_ms = int(to_date.timestamp() * 1000)
+    from_human_str = humanize.naturaltime(
+        dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
+    )
+    to_human_str = humanize.naturaltime(dt.datetime.utcfromtimestamp(to_ts_ms / 1000))
+    logging.info(
+        "Using a time-delta from {} to {}".format(from_human_str, to_human_str)
+    )
     baseline_str, by_str_baseline, comparison_str, by_str_comparison = get_by_strings(
         baseline_branch,
         comparison_branch,
@@ -773,10 +694,6 @@ def compute_regression_table(
         comparison_tag,
         from_date,
         to_date,
-        from_ts_ms_baseline,
-        to_ts_ms_baseline,
-        from_ts_ms_comparison,
-        to_ts_ms_comparison,
     )
     logging.info(
         "Printing differential analysis between {} and {}".format(
@@ -1027,56 +944,7 @@ def from_rts_to_regression_table(
     comparison_tag=None,
     from_date=None,
     to_date=None,
-    from_ts_ms_baseline=None,
-    to_ts_ms_baseline=None,
-    from_ts_ms_comparison=None,
-    to_ts_ms_comparison=None,
 ):
-    # Use separate timestamp ranges if provided, otherwise use legacy single range
-    if (
-        from_ts_ms_baseline is not None
-        and to_ts_ms_baseline is not None
-        and from_ts_ms_comparison is not None
-        and to_ts_ms_comparison is not None
-    ):
-        # Use separate ranges for baseline and comparison
-        baseline_from_ts = from_ts_ms_baseline
-        baseline_to_ts = to_ts_ms_baseline
-        comparison_from_ts = from_ts_ms_comparison
-        comparison_to_ts = to_ts_ms_comparison
-        baseline_from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(baseline_from_ts / 1000)
-        )
-        baseline_to_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(baseline_to_ts / 1000)
-        )
-        comparison_from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(comparison_from_ts / 1000)
-        )
-        comparison_to_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(comparison_to_ts / 1000)
-        )
-        logging.info(
-            "Using separate timestamp ranges - Baseline: {} to {}, Comparison: {} to {}".format(
-                baseline_from_human, baseline_to_human, comparison_from_human, comparison_to_human
-            )
-        )
-    else:
-        # Use legacy single range for both
-        baseline_from_ts = from_ts_ms
-        baseline_to_ts = to_ts_ms
-        comparison_from_ts = from_ts_ms
-        comparison_to_ts = to_ts_ms
-        from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
-        )
-        to_human = humanize.naturaltime(dt.datetime.utcfromtimestamp(to_ts_ms / 1000))
-        logging.info(
-            "Using single timestamp range for both baseline and comparison: {} to {}".format(
-                from_human, to_human
-            )
-        )
-
     print_all = print_regressions_only is False and print_improvements_only is False
     table = []
     detected_regressions = []
@@ -1177,7 +1045,7 @@ def from_rts_to_regression_table(
         try:
             for ts_name_baseline in baseline_timeseries:
                 datapoints_inner = rts.ts().revrange(
-                    ts_name_baseline, baseline_from_ts, baseline_to_ts
+                    ts_name_baseline, from_ts_ms, to_ts_ms
                 )
                 baseline_datapoints.extend(datapoints_inner)
             (
@@ -1196,7 +1064,7 @@ def from_rts_to_regression_table(
             )
             for ts_name_comparison in comparison_timeseries:
                 datapoints_inner = rts.ts().revrange(
-                    ts_name_comparison, comparison_from_ts, comparison_to_ts
+                    ts_name_comparison, from_ts_ms, to_ts_ms
                 )
                 comparison_datapoints.extend(datapoints_inner)
 
@@ -1665,11 +1533,9 @@ def check_client_side_latency(
             comparison_ts = comparison_client_ts[0]
 
             # Get client-side latency data
-            baseline_client_data = rts.ts().revrange(
-                baseline_ts, baseline_from_ts, baseline_to_ts
-            )
+            baseline_client_data = rts.ts().revrange(baseline_ts, from_ts_ms, to_ts_ms)
             comparison_client_data = rts.ts().revrange(
-                comparison_ts, comparison_from_ts, comparison_to_ts
+                comparison_ts, from_ts_ms, to_ts_ms
             )
 
             if len(baseline_client_data) == 0 or len(comparison_client_data) == 0:
@@ -2012,15 +1878,11 @@ def perform_variance_and_p99_analysis(
             comparison_p99_data = []
 
             for ts_name in baseline_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, baseline_from_ts, baseline_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 baseline_p99_data.extend(datapoints)
 
             for ts_name in comparison_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, comparison_from_ts, comparison_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 comparison_p99_data.extend(datapoints)
 
             if len(baseline_p99_data) < 3 or len(comparison_p99_data) < 3:
@@ -2368,15 +2230,11 @@ def check_latency_for_unstable_throughput(
             comparison_latency_data = []
 
             for ts_name in baseline_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, baseline_from_ts, baseline_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 baseline_latency_data.extend(datapoints)
 
             for ts_name in comparison_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, comparison_from_ts, comparison_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 comparison_latency_data.extend(datapoints)
 
             if len(baseline_latency_data) == 0 or len(comparison_latency_data) == 0:

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/export/export.py

@@ -76,7 +76,6 @@ def export_command_logic(args, project_name, project_version):
                 exporter_timemetric_path,
                 _,
                 _,
-                _,
             ) = get_defaults(exporter_spec_file)
     arch = args.architecture
     logging.info("Using the following architecture on the timeseries: {}".format(arch))

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/profilers/daemon.py

@@ -16,7 +16,7 @@ import botocore
 import daemonize
 from flask import Flask, request
 
-from redisbench_admin.cli import populate_with_poetry_data
+from redisbench_admin.cli import populate_with_project_data
 from redisbench_admin.profilers.perf import Perf
 from redisbench_admin.profilers.perf_daemon_caller import PERF_DAEMON_LOGNAME
 from redisbench_admin.profilers.profilers_local import local_profilers_platform_checks
@@ -282,7 +282,7 @@ class PerfDaemon:
 
 
 def main():
-    _, project_description, project_version = populate_with_poetry_data()
+    _, project_description, project_version = populate_with_project_data()
     project_name = "perf-daemon"
     parser = argparse.ArgumentParser(
         description=project_description,

redisbench_admin-0.11.51/redisbench_admin/run/modules.py

@@ -0,0 +1,50 @@
+#  BSD 3-Clause License
+#
+#  Copyright (c) 2021., Redis Labs Modules
+#  All rights reserved.
+#
+import logging
+import os
+
+
+def redis_modules_check(local_module_files):
+    status = True
+    error_message = ""
+    if local_module_files is not None:
+        logging.info(
+            "Using the following module artifacts: {}".format(local_module_files)
+        )
+        for local_module_file in local_module_files:
+            if type(local_module_file) is str:
+                logging.info(
+                    "Checking if module artifact {} exists...".format(local_module_file)
+                )
+                error_message, status = exists_check(
+                    error_message, local_module_file, status
+                )
+            if type(local_module_file) is list:
+                for inner_local_module_file in local_module_file:
+                    logging.info(
+                        "Checking if module artifact {} exists...".format(
+                            inner_local_module_file
+                        )
+                    )
+                    error_message, status = exists_check(
+                        error_message, inner_local_module_file, status
+                    )
+
+    return status, error_message
+
+
+def exists_check(error_message, local_module_file, status):
+    if os.path.exists(local_module_file) is False:
+        error_message = "Specified module artifact does not exist: {}".format(
+            local_module_file
+        )
+        logging.error(error_message)
+        status = False
+    else:
+        logging.info(
+            "Confirmed that module artifact: '{}' exists!".format(local_module_file)
+        )
+    return error_message, status

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/run_async/benchmark.py

@@ -41,7 +41,6 @@ class BenchmarkClass:
             self.exporter_timemetric_path,
             self.default_specs,
             self.clusterconfig,
-            _,
         ) = prepare_benchmark_definitions(args)
 
     def populate_remote_envs_timeout(self):

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/run_local/run_local.py

@@ -149,7 +149,6 @@ def run_local_command_logic(args, project_name, project_version):
         exporter_timemetric_path,
         default_specs,
         clusterconfig,
-        _,
     ) = prepare_benchmark_definitions(args)
 
     return_code = 0

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/run_remote/args.py

@@ -148,7 +148,7 @@ def create_run_remote_arguments(parser):
         "--spin-test",
         default=False,
         action="store_true",
-        help="Setup standalone Redis server, run INFO SERVER, print output as markdown and exit (reads install_steps from defaults.yml)",
+        help="Setup standalone Redis server, run INFO SERVER, print output as markdown and exit",
     )
 
     return parser

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/run_remote/remote_db.py

@@ -105,8 +105,6 @@ def remote_db_spin(
     continue_on_module_check_error=False,
     keyspace_check_timeout=60,
     architecture="x86_64",
-    custom_redis_server_path=None,
-    custom_redis_conf_path=None,
 ):
     (
         _,
@@ -116,116 +114,6 @@ def remote_db_spin(
         modules_configuration_parameters_map,
     ) = extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
 
-    # Execute install_steps from dbconfig and clientconfig if present
-    from redisbench_admin.run_remote.standalone import execute_install_steps
-
-    if benchmark_config is not None:
-        execute_install_steps(
-            benchmark_config, server_public_ip, username, private_key, db_ssh_port
-        )
-
-    # Copy custom Redis files to remote host if provided
-    remote_redis_server_path = None
-    remote_redis_conf_path = None
-
-    if custom_redis_server_path or custom_redis_conf_path:
-        from redisbench_admin.utils.remote import copy_file_to_remote_setup
-        import os
-
-        if custom_redis_conf_path:
-            # Convert relative paths to absolute paths
-            custom_redis_conf_path = os.path.abspath(
-                os.path.expanduser(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_code = 1
-                return (None, None, None, [], [], return_code, None, None)
-
-            remote_redis_conf_path = "/tmp/redis.conf"
-            logging.info(
-                f"📁 Copying custom redis.conf from {custom_redis_conf_path} to {remote_redis_conf_path}"
-            )
-
-            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_code = 1
-                return (None, None, None, [], [], return_code, None, None)
-            else:
-                logging.info(
-                    f"✅ Successfully copied redis.conf to {remote_redis_conf_path}"
-                )
-
-        if custom_redis_server_path:
-            # Convert relative paths to absolute paths
-            custom_redis_server_path = os.path.abspath(
-                os.path.expanduser(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_code = 1
-                return (None, None, None, [], [], return_code, None, None)
-
-            remote_redis_server_path = "/tmp/redis-server"
-            logging.info(
-                f"📁 Copying custom redis-server binary from {custom_redis_server_path} to {remote_redis_server_path}"
-            )
-
-            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_code = 1
-                return (None, None, None, [], [], return_code, None, None)
-
-            # 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(
-                    f"✅ Successfully copied and made executable: {remote_redis_server_path}"
-                )
-
-    # Update the custom paths to use the remote paths
-    if remote_redis_server_path:
-        custom_redis_server_path = remote_redis_server_path
-    if remote_redis_conf_path:
-        custom_redis_conf_path = remote_redis_conf_path
-
     full_logfiles = []
     cluster_enabled = False
     if setup_type == "oss-cluster":
@@ -319,8 +207,6 @@ def remote_db_spin(
                     db_ssh_port,
                     modules_configuration_parameters_map,
                     redis_7,
-                    custom_redis_server_path,
-                    custom_redis_conf_path,
                 )
                 full_logfiles.append(full_logfile)
             local_redis_conn, ssh_tunnel = ssh_tunnel_redisconn(

{redisbench_admin-0.11.50 → redisbench_admin-0.11.51}/redisbench_admin/run_remote/run_remote.py

@@ -4,7 +4,6 @@
 #  All rights reserved.
 #
 import logging
-import os
 import random
 import string
 import sys
@@ -35,7 +34,7 @@ from redisbench_admin.run.common import (
 )
 from redisbench_admin.run.git import git_vars_crosscheck
 from redisbench_admin.run.grafana import generate_artifacts_table_grafana_redis
-from redisbench_admin.run.modules import redis_modules_check, redis_files_check
+from redisbench_admin.run.modules import redis_modules_check
 from redisbench_admin.run.redistimeseries import (
     timeseries_test_sucess_flow,
     timeseries_test_failure_flow,
@@ -229,25 +228,6 @@ def run_remote_command_logic(args, project_name, project_version):
                 )
             )
 
-    # Validate Redis server binary and config file paths early
-    redis_files_check_status, redis_error_message = redis_files_check(
-        args.redis_server_binary, args.redis_conf
-    )
-    if redis_files_check_status is False:
-        if webhook_notifications_active:
-            failure_reason = redis_error_message
-            generate_failure_notification(
-                webhook_client_slack,
-                ci_job_name,
-                ci_job_link,
-                failure_reason,
-                tf_github_org,
-                tf_github_repo,
-                tf_github_branch,
-                None,
-            )
-        exit(1)
-
     common_properties_log(
         tf_bin_path,
         tf_github_actor,
@@ -290,31 +270,6 @@ def run_remote_command_logic(args, project_name, project_version):
             logging.error("❌ --spin-test requires server_public_ip in --inventory")
             exit(1)
 
-        # Load benchmark config from defaults.yml
-        benchmark_config = None
-
-        # Try to load defaults.yml
-        defaults_file = (
-            args.defaults_filename
-            if hasattr(args, "defaults_filename")
-            else "defaults.yml"
-        )
-        if os.path.exists(defaults_file):
-            try:
-                import yaml
-
-                with open(defaults_file, "r") as config_file:
-                    defaults_config = yaml.safe_load(config_file)
-                    if defaults_config:
-                        benchmark_config = defaults_config
-                        logging.info(f"📋 Loaded configuration from {defaults_file}")
-            except Exception as e:
-                logging.warning(f"⚠️ Failed to load defaults config: {e}")
-        else:
-            logging.info(
-                f"📋 No {defaults_file} found - proceeding without install_steps"
-            )
-
         # Run spin test
         success = spin_test_standalone_redis(
             server_public_ip=server_public_ip,
@@ -327,7 +282,6 @@ def run_remote_command_logic(args, project_name, project_version):
             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)
@@ -339,7 +293,6 @@ def run_remote_command_logic(args, project_name, project_version):
         exporter_timemetric_path,
         default_specs,
         clusterconfig,
-        _,
     ) = prepare_benchmark_definitions(args)
 
     return_code = 0
@@ -685,8 +638,6 @@ def run_remote_command_logic(args, project_name, project_version):
                                             continue_on_module_check_error,
                                             60,
                                             architecture,
-                                            args.redis_server_binary,
-                                            args.redis_conf,
                                         )
                                         if benchmark_type == "read-only":
                                             ro_benchmark_set(