redis-benchmarks-specification 0.1.101__py3-none-any.whl → 0.1.150__py3-none-any.whl

redis_benchmarks_specification/__common__/builder_schema.py

@@ -107,7 +107,8 @@ def get_commit_dict_from_sha(
             commit.commit.author.date.timestamp() * 1000.0
         )
     else:
-        use_git_timestamp = False
+        if "git_timestamp_ms" not in commit_dict:
+            use_git_timestamp = False
     commit_dict["use_git_timestamp"] = str(use_git_timestamp)
     commit_dict["git_hash"] = git_hash
     if gh_branch is not None:
@@ -173,6 +174,10 @@ def get_branch_version_from_test_details(testDetails):
             git_branch = git_branch.decode()
         if git_branch.startswith("/refs/heads/"):
             git_branch = git_branch.replace("/refs/heads/", "")
+        if git_branch.startswith("refs/heads/"):
+            git_branch = git_branch.replace("refs/heads/", "")
+        if git_branch.startswith("/"):
+            git_branch = git_branch[1:]
     if git_version is not None:
         if type(git_version) == bytes:
             git_version = git_version.decode()

redis_benchmarks_specification/__common__/env.py

@@ -45,7 +45,7 @@ GH_REDIS_SERVER_USER = os.getenv("GH_REDIS_SERVER_USER", None)
 
 # DB used to authenticate ( read-only/non-dangerous access only )
 REDIS_AUTH_SERVER_HOST = os.getenv("REDIS_AUTH_SERVER_HOST", "localhost")
