redis-benchmarks-specification 0.1.322__py3-none-any.whl → 0.1.323__py3-none-any.whl

redis_benchmarks_specification/__builder__/builder.py

@@ -73,6 +73,18 @@ def main():
     parser.add_argument(
         "--arch", type=str, default="amd64", help="arch to build artifacts"
     )
+    parser.add_argument(
+        "--builder-group",
+        type=str,
+        default=STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
+        help="Consumer group name to read from the stream",
+    )
+    parser.add_argument(
+        "--builder-id",
+        type=str,
+        default="1",
+        help="Consumer id to read from the stream",
+    )
     parser.add_argument(
         "--setups-folder",
         type=str,
@@ -149,7 +161,14 @@ def main():
 
     build_spec_image_prefetch(builders_folder, different_build_specs)
 
-    builder_consumer_group_create(conn)
+    builder_group = args.builder_group
+    builder_id = args.builder_id
+    if builder_group is None:
+        builder_group = STREAM_GH_EVENTS_COMMIT_BUILDERS_CG
+    if builder_id is None:
+        builder_id = "1"
+
+    builder_consumer_group_create(conn, builder_group)
     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
@@ -162,28 +181,26 @@ def main():
             args.docker_air_gap,
             arch,
             args.github_token,
+            builder_group,
+            builder_id,
         )
 
 
-def builder_consumer_group_create(conn, id="$"):
+def builder_consumer_group_create(
+    conn, builder_group=STREAM_GH_EVENTS_COMMIT_BUILDERS_CG, id="$"
+):
     try:
         conn.xgroup_create(
             STREAM_KEYNAME_GH_EVENTS_COMMIT,
-            STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
+            builder_group,
             mkstream=True,
             id=id,
         )
         logging.info(
-            "Created consumer group named {} to distribute work.".format(
-                STREAM_GH_EVENTS_COMMIT_BUILDERS_CG
-            )
+            "Created consumer group named {} to distribute work.".format(builder_group)
         )
     except redis.exceptions.ResponseError:
-        logging.info(
-            "Consumer group named {} already existed.".format(
-                STREAM_GH_EVENTS_COMMIT_BUILDERS_CG
-            )
-        )
+        logging.info("Consumer group named {} already existed.".format(builder_group))
 
 
 def check_benchmark_build_comment(comments):
@@ -205,14 +222,22 @@ def builder_process_stream(
     docker_air_gap=False,
     arch="amd64",
     github_token=None,
+    builder_group=None,
+    builder_id=None,
 ):
     new_builds_count = 0
     auto_approve_github_comments = True
     build_stream_fields_arr = []
