redis-benchmarks-specification 0.1.339__tar.gz → 0.2.0__tar.gz

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.339
+Version: 0.2.0
 Summary: The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute.
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-benchmarks-specification"
-version = "0.1.339"
+version = "0.2.0"
 description = "The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "Readme.md"

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__builder__/builder.py

@@ -28,6 +28,7 @@ from redis_benchmarks_specification.__common__.env import (
     SPECS_PATH_SETUPS,
     STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
     STREAM_KEYNAME_NEW_BUILD_EVENTS,
+    get_arch_specific_stream_name,
     REDIS_HEALTH_CHECK_INTERVAL,
     REDIS_SOCKET_TIMEOUT,
     REDIS_BINS_EXPIRE_SECS,
@@ -47,6 +48,69 @@ from redis_benchmarks_specification.__common__.package import (
 PERFORMANCE_GH_TOKEN = os.getenv("PERFORMANCE_GH_TOKEN", None)
 
 
+def clear_pending_messages_for_builder_consumer(conn, builder_group, builder_id):
+    """Clear all pending messages for a specific builder consumer on startup"""
+    consumer_name = f"{builder_group}-proc#{builder_id}"
+
+    try:
+        # Get pending messages for this specific consumer
+        pending_info = conn.xpending_range(
+            STREAM_KEYNAME_GH_EVENTS_COMMIT,
+            builder_group,
+            min="-",
+            max="+",
+            count=1000,  # Get up to 1000 pending messages
+            consumername=consumer_name,
+        )
+
+        if pending_info:
+            message_ids = [msg["message_id"] for msg in pending_info]
+            logging.info(
+                f"Found {len(message_ids)} pending messages for builder consumer {consumer_name}. Clearing them..."
+            )
+
+            # Acknowledge all pending messages to clear them
+            ack_count = conn.xack(
+                STREAM_KEYNAME_GH_EVENTS_COMMIT, builder_group, *message_ids
+            )
+
+            logging.info(
+                f"Successfully cleared {ack_count} pending messages for builder consumer {consumer_name}"
+            )
+        else:
+            logging.info(
+                f"No pending messages found for builder consumer {consumer_name}"
+            )
+
+    except redis.exceptions.ResponseError as e:
+        if "NOGROUP" in str(e):
+            logging.info(f"Builder consumer group {builder_group} does not exist yet")
+        else:
+            logging.warning(f"Error clearing pending messages: {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error clearing pending messages: {e}")
+
+
+def reset_builder_consumer_group_to_latest(conn, builder_group):
+    """Reset the builder consumer group position to only read new messages (skip old ones)"""
+    try:
+        # Set the consumer group position to '$' (latest) to skip all existing messages
+        conn.xgroup_setid(STREAM_KEYNAME_GH_EVENTS_COMMIT, builder_group, id="$")
+        logging.info(
+            f"Reset builder consumer group {builder_group} position to latest - will only process new messages"
+        )
+
+    except redis.exceptions.ResponseError as e:
+        if "NOGROUP" in str(e):
+            logging.info(f"Builder consumer group {builder_group} does not exist yet")
+        else:
+            logging.warning(f"Error resetting builder consumer group position: {e}")
+    except Exception as e:
+        logging.error(
+            f"Unexpected error resetting builder consumer group position: {e}"
+        )
+
+
 class ZipFileWithPermissions(ZipFile):
     def _extract_member(self, member, targetpath, pwd):
         if not isinstance(member, ZipInfo):
@@ -104,6 +168,12 @@ def main():
     )
     parser.add_argument("--github_token", type=str, default=PERFORMANCE_GH_TOKEN)
     parser.add_argument("--pull-request", type=str, default=None, nargs="?", const="")
+    parser.add_argument(
+        "--skip-clear-pending-on-startup",
+        default=False,
+        action="store_true",
+        help="Skip automatically clearing pending messages and resetting consumer group position on startup. By default, pending messages are cleared and consumer group is reset to latest position to skip old work and recover from crashes.",
+    )
     args = parser.parse_args()
     if args.logname is not None:
         print("Writting log to {}".format(args.logname))
@@ -169,6 +239,19 @@ def main():
         builder_id = "1"
 
     builder_consumer_group_create(conn, builder_group)
+
+    # Clear pending messages and reset consumer group position by default (unless explicitly skipped)
+    if not args.skip_clear_pending_on_startup:
+        logging.info(
+            "Clearing pending messages and resetting builder consumer group position on startup (default behavior)"
+        )
+        clear_pending_messages_for_builder_consumer(conn, builder_group, builder_id)
+        reset_builder_consumer_group_to_latest(conn, builder_group)
+    else:
+        logging.info(
+            "Skipping pending message cleanup and builder consumer group reset as requested"
+        )
+
     if args.github_token is not None:
         logging.info("detected a github token. will update as much as possible!!! =)")
     previous_id = args.consumer_start_id
@@ -268,7 +351,32 @@ def builder_process_stream(
                     build_request_arch, arch
                 )
             )
