redisbench-admin 0.11.39__py3-none-any.whl → 0.11.41__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,
@@ -161,6 +162,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,14 @@ 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)
@@ -321,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:
@@ -385,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"
@@ -1216,9 +1216,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 +1244,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 +1291,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