-    logging.info("Entering blocking read waiting for work.")
-    consumer_name = "{}-proc#{}".format(STREAM_GH_EVENTS_COMMIT_BUILDERS_CG, "1")
+    if builder_group is None:
+        builder_group = STREAM_GH_EVENTS_COMMIT_BUILDERS_CG
+    if builder_id is None:
+        builder_id = "1"
+    consumer_name = "{}-proc#{}".format(builder_group, builder_id)
+    logging.info(
+        f"Entering blocking read waiting for work. building for arch: {arch}. Using consumer id {consumer_name}"
+    )
     newTestInfo = conn.xreadgroup(
-        STREAM_GH_EVENTS_COMMIT_BUILDERS_CG,
+        builder_group,
         consumer_name,
         {STREAM_KEYNAME_GH_EVENTS_COMMIT: previous_id},
         count=1,
@@ -230,6 +255,21 @@ def builder_process_stream(
         docker_client = docker.from_env()
         from pathlib import Path
 
+        build_request_arch = None
+        if b"arch" in testDetails:
+            build_request_arch = testDetails[b"arch"].decode()
+        elif b"build_arch" in testDetails:
+            build_request_arch = testDetails[b"build_arch"].decode()
+        else:
+            logging.info("No arch info found on the stream.")
+        if build_request_arch is not None and build_request_arch != arch:
+            logging.info(
+                "skipping build request given requested build arch {}!={}".format(
+                    build_request_arch, arch
+                )
+            )
+            return previous_id, new_builds_count, build_stream_fields_arr
+
         home = str(Path.home())
         if b"git_hash" in testDetails:
             git_hash = testDetails[b"git_hash"]

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="amd64")
+    parser.add_argument("--build_arch", type=str, default=None)
     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/__cli__/cli.py

@@ -432,6 +432,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.server_name is not None and args.server_name != "":
                 commit_dict["server_name"] = args.server_name
             if args.build_artifacts != "":

redis_benchmarks_specification/__cli__/stats.py

@@ -40,6 +40,28 @@ def clean_number(value):
         return 0  # Default to 0 if invalid
 
 
+def clean_percentage(value):
+    """Parse percentage values like '17.810220866%'"""
+    try:
+        value = value.replace("%", "").strip()
+        return float(value)
+    except ValueError:
+        logging.error(f"Skipping invalid percentage value: {value}")
+        return 0.0
+
+
+def format_number_with_suffix(value):
+    """Format large numbers with B/M/K suffixes for readability"""
+    if value >= 1_000_000_000:
+        return f"{value / 1_000_000_000:.1f}B"
+    elif value >= 1_000_000:
+        return f"{value / 1_000_000:.1f}M"
+    elif value >= 1_000:
+        return f"{value / 1_000:.1f}K"
+    else:
+        return str(value)
+
+
 def get_arg_value(args, flag, default):
     """Extract integer values safely from CLI arguments"""
     if flag in args:
@@ -93,6 +115,35 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
             priority_json = json.load(fd)
     tracked_groups = []
     tracked_groups_hist = {}
+
+    # ACL category tracking for benchmark YAML files
+    benchmark_read_commands = {}
+    benchmark_write_commands = {}
+    benchmark_fast_commands = {}
+    benchmark_slow_commands = {}
+    benchmark_total_command_count = 0
+
+    # Group-based read/write tracking for benchmarks
+    benchmark_group_read = {}  # group -> count
+    benchmark_group_write = {}  # group -> count
+    benchmark_group_total = {}  # group -> total count
+
+    # ACL category tracking for commandstats CSV
+    csv_read_commands = {}
+    csv_write_commands = {}
+    csv_fast_commands = {}
+    csv_slow_commands = {}
+    csv_total_command_count = 0
+
+    # Group-based read/write tracking for CSV
+    csv_group_read = {}  # group -> count
+    csv_group_write = {}  # group -> count
+    csv_group_total = {}  # group -> total count
+
+    # Percentage validation tracking
+    csv_provided_percentages = {}  # command -> provided percentage
+    csv_original_counts = {}  # command -> original count from CSV
+
     override_enabled = args.override_tests
     fail_on_required_diff = args.fail_on_required_diff
     overall_result = True
@@ -252,6 +303,75 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
                                 tracked_groups_hist[group] = 0
                             tracked_groups_hist[group] = tracked_groups_hist[group] + 1
 
+                            # Track ACL categories for read/write and fast/slow analysis
+                            if "acl_categories" in command_json:
+                                acl_categories = command_json["acl_categories"]
+                                benchmark_total_command_count += 1
+
+                                # Track total by group (all commands)
+                                if group not in benchmark_group_total:
+                                    benchmark_group_total[group] = 0
+                                benchmark_group_total[group] += 1
+
+                                # Track read/write commands
+                                is_read = False
+                                is_write = False
+
+                                if "@read" in acl_categories:
+                                    is_read = True
+                                elif "@write" in acl_categories:
+                                    is_write = True
+                                elif "_ro" in command.lower():
+                                    # Commands with _ro suffix are read-only (like EVALSHA_RO)
+                                    is_read = True
+                                elif "@pubsub" in acl_categories:
+                                    # Pubsub commands: SUBSCRIBE/UNSUBSCRIBE are read, PUBLISH is write
+                                    if command.lower() in [
+                                        "subscribe",
+                                        "unsubscribe",
+                                        "psubscribe",
+                                        "punsubscribe",
+                                    ]:
+                                        is_read = True
+                                    else:
+                                        is_write = (
+                                            True  # PUBLISH and other pubsub commands
+                                        )
+                                else:
+                                    # Commands without explicit read/write ACL but not _ro are assumed write
+                                    # This covers cases like EVALSHA which can modify data
+                                    is_write = True
+
+                                if is_read:
+                                    if command not in benchmark_read_commands:
+                                        benchmark_read_commands[command] = 0
+                                    benchmark_read_commands[command] += 1
+
+                                    # Track by group
+                                    if group not in benchmark_group_read:
+                                        benchmark_group_read[group] = 0
+                                    benchmark_group_read[group] += 1
+
+                                elif is_write:
+                                    if command not in benchmark_write_commands:
+                                        benchmark_write_commands[command] = 0
+                                    benchmark_write_commands[command] += 1
+
+                                    # Track by group
+                                    if group not in benchmark_group_write:
+                                        benchmark_group_write[group] = 0
+                                    benchmark_group_write[group] += 1
+
+                                # Track fast/slow commands
+                                if "@fast" in acl_categories:
+                                    if command not in benchmark_fast_commands:
+                                        benchmark_fast_commands[command] = 0
+                                    benchmark_fast_commands[command] += 1
+                                elif "@slow" in acl_categories:
+                                    if command not in benchmark_slow_commands:
+                                        benchmark_slow_commands[command] = 0
+                                    benchmark_slow_commands[command] += 1
+
                 # Calculate total connections
                 total_connections = clients * threads
 
@@ -428,6 +548,15 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
                 if len(row) > 2:
                     usecs = clean_number(row[2])
                     total_usecs += usecs
+
+                # Parse percentage and original count if available
+                provided_percentage = None
+                original_count = None
+                if len(row) > 3:
+                    provided_percentage = clean_percentage(row[3])
+                if len(row) > 4:
+                    original_count = clean_number(row[4])
+
                 if count == 0:
                     continue
                 tracked = False
@@ -452,11 +581,97 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
                     if "deprecated_since" in command_json:
                         deprecated = True
 
+                    # Track ACL categories for commandstats CSV data
+                    if "acl_categories" in command_json:
+                        acl_categories = command_json["acl_categories"]
+
+                        # Use original count if available, otherwise use parsed count
+                        tracking_count = (
+                            original_count if original_count is not None else count
+                        )
+                        csv_total_command_count += tracking_count
+
+                        # Track total by group (all commands)
+                        if group not in csv_group_total:
+                            csv_group_total[group] = 0
+                        csv_group_total[group] += tracking_count
+
+                        # Track read/write commands
+                        is_read = False
+                        is_write = False
+
+                        if "@read" in acl_categories:
+                            is_read = True
+                        elif "@write" in acl_categories:
+                            is_write = True
+                        elif "_ro" in cmd.lower():
+                            # Commands with _ro suffix are read-only (like EVALSHA_RO)
+                            is_read = True
+                        elif "@pubsub" in acl_categories:
+                            # Pubsub commands: SUBSCRIBE/UNSUBSCRIBE are read, PUBLISH is write
+                            if cmd.lower() in [
+                                "subscribe",
+                                "unsubscribe",
+                                "psubscribe",
+                                "punsubscribe",
+                            ]:
+                                is_read = True
+                            else:
+                                is_write = True  # PUBLISH and other pubsub commands
+                        else:
+                            # Commands without explicit read/write ACL but not _ro are assumed write
+                            # This covers cases like EVALSHA which can modify data
+                            is_write = True
+
+                        if is_read:
+                            if cmd.lower() not in csv_read_commands:
+                                csv_read_commands[cmd.lower()] = 0
+                            csv_read_commands[cmd.lower()] += tracking_count
+
+                            # Track by group
+                            if group not in csv_group_read:
+                                csv_group_read[group] = 0
+                            csv_group_read[group] += tracking_count
+
+                        elif is_write:
+                            if cmd.lower() not in csv_write_commands:
+                                csv_write_commands[cmd.lower()] = 0
+                            csv_write_commands[cmd.lower()] += tracking_count
+
+                            # Track by group
+                            if group not in csv_group_write:
+                                csv_group_write[group] = 0
+                            csv_group_write[group] += tracking_count
+
+                        # Track fast/slow commands
+                        if "@fast" in acl_categories:
+                            if cmd.lower() not in csv_fast_commands:
+                                csv_fast_commands[cmd.lower()] = 0
+                            csv_fast_commands[cmd.lower()] += tracking_count
+                        elif "@slow" in acl_categories:
+                            if cmd.lower() not in csv_slow_commands:
+                                csv_slow_commands[cmd.lower()] = 0
+                            csv_slow_commands[cmd.lower()] += tracking_count
+
                 if module is False or include_modules:
-                    priority[cmd.lower()] = count
+                    # Use original count if available and different from parsed count
+                    final_count = count
+                    if original_count is not None and original_count != count:
+                        logging.warning(
+                            f"Using original count for {cmd}: {original_count:,} instead of parsed {count:,}"
+                        )
+                        final_count = original_count
+
+                    priority[cmd.lower()] = final_count
                     if type(usecs) == int:
                         priority_usecs[cmd.lower()] = usecs
 
+                    # Store percentage and original count for validation
+                    if provided_percentage is not None:
+                        csv_provided_percentages[cmd.lower()] = provided_percentage
+                    if original_count is not None:
+                        csv_original_counts[cmd.lower()] = original_count
+
                 if cmdstat in tracked_commands_json:
                     tracked = True
                 if module is False or include_modules:
@@ -651,6 +866,249 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
     logging.info(
         f"There is a total of : {len(list(tracked_commands_json.keys()))} tracked commands."
     )
+
+    # ACL Category Analysis Summary
+    logging.info("=" * 80)
+    logging.info("ACL CATEGORY ANALYSIS SUMMARY")
+    logging.info("=" * 80)
+
+    # Benchmark YAML files analysis
+    if benchmark_total_command_count > 0:
+        logging.info("BENCHMARK TEST SUITES ANALYSIS (from YAML files):")
+        logging.info("-" * 50)
+
+        # Calculate read/write percentages for benchmarks
+        benchmark_read_count = sum(benchmark_read_commands.values())
+        benchmark_write_count = sum(benchmark_write_commands.values())
+        benchmark_rw_count = benchmark_read_count + benchmark_write_count
+
+        if benchmark_rw_count > 0:
+            read_percentage = (benchmark_read_count / benchmark_rw_count) * 100
+            write_percentage = (benchmark_write_count / benchmark_rw_count) * 100
+
+            logging.info(f"READ/WRITE COMMAND DISTRIBUTION:")
+            logging.info(
+                f"  Read commands:  {benchmark_read_count:6d} ({read_percentage:5.1f}%)"
+            )
+            logging.info(
+                f"  Write commands: {benchmark_write_count:6d} ({write_percentage:5.1f}%)"
+            )
+            logging.info(f"  Total R/W:      {benchmark_rw_count:6d} (100.0%)")
+        else:
+            logging.info("No read/write commands detected in benchmark ACL categories")
+
+        # Calculate fast/slow percentages for benchmarks
+        benchmark_fast_count = sum(benchmark_fast_commands.values())
+        benchmark_slow_count = sum(benchmark_slow_commands.values())
+        benchmark_fs_count = benchmark_fast_count + benchmark_slow_count
+
+        if benchmark_fs_count > 0:
+            fast_percentage = (benchmark_fast_count / benchmark_fs_count) * 100
+            slow_percentage = (benchmark_slow_count / benchmark_fs_count) * 100
+
+            logging.info(f"")
+            logging.info(f"FAST/SLOW COMMAND DISTRIBUTION:")
+            logging.info(
+                f"  Fast commands: {benchmark_fast_count:6d} ({fast_percentage:5.1f}%)"
+            )
+            logging.info(
+                f"  Slow commands: {benchmark_slow_count:6d} ({slow_percentage:5.1f}%)"
+            )
+            logging.info(f"  Total F/S:     {benchmark_fs_count:6d} (100.0%)")
+        else:
+            logging.info("No fast/slow commands detected in benchmark ACL categories")
+
+        # Group breakdown for benchmarks
+        if benchmark_group_total:
+            logging.info("")
+            logging.info("READ/WRITE BREAKDOWN BY COMMAND GROUP:")
+
+            # Calculate total calls across all groups
+            total_all_calls = sum(benchmark_group_total.values())
+
+            # Create list of groups with their total calls for sorting
+            group_data = []
+            for group, total_group in benchmark_group_total.items():
+                read_count = benchmark_group_read.get(group, 0)
+                write_count = benchmark_group_write.get(group, 0)
+                group_data.append((group, read_count, write_count, total_group))
+
+            # Sort by total calls (descending)
+            group_data.sort(key=lambda x: x[3], reverse=True)
+
+            total_read_all = 0
+            total_write_all = 0
+
+            for group, read_count, write_count, total_group in group_data:
+                group_pct = (total_group / total_all_calls) * 100
+                read_pct = (read_count / total_group) * 100 if total_group > 0 else 0
+                write_pct = (write_count / total_group) * 100 if total_group > 0 else 0
+
+                read_formatted = format_number_with_suffix(read_count)
+                write_formatted = format_number_with_suffix(write_count)
+
+                logging.info(
+                    f"  {group.upper():>12} ({group_pct:4.1f}%): {read_formatted:>8} read ({read_pct:5.1f}%), {write_formatted:>8} write ({write_pct:5.1f}%)"
+                )
+
+                total_read_all += read_count
+                total_write_all += write_count
+
+            # Add total row
+            if group_data:
+                total_read_pct = (total_read_all / total_all_calls) * 100
+                total_write_pct = (total_write_all / total_all_calls) * 100
+                total_read_formatted = format_number_with_suffix(total_read_all)
+                total_write_formatted = format_number_with_suffix(total_write_all)
+
+                logging.info(
+                    f"  {'TOTAL':>12} (100.0%): {total_read_formatted:>8} read ({total_read_pct:5.1f}%), {total_write_formatted:>8} write ({total_write_pct:5.1f}%)"
+                )
+    else:
+        logging.info(
+            "BENCHMARK TEST SUITES ANALYSIS: No commands with ACL categories found"
+        )
+
+    # CommandStats CSV analysis
+    if csv_total_command_count > 0:
+        logging.info("")
+        logging.info("COMMANDSTATS CSV ANALYSIS (actual Redis usage):")
+        logging.info("-" * 50)
+
+        # Calculate read/write percentages for CSV data
+        csv_read_count = sum(csv_read_commands.values())
+        csv_write_count = sum(csv_write_commands.values())
+        csv_rw_count = csv_read_count + csv_write_count
+
+        if csv_rw_count > 0:
+            read_percentage = (csv_read_count / csv_rw_count) * 100
+            write_percentage = (csv_write_count / csv_rw_count) * 100
+
+            logging.info(f"READ/WRITE COMMAND DISTRIBUTION:")
+            logging.info(
+                f"  Read commands:  {csv_read_count:8d} ({read_percentage:5.1f}%)"
+            )
+            logging.info(
+                f"  Write commands: {csv_write_count:8d} ({write_percentage:5.1f}%)"
+            )
+            logging.info(f"  Total R/W:      {csv_rw_count:8d} (100.0%)")
+        else:
+            logging.info("No read/write commands detected in CSV ACL categories")
+
+        # Calculate fast/slow percentages for CSV data
+        csv_fast_count = sum(csv_fast_commands.values())
+        csv_slow_count = sum(csv_slow_commands.values())
+        csv_fs_count = csv_fast_count + csv_slow_count
+
+        if csv_fs_count > 0:
+            fast_percentage = (csv_fast_count / csv_fs_count) * 100
+            slow_percentage = (csv_slow_count / csv_fs_count) * 100
+
+            logging.info(f"")
+            logging.info(f"FAST/SLOW COMMAND DISTRIBUTION:")
+            logging.info(
+                f"  Fast commands: {csv_fast_count:8d} ({fast_percentage:5.1f}%)"
+            )
+            logging.info(
+                f"  Slow commands: {csv_slow_count:8d} ({slow_percentage:5.1f}%)"
+            )
+            logging.info(f"  Total F/S:     {csv_fs_count:8d} (100.0%)")
+        else:
+            logging.info("No fast/slow commands detected in CSV ACL categories")
+
+        # Group breakdown for CSV data
+        if csv_group_total:
+            logging.info("")
+            logging.info("READ/WRITE BREAKDOWN BY COMMAND GROUP:")
+
+            # Calculate total calls across all groups
+            total_all_calls = sum(csv_group_total.values())
+
+            # Create list of groups with their total calls for sorting
+            group_data = []
+            for group, total_group in csv_group_total.items():
+                read_count = csv_group_read.get(group, 0)
+                write_count = csv_group_write.get(group, 0)
+                group_data.append((group, read_count, write_count, total_group))
+
+            # Sort by total calls (descending)
+            group_data.sort(key=lambda x: x[3], reverse=True)
+
+            total_read_all = 0
+            total_write_all = 0
+
+            for group, read_count, write_count, total_group in group_data:
+                group_pct = (total_group / total_all_calls) * 100
+                read_pct = (read_count / total_group) * 100 if total_group > 0 else 0
+                write_pct = (write_count / total_group) * 100 if total_group > 0 else 0
+
+                read_formatted = format_number_with_suffix(read_count)
+                write_formatted = format_number_with_suffix(write_count)
+
+                logging.info(
+                    f"  {group.upper():>12} ({group_pct:4.1f}%): {read_formatted:>8} read ({read_pct:5.1f}%), {write_formatted:>8} write ({write_pct:5.1f}%)"
+                )
+
+                total_read_all += read_count
+                total_write_all += write_count
+
+            # Add total row
+            if group_data:
+                total_read_pct = (total_read_all / total_all_calls) * 100
+                total_write_pct = (total_write_all / total_all_calls) * 100
+                total_read_formatted = format_number_with_suffix(total_read_all)
+                total_write_formatted = format_number_with_suffix(total_write_all)
+
+                logging.info(
+                    f"  {'TOTAL':>12} (100.0%): {total_read_formatted:>8} read ({total_read_pct:5.1f}%), {total_write_formatted:>8} write ({total_write_pct:5.1f}%)"
+                )
+
+        # Validate parsing accuracy by comparing with provided percentages
+        if csv_provided_percentages and csv_original_counts:
+            logging.info("")
+            logging.info("PARSING VALIDATION:")
+            logging.info("-" * 30)
+
+            # Calculate total from original counts
+            total_original = sum(csv_original_counts.values())
+            total_provided_percentage = sum(csv_provided_percentages.values())
+
+            logging.info(f"Total original count: {total_original:,}")
+            logging.info(
+                f"Sum of provided percentages: {total_provided_percentage:.6f}%"
+            )
+
+            # Check if our billion parsing matches original counts
+            parsing_errors = 0
+            for cmd in csv_original_counts:
+                if cmd in priority:  # priority contains our parsed values
+                    parsed_value = priority[cmd]
+                    original_value = csv_original_counts[cmd]
+                    if parsed_value != original_value:
+                        parsing_errors += 1
+                        logging.warning(
+                            f"Parsing mismatch for {cmd}: parsed={parsed_value:,} vs original={original_value:,}"
+                        )
+
+            if parsing_errors == 0:
+                logging.info("✓ All billion/million/thousand parsing is accurate")
+            else:
+                logging.warning(f"✗ Found {parsing_errors} parsing errors")
+
+            # Validate percentage calculation
+            if abs(total_provided_percentage - 100.0) < 0.001:
+                logging.info("✓ Provided percentages sum to 100%")
+            else:
+                logging.warning(
+                    f"✗ Provided percentages sum to {total_provided_percentage:.6f}% (not 100%)"
+                )
+    else:
+        logging.info("")
+        logging.info(
+            "COMMANDSTATS CSV ANALYSIS: No CSV file provided or no commands found"
+        )
+
+    logging.info("=" * 80)
     # Save pipeline count to CSV
     csv_filename = "memtier_pipeline_count.csv"
     with open(csv_filename, "w", newline="") as csvfile:
@@ -714,3 +1172,133 @@ def generate_stats_cli_command_logic(args, project_name, project_version):
             )
 
     logging.info(f"Sorted command groups count data saved to {csv_filename}")