+            # Acknowledge the message even though we're skipping it
+            ack_reply = conn.xack(
+                STREAM_KEYNAME_GH_EVENTS_COMMIT,
+                STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
+                streamId,
+            )
+            if type(ack_reply) == bytes:
+                ack_reply = ack_reply.decode()
+            if ack_reply == "1" or ack_reply == 1:
+                logging.info(
+                    "Successfully acknowledged build variation stream with id {} (filtered by arch).".format(
+                        streamId
+                    )
+                )
+            else:
+                logging.error(
+                    "Unable to acknowledge build variation stream with id {}. XACK reply {}".format(
+                        streamId, ack_reply
+                    )
+                )
             return previous_id, new_builds_count, build_stream_fields_arr
+        else:
+            logging.info(
+                "No arch info found on the stream. Using default arch {}.".format(arch)
+            )
+            build_request_arch = arch
 
         home = str(Path.home())
         if b"git_hash" in testDetails:
@@ -430,7 +538,7 @@ def builder_process_stream(
                     server_name = testDetails[b"server_name"].decode()
 
                 # Check if artifacts already exist before building
-                prefix = f"github_org={github_org}/github_repo={github_repo}/git_branch={str(git_branch)}/git_version={str(git_version)}/git_hash={str(git_hash)}"
+                prefix = f"build_spec={build_spec}/github_org={github_org}/github_repo={github_repo}/git_branch={str(git_branch)}/git_version={str(git_version)}/git_hash={str(git_hash)}"
 
                 # Create a comprehensive build signature that includes all build-affecting parameters
                 import hashlib
@@ -496,6 +604,32 @@ def builder_process_stream(
                         github_repo,
                         artifact_keys,  # Pass existing artifact keys
                     )
+                    # Add to benchmark stream even when reusing artifacts
+                    if result is True:
+                        arch_specific_stream = get_arch_specific_stream_name(build_arch)
+                        logging.info(
+                            f"Adding reused build work to architecture-specific stream: {arch_specific_stream}"
+                        )
+                        benchmark_stream_id = conn.xadd(
+                            arch_specific_stream, build_stream_fields
+                        )
+                        logging.info(
+                            "successfully reused build variant {} for redis git_sha {}. Stream id: {}".format(
+                                id, git_hash, benchmark_stream_id
+                            )
+                        )
+                        streamId_decoded = streamId.decode()
+                        benchmark_stream_id_decoded = benchmark_stream_id.decode()
+                        builder_list_completed = (
+                            f"builder:{streamId_decoded}:builds_completed"
+                        )
+                        conn.lpush(builder_list_completed, benchmark_stream_id_decoded)
+                        conn.expire(builder_list_completed, REDIS_BINS_EXPIRE_SECS)
+                        logging.info(
+                            f"Adding information of build->benchmark stream info in list {builder_list_completed}. Adding benchmark stream id: {benchmark_stream_id_decoded}"
+                        )
+                        build_stream_fields_arr.append(build_stream_fields)
+                        new_builds_count = new_builds_count + 1
                     continue  # Skip to next build spec
 
                 logging.info(
@@ -583,8 +717,12 @@ def builder_process_stream(
                     None,  # existing_artifact_keys - None for new builds
                 )
                 if result is True:
+                    arch_specific_stream = get_arch_specific_stream_name(build_arch)
+                    logging.info(
+                        f"Adding new build work to architecture-specific stream: {arch_specific_stream}"
+                    )
                     benchmark_stream_id = conn.xadd(
-                        STREAM_KEYNAME_NEW_BUILD_EVENTS, build_stream_fields
+                        arch_specific_stream, build_stream_fields
                     )
                     logging.info(
                         "sucessfully built build variant {} for redis git_sha {}. Stream id: {}".format(

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__cli__/args.py

@@ -138,7 +138,7 @@ def spec_cli_args(parser):
     parser.add_argument("--gh_repo", type=str, default="redis")
     parser.add_argument("--server_name", type=str, default=None)
     parser.add_argument("--run_image", type=str, default="redis")
-    parser.add_argument("--build_arch", type=str, default=None)
+    parser.add_argument("--arch", type=str, default="amd64")
     parser.add_argument("--id", type=str, default="dockerhub")
     parser.add_argument("--mnt_point", type=str, default="")
     parser.add_argument("--trigger-unstable-commits", type=bool, default=True)

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__cli__/cli.py

@@ -44,6 +44,7 @@ from redis_benchmarks_specification.__common__.env import (
     STREAM_KEYNAME_GH_EVENTS_COMMIT,
     STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
     STREAM_KEYNAME_NEW_BUILD_EVENTS,
+    get_arch_specific_stream_name,
 )
 from redis_benchmarks_specification.__common__.package import (
     get_version_string,
@@ -84,7 +85,7 @@ def trigger_tests_dockerhub_cli_command_logic(args, project_name, project_versio
         args.id,
         conn,
         args.run_image,
-        args.build_arch,
+        args.arch,
         testDetails,
         "n/a",
         [],
@@ -124,9 +125,12 @@ def trigger_tests_dockerhub_cli_command_logic(args, project_name, project_versio
         store_airgap_image_redis(conn, docker_client, args.run_image)
 
     if result is True:
-        benchmark_stream_id = conn.xadd(
-            STREAM_KEYNAME_NEW_BUILD_EVENTS, build_stream_fields
+        # Use architecture-specific stream
+        arch_specific_stream = get_arch_specific_stream_name(args.arch)
+        logging.info(
+            f"CLI adding work to architecture-specific stream: {arch_specific_stream}"
         )
+        benchmark_stream_id = conn.xadd(arch_specific_stream, build_stream_fields)
         logging.info(
             "sucessfully requested a new run {}. Stream id: {}".format(
                 build_stream_fields, benchmark_stream_id
@@ -438,9 +442,9 @@ def trigger_tests_cli_command_logic(args, project_name, project_version):
             commit_dict["tests_groups_regexp"] = tests_groups_regexp
             commit_dict["github_org"] = args.gh_org
             commit_dict["github_repo"] = args.gh_repo
-            if args.build_arch is not None:
-                commit_dict["build_arch"] = args.build_arch
-                commit_dict["arch"] = args.build_arch
+            if args.arch is not None:
+                commit_dict["build_arch"] = args.arch
+                commit_dict["arch"] = args.arch
             if args.server_name is not None and args.server_name != "":
                 commit_dict["server_name"] = args.server_name
             if args.build_artifacts != "":

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__common__/env.py

@@ -32,6 +32,20 @@ STREAM_KEYNAME_NEW_BUILD_EVENTS = os.getenv(
     "STREAM_KEYNAME_NEW_BUILD_EVENTS", "oss:api:gh/redis/redis/builds"
 )
 
+
+# Function to get architecture-specific build events stream name
+def get_arch_specific_stream_name(arch):
+    """Get architecture-specific stream name for build events"""
+    base_stream = STREAM_KEYNAME_NEW_BUILD_EVENTS
+    if arch in ["amd64", "x86_64"]:
+        return f"{base_stream}:amd64"
+    elif arch in ["arm64", "aarch64"]:
+        return f"{base_stream}:arm64"
+    else:
+        # Fallback to base stream for unknown architectures
+        return base_stream
+
+
 STREAM_GH_NEW_BUILD_RUNNERS_CG = os.getenv(
     "STREAM_GH_NEW_BUILD_RUNNERS_CG", "runners-cg:redis/redis/commits"
 )

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__self_contained_coordinator__/runners.py

@@ -38,6 +38,7 @@ from redisbench_admin.utils.results import post_process_benchmark_results
 
 from redis_benchmarks_specification.__common__.env import (
     STREAM_KEYNAME_NEW_BUILD_EVENTS,
+    get_arch_specific_stream_name,
     STREAM_GH_NEW_BUILD_RUNNERS_CG,
     S3_BUCKET_NAME,
 )
@@ -71,12 +72,16 @@ from redis_benchmarks_specification.__self_contained_coordinator__.prepopulation
 )
 
 
-def build_runners_consumer_group_create(conn, running_platform, id="$"):
+def build_runners_consumer_group_create(conn, running_platform, arch="amd64", id="$"):
     consumer_group_name = get_runners_consumer_group_name(running_platform)
+    arch_specific_stream = get_arch_specific_stream_name(arch)
     logging.info("Will use consumer group named {}.".format(consumer_group_name))
+    logging.info(
+        "Will read from architecture-specific stream: {}.".format(arch_specific_stream)
+    )
     try:
         conn.xgroup_create(
-            STREAM_KEYNAME_NEW_BUILD_EVENTS,
+            arch_specific_stream,
             consumer_group_name,
             mkstream=True,
             id=id,
@@ -99,17 +104,23 @@ def get_runners_consumer_group_name(running_platform):
     return consumer_group_name
 
 
-def clear_pending_messages_for_consumer(conn, running_platform, consumer_pos):
+def clear_pending_messages_for_consumer(
+    conn, running_platform, consumer_pos, arch="amd64"
+):
     """Clear all pending messages for a specific consumer on startup"""
     consumer_group_name = get_runners_consumer_group_name(running_platform)
     consumer_name = "{}-self-contained-proc#{}".format(
         consumer_group_name, consumer_pos
     )
+    arch_specific_stream = get_arch_specific_stream_name(arch)
+    logging.info(
+        f"Clearing pending messages from architecture-specific stream: {arch_specific_stream}"
+    )
 
     try:
         # Get pending messages for this specific consumer
         pending_info = conn.xpending_range(
-            STREAM_KEYNAME_NEW_BUILD_EVENTS,
+            arch_specific_stream,
             consumer_group_name,
             min="-",
             max="+",
@@ -125,7 +136,7 @@ def clear_pending_messages_for_consumer(conn, running_platform, consumer_pos):
 
             # Acknowledge all pending messages to clear them
             ack_count = conn.xack(
-                STREAM_KEYNAME_NEW_BUILD_EVENTS, consumer_group_name, *message_ids
+                arch_specific_stream, consumer_group_name, *message_ids
             )
 
             logging.info(
@@ -143,15 +154,19 @@ def clear_pending_messages_for_consumer(conn, running_platform, consumer_pos):
         logging.error(f"Unexpected error clearing pending messages: {e}")
 
 
-def reset_consumer_group_to_latest(conn, running_platform):
+def reset_consumer_group_to_latest(conn, running_platform, arch="amd64"):
     """Reset the consumer group position to only read new messages (skip old ones)"""
     consumer_group_name = get_runners_consumer_group_name(running_platform)
+    arch_specific_stream = get_arch_specific_stream_name(arch)
+    logging.info(
+        f"Resetting consumer group position for architecture-specific stream: {arch_specific_stream}"
+    )
 
     try:
         # Set the consumer group position to '$' (latest) to skip all existing messages
-        conn.xgroup_setid(STREAM_KEYNAME_NEW_BUILD_EVENTS, consumer_group_name, id="$")
+        conn.xgroup_setid(arch_specific_stream, consumer_group_name, id="$")
         logging.info(
-            f"Reset consumer group {consumer_group_name} position to latest - will only process new messages"
+            f"Reset consumer group {consumer_group_name} position to latest on stream {arch_specific_stream} - will only process new messages"
         )
 
     except redis.exceptions.ResponseError as e:

{redis_benchmarks_specification-0.1.339 → redis_benchmarks_specification-0.2.0}/redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -102,6 +102,7 @@ from redisbench_admin.utils.results import post_process_benchmark_results
 
 from redis_benchmarks_specification.__common__.env import (
     STREAM_KEYNAME_NEW_BUILD_EVENTS,
+    get_arch_specific_stream_name,
     S3_BUCKET_NAME,
 )
 from redis_benchmarks_specification.__common__.spec import (
@@ -650,7 +651,7 @@ def main():
 
     logging.info("checking build spec requirements")
     running_platform = args.platform_name
-    build_runners_consumer_group_create(gh_event_conn, running_platform)
+    build_runners_consumer_group_create(gh_event_conn, running_platform, args.arch)
 
     # Clear pending messages and reset consumer group position by default (unless explicitly skipped)
     if not args.skip_clear_pending_on_startup:
@@ -659,9 +660,9 @@ def main():
             "Clearing pending messages and resetting consumer group position on startup (default behavior)"
         )
         clear_pending_messages_for_consumer(
-            gh_event_conn, running_platform, consumer_pos
+            gh_event_conn, running_platform, consumer_pos, args.arch
         )
-        reset_consumer_group_to_latest(gh_event_conn, running_platform)
+        reset_consumer_group_to_latest(gh_event_conn, running_platform, args.arch)
     else:
         logging.info(
             "Skipping pending message cleanup and consumer group reset as requested"
@@ -819,10 +820,15 @@ def self_contained_coordinator_blocking_read(
             get_runners_consumer_group_name(platform_name), consumer_name
         )
     )
+    # Use architecture-specific stream
+    arch_specific_stream = get_arch_specific_stream_name(arch)
+    logging.info(
+        f"Reading work from architecture-specific stream: {arch_specific_stream}"
+    )
     newTestInfo = github_event_conn.xreadgroup(
         get_runners_consumer_group_name(platform_name),
         consumer_name,
-        {STREAM_KEYNAME_NEW_BUILD_EVENTS: stream_id},
+        {arch_specific_stream: stream_id},
         count=1,
         block=0,
     )
@@ -872,26 +878,35 @@ def self_contained_coordinator_blocking_read(
         )
         num_process_streams = num_process_streams + 1
         num_process_test_suites = num_process_test_suites + total_test_suite_runs
-        if overall_result is True:
-            ack_reply = github_event_conn.xack(
-                STREAM_KEYNAME_NEW_BUILD_EVENTS,
-                get_runners_consumer_group_name(platform_name),
-                stream_id,
-            )
-            if type(ack_reply) == bytes:
-                ack_reply = ack_reply.decode()
-            if ack_reply == "1" or ack_reply == 1:
+
+        # Always acknowledge the message, even if it was filtered out
+        arch_specific_stream = get_arch_specific_stream_name(arch)
+        ack_reply = github_event_conn.xack(
+            arch_specific_stream,
+            get_runners_consumer_group_name(platform_name),
+            stream_id,
+        )
+        if type(ack_reply) == bytes:
+            ack_reply = ack_reply.decode()
+        if ack_reply == "1" or ack_reply == 1:
+            if overall_result is True:
                 logging.info(
-                    "Sucessfully acknowledge BENCHMARK variation stream with id {}.".format(
+                    "Successfully acknowledged BENCHMARK variation stream with id {} (processed).".format(
                         stream_id
                     )
                 )
             else:
-                logging.error(
-                    "Unable to acknowledge build variation stream with id {}. XACK reply {}".format(
-                        stream_id, ack_reply
+                logging.info(
+                    "Successfully acknowledged BENCHMARK variation stream with id {} (filtered/skipped).".format(
+                        stream_id
                     )
                 )
+        else:
+            logging.error(
+                "Unable to acknowledge build variation stream with id {}. XACK reply {}".format(
+                    stream_id, ack_reply
+                )
+            )
     return overall_result, stream_id, num_process_streams, num_process_test_suites