redis-benchmarks-specification 0.1.333__tar.gz → 0.1.334__tar.gz

{redis_benchmarks_specification-0.1.333 → redis_benchmarks_specification-0.1.334}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.1.333
+Version: 0.1.334
 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.333 → redis_benchmarks_specification-0.1.334}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-benchmarks-specification"
-version = "0.1.333"
+version = "0.1.334"
 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.333 → redis_benchmarks_specification-0.1.334}/redis_benchmarks_specification/__runner__/runner.py

@@ -182,7 +182,7 @@ def validate_benchmark_metrics(
             "all_stats.totals.ops/sec",
         ]
 
-        latency_patterns = ["latency", "p50", "p95", "p99", "p999", "usec", "msec"]
+        latency_patterns = ["p50", "p95", "p99", "p999", "percentile"]
 
         validation_errors = []
 
@@ -195,6 +195,22 @@ def validate_benchmark_metrics(
             elif isinstance(data, (int, float)):
                 metric_path_lower = path.lower()
 
+                # Skip Waits metrics as they can legitimately be 0
+                if "waits" in metric_path_lower:
+                    return
+
+                # Skip general latency metrics that can legitimately be 0
+                # Only validate specific percentile latencies (p50, p95, etc.)
+                if any(
+                    pattern in metric_path_lower
+                    for pattern in [
+                        "average latency",
+                        "totals.latency",
+                        "all_stats.totals.latency",
+                    ]
+                ):
+                    return
+
                 # Check throughput metrics
                 for pattern in throughput_patterns:
                     if pattern in metric_path_lower:

{redis_benchmarks_specification-0.1.333 → redis_benchmarks_specification-0.1.334}/redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -191,6 +191,22 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
                 "service": "redis-benchmarks-self-contained-coordinator",
             }
             self.wfile.write(json.dumps(response).encode())
+
+        elif parsed_path.path == "/containers":
+            # Check for stuck containers
+            stuck_containers = self._check_stuck_containers()
+
+            self.send_response(200)
+            self.send_header("Content-type", "application/json")
+            self.end_headers()
+            response = {
+                "status": "success",
+                "stuck_containers": stuck_containers,
+                "total_stuck": len(stuck_containers),
+                "timestamp": datetime.datetime.utcnow().isoformat(),
+            }
+            self.wfile.write(json.dumps(response).encode())
+
         else:
             self.send_response(404)
             self.send_header("Content-type", "application/json")
@@ -259,7 +275,9 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
                 flush_time = datetime.datetime.utcnow()
                 _flush_timestamp = flush_time
 
-                logging.info("Flush requested via HTTP endpoint - stopping all containers and processes")
+                logging.info(
+                    "Flush requested via HTTP endpoint - stopping all containers and processes"
+                )
 
                 # Perform flush cleanup
                 self._perform_flush_cleanup()
@@ -271,7 +289,7 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
                     "status": "success",
                     "message": "Flush completed - all containers stopped and processes killed",
                     "flush_timestamp": flush_time.isoformat(),
-                    "timestamp": datetime.datetime.utcnow().isoformat()
+                    "timestamp": datetime.datetime.utcnow().isoformat(),
                 }
                 self.wfile.write(json.dumps(response).encode())
 
@@ -283,7 +301,7 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
                 response = {
                     "status": "error",
                     "message": f"Flush failed: {str(e)}",
-                    "timestamp": datetime.datetime.utcnow().isoformat()
+                    "timestamp": datetime.datetime.utcnow().isoformat(),
                 }
                 self.wfile.write(json.dumps(response).encode())
 
@@ -300,27 +318,114 @@ class CoordinatorHTTPHandler(BaseHTTPRequestHandler):
         # Kill all memtier processes
         try:
             logging.info("Killing all memtier_benchmark processes")