+
+    # Save ACL category data to CSV files
+
+    # Benchmark data CSV files
+    csv_filename = "benchmark_acl_read_write_commands.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = ["command", "type", "count"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        for command, count in sorted(benchmark_read_commands.items()):
+            writer.writerow({"command": command, "type": "read", "count": count})
+        for command, count in sorted(benchmark_write_commands.items()):
+            writer.writerow({"command": command, "type": "write", "count": count})
+
+    logging.info(f"Benchmark ACL read/write commands data saved to {csv_filename}")
+
+    csv_filename = "benchmark_acl_fast_slow_commands.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = ["command", "type", "count"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        for command, count in sorted(benchmark_fast_commands.items()):
+            writer.writerow({"command": command, "type": "fast", "count": count})
+        for command, count in sorted(benchmark_slow_commands.items()):
+            writer.writerow({"command": command, "type": "slow", "count": count})
+
+    logging.info(f"Benchmark ACL fast/slow commands data saved to {csv_filename}")
+
+    # CommandStats CSV data files
+    csv_filename = "commandstats_acl_read_write_commands.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = ["command", "type", "count"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        for command, count in sorted(csv_read_commands.items()):
+            writer.writerow({"command": command, "type": "read", "count": count})
+        for command, count in sorted(csv_write_commands.items()):
+            writer.writerow({"command": command, "type": "write", "count": count})
+
+    logging.info(f"CommandStats ACL read/write commands data saved to {csv_filename}")
+
+    csv_filename = "commandstats_acl_fast_slow_commands.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = ["command", "type", "count"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        for command, count in sorted(csv_fast_commands.items()):
+            writer.writerow({"command": command, "type": "fast", "count": count})
+        for command, count in sorted(csv_slow_commands.items()):
+            writer.writerow({"command": command, "type": "slow", "count": count})
+
+    logging.info(f"CommandStats ACL fast/slow commands data saved to {csv_filename}")
+
+    # Save group breakdown data to CSV files
+
+    # Benchmark group breakdown
+    csv_filename = "benchmark_group_read_write_breakdown.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = [
+            "group",
+            "read_count",
+            "write_count",
+            "total_count",
+            "read_percentage",
+            "write_percentage",
+        ]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        all_groups = set(benchmark_group_read.keys()) | set(
+            benchmark_group_write.keys()
+        )
+        for group in sorted(all_groups):
+            read_count = benchmark_group_read.get(group, 0)
+            write_count = benchmark_group_write.get(group, 0)
+            total_count = read_count + write_count
+            read_pct = (read_count / total_count * 100) if total_count > 0 else 0
+            write_pct = (write_count / total_count * 100) if total_count > 0 else 0
+
+            writer.writerow(
+                {
+                    "group": group,
+                    "read_count": read_count,
+                    "write_count": write_count,
+                    "total_count": total_count,
+                    "read_percentage": round(read_pct, 2),
+                    "write_percentage": round(write_pct, 2),
+                }
+            )
+
+    logging.info(f"Benchmark group read/write breakdown saved to {csv_filename}")
+
+    # CommandStats group breakdown
+    csv_filename = "commandstats_group_read_write_breakdown.csv"
+    with open(csv_filename, "w", newline="") as csvfile:
+        fieldnames = [
+            "group",
+            "read_count",
+            "write_count",
+            "total_count",
+            "read_percentage",
+            "write_percentage",
+        ]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+        all_groups = set(csv_group_read.keys()) | set(csv_group_write.keys())
+        for group in sorted(all_groups):
+            read_count = csv_group_read.get(group, 0)
+            write_count = csv_group_write.get(group, 0)
+            total_count = read_count + write_count
+            read_pct = (read_count / total_count * 100) if total_count > 0 else 0
+            write_pct = (write_count / total_count * 100) if total_count > 0 else 0
+
+            writer.writerow(
+                {
+                    "group": group,
+                    "read_count": read_count,
+                    "write_count": write_count,
+                    "total_count": total_count,
+                    "read_percentage": round(read_pct, 2),
+                    "write_percentage": round(write_pct, 2),
+                }
+            )
+
+    logging.info(f"CommandStats group read/write breakdown saved to {csv_filename}")

