redisbench-admin 0.10.29__py3-none-any.whl → 0.11.1__py3-none-any.whl

redisbench_admin/compare/compare.py

@@ -722,7 +722,6 @@ def from_rts_to_regression_table(
     total_comparison_points = 0
     noise_waterline = 3
     progress = tqdm(unit="benchmark time-series", total=len(test_names))
-    at_comparison = 0
     for test_name in test_names:
         multi_value_baseline = check_multi_value_filter(baseline_str)
         multi_value_comparison = check_multi_value_filter(comparison_str)

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/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,
@@ -484,6 +499,36 @@ def extract_test_feasible_setups(
         for setup_name in feasible_setups_list:
             if default_specs is not None:
                 feasible_setups_map[setup_name] = {}
+                #  spec:
+                #   setups:
+                #   - name: oss-standalone
+                #     type: oss-standalone
+                #     redis_topology:
+                #       primaries: 1
+                #       replicas: 1
+                #       placement: "sparse"
+                #     resources:
+                #       requests:
+                #         cpus: "2"
+                #         memory: "10g"
+                #   - name: oss-standalone-threads-6
+                #     type: oss-standalone
+                #     redis_topology:
+                #       primaries: 1
+                #       replicas: 1
+                #       placement: "sparse"
+                #     resources:
+                #       requests:
+                #         cpus: "2"
+                #         memory: "10g"
+                #     dbconfig:
+                #       module-configuration-parameters:
+                #         redisearch:
+                #           WORKERS: 6
+                #           MIN_OPERATION_WORKERS: 6
+                #         module-oss:
+                #           WORKERS: 6
+                #           MIN_OPERATION_WORKERS: 6
                 if "setups" in default_specs:
                     for setup in default_specs["setups"]:
                         if setup_name == setup["name"]:
@@ -515,7 +560,9 @@ def extract_test_feasible_setups(
                 feasible_setups_map[setup_name]
             )
         )
-
+    logging.info(
+        f"There a total of {len(feasible_setups_map.keys())} setups. Setups: {feasible_setups_map}"
+    )
     return feasible_setups_map
 
 
@@ -731,7 +778,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/run.py

@@ -4,6 +4,7 @@
 #  All rights reserved.
 #
 import logging
+import copy
 
 from redisbench_admin.run.common import extract_test_feasible_setups
 from redisbench_admin.run_remote.consts import min_recommended_benchmark_duration
@@ -30,6 +31,20 @@ def calculate_client_tool_duration_and_check(
     return benchmark_duration_seconds
 
 
+def merge_dicts(dict1, dict2):
+    result = copy.deepcopy(dict1)  # Start with dict1's keys and values
+    for key, value in dict2.items():
+        if key in result:
+            if isinstance(result[key], dict) and isinstance(value, dict):
+                # Recursively merge nested dictionaries
+                result[key] = merge_dicts(result[key], value)
+            # If it's not a dict, we keep the value from dict1 (result)
+        else:
+            result[key] = value
+    print(f"merging dict1 {dict1} with with dict2 {dict2}. final {result}")
+    return result
+
+
 def define_benchmark_plan(benchmark_definitions, default_specs):
     benchmark_runs_plan = {}
     for test_name, benchmark_config in benchmark_definitions.items():
@@ -42,8 +57,11 @@ def define_benchmark_plan(benchmark_definitions, default_specs):
             benchmark_runs_plan[benchmark_type] = {}
 
         # extract dataset-name
-        dbconfig_present, dataset_name, _, _, _ = extract_redis_dbconfig_parameters(
-            benchmark_config, "dbconfig"
+        benchmark_contains_dbconfig, dataset_name, _, _, _ = (
+            extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
+        )
+        logging.info(
+            f"Benchmark contains specific dbconfig on test {test_name}: {benchmark_contains_dbconfig}"
         )
         if dataset_name is None:
             dataset_name = test_name
@@ -60,6 +78,14 @@ def define_benchmark_plan(benchmark_definitions, default_specs):
         )
 
         for setup_name, setup_settings in test_setups.items():
+            test_benchmark_config = copy.deepcopy(benchmark_config)
+            setup_contains_dbconfig = False
+            if "dbconfig" in setup_settings:
+                setup_contains_dbconfig = True
+            logging.info(
+                f"setup ({setup_name}): {setup_settings}. contains dbconfig {setup_contains_dbconfig}"
+            )
+
             if setup_name not in benchmark_runs_plan[benchmark_type][dataset_name]:
                 benchmark_runs_plan[benchmark_type][dataset_name][setup_name] = {}
                 benchmark_runs_plan[benchmark_type][dataset_name][setup_name][
@@ -68,6 +94,7 @@ def define_benchmark_plan(benchmark_definitions, default_specs):
                 benchmark_runs_plan[benchmark_type][dataset_name][setup_name][
                     "benchmarks"
                 ] = {}
+
             if (
                 test_name
                 in benchmark_runs_plan[benchmark_type][dataset_name][setup_name][
@@ -80,8 +107,25 @@ def define_benchmark_plan(benchmark_definitions, default_specs):
                     )
                 )
             else:
+                # check if we need to merge dbconfigs from the setup defaults
+                if setup_contains_dbconfig:
+                    if "dbconfig" not in test_benchmark_config:
+                        test_benchmark_config["dbconfig"] = {}
+                    setup_dbconfig = setup_settings["dbconfig"]
+                    benchmark_dbconfig = test_benchmark_config["dbconfig"]
+                    logging.info(
+                        f"Merging setup dbconfig: {setup_dbconfig}, with benchmark dbconfig {test_benchmark_config}"
+                    )
+                    final_db_config = merge_dicts(benchmark_dbconfig, setup_dbconfig)
+                    logging.info(f"FINAL DB CONFIG: {final_db_config}")
+                    test_benchmark_config["dbconfig"] = final_db_config
+
+                logging.info(
+                    f"final benchmark config for setup: {setup_name} and test: {test_name}. {test_benchmark_config}"
+                )
+                # add benchmark
                 benchmark_runs_plan[benchmark_type][dataset_name][setup_name][
                     "benchmarks"
-                ][test_name] = benchmark_config
+                ][test_name] = test_benchmark_config
 
     return benchmark_runs_plan

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/run_local.py

@@ -65,9 +65,7 @@ from redisbench_admin.utils.benchmark_config import (
 from redisbench_admin.utils.local import (
     get_local_run_full_filename,
 )
-from redisbench_admin.utils.remote import (
-    extract_git_vars,
-)
+
 from redisbench_admin.utils.results import post_process_benchmark_results
 
 import threading
@@ -682,17 +680,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/run_remote.py

@@ -1374,20 +1374,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

@@ -31,7 +31,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/redis-performance/testing-infrastructure.git",
         "master",

redisbench_admin/utils/benchmark_config.py

@@ -17,6 +17,8 @@ from redisbench_admin.utils.remote import (
     fetch_remote_id_from_config,
 )
 
+CONFIG_PARAMS_KEY = "module-configuration-parameters"
+
 
 def parse_exporter_metrics_definition(
     benchmark_config: dict, configkey: str = "redistimeseries"
@@ -226,6 +228,7 @@ def merge_default_and_specific_properties_dict_type(
 
 
 def extract_redis_dbconfig_parameters(benchmark_config, dbconfig_keyname):
+
     redis_configuration_parameters = {}
     modules_configuration_parameters_map = {}
     dataset_load_timeout_secs = 120
@@ -235,10 +238,8 @@ def extract_redis_dbconfig_parameters(benchmark_config, dbconfig_keyname):
         dbconfig_present = True
         if type(benchmark_config[dbconfig_keyname]) == list:
             for k in benchmark_config[dbconfig_keyname]:
-                if "module-configuration-parameters" in k:
-                    modules_configuration_parameters_map = k[
-                        "module-configuration-parameters"
-                    ]
+                if CONFIG_PARAMS_KEY in k:
+                    modules_configuration_parameters_map = k[CONFIG_PARAMS_KEY]
                 if "configuration-parameters" in k:
                     cp = k["configuration-parameters"]
                     for item in cp:
@@ -249,18 +250,20 @@ def extract_redis_dbconfig_parameters(benchmark_config, dbconfig_keyname):
                 if "dataset_name" in k:
                     dataset_name = k["dataset_name"]
         if type(benchmark_config[dbconfig_keyname]) == dict:
-            if "module-configuration-parameters" in benchmark_config[dbconfig_keyname]:
+            if CONFIG_PARAMS_KEY in benchmark_config[dbconfig_keyname]:
                 modules_configuration_parameters_map = benchmark_config[
                     dbconfig_keyname
-                ]["module-configuration-parameters"]
+                ][CONFIG_PARAMS_KEY]
             if "configuration-parameters" in benchmark_config[dbconfig_keyname]:
                 cp = benchmark_config[dbconfig_keyname]["configuration-parameters"]
                 for k, v in cp.items():
                     redis_configuration_parameters[k] = v
-                if "dataset_load_timeout_secs" in cp:
-                    dataset_load_timeout_secs = cp["dataset_load_timeout_secs"]
-                if "dataset_name" in cp:
-                    dataset_name = cp["dataset_name"]
+            if "dataset_load_timeout_secs" in benchmark_config[dbconfig_keyname]:
+                dataset_load_timeout_secs = benchmark_config[dbconfig_keyname][
+                    "dataset_load_timeout_secs"
+                ]
+            if "dataset_name" in benchmark_config[dbconfig_keyname]:
+                dataset_name = benchmark_config[dbconfig_keyname]["dataset_name"]
 
     return (
         dbconfig_present,

redisbench_admin/utils/remote.py

@@ -638,6 +638,14 @@ def push_data_to_redistimeseries(rts, time_series_dict: dict, expire_msecs=0):
 
 def exporter_create_ts(rts, time_series, timeseries_name):
     updated_create = False
+    final_labels = {}
+    for label_name, value in time_series["labels"].items():
+        if value is not None:
+            final_labels[label_name] = value
+        else:
+            logging.warning(f"The label {label_name} value was None. skipping it...")
+
+    time_series["labels"] = final_labels
     try:
         if rts.exists(timeseries_name):
             updated_create = check_rts_labels(rts, time_series, timeseries_name)
@@ -647,11 +655,22 @@ def exporter_create_ts(rts, time_series, timeseries_name):
                     timeseries_name, time_series["labels"]
                 )
             )
+
             rts.ts().create(
                 timeseries_name, labels=time_series["labels"], chunk_size=128
             )
             updated_create = True
-
+    except redis.exceptions.DataError as e:
+        logging.error(
+            "While creating timeseries named {} with the following labels: {} this error ocurred: {}".format(
+                timeseries_name, time_series["labels"], e.__str__()
+            )
+        )
+        raise Exception(
+            "While creating timeseries named {} with the following labels: {} this error ocurred: {}".format(
+                timeseries_name, time_series["labels"], e.__str__()
+            )
+        )
     except redis.exceptions.ResponseError as e:
         if "already exists" in e.__str__():
             updated_create = check_rts_labels(rts, time_series, timeseries_name)
@@ -712,7 +731,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,
@@ -883,9 +905,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
 
 

{redisbench_admin-0.10.29.dist-info → redisbench_admin-0.11.1.dist-info}/METADATA

@@ -1,30 +1,29 @@
 Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.10.29
+Version: 0.11.1
 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
-Requires-Python: >=3.7.0,<4.0.0
+Requires-Python: >=3.10.0,<4.0.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Flask (>=2.0.1,<3.0.0)
 Requires-Dist: Flask-HTTPAuth (>=4.4.0,<5.0.0)
 Requires-Dist: GitPython (>=3.1.12,<4.0.0)
 Requires-Dist: Jinja2 (>=3.0.3,<4.0.0)
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: boto3 (>=1.13.24,<2.0.0)
-Requires-Dist: certifi (>=2021.10.8,<2022.0.0)
+Requires-Dist: certifi (>=2021.10.8,<2025.0.0)
 Requires-Dist: daemonize (>=2.5.0,<3.0.0)
 Requires-Dist: flask-restx (>=0.5.1,<0.6.0)
 Requires-Dist: humanize (>=2.4.0,<3.0.0)
 Requires-Dist: jsonpath_ng (>=1.5.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.1.2,<4.0.0)
-Requires-Dist: pandas (>=1.0,<2.0)
-Requires-Dist: paramiko (>=2.7.2,<3.0.0)
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: pandas (>=2.1.2,<3.0.0)
+Requires-Dist: paramiko (>=2.7.2,<4.0.0)
 Requires-Dist: psutil (>=5.6.6,<6.0.0)
 Requires-Dist: pyWorkFlow (>=0.0.2,<0.0.3)
 Requires-Dist: py_cpuinfo (>=5.0.0,<6.0.0)
@@ -33,7 +32,7 @@ Requires-Dist: pysftp (>=0.2.9,<0.3.0)
 Requires-Dist: pytablewriter[html] (>=0.64.1,<0.65.0)
 Requires-Dist: python_terraform (>=0.10.1,<0.11.0)
 Requires-Dist: redis (>=4.2.2,<5.0.0)
-Requires-Dist: requests (>=2.23.0,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: slack-bolt (>=1.13.0,<2.0.0)
 Requires-Dist: slack-sdk (>=3.15.2,<4.0.0)
 Requires-Dist: sshtunnel (>=0.4.0,<0.5.0)
@@ -158,6 +157,12 @@ To run a specific test:
 $ tox -- tests/test_redistimeseries.py
 ```
 
+To run a specific test with verbose logging:
+
+```sh
+# tox -- -vv --log-cli-level=INFO tests/test_run.py
+```
+
 ## License
 
 redisbench-admin is distributed under the BSD3 license - see [LICENSE](LICENSE)