-REDIS_AUTH_SERVER_PORT = int(os.getenv("REDIS_AUTH_SERVER_PORT", "6380"))
+REDIS_AUTH_SERVER_PORT = int(os.getenv("REDIS_AUTH_SERVER_PORT", "6379"))
 REDIS_HEALTH_CHECK_INTERVAL = int(os.getenv("REDIS_HEALTH_CHECK_INTERVAL", "15"))
 REDIS_SOCKET_TIMEOUT = int(os.getenv("REDIS_SOCKET_TIMEOUT", "300"))
 REDIS_BINS_EXPIRE_SECS = int(

redis_benchmarks_specification/__common__/github.py

@@ -24,9 +24,7 @@ def generate_build_started_pr_comment(
     tests_priority_upper_limit,
     tests_regexp,
 ):
-    comment_body = (
-        f"### CE Performance Automation : step 1 of 2 (build) STARTING...\n\n"
-    )
+    comment_body = "### CE Performance Automation : step 1 of 2 (build) STARTING...\n\n"
     comment_body += (
         "This comment was automatically generated given a benchmark was triggered.\n"
     )
@@ -38,7 +36,7 @@ def generate_build_started_pr_comment(
     comment_body += f"   - git branch: {git_branch}\n"
     comment_body += f"   - commit date and time: {commit_datetime}\n"
     comment_body += f"   - commit summary: {commit_summary}\n"
-    comment_body += f"   - test filters:\n"
+    comment_body += "   - test filters:\n"
     comment_body += (
         f"       - command priority lower limit: {tests_priority_lower_limit}\n"
     )
@@ -64,7 +62,7 @@ def generate_build_finished_pr_comment(
     build_duration_seconds,
 ):
     build_duration_seconds = int(build_duration_seconds)
-    comment_body = f"### CE Performance Automation : step 1 of 2 (build) DONE.\n\n"
+    comment_body = "### CE Performance Automation : step 1 of 2 (build) DONE.\n\n"
     comment_body += (
         "This comment was automatically generated given a benchmark was triggered.\n"
     )
@@ -76,7 +74,7 @@ def generate_build_finished_pr_comment(
     comment_body += f"   - git branch: {git_branch}\n"
     comment_body += f"   - commit date and time: {commit_datetime}\n"
     comment_body += f"   - commit summary: {commit_summary}\n"
-    comment_body += f"   - test filters:\n"
+    comment_body += "   - test filters:\n"
     comment_body += (
         f"       - command priority lower limit: {tests_priority_lower_limit}\n"
     )
@@ -104,39 +102,46 @@ def check_github_available_and_actionable(
     regression_comment = None
     github_pr = None
     old_regression_comment_body = ""
+    pr_link = None
     if github_token is not None:
         logging.info("Detected github token")
         g = Github(github_token)
         if pull_request is not None and pull_request != "":
-            pull_request_n = int(pull_request)
-            github_pr = (
-                g.get_user(tf_github_org)
-                .get_repo(tf_github_repo)
-                .get_issue(pull_request_n)
-            )
-            comments = github_pr.get_comments()
-            pr_link = github_pr.html_url
-            logging.info("Working on github PR already: {}".format(pr_link))
-            is_actionable_pr = True
-            contains_regression_comment, pos = fn(comments)
-            if contains_regression_comment:
-                regression_comment = comments[pos]
-                old_regression_comment_body = regression_comment.body
-                logging.info(
-                    "Already contains PR comment. Link: {}".format(
-                        regression_comment.html_url
+            try:
+                pull_request_n = int(pull_request)
+                github_pr = (
+                    g.get_user(tf_github_org)
+                    .get_repo(tf_github_repo)
+                    .get_issue(pull_request_n)
+                )
+                comments = github_pr.get_comments()
+                pr_link = github_pr.html_url
+                logging.info("Working on github PR already: {}".format(pr_link))
+                is_actionable_pr = True
+                contains_regression_comment, pos = fn(comments)
+                if contains_regression_comment:
+                    regression_comment = comments[pos]
+                    old_regression_comment_body = regression_comment.body
+                    logging.info(
+                        "Already contains PR comment. Link: {}".format(
+                            regression_comment.html_url
+                        )
                     )
+                    if verbose:
+                        logging.info("Printing old PR comment:")
+                        print("".join(["-" for x in range(1, 80)]))
+                        print(regression_comment.body)
+                        print("".join(["-" for x in range(1, 80)]))
+                else:
+                    logging.info("Does not contain PR comment")
+            except Exception as e:
+                logging.error(
+                    f"an error occured when checking github info. {e.__str__()}. proceeding..."
                 )
-                if verbose:
-                    logging.info("Printing old PR comment:")
-                    print("".join(["-" for x in range(1, 80)]))
-                    print(regression_comment.body)
-                    print("".join(["-" for x in range(1, 80)]))
-            else:
-                logging.info("Does not contain PR comment")
-    logging.info(
-        f"contains_regression_comment: {contains_regression_comment}, is_actionable_pr: {is_actionable_pr}, pr_link: {pr_link}"
-    )
+            logging.info(
+                f"contains_regression_comment: {contains_regression_comment}, is_actionable_pr: {is_actionable_pr}, pr_link: {pr_link}"
+            )
+
     return (
         contains_regression_comment,
         github_pr,
@@ -195,12 +200,10 @@ def update_comment_if_needed(
                 )
             )
         if user_input.lower() == "y" or auto_approve:
-            print("Updating comment {}".format(regression_comment.html_url))
-            regression_comment.edit(comment_body)
             html_url = regression_comment.html_url
-            print(
-                "Updated comment. Access it via {}".format(regression_comment.html_url)
-            )
+            print("Updating comment {}".format(html_url))
+            regression_comment.edit(comment_body)
+            print("Updated comment. Access it via {}".format(html_url))
 
 
 def check_benchmark_build_comment(comments):
@@ -226,7 +229,9 @@ def check_benchmark_running_comment(comments):
 
 
 def markdown_progress_bar(current, total, bar_length=40):
-    progress = current / total
+    progress = 1.0
+    if total > 0:
+        progress = current / total
     block = int(round(bar_length * progress))
     bar = "#" * block + "-" * (bar_length - block)
     percentage = round(progress * 100, 2)

redis_benchmarks_specification/__common__/runner.py

@@ -6,9 +6,12 @@ import re
 
 import redis
 from redisbench_admin.run.metrics import collect_redis_metrics
-from redisbench_admin.run.redistimeseries import timeseries_test_sucess_flow
 from redisbench_admin.run_remote.run_remote import export_redis_metrics
 
+from redis_benchmarks_specification.__common__.timeseries import (
+    timeseries_test_sucess_flow,
+)
+
 
 def execute_init_commands(benchmark_config, r, dbconfig_keyname="dbconfig"):
     cmds = None
@@ -144,8 +147,11 @@ def exporter_datasink_common(
     tf_triggering_env,
     topology_spec_name,
     default_metrics=None,
+    git_hash=None,
 ):
-    logging.info("Using datapoint_time_ms: {}".format(datapoint_time_ms))
+    logging.info(
+        f"Using datapoint_time_ms: {datapoint_time_ms}. git_hash={git_hash}, git_branch={git_branch}, git_version={git_version}. gh_org={tf_github_org}, gh_repo={tf_github_repo}"
+    )
     timeseries_test_sucess_flow(
         datasink_push_results_redistimeseries,
         git_version,
@@ -167,9 +173,15 @@ def exporter_datasink_common(
         metadata,
         build_variant_name,
         running_platform,
+        None,
+        git_hash,
     )
     logging.info("Collecting memory metrics")
-    (_, _, overall_end_time_metrics,) = collect_redis_metrics(
+    (
+        _,
+        _,
+        overall_end_time_metrics,
+    ) = collect_redis_metrics(
         redis_conns,
         ["memory"],
         {

redis_benchmarks_specification/__common__/spec.py

@@ -1,4 +1,56 @@
 import math
+import logging
+
+
+def extract_redis_dbconfig_parameters(benchmark_config, dbconfig_keyname):
+    redis_configuration_parameters = {}
+    modules_configuration_parameters_map = {}
+    dataset_load_timeout_secs = 120
+    dataset_name = None
+    dbconfig_present = False
+    if dbconfig_keyname in benchmark_config:
+        dbconfig_present = True
+        if type(benchmark_config[dbconfig_keyname]) == list:
+            for k in benchmark_config[dbconfig_keyname]:
+                if "configuration-parameters" in k:
+                    cp = k["configuration-parameters"]
+                    for item in cp:
+                        for k, v in item.items():
+                            redis_configuration_parameters[k] = v
+                if "dataset_load_timeout_secs" in k:
+                    dataset_load_timeout_secs = k["dataset_load_timeout_secs"]
+                if "dataset_name" in k:
+                    dataset_name = k["dataset_name"]
+        if type(benchmark_config[dbconfig_keyname]) == dict:
+            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 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,
+        dataset_name,
+        redis_configuration_parameters,
+        dataset_load_timeout_secs,
+        modules_configuration_parameters_map,
+    )
+
+
+def extract_redis_configuration_from_topology(topologies_map, topology_spec_name):
+    redis_arguments = ""
+    topology_spec = topologies_map[topology_spec_name]
+    if "redis_arguments" in topology_spec:
+        redis_arguments = topology_spec["redis_arguments"]
+        logging.info(
+            f"extracted redis_arguments: {redis_arguments} from topology: {topology_spec_name}"
+        )
+    return redis_arguments
 
 
 def extract_client_cpu_limit(benchmark_config):