redis_benchmarks_specification/__compare__/args.py

@@ -46,12 +46,6 @@ def create_compare_arguments(parser):
         default="",
         help="specify a test (or a comma separated list of tests) to use for comparison. If none is specified by default will use all of them.",
     )
-    parser.add_argument(
-        "--use-test-suites-folder",
-        action="store_true",
-        default=False,
-        help="Use test names from YAML files in test-suites folder instead of database",
-    )
     parser.add_argument(
         "--defaults_filename",
         type=str,

redis_benchmarks_specification/__compare__/compare.py

@@ -399,8 +399,6 @@ def compare_command_logic(args, project_name, project_version):
         args.regression_str,
         args.improvement_str,
         tests_with_config,
-        args.use_test_suites_folder,
-        testsuites_folder,
     )
     total_regressions = len(regressions_list)
     total_improvements = len(improvements_list)
@@ -688,8 +686,6 @@ def compute_regression_table(
     regression_str="REGRESSION",
     improvement_str="IMPROVEMENT",
     tests_with_config={},
-    use_test_suites_folder=False,
-    test_suites_folder=None,
 ):
     START_TIME_NOW_UTC, _, _ = get_start_time_vars()
     START_TIME_LAST_MONTH_UTC = START_TIME_NOW_UTC - datetime.timedelta(days=31)
