redis-benchmarks-specification 0.1.281__py3-none-any.whl → 0.1.282__py3-none-any.whl

redis_benchmarks_specification/__runner__/remote_profiling.py

@@ -19,10 +19,10 @@ import requests
 def extract_redis_pid(redis_conn) -> Optional[int]:
     """
     Extract Redis process ID from Redis INFO command.
-    
+
     Args:
         redis_conn: Redis connection object
-        
+
     Returns:
         Redis process ID as integer, or None if not found
     """
@@ -43,10 +43,10 @@ def extract_redis_pid(redis_conn) -> Optional[int]:
 def extract_redis_metadata(redis_conn) -> Dict[str, Any]:
     """
     Extract Redis metadata for profile comments.
-    
+
     Args:
         redis_conn: Redis connection object
-        
+
     Returns:
         Dictionary containing Redis metadata
     """
@@ -60,18 +60,20 @@ def extract_redis_metadata(redis_conn) -> Dict[str, Any]:
             "process_id": redis_info.get("process_id", "unknown"),
             "tcp_port": redis_info.get("tcp_port", "unknown"),
         }
-        
+
         # Use build_id if git_sha1 is empty or 0
         if metadata["redis_git_sha1"] in ("", 0, "0"):
             metadata["redis_git_sha1"] = metadata["redis_build_id"]