-            subprocess.run(["pkill", "-f", "memtier_benchmark"], check=False)
-            subprocess.run(["pkill", "-f", "memtier"], check=False)
+            result = subprocess.run(
+                ["pkill", "-f", "memtier_benchmark"], capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                logging.info("Successfully killed memtier_benchmark processes")
+            else:
+                logging.info("No memtier_benchmark processes found to kill")
+
+            result = subprocess.run(
+                ["pkill", "-f", "memtier"], capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                logging.info("Successfully killed memtier processes")
+            else:
+                logging.info("No memtier processes found to kill")
         except Exception as e:
             logging.warning(f"Error killing memtier processes: {e}")
 
-        # Stop all Docker containers
+        # Stop all Docker containers with force if needed
         try:
             logging.info("Stopping all Docker containers")
             client = docker.from_env()
             containers = client.containers.list()
+
+            if not containers:
+                logging.info("No running containers found")
+                return
+
+            logging.info(f"Found {len(containers)} running containers")
+
             for container in containers:
                 try:
-                    logging.info(f"Stopping container: {container.name} ({container.id[:12]})")
-                    container.stop(timeout=5)
+                    # Get container info
+                    created_time = container.attrs["Created"]
+                    uptime = (
+                        datetime.datetime.utcnow()
+                        - datetime.datetime.fromisoformat(
+                            created_time.replace("Z", "+00:00")
+                        )
+                    )
+
+                    logging.info(
+                        f"Stopping container: {container.name} ({container.id[:12]}) - uptime: {uptime}"
+                    )
+
+                    # Try graceful stop first
+                    container.stop(timeout=10)
+                    logging.info(f"Successfully stopped container: {container.name}")
+
                 except Exception as e:
                     logging.warning(f"Error stopping container {container.name}: {e}")
+                    try:
+                        # Force kill if graceful stop failed
+                        logging.info(f"Force killing container: {container.name}")
+                        container.kill()
+                        logging.info(
+                            f"Successfully force killed container: {container.name}"
+                        )
+                    except Exception as e2:
+                        logging.error(
+                            f"Failed to force kill container {container.name}: {e2}"
+                        )
+
         except Exception as e:
             logging.warning(f"Error accessing Docker client: {e}")
 
         logging.info("Flush cleanup completed")
 
+    def _check_stuck_containers(self, max_hours=2):
+        """Check for containers running longer than max_hours and return info"""
+        try:
+            client = docker.from_env()
+            containers = client.containers.list()
+            stuck_containers = []
+
+            for container in containers:
+                try:
+                    created_time = container.attrs["Created"]
+                    uptime = (
+                        datetime.datetime.utcnow()
+                        - datetime.datetime.fromisoformat(
+                            created_time.replace("Z", "+00:00")
+                        )
+                    )
+                    uptime_hours = uptime.total_seconds() / 3600
+
+                    if uptime_hours > max_hours:
+                        stuck_containers.append(
+                            {
+                                "name": container.name,
+                                "id": container.id[:12],
+                                "image": (
+                                    container.image.tags[0]
+                                    if container.image.tags
+                                    else "unknown"
+                                ),
+                                "uptime_hours": round(uptime_hours, 2),
+                                "status": container.status,
+                            }
+                        )
+                except Exception as e:
+                    logging.warning(f"Error checking container {container.name}: {e}")
+
+            return stuck_containers
+        except Exception as e:
+            logging.warning(f"Error accessing Docker client: {e}")
+            return []
+
 
 def start_http_server(port=8080):
     """Start the HTTP server in a separate thread"""
@@ -331,6 +436,7 @@ def start_http_server(port=8080):
             logging.info(f"Starting HTTP server on port {port}")
             logging.info(f"Available endpoints:")
             logging.info(f"  GET  /ping - Health check")
+            logging.info(f"  GET  /containers - Check for stuck containers")
             logging.info(
                 f"  POST /reset-queue - Reset pending streams and skip running tests"
             )
@@ -865,7 +971,11 @@ def process_self_contained_coordinator_stream(
 
             # Check if this work should be ignored due to flush
             global _flush_timestamp
-            if _flush_timestamp is not None and use_git_timestamp and git_timestamp_ms is not None:
+            if (
+                _flush_timestamp is not None
+                and use_git_timestamp
+                and git_timestamp_ms is not None
+            ):
                 # Convert flush timestamp to milliseconds for comparison
                 flush_timestamp_ms = int(_flush_timestamp.timestamp() * 1000)
                 if git_timestamp_ms < flush_timestamp_ms:
@@ -1045,7 +1155,9 @@ def process_self_contained_coordinator_stream(
                     command_regexp,
                 )
 
-                logging.info(f"Adding {len(filtered_test_files)} tests to pending test list")
+                logging.info(
+                    f"Adding {len(filtered_test_files)} tests to pending test list"
+                )
 
                 # Use pipeline for efficient bulk operations
                 pipeline = github_event_conn.pipeline()
@@ -1068,7 +1180,9 @@ def process_self_contained_coordinator_stream(
                 pipeline.expire(stream_test_list_pending, REDIS_BINS_EXPIRE_SECS)
                 pipeline.execute()
 
-                logging.info(f"Successfully added {len(test_names_added)} tests to pending test list in key {stream_test_list_pending}")
+                logging.info(
+                    f"Successfully added {len(test_names_added)} tests to pending test list in key {stream_test_list_pending}"
+                )
 
                 pending_tests = len(filtered_test_files)
                 failed_tests = 0
@@ -1426,25 +1540,111 @@ def process_self_contained_coordinator_stream(
                                 )
                                 # run the benchmark
                                 benchmark_start_time = datetime.datetime.now()
+
+                                # Calculate container timeout
+                                container_timeout = 300  # 5 minutes default
+                                buffer_timeout = 60  # Default buffer
+
+                                # Try to extract test time from command and add buffer
+                                import re
+
+                                test_time_match = re.search(
+                                    r"--?test-time[=\s]+(\d+)", benchmark_command_str
+                                )
+                                if test_time_match:
+                                    test_time = int(test_time_match.group(1))
+                                    container_timeout = test_time + buffer_timeout
+                                    logging.info(
+                                        f"Set container timeout to {container_timeout}s (test-time: {test_time}s + {buffer_timeout}s buffer)"
+                                    )
+                                else:
+                                    logging.info(
+                                        f"Using default container timeout: {container_timeout}s"
+                                    )
+
                                 try:
-                                    client_container_stdout = (
-                                        docker_client.containers.run(
-                                            image=client_container_image,
-                                            volumes={
-                                                temporary_dir_client: {
-                                                    "bind": client_mnt_point,
-                                                    "mode": "rw",
-                                                },
+                                    # Start container with detach=True to enable timeout handling
+                                    container = docker_client.containers.run(
+                                        image=client_container_image,
+                                        volumes={
+                                            temporary_dir_client: {
+                                                "bind": client_mnt_point,
+                                                "mode": "rw",
                                             },
-                                            auto_remove=True,
-                                            privileged=True,
-                                            working_dir=benchmark_tool_workdir,
-                                            command=benchmark_command_str,
-                                            network_mode="host",
-                                            detach=False,
-                                            cpuset_cpus=client_cpuset_cpus,
-                                        )
+                                        },
+                                        auto_remove=False,  # Don't auto-remove so we can get logs if timeout
+                                        privileged=True,
+                                        working_dir=benchmark_tool_workdir,
+                                        command=benchmark_command_str,
+                                        network_mode="host",
+                                        detach=True,  # Detach to enable timeout
+                                        cpuset_cpus=client_cpuset_cpus,
+                                    )
+
+                                    logging.info(
+                                        f"Started container {container.name} ({container.id[:12]}) with {container_timeout}s timeout"
                                     )
+
+                                    # Wait for container with timeout
+                                    try:
+                                        result = container.wait(
+                                            timeout=container_timeout
+                                        )
+                                        client_container_stdout = container.logs(
+                                            stdout=True, stderr=False
+                                        ).decode("utf-8")
+                                        container_stderr = container.logs(
+                                            stdout=False, stderr=True
+                                        ).decode("utf-8")
+
+                                        # Check exit code
+                                        if result["StatusCode"] != 0:
+                                            logging.error(
+                                                f"Container exited with code {result['StatusCode']}"
+                                            )
+                                            logging.error(
+                                                f"Container stderr: {container_stderr}"
+                                            )
+                                            raise docker.errors.ContainerError(
+                                                container,
+                                                result["StatusCode"],
+                                                benchmark_command_str,
+                                                client_container_stdout,
+                                                container_stderr,
+                                            )
+
+                                        logging.info(
+                                            f"Container {container.name} completed successfully"
+                                        )
+
+                                    except Exception as timeout_error:
+                                        if "timeout" in str(timeout_error).lower():
+                                            logging.error(
+                                                f"Container {container.name} timed out after {container_timeout}s"
+                                            )
+                                            # Get logs before killing
+                                            try:
+                                                timeout_logs = container.logs(
+                                                    stdout=True, stderr=True
+                                                ).decode("utf-8")
+                                                logging.error(
+                                                    f"Container logs before timeout: {timeout_logs}"
+                                                )
+                                            except:
+                                                pass
+                                            # Kill the container
+                                            container.kill()
+                                            raise Exception(
+                                                f"Container timed out after {container_timeout} seconds"
+                                            )
+                                        else:
+                                            raise timeout_error
+                                    finally:
+                                        # Clean up container
+                                        try:
+                                            container.remove(force=True)
+                                        except:
+                                            pass
                                 except docker.errors.ContainerError as e:
                                     logging.info(
                                         "stdout: {}".format(
@@ -2208,22 +2408,92 @@ def data_prepopulation_step(
         # run the benchmark
         preload_start_time = datetime.datetime.now()
 
-        client_container_stdout = docker_client.containers.run(
-            image=preload_image,
-            volumes={
-                temporary_dir: {
-                    "bind": client_mnt_point,
-                    "mode": "rw",
+        # Set preload timeout (preload can take longer than benchmarks)
+        preload_timeout = 1800  # 30 minutes default for data loading
+        logging.info(f"Starting preload container with {preload_timeout}s timeout")
+
+        try:
+            # Start container with detach=True to enable timeout handling
+            container = docker_client.containers.run(
+                image=preload_image,
+                volumes={
+                    temporary_dir: {
+                        "bind": client_mnt_point,
+                        "mode": "rw",
+                    },
                 },
-            },
-            auto_remove=True,
-            privileged=True,
-            working_dir=benchmark_tool_workdir,
-            command=preload_command_str,
-            network_mode="host",
-            detach=False,
-            cpuset_cpus=client_cpuset_cpus,
-        )
+                auto_remove=False,  # Don't auto-remove so we can get logs if timeout
+                privileged=True,
+                working_dir=benchmark_tool_workdir,
+                command=preload_command_str,
+                network_mode="host",
+                detach=True,  # Detach to enable timeout
+                cpuset_cpus=client_cpuset_cpus,
+            )
+
+            logging.info(
+                f"Started preload container {container.name} ({container.id[:12]}) with {preload_timeout}s timeout"
+            )
+
+            # Wait for container with timeout
+            try:
+                result = container.wait(timeout=preload_timeout)
+                client_container_stdout = container.logs(
+                    stdout=True, stderr=False
+                ).decode("utf-8")
+                container_stderr = container.logs(stdout=False, stderr=True).decode(
+                    "utf-8"
+                )
+
+                # Check exit code
+                if result["StatusCode"] != 0:
+                    logging.error(
+                        f"Preload container exited with code {result['StatusCode']}"
+                    )
+                    logging.error(f"Preload container stderr: {container_stderr}")
+                    raise docker.errors.ContainerError(
+                        container,
+                        result["StatusCode"],
+                        preload_command_str,
+                        client_container_stdout,
+                        container_stderr,
+                    )
+
+                logging.info(
+                    f"Preload container {container.name} completed successfully"
+                )
+
+            except Exception as timeout_error:
+                if "timeout" in str(timeout_error).lower():
+                    logging.error(
+                        f"Preload container {container.name} timed out after {preload_timeout}s"
+                    )
+                    # Get logs before killing
+                    try:
+                        timeout_logs = container.logs(stdout=True, stderr=True).decode(
+                            "utf-8"
+                        )
+                        logging.error(
+                            f"Preload container logs before timeout: {timeout_logs}"
+                        )
+                    except:
+                        pass
+                    # Kill the container
+                    container.kill()
+                    raise Exception(
+                        f"Preload container timed out after {preload_timeout} seconds"
+                    )
+                else:
+                    raise timeout_error
+            finally:
+                # Clean up container
+                try:
+                    container.remove(force=True)
+                except:
+                    pass
+        except Exception as e:
+            logging.error(f"Preload container failed: {e}")
+            raise e
 
         preload_end_time = datetime.datetime.now()
         preload_duration_seconds = calculate_client_tool_duration_and_check(