@@ -750,10 +746,6 @@ def compute_regression_table(
     if test != "":
         test_names = test.split(",")
         logging.info("Using test name {}".format(test_names))
-    elif use_test_suites_folder:
-        test_names = get_test_names_from_yaml_files(
-            test_suites_folder, tags_regex_string
-        )
     else:
         test_names = get_test_names_from_db(
             rts, tags_regex_string, test_names, used_key
@@ -1628,31 +1620,6 @@ def get_test_names_from_db(rts, tags_regex_string, test_names, used_key):
     return test_names
 
 
-def get_test_names_from_yaml_files(test_suites_folder, tags_regex_string):
-    """Get test names from YAML files in test-suites folder"""
-    from redis_benchmarks_specification.__common__.runner import get_benchmark_specs
-
-    # Get all YAML files
-    yaml_files = get_benchmark_specs(test_suites_folder, test="", test_regex=".*")
-
-    # Extract test names (remove path and .yml extension)
-    test_names = []
-    for yaml_file in yaml_files:
-        test_name = os.path.basename(yaml_file).replace(".yml", "")
-        # Apply regex filtering like database version
-        match_obj = re.search(tags_regex_string, test_name)
-        if match_obj is not None:
-            test_names.append(test_name)
-
-    test_names.sort()
-    logging.info(
-        "Based on test-suites folder ({}) we have {} comparison points: {}".format(
-            test_suites_folder, len(test_names), test_names
-        )
-    )
-    return test_names
-
-
 def get_line(
     baseline_v_str,
     comparison_v_str,

redis_benchmarks_specification/__self_contained_coordinator__/docker.py

@@ -15,7 +15,7 @@ def generate_standalone_redis_server_args(
     redis_arguments="",
     password=None,
 ):
-    added_params = ["port", "protected-mode", "dir", "requirepass"]
+    added_params = ["port", "protected-mode", "dir", "requirepass", "logfile"]
     # start redis-server
     command = [
         binary,
@@ -31,6 +31,7 @@ def generate_standalone_redis_server_args(
         logging.info("Redis server will be started with password authentication")
     if dbdir != "":
         command.extend(["--dir", dbdir])
+        command.extend(["--logfile", f"{dbdir}redis.log"])
     if configuration_parameters is not None:
         for parameter, parameter_value in configuration_parameters.items():
             if parameter not in added_params:

redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -107,6 +107,43 @@ from redis_benchmarks_specification.__self_contained_coordinator__.artifacts imp
 from redis_benchmarks_specification.__self_contained_coordinator__.build_info import (
     extract_build_info_from_streamdata,
 )
+
+
+def print_directory_logs(directory_path, description=""):
+    """Print all .log files in a directory for debugging purposes."""
+    if not os.path.exists(directory_path):
+        logging.warning(f"Directory {directory_path} does not exist")
+        return
+
+    logging.info(
+        f"Printing all .log files in {description} directory: {directory_path}"
+    )
+    try:
+        for root, dirs, files in os.walk(directory_path):
+            for file in files:
+                # Only process .log files
+                if not file.endswith(".log"):
+                    continue
+
+                file_path = os.path.join(root, file)
+                logging.info(f"Found log file: {file_path}")
+                try:
+                    # Try to read and print the log file content
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read()
+                        if content.strip():  # Only print non-empty files
+                            logging.info(f"Content of {file_path}:")
+                            logging.info("-" * 40)
+                            logging.info(content)
+                            logging.info("-" * 40)
+                        else:
+                            logging.info(f"Log file {file_path} is empty")
+                except Exception as e:
+                    logging.warning(f"Could not read log file {file_path}: {e}")
+    except Exception as e:
+        logging.error(f"Error walking directory {directory_path}: {e}")
+
+
 from redis_benchmarks_specification.__self_contained_coordinator__.cpuset import (
     extract_db_cpu_limit,
     generate_cpuset_cpus,
@@ -1319,6 +1356,18 @@ def process_self_contained_coordinator_stream(
 
                                     print("-" * 60)
 
+                                # Print all log files in the temporary directories for debugging
+                                logging.critical(
+                                    "Printing all files in temporary directories for debugging..."
+                                )
+                                try:
+                                    print_directory_logs(temporary_dir, "Redis server")
+                                    print_directory_logs(temporary_dir_client, "Client")
+                                except Exception as log_error:
+                                    logging.error(
+                                        f"Failed to print directory logs: {log_error}"
+                                    )
+
                                 test_result = False
                             # tear-down
                             logging.info("Tearing down setup")
@@ -1349,14 +1398,27 @@ def process_self_contained_coordinator_stream(
                                                 )
                                             )
                                             pass
-                                logging.info(
-                                    "Removing temporary dirs {} and {}".format(
-                                        temporary_dir, temporary_dir_client
-                                    )
-                                )
 
-                                shutil.rmtree(temporary_dir, ignore_errors=True)
-                                shutil.rmtree(temporary_dir_client, ignore_errors=True)
+                                # Only remove temporary directories if test passed
+                                if test_result:
+                                    logging.info(
+                                        "Test passed. Removing temporary dirs {} and {}".format(
+                                            temporary_dir, temporary_dir_client
+                                        )
+                                    )
+                                    shutil.rmtree(temporary_dir, ignore_errors=True)
+                                    shutil.rmtree(
+                                        temporary_dir_client, ignore_errors=True
+                                    )
+                                else:
+                                    logging.warning(
+                                        "Test failed. Preserving temporary dirs for debugging: {} and {}".format(
+                                            temporary_dir, temporary_dir_client
+                                        )
+                                    )
+                                    # Print all log files in the temporary directories for debugging
+                                    print_directory_logs(temporary_dir, "Redis server")
+                                    print_directory_logs(temporary_dir_client, "Client")
 
                             overall_result &= test_result
 

redis_benchmarks_specification/test-suites/memtier_benchmark-10Kkeys-load-list-rpush-bulkload-pipeline-50.yml

@@ -0,0 +1,39 @@
+ersion: 0.4
+name: memtier_benchmark-10Kkeys-load-list-rpush-bulkload-pipeline-50
+description: |
+  Runs memtier_benchmark to stress multi-element RPUSH on a single LIST key using
+  high pipelining and concurrency. This targets quicklist multi-insert behavior and
+  bulk argument parsing performance (context: Redis PR #13860).
+dbconfig:
+  configuration-parameters:
+    save: '""'
+  check:
+    keyspacelen: 0
+  resources:
+    requests:
+      memory: 1g
+tested-groups:
+- list
+tested-commands:
+- rpush
+redis-topologies:
+- oss-standalone
+build-variants:
+- gcc:15.2.0-amd64-debian-bookworm-default
+- gcc:15.2.0-arm64-debian-bookworm-default
+- dockerhub
+clientconfig:
+  run_image: redislabs/memtier_benchmark:edge
+  tool: memtier_benchmark
+  arguments: >-
+    --pipeline 50
+    --command "RPUSH __key__ a b c d e f g h i j k l m n o p q r s t u v w x y z
+    aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv ww xx yy zz
+    ab bc cd de ef fg gh hi ij jk kl lm mn no op pq qr rs st tu uv vw wx xy yz za
+    ac bd ce df eg fh gi hj ik jl km ln mo np oq pr qs rt su tv uw vx" --distinct-client-seed
+    --test-time 120 -c 50 -t 4 --hide-histogram --key-minimum=1 --key-maximum 10000
+  resources:
+    requests:
+      cpus: '4'
+      memory: 2g
+priority: 39

{redis_benchmarks_specification-0.1.322.dist-info → redis_benchmarks_specification-0.1.323.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.322
+Version: 0.1.323
 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.322.dist-info → redis_benchmarks_specification-0.1.323.dist-info}/RECORD

@@ -4,12 +4,12 @@ redis_benchmarks_specification/__api__/api.py,sha256=k_CMICtMm1z8jY3hByaL0hIr_5v
 redis_benchmarks_specification/__api__/app.py,sha256=JzQm84DjIVdfLbDO423BJbrds6gFzMbA0syRkHE_aUU,7063
 redis_benchmarks_specification/__builder__/Readme.md,sha256=O6MV_J3OSgzW-ir2TbukP8Vhkm_LOzQJJndG1Cykqic,111
 redis_benchmarks_specification/__builder__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
-redis_benchmarks_specification/__builder__/builder.py,sha256=cK2yGtoS6Xnux7wANQkTT2rCvkz5Y5_7huQbQFAcMMk,28324
+redis_benchmarks_specification/__builder__/builder.py,sha256=86DQuqf9LhPl1_bpmQK2rkACBxYBz13Wu8fsAnKkm7g,29730
 redis_benchmarks_specification/__builder__/schema.py,sha256=1wcmyVJBcWrBvK58pghN9NCoWLCO3BzPsmdKWYfkVog,584
 redis_benchmarks_specification/__cli__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
-redis_benchmarks_specification/__cli__/args.py,sha256=uZkk1Jom9i0xJ_OpVMrIWbw_70jFo7IswLV2EtKTKEA,7210
-redis_benchmarks_specification/__cli__/cli.py,sha256=6tt0Ai-JIFEF3ykWFU2_g5ZrzKVIoyLLXUmyzYpVDF4,21843
-redis_benchmarks_specification/__cli__/stats.py,sha256=8R6fsiR00Uqa-01_Yq0PegriZkiM313KjCpDv5PhEdM,28965
+redis_benchmarks_specification/__cli__/args.py,sha256=C0EdJbq5F6Td6kvEkzN5ZWMhWYuizV_tGzVhkPLKEi0,7207
+redis_benchmarks_specification/__cli__/cli.py,sha256=iTjINQ-RV_q2ovq1neSoRCAggpGdeP5mX3_1aFxSScY,22001
+redis_benchmarks_specification/__cli__/stats.py,sha256=r9JIfwGCSR3maozYbDZfZrkthNFQSs0xIymS86yZ6Iw,55574
 redis_benchmarks_specification/__common__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis_benchmarks_specification/__common__/builder_schema.py,sha256=kfDpRIk7NkJrb5qj9jzsBhLVNO7K_W2Clumj4pxrkG8,5938
 redis_benchmarks_specification/__common__/env.py,sha256=kvJ8Ll-fvI_Tc0vynrzUEr22TqnJizzvJ4Lu9RjNr_M,3119
@@ -19,8 +19,8 @@ redis_benchmarks_specification/__common__/runner.py,sha256=M-o1QZVlp3thFW-55PiaW
 redis_benchmarks_specification/__common__/spec.py,sha256=D_SN48wg6NMthW_-OS1H5bydSDiuZpfd4WPPj7Vfwmc,5760
 redis_benchmarks_specification/__common__/timeseries.py,sha256=uvS3T2zdrSmW_B2S0MYTekJfHUllqU3RlD0LrF957RQ,52904
 redis_benchmarks_specification/__compare__/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
-redis_benchmarks_specification/__compare__/args.py,sha256=-3lPYzvLPiDsx1oW9KmuafxZWzA4hhbhYsBAgiGtD_w,7816
-redis_benchmarks_specification/__compare__/compare.py,sha256=uHlnjnF2kkiPIBDIJIw1inEnfUQX0OiABPfrJkp1bgo,64111
+redis_benchmarks_specification/__compare__/args.py,sha256=f3ZSs8GzyIzaMzX2h9cx0nOrnlO4aXToO1SBzBlpzKM,7608
+redis_benchmarks_specification/__compare__/compare.py,sha256=OrpCpY66rlbP5so6aYCdSF9Sy3sdhKrnzVJK1u3XQno,62912
 redis_benchmarks_specification/__init__.py,sha256=YQIEx2sLPPA0JR9OuCuMNMNtm-f_gqDKgzvNJnkGNKY,491
 redis_benchmarks_specification/__runner__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
 redis_benchmarks_specification/__runner__/args.py,sha256=-el2RttOjjc4Y9yOM1P5y9BwIkBPp_Y1k7OsP91P2BI,10651
@@ -32,11 +32,11 @@ redis_benchmarks_specification/__self_contained_coordinator__/artifacts.py,sha25
 redis_benchmarks_specification/__self_contained_coordinator__/build_info.py,sha256=vlg8H8Rxu2falW8xp1GvL1SV1fyBguSbz6Apxc7A2yM,2282
 redis_benchmarks_specification/__self_contained_coordinator__/clients.py,sha256=EL1V4-i-tTav1mcF_CUosqPF3Q1qi9BZL0zFajEk70c,1878
 redis_benchmarks_specification/__self_contained_coordinator__/cpuset.py,sha256=sRvtoJIitppcOpm3R5LbVmSfPEAqPumOqVATnF5Wbek,594
-redis_benchmarks_specification/__self_contained_coordinator__/docker.py,sha256=eXJM2FybaVNTjvTrKwHextcNmkCIK9HQaG8ZNWjgx18,3086
+redis_benchmarks_specification/__self_contained_coordinator__/docker.py,sha256=09SyAfqlzs1KG9ZAajClNWtiNk4Jqzd--4-m3n1rLjU,3156
 redis_benchmarks_specification/__self_contained_coordinator__/post_processing.py,sha256=sVLKNnWdAqYY9DjVdqRC5tDaIrVSaI3Ca7w8-DQ-LRM,776
 redis_benchmarks_specification/__self_contained_coordinator__/prepopulation.py,sha256=1UeFr2T1ZQBcHCSd4W1ZtaWgXyFPfjLyDi_DgDc1eTA,2957
 redis_benchmarks_specification/__self_contained_coordinator__/runners.py,sha256=noRHn9leTfEm2fa1yHBHQd8TUGhFDoU86QQkHABnWSs,30073
-redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=hlSBMa-n6byXW7zVxq5nzqEKN34DrPpcgN-NnzGk-_c,79375
+redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=QcQwPWvhS5C96NNkZFzi0xwMzwLzl6kxYmS1sWTU7s0,82532
 redis_benchmarks_specification/__setups__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis_benchmarks_specification/__setups__/topologies.py,sha256=xQ1IJkcTji_ZjLiJd3vOxZpvbNtBLZw9cPkw5hGJKHU,481
 redis_benchmarks_specification/__spec__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
@@ -59,6 +59,7 @@ redis_benchmarks_specification/test-suites/memtier_benchmark-100Kkeys-load-hash-
 redis_benchmarks_specification/test-suites/memtier_benchmark-100Kkeys-load-hash-50-fields-with-100B-values.yml,sha256=QcXCcTdWyaNW5M0qHNC7nUmevzCxwuQVoOMbFU0DmkE,1849
 redis_benchmarks_specification/test-suites/memtier_benchmark-100Kkeys-load-hash-50-fields-with-10B-values.yml,sha256=WIdn1sGgeeYsCC9FMggHBxSsR_2fQR_q5hpPTs0iXw0,1842
 redis_benchmarks_specification/test-suites/memtier_benchmark-10Kkeys-load-hash-50-fields-with-10000B-values.yml,sha256=QVVn2S5wtCvjHnBuSTU3U1S9nCTvA0HMHnwoKCX4Quo,1852
+redis_benchmarks_specification/test-suites/memtier_benchmark-10Kkeys-load-list-rpush-bulkload-pipeline-50.yml,sha256=Grvp5OgJ9dMpB8kTKZ6PBjWnPR6tcu9_AvQHV5tyR9o,1262
 redis_benchmarks_specification/test-suites/memtier_benchmark-10Kkeys-load-list-with-10B-values-pipeline-50.yml,sha256=MOvXrPrkdkmIyFaFaEBQbl5UlFSaS4VoQIjl3Ue-Yl4,894
 redis_benchmarks_specification/test-suites/memtier_benchmark-10Mkeys-load-hash-5-fields-with-100B-values-pipeline-10.yml,sha256=yQDHjk7C1wxxGgY3wiw0ebtX19VeQYAZ6U9nZj7jii0,1003
 redis_benchmarks_specification/test-suites/memtier_benchmark-10Mkeys-load-hash-5-fields-with-100B-values.yml,sha256=r_8UlvEcYm49UND5-Kt4EY7-0XOeH-DtmhvJNiGVu5Q,969
@@ -278,8 +279,8 @@ redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-st
 redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-storage-1k-sessions.yml,sha256=2egtIxPxCze2jlbAfgsk4v9JSQHNMoPLbDWFEW8olDg,7006
 redis_benchmarks_specification/test-suites/template.txt,sha256=ezqGiRPOvuSDO0iG7GEf-AGXNfHbgXI89_G0RUEzL88,481
 redis_benchmarks_specification/vector-search-test-suites/vector_db_benchmark_test.yml,sha256=PD7ow-k4Ll2BkhEC3aIqiaCZt8Hc4aJIp96Lw3J3mcI,791
-redis_benchmarks_specification-0.1.322.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-redis_benchmarks_specification-0.1.322.dist-info/METADATA,sha256=IJ8st5rZHb_Jz7k27HlFYeDiiNfowbXUzdhYCwcjCW4,22726
-redis_benchmarks_specification-0.1.322.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redis_benchmarks_specification-0.1.322.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
-redis_benchmarks_specification-0.1.322.dist-info/RECORD,,
+redis_benchmarks_specification-0.1.323.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+redis_benchmarks_specification-0.1.323.dist-info/METADATA,sha256=KIfE50uAlLrrLWpEoihY9p6EoCqobK4Txg7ZfUSTcHE,22726
+redis_benchmarks_specification-0.1.323.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redis_benchmarks_specification-0.1.323.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
+redis_benchmarks_specification-0.1.323.dist-info/RECORD,,