-            
-        logging.info(f"Extracted Redis metadata: version={metadata['redis_version']}, sha={metadata['redis_git_sha1']}, pid={metadata['process_id']}")
+
+        logging.info(
+            f"Extracted Redis metadata: version={metadata['redis_version']}, sha={metadata['redis_git_sha1']}, pid={metadata['process_id']}"
+        )
         return metadata
     except Exception as e:
         logging.error(f"Failed to extract Redis metadata: {e}")
         return {
             "redis_version": "unknown",
-            "redis_git_sha1": "unknown", 
+            "redis_git_sha1": "unknown",
             "redis_git_dirty": "unknown",
             "redis_build_id": "unknown",
             "process_id": "unknown",
@@ -82,16 +84,18 @@ def extract_redis_metadata(redis_conn) -> Dict[str, Any]:
 def calculate_profile_duration(benchmark_duration_seconds: int) -> int:
     """
     Calculate profiling duration based on benchmark duration.
-    
+
     Args:
         benchmark_duration_seconds: Expected benchmark duration in seconds
-        
+
     Returns:
         Profiling duration in seconds (minimum: benchmark duration, maximum: 30)
     """
     # Minimum duration is the benchmark duration, maximum is 30 seconds
     duration = min(max(benchmark_duration_seconds, 10), 30)
-    logging.info(f"Calculated profile duration: {duration}s (benchmark: {benchmark_duration_seconds}s)")
+    logging.info(
+        f"Calculated profile duration: {duration}s (benchmark: {benchmark_duration_seconds}s)"
+    )
     return duration
 
 
@@ -102,7 +106,7 @@ def trigger_remote_profile(
     duration: int,
     timeout: int = 60,
     username: Optional[str] = None,
-    password: Optional[str] = None
+    password: Optional[str] = None,
 ) -> Optional[bytes]:
     """
     Trigger remote profiling via HTTP GET request using pprof endpoint.
@@ -120,10 +124,7 @@ def trigger_remote_profile(
         Profile content in pprof binary format, or None if failed
     """
     url = f"http://{host}:{port}/debug/pprof/profile"
-    params = {
-        "pid": pid,
-        "seconds": duration
-    }
+    params = {"pid": pid, "seconds": duration}
 
     # Prepare authentication if provided
     auth = None
@@ -132,7 +133,9 @@ def trigger_remote_profile(
         logging.info(f"Using HTTP basic authentication with username: {username}")
 
     try:
-        logging.info(f"Triggering remote profile: {url} with PID={pid}, duration={duration}s")
+        logging.info(
+            f"Triggering remote profile: {url} with PID={pid}, duration={duration}s"
+        )
         response = requests.get(url, params=params, timeout=timeout, auth=auth)
         response.raise_for_status()
 
@@ -161,7 +164,7 @@ def save_profile_with_metadata(
     benchmark_name: str,
     output_dir: str,
     redis_metadata: Dict[str, Any],
-    duration: int
+    duration: int,
 ) -> Optional[str]:
     """
     Save profile content to file in pprof binary format.
@@ -188,7 +191,7 @@ def save_profile_with_metadata(
         timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
         # Write binary profile content directly
-        with open(filepath, 'wb') as f:
+        with open(filepath, "wb") as f:
             f.write(profile_content)
 
         # Create a separate metadata file
@@ -209,7 +212,7 @@ def save_profile_with_metadata(
             f"duration_seconds={duration}\n"
         )
 
-        with open(metadata_filepath, 'w') as f:
+        with open(metadata_filepath, "w") as f:
             f.write(metadata_content)
 
         logging.info(f"Saved profile to: {filepath}")
@@ -226,7 +229,14 @@ class RemoteProfiler:
     Remote profiler class to handle threaded profiling execution.
     """
 
-    def __init__(self, host: str, port: int, output_dir: str, username: Optional[str] = None, password: Optional[str] = None):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        output_dir: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+    ):
         self.host = host
         self.port = port
         self.output_dir = output_dir
@@ -235,21 +245,18 @@ class RemoteProfiler:
         self.profile_thread = None
         self.profile_result = None
         self.profile_error = None
-        
+
     def start_profiling(
-        self,
-        redis_conn,
-        benchmark_name: str,
-        benchmark_duration_seconds: int
+        self, redis_conn, benchmark_name: str, benchmark_duration_seconds: int
     ) -> bool:
         """
         Start profiling in a separate thread.
-        
+
         Args:
             redis_conn: Redis connection object
             benchmark_name: Name of the benchmark
             benchmark_duration_seconds: Expected benchmark duration
-            
+
         Returns:
             True if profiling thread started successfully, False otherwise
         """
@@ -257,44 +264,60 @@ class RemoteProfiler:
             # Extract Redis metadata and PID
             redis_metadata = extract_redis_metadata(redis_conn)
             pid = redis_metadata.get("process_id")
-            
+
             if pid == "unknown" or pid is None:
                 logging.error("Cannot start remote profiling: Redis PID not available")
                 return False
-                
+
             # Calculate profiling duration
             duration = calculate_profile_duration(benchmark_duration_seconds)
-            
+
             # Start profiling thread
             self.profile_thread = threading.Thread(
                 target=self._profile_worker,
                 args=(pid, duration, benchmark_name, redis_metadata),
-                daemon=True
+                daemon=True,
             )
             self.profile_thread.start()
-            
-            logging.info(f"Started remote profiling thread for benchmark: {benchmark_name}")
+
+            logging.info(
+                f"Started remote profiling thread for benchmark: {benchmark_name}"
+            )
             return True
-            
+
         except Exception as e:
             logging.error(f"Failed to start remote profiling: {e}")
             return False
-    
-    def _profile_worker(self, pid: int, duration: int, benchmark_name: str, redis_metadata: Dict[str, Any]):
+
+    def _profile_worker(
+        self,
+        pid: int,
+        duration: int,
+        benchmark_name: str,
+        redis_metadata: Dict[str, Any],
+    ):
         """
         Worker function for profiling thread.
         """
         try:
             # Trigger remote profiling
             profile_content = trigger_remote_profile(
-                self.host, self.port, pid, duration,
-                username=self.username, password=self.password
+                self.host,
+                self.port,
+                pid,
+                duration,
+                username=self.username,
+                password=self.password,
             )
 
             if profile_content is not None:
                 # Save profile with metadata
                 filepath = save_profile_with_metadata(
-                    profile_content, benchmark_name, self.output_dir, redis_metadata, duration
+                    profile_content,
+                    benchmark_name,
+                    self.output_dir,
+                    redis_metadata,
+                    duration,
                 )
                 self.profile_result = filepath
             else:
@@ -303,38 +326,42 @@ class RemoteProfiler:
         except Exception as e:
             self.profile_error = f"Profile worker error: {e}"
             logging.error(self.profile_error)
-    
+
     def wait_for_completion(self, timeout: int = 60) -> bool:
         """
         Wait for profiling thread to complete.
-        
+
         Args:
             timeout: Maximum time to wait in seconds
-            
+
         Returns:
             True if completed successfully, False if timed out or failed
         """
         if self.profile_thread is None:
             return False
-            
+
         try:
             self.profile_thread.join(timeout=timeout)
-            
+
             if self.profile_thread.is_alive():
-                logging.warning(f"Remote profiling thread did not complete within {timeout}s")
+                logging.warning(
+                    f"Remote profiling thread did not complete within {timeout}s"
+                )
                 return False
-                
+
             if self.profile_error:
                 logging.error(f"Remote profiling failed: {self.profile_error}")
                 return False
-                
+
             if self.profile_result:
-                logging.info(f"Remote profiling completed successfully: {self.profile_result}")
+                logging.info(
+                    f"Remote profiling completed successfully: {self.profile_result}"
+                )
                 return True
             else:
                 logging.warning("Remote profiling completed but no result available")
                 return False
-                
+
         except Exception as e:
             logging.error(f"Error waiting for remote profiling completion: {e}")
             return False