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

redisbench_admin/compare/args.py

@@ -161,6 +161,10 @@ def create_compare_arguments(parser):
         type=str,
         default="https://benchmarksrediscom.grafana.net/d/",
     )
+    parser.add_argument(
+        "--grafana_uid",
+        default=None,
+    )
     parser.add_argument(
         "--auto-approve",
         required=False,

redisbench_admin/compare/compare.py

@@ -251,9 +251,12 @@ def compare_command_logic(args, project_name, project_version):
     }
     baseline_architecture = args.baseline_architecture
     comparison_architecture = args.comparison_architecture
-    uid = None
-    if tf_github_repo.lower() in grafana_dashboards_uids:
+    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}")
+    else:
+        logging.info(f"Using uid from args. uid={uid}")
     grafana_link_base = None
     if uid is not None:
         grafana_link_base = "{}/{}".format(grafana_base_dashboard, uid)
@@ -1216,9 +1219,9 @@ def from_rts_to_regression_table(
                             f"Blocking regression confirmation for '{test_name}' due to unstable latency data"
                         )
                         if server_has_unstable:
-                            logging.info(f"  Server-side latency data is unstable")
+                            logging.info("  Server-side latency data is unstable")
                         if client_has_unstable:
-                            logging.info(f"  Client-side latency data is unstable")
+                            logging.info("  Client-side latency data is unstable")
                     else:
                         both_confirm_regression = (
                             server_confirms_regression and client_confirms_regression
@@ -1244,12 +1247,12 @@ def from_rts_to_regression_table(
                                 server_regression_details or client_regression_details
                             )
                             if combined_regression_details:
-                                combined_regression_details[
-                                    "server_side"
-                                ] = server_confirms_regression
-                                combined_regression_details[
-                                    "client_side"
-                                ] = client_confirms_regression
+                                combined_regression_details["server_side"] = (
+                                    server_confirms_regression
+                                )
+                                combined_regression_details["client_side"] = (
+                                    client_confirms_regression
+                                )
 
                                 # 2nd level confirmation is sufficient - always add to confirmed regressions
                                 logging.info(
@@ -1291,17 +1294,17 @@ def from_rts_to_regression_table(
                                         f"Confidence analysis for '{test_name}': {confidence_note}"
                                     )
                                     # Use 3rd level confidence if available
-                                    combined_regression_details[
-                                        "high_confidence"
-                                    ] = high_confidence
+                                    combined_regression_details["high_confidence"] = (
+                                        high_confidence
+                                    )
                                 else:
                                     # No 3rd level data available - default to moderate confidence since 2nd level confirmed
                                     logging.info(
                                         f"No 3rd level data available for '{test_name}' - using 2nd level confirmation"
                                     )
-                                    combined_regression_details[
-                                        "high_confidence"
-                                    ] = True  # 2nd level confirmation is reliable
+                                    combined_regression_details["high_confidence"] = (
+                                        True  # 2nd level confirmation is reliable
+                                    )
 
                                 # Always add to confirmed regressions when 2nd level confirms
                                 latency_confirmed_regression_details.append(

redisbench_admin/deploy/deploy.py

@@ -73,7 +73,15 @@ def deploy_command_logic(args, project_name, project_version):
     tf_triggering_env = "redisbench-admin-deploy"
     logging.info("Setting an infra timeout of {} secs".format(infra_timeout_secs))
     if args.destroy is False:
-        (tf_return_code, _, _, _, _, _, _,) = setup_remote_environment(
+        (
+            tf_return_code,
+            _,
+            _,
+            _,
+            _,
+            _,
+            _,
+        ) = setup_remote_environment(
             tf,
             tf_github_sha,
             tf_github_actor,

redisbench_admin/environments/oss_cluster.py

@@ -89,6 +89,20 @@ def generate_meet_cmds(shard_count, shard_host, start_port):
 def setup_oss_cluster_from_conns(meet_cmds, redis_conns, shard_count):
     status = False
     try:
+        # Pre-setup validation: check uptime and cluster mode
+        for primary_pos, redis_conn in enumerate(redis_conns):
+            redis_conn.ping()
+
+            server_info = redis_conn.info("server")
+            uptime = server_info.get("uptime_in_seconds", 0)
+            cluster_enabled = server_info.get("cluster_enabled", 0)
+            tcp_port = server_info.get("tcp_port", "n/a")
+
+            logging.info(
+                f"Node {primary_pos} ({tcp_port}): uptime={uptime}s cluster_enabled={cluster_enabled}"
+            )
+
+        # Send meet commands
         for primary_pos, redis_conn in enumerate(redis_conns):
             logging.info(
                 "Sending to primary #{} a total of {} MEET commands".format(
@@ -138,6 +152,29 @@ def setup_oss_cluster_from_conns(meet_cmds, redis_conns, shard_count):
                 )
                 logging.info("Node {}: cluster_state {}".format(n, cluster_state_ok))
                 sleep(1)
+
+        # Post-setup validation: check uptime and cluster mode
+        sleep(10)
+        for primary_pos, redis_conn in enumerate(redis_conns):
+            redis_conn.ping()
+
+            server_info = redis_conn.info("server")
+            uptime = server_info.get("uptime_in_seconds", 0)
+            server_info = redis_conn.info("cluster")
+            cluster_enabled = server_info.get("cluster_enabled", -1)
+            tcp_port = server_info.get("tcp_port", "n/a")
+
+            logging.info(
+                f"Node {primary_pos} ({tcp_port}): uptime={uptime}s cluster_enabled={cluster_enabled}"
+            )
+
+            if cluster_enabled != 1:
+                logging.error(
+                    "Node {}: cluster mode is not enabled (cluster_enabled={})".format(
+                        primary_pos, cluster_enabled
+                    )
+                )
+                return False
         status = True
     except redis.exceptions.RedisError as e:
         logging.warning("Received an error {}".format(e.__str__()))

redisbench_admin/export/export.py

@@ -42,7 +42,13 @@ def export_command_logic(args, project_name, project_version):
     deployment_name = args.deployment_name
     deployment_type = args.deployment_type
     results_format = args.results_format
-    (_, github_branch, github_org, github_repo, _,) = git_vars_crosscheck(
+    (
+        _,
+        github_branch,
+        github_org,
+        github_repo,
+        _,
+    ) = git_vars_crosscheck(
         None, args.github_branch, args.github_org, args.github_repo, None
     )
     exporter_timemetric_path = None

redisbench_admin/profilers/perf.py

@@ -400,9 +400,9 @@ class Perf:
             "Main THREAD Flame Graph: " + use_case, details
         )
         if artifact_result is True:
-            outputs[
-                "Main THREAD Flame Graph {}".format(identifier)
-            ] = flame_graph_output
+            outputs["Main THREAD Flame Graph {}".format(identifier)] = (
+                flame_graph_output
+            )
         result &= artifact_result
 
         tid = self.pid
@@ -440,9 +440,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report per dso,sym
@@ -460,9 +460,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym with callgraph {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym with callgraph {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report per dso,sym,srcline
@@ -487,9 +487,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report per dso,sym,srcline {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report per dso,sym,srcline {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         self.logger.info(
@@ -527,9 +527,9 @@ class Perf:
         )
 
         if artifact_result is True:
-            outputs[
-                "perf report top self-cpu {}".format(identifier)
-            ] = perf_report_artifact
+            outputs["perf report top self-cpu {}".format(identifier)] = (
+                perf_report_artifact
+            )
         result &= artifact_result
 
         # generate perf report --stdio report
@@ -546,9 +546,9 @@ class Perf:
             )
 
             if artifact_result is True:
-                outputs[
-                    "perf report top self-cpu (dso={})".format(binary)
-                ] = perf_report_artifact
+                outputs["perf report top self-cpu (dso={})".format(binary)] = (
+                    perf_report_artifact
+                )
         result &= artifact_result
 
         if self.callgraph_mode == "dwarf":
@@ -590,9 +590,9 @@ class Perf:
                 )
                 result &= artifact_result
                 if artifact_result is True:
-                    outputs[
-                        "Top entries in text form by LOC"
-                    ] = pprof_artifact_text_output
+                    outputs["Top entries in text form by LOC"] = (
+                        pprof_artifact_text_output
+                    )
                     tabular_data_map["text-lines"] = tabular_data
                 self.logger.info("Generating pprof png output")
                 pprof_png_output = self.output + ".pprof.png"
@@ -604,9 +604,9 @@ class Perf:
                     self.output,
                 )
                 if artifact_result is True:
-                    outputs[
-                        "Output graph image in PNG format"
-                    ] = pprof_artifact_png_output
+                    outputs["Output graph image in PNG format"] = (
+                        pprof_artifact_png_output
+                    )
                 result &= artifact_result
 
         # save stack collapsed

redisbench_admin/run/common.py

@@ -206,7 +206,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_tsbs_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_tsbs_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -218,7 +221,10 @@ def prepare_benchmark_parameters_specif_tooling(
             cluster_api_enabled,
         )
     if "memtier_benchmark" in benchmark_tool:
-        (command_arr, command_str,) = prepare_memtier_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_memtier_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -236,7 +242,10 @@ def prepare_benchmark_parameters_specif_tooling(
             ann_path = stdout[0].strip() + "/run/ann/pkg/multirun.py"
             logging.info("Remote ann-benchmark path: {}".format(ann_path))
 
-        (command_arr, command_str,) = prepare_ann_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_ann_benchmark_command(
             server_private_ip,
             server_plaintext_port,
             cluster_api_enabled,
@@ -250,7 +259,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_ftsb_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_ftsb_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -267,7 +279,10 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (command_arr, command_str,) = prepare_aibench_benchmark_command(
+        (
+            command_arr,
+            command_str,
+        ) = prepare_aibench_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -772,7 +787,10 @@ def print_results_table_stdout(
     metric_names=[],
 ):
     # check which metrics to extract
-    (_, metrics,) = merge_default_and_config_metrics(
+    (
+        _,
+        metrics,
+    ) = merge_default_and_config_metrics(
         benchmark_config,
         default_metrics,
         None,

redisbench_admin/run/metrics.py

@@ -188,8 +188,6 @@ BENCHMARK_CPU_STATS_GLOBAL = {}
 
 
 def collect_cpu_data(redis_conns=[], delta_secs: float = 5.0, delay_start: float = 1.0):
-    global BENCHMARK_CPU_STATS_GLOBAL
-    global BENCHMARK_RUNNING_GLOBAL
     import time
 
     counter = 0

redisbench_admin/run_async/async_terraform.py

@@ -114,7 +114,11 @@ class TerraformClass:
     def async_runner_setup(
         self,
     ):
-        (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
+        (
+            remote_setup,
+            deployment_type,
+            remote_id,
+        ) = fetch_remote_setup_from_config(
             [{"type": "async", "setup": "runner"}],
             "https://github.com/RedisLabsModules/testing-infrastructure.git",
             "master",
@@ -229,7 +233,11 @@ def terraform_spin_or_reuse_env(
     tf_override_name=None,
     tf_folder_path=None,
 ):
-    (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/RedisLabsModules/testing-infrastructure.git",
         "master",

redisbench_admin/run_async/render_files.py

@@ -28,9 +28,9 @@ WantedBy=multi-user.target
         argv.append("--private_key")
         argv.append("/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem")
     else:
-        argv[
-            argv.index(args.private_key)
-        ] = "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
+        argv[argv.index(args.private_key)] = (
+            "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
+        )
     if len(args.module_path) != 0:
         argv[argv.index(args.module_path[0])] = (
             "/home/ubuntu/work_dir/tests/benchmarks/"

redisbench_admin/run_local/args.py

@@ -40,4 +40,16 @@ def create_run_local_arguments(parser):
         default=IGNORE_KEYSPACE_ERRORS,
         help="Ignore keyspace check errors. Will still log them as errors",
     )
+    parser.add_argument(
+        "--dry-run",
+        default=False,
+        action="store_true",
+        help="Setup environment and test connectivity without running benchmarks",
+    )
+    parser.add_argument(
+        "--dry-run-with-preload",
+        default=False,
+        action="store_true",
+        help="Setup environment, preload data, and test connectivity without running benchmarks",
+    )
     return parser

redisbench_admin/run_local/run_local.py

@@ -16,6 +16,7 @@ from redisbench_admin.run.git import git_vars_crosscheck
 from redisbench_admin.utils.remote import (
     get_project_ts_tags,
     push_data_to_redistimeseries,
+    perform_connectivity_test,
 )
 
 import redisbench_admin.run.metrics
@@ -326,6 +327,7 @@ def run_local_command_logic(args, project_name, project_version):
                                 )
 
                                 # run the benchmark
+
                                 cpu_stats_thread = threading.Thread(
                                     target=collect_cpu_data,
                                     args=(redis_conns, 5.0, 1.0),
@@ -335,9 +337,60 @@ def run_local_command_logic(args, project_name, project_version):
                                 )
                                 cpu_stats_thread.start()
                                 benchmark_start_time = datetime.datetime.now()
-                                stdout, stderr = run_local_benchmark(
-                                    benchmark_tool, command
+                                logging.info(
+                                    "Running benchmark command: {}".format(command)
                                 )
+                                # Handle dry-run modes
+                                if args.dry_run or args.dry_run_with_preload:
+                                    logging.info(
+                                        "🏃 Dry-run mode detected - performing connectivity tests"
+                                    )
+
+                                    # Test basic connectivity after setup
+                                    connectivity_success = perform_connectivity_test(
+                                        redis_conns, "after local environment setup"
+                                    )
+
+                                    if args.dry_run_with_preload:
+                                        logging.info(
+                                            "📦 Dry-run with preload - data loading already completed during setup"
+                                        )
+                                        # Test connectivity after preload (data was loaded during local_db_spin)
+                                        connectivity_success = (
+                                            perform_connectivity_test(
+                                                redis_conns, "after data preloading"
+                                            )
+                                            and connectivity_success
+                                        )
+
+                                    # Print dry-run summary
+                                    logging.info("=" * 50)
+                                    logging.info("🎯 DRY-RUN SUMMARY")
+                                    logging.info("=" * 50)
+                                    logging.info(
+                                        f"✅ Database: {setup_type} ({'cluster' if cluster_api_enabled else 'standalone'}) started locally"
+                                    )
+                                    logging.info(
+                                        f"✅ Client tools: {benchmark_tool} available"
+                                    )
+                                    logging.info(
+                                        f"{'✅' if connectivity_success else '❌'} Connectivity: {len(redis_conns)} connection(s) tested"
+                                    )
+                                    if args.dry_run_with_preload:
+                                        logging.info(
+                                            "✅ Data preload: Completed during setup"
+                                        )
+                                    logging.info("🏁 Dry-run completed successfully")
+                                    logging.info(
+                                        "⏭️  Benchmark execution skipped (dry-run mode)"
+                                    )
+                                    logging.info("=" * 50)
+
+                                    # Skip benchmark execution and continue to next test
+                                else:
+                                    stdout, stderr = run_local_benchmark(
+                                        benchmark_tool, command
+                                    )
                                 benchmark_end_time = datetime.datetime.now()
                                 redisbench_admin.run.metrics.BENCHMARK_RUNNING_GLOBAL = (
                                     False
@@ -364,10 +417,10 @@ def run_local_command_logic(args, project_name, project_version):
                                         benchmark_end_time, benchmark_start_time
                                     )
                                 )
-
-                                logging.info("Extracting the benchmark results")
-                                logging.info("stdout: {}".format(stdout))
-                                logging.info("stderr: {}".format(stderr))
+                                if args.dry_run is False:
+                                    logging.info("Extracting the benchmark results")
+                                    logging.info("stdout: {}".format(stdout))
+                                    logging.info("stderr: {}".format(stderr))
 
                                 (
                                     _,
@@ -420,53 +473,54 @@ def run_local_command_logic(args, project_name, project_version):
                                         test_name,
                                         tf_triggering_env,
                                     )
-
-                                post_process_benchmark_results(
-                                    benchmark_tool,
-                                    local_benchmark_output_filename,
-                                    start_time_ms,
-                                    start_time_str,
-                                    stdout,
-                                )
                                 results_dict = {}
-                                with open(
-                                    local_benchmark_output_filename, "r"
-                                ) as json_file:
-                                    results_dict = json.load(json_file)
-                                    print_results_table_stdout(
-                                        benchmark_config,
-                                        default_metrics,
-                                        results_dict,
-                                        setup_name,
-                                        setup_type,
-                                        test_name,
-                                        total_shards_cpu_usage,
-                                        overall_end_time_metrics,
-                                        [
-                                            "memory_used_memory",
-                                            "memory_used_memory_dataset",
-                                        ],
-                                    )
-                                    export_redis_metrics(
-                                        artifact_version,
-                                        end_time_ms,
-                                        overall_end_time_metrics,
-                                        rts,
-                                        setup_name,
-                                        setup_type,
-                                        test_name,
-                                        tf_github_branch,
-                                        tf_github_org,
-                                        tf_github_repo,
-                                        tf_triggering_env,
-                                        {"metric-type": "redis-metrics"},
-                                        0,
+                                if args.dry_run is False:
+                                    post_process_benchmark_results(
+                                        benchmark_tool,
+                                        local_benchmark_output_filename,
+                                        start_time_ms,
+                                        start_time_str,
+                                        stdout,
                                     )
 
-                                    # check KPIs
-                                    return_code = results_dict_kpi_check(
-                                        benchmark_config, results_dict, return_code
-                                    )
+                                    with open(
+                                        local_benchmark_output_filename, "r"
+                                    ) as json_file:
+                                        results_dict = json.load(json_file)
+                                        print_results_table_stdout(
+                                            benchmark_config,
+                                            default_metrics,
+                                            results_dict,
+                                            setup_name,
+                                            setup_type,
+                                            test_name,
+                                            total_shards_cpu_usage,
+                                            overall_end_time_metrics,
+                                            [
+                                                "memory_used_memory",
+                                                "memory_used_memory_dataset",
+                                            ],
+                                        )
+                                        export_redis_metrics(
+                                            artifact_version,
+                                            end_time_ms,
+                                            overall_end_time_metrics,
+                                            rts,
+                                            setup_name,
+                                            setup_type,
+                                            test_name,
+                                            tf_github_branch,
+                                            tf_github_org,
+                                            tf_github_repo,
+                                            tf_triggering_env,
+                                            {"metric-type": "redis-metrics"},
+                                            0,
+                                        )
+
+                                        # check KPIs
+                                        return_code = results_dict_kpi_check(
+                                            benchmark_config, results_dict, return_code
+                                        )
 
                                 metadata_tags = get_metadata_tags(benchmark_config)
                                 (
@@ -508,7 +562,10 @@ def run_local_command_logic(args, project_name, project_version):
                                     "Some unexpected exception was caught "
                                     "during local work. Failing test...."
                                 )
-                                logging.critical(sys.exc_info()[0])
+                                if len(sys.exc_info()) > 0:
+                                    logging.critical(sys.exc_info()[0])
+                                else:
+                                    logging.critical(sys.exc_info())
                                 print("-" * 60)
                                 traceback.print_exc(file=sys.stdout)
                                 print("-" * 60)
@@ -687,17 +744,17 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict[
-                "command_and_metric_and_version"
-            ] = "{} - {} - {}".format(command, metric, version)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_version"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            variant_labels_dict["command_and_metric_and_version"] = (
+                "{} - {} - {}".format(command, metric, version)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            )
 
         if branch is not None:
-            variant_labels_dict[
-                "command_and_metric_and_branch"
-            ] = "{} - {} - {}".format(command, metric, branch)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_branch"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            variant_labels_dict["command_and_metric_and_branch"] = (
+                "{} - {} - {}".format(command, metric, branch)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            )

redisbench_admin/run_remote/args.py

@@ -112,6 +112,18 @@ def create_run_remote_arguments(parser):
         action="store_true",
         help="skip environment variables check",
     )
+    parser.add_argument(
+        "--dry-run",
+        default=False,
+        action="store_true",
+        help="Setup environment and test connectivity without running benchmarks",
+    )
+    parser.add_argument(
+        "--dry-run-with-preload",
+        default=False,
+        action="store_true",
+        help="Setup environment, preload data, and test connectivity without running benchmarks",
+    )
     parser.add_argument(
         "--continue-on-module-check-error",
         default=False,

redisbench_admin/run_remote/remote_helpers.py

@@ -106,7 +106,11 @@ def remote_tool_pre_bench_step(
         )
 
     if "ftsb_" in benchmark_tool:
-        (queries_file_link, remote_tool_link, tool_link,) = extract_ftsb_extra_links(
+        (
+            queries_file_link,
+            remote_tool_link,
+            tool_link,
+        ) = extract_ftsb_extra_links(
             benchmark_config, benchmark_tool, config_key, architecture
         )
         logging.info(

redisbench_admin/run_remote/run_remote.py

@@ -69,6 +69,7 @@ from redisbench_admin.utils.remote import (
     get_project_ts_tags,
     push_data_to_redistimeseries,
     fetch_remote_id_from_config,
+    perform_connectivity_test,
 )
 
 from redisbench_admin.utils.utils import (
@@ -695,6 +696,62 @@ def run_remote_command_logic(args, project_name, project_version):
                                                 )
                                             )
 
+                                    # Handle dry-run modes
+                                    if args.dry_run or args.dry_run_with_preload:
+                                        logging.info(
+                                            "🏃 Dry-run mode detected - performing connectivity tests"
+                                        )
+
+                                        # Test basic connectivity after setup
+                                        connectivity_success = (
+                                            perform_connectivity_test(
+                                                redis_conns, "after environment setup"
+                                            )
+                                        )
+
+                                        if args.dry_run_with_preload:
+                                            logging.info(
+                                                "📦 Dry-run with preload - data loading already completed during setup"
+                                            )
+                                            # Test connectivity after preload (data was loaded during remote_db_spin)
+                                            connectivity_success = (
+                                                perform_connectivity_test(
+                                                    redis_conns, "after data preloading"
+                                                )
+                                                and connectivity_success
+                                            )
+
+                                        # Print dry-run summary
+                                        logging.info("=" * 50)
+                                        logging.info("🎯 DRY-RUN SUMMARY")
+                                        logging.info("=" * 50)
+                                        logging.info(
+                                            f"✅ Infrastructure: {'Deployed' if args.inventory is None else 'Using existing'}"
+                                        )
+                                        logging.info(
+                                            f"✅ Database: {setup_type} ({'cluster' if cluster_enabled else 'standalone'}) started"
+                                        )
+                                        logging.info(
+                                            f"✅ Client tools: Setup completed on {client_public_ip}"
+                                        )
+                                        logging.info(
+                                            f"{'✅' if connectivity_success else '❌'} Connectivity: {len(redis_conns)} connection(s) tested"
+                                        )
+                                        if args.dry_run_with_preload:
+                                            logging.info(
+                                                "✅ Data preload: Completed during setup"
+                                            )
+                                        logging.info(
+                                            "🏁 Dry-run completed successfully"
+                                        )
+                                        logging.info(
+                                            "⏭️  Benchmark execution skipped (dry-run mode)"
+                                        )
+                                        logging.info("=" * 50)
+
+                                        # Skip benchmark execution and continue to next test
+                                        continue
+
                                     logging.info(
                                         "Will store benchmark json output to local file {}".format(
                                             local_bench_fname
@@ -1429,20 +1486,20 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict[
-                "command_and_metric_and_version"
-            ] = "{} - {} - {}".format(command, metric, version)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_version"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            variant_labels_dict["command_and_metric_and_version"] = (
+                "{} - {} - {}".format(command, metric, version)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, version)
+            )
 
         if branch is not None:
-            variant_labels_dict[
-                "command_and_metric_and_branch"
-            ] = "{} - {} - {}".format(command, metric, branch)
-            variant_labels_dict[
-                "command_and_metric_and_setup_and_branch"
-            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            variant_labels_dict["command_and_metric_and_branch"] = (
+                "{} - {} - {}".format(command, metric, branch)
+            )
+            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
+                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
+            )
 
 
 def shutdown_remote_redis(redis_conns, ssh_tunnel):

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

@@ -771,7 +771,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 +945,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 +1189,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.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.39
+Version: 0.11.40
 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.40.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=qyOgo0CBE3NdDRTa5dqgNV_0eZJ0jkGBliGTasHuWls,6256
+redisbench_admin/compare/compare.py,sha256=ZE6j5T8SIiyW6mpUCkVWRvo5xT4Tkf-SnOnYSSQ9zt4,103382
 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=VnZ20gqpk-NMzNxaaUHgedgl3B6fZm3Fewj6cPZ1iCg,4231
 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/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/terraform.py,sha256=FCkE69h2nYK6ehfHGkoQqE-e2tPh2FWSYX1AoAei4GA,3988
+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=qlO49qdJh96rOEXnFMgFcpiwYjmrG0K060bEc3nyHD0,41643
 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.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,,