redis-benchmarks-specification 0.1.282__tar.gz → 0.1.284__tar.gz

{redis_benchmarks_specification-0.1.282 → redis_benchmarks_specification-0.1.284}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-benchmarks-specification"
-version = "0.1.282"
+version = "0.1.284"
 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.282 → redis_benchmarks_specification-0.1.284}/redis_benchmarks_specification/__runner__/remote_profiling.py

@@ -81,6 +81,157 @@ def extract_redis_metadata(redis_conn) -> Dict[str, Any]:
         }
 
 
+def extract_server_info_for_args(redis_conn) -> Dict[str, str]:
+    """
+    Extract server information from Redis INFO SERVER to auto-detect
+    github_org, github_repo, and github_version when not explicitly provided.
+
+    Args:
+        redis_conn: Redis connection object
+
+    Returns:
+        Dictionary containing detected server information:
+        - github_org: Detected organization (e.g., 'redis', 'valkey-io')
+        - github_repo: Detected repository (e.g., 'redis', 'valkey')
+        - github_version: Detected version
+        - server_name: Server name from INFO
+    """
+    try:
+        server_info = redis_conn.info("server")
+
+        # Extract server name and version info
+        server_name = server_info.get("server_name", "").lower()
+        redis_version = server_info.get("redis_version", "unknown")
+
+        # Default values
+        github_org = "redis"
+        github_repo = "redis"
+        github_version = redis_version
+
+        # Check for Valkey
+        if "valkey" in server_name:
+            github_org = "valkey-io"
+            github_repo = "valkey"
+            # Use valkey_version if available, fallback to redis_version
+            valkey_version = server_info.get("valkey_version")
+            if valkey_version:
+                github_version = valkey_version
+
+        logging.info(
+            f"Auto-detected server info: org={github_org}, repo={github_repo}, "
+            f"version={github_version}, server_name={server_name}"
+        )
+
+        return {
+            "github_org": github_org,
+            "github_repo": github_repo,
+            "github_version": github_version,
+            "server_name": server_name,
+        }
+
+    except Exception as e:
+        logging.error(f"Failed to extract server info: {e}")
+        return {
+            "github_org": "redis",
+            "github_repo": "redis",
+            "github_version": "unknown",
+            "server_name": "unknown",
+        }
+
+
+def extract_server_metadata_for_timeseries(redis_conn) -> Dict[str, str]:
+    """
+    Extract comprehensive server metadata from Redis INFO SERVER for use as
+    timeseries metadata tags.
+
+    Args:
+        redis_conn: Redis connection object
+
+    Returns:
+        Dictionary containing server metadata for timeseries tags:
+        - os: Operating system information
+        - arch_bits: Architecture bits (32/64)
+        - gcc_version: GCC compiler version
+        - server_mode: Server mode (standalone/cluster/sentinel)
+        - multiplexing_api: Multiplexing API used (epoll/kqueue/etc)
+        - atomicvar_api: Atomic variable API
+        - redis_build_id: Build ID
+        - redis_git_dirty: Git dirty flag
+        - process_supervised: Process supervision status
+        - availability_zone: Availability zone (if available)
+        - And other interesting metadata fields
+    """
+    try:
+        server_info = redis_conn.info("server")
+
+        # Extract interesting metadata fields for timeseries tags
+        metadata = {}
+
+        # Core system information
+        if "os" in server_info:
+            metadata["os"] = str(server_info["os"])
+        if "arch_bits" in server_info:
+            metadata["arch_bits"] = str(server_info["arch_bits"])
+        if "gcc_version" in server_info:
+            metadata["gcc_version"] = str(server_info["gcc_version"])
+
+        # Server configuration
+        if "server_mode" in server_info:
+            metadata["server_mode"] = str(server_info["server_mode"])
+        elif "redis_mode" in server_info:  # Fallback for older versions
+            metadata["server_mode"] = str(server_info["redis_mode"])
+
+        # Performance-related APIs
+        if "multiplexing_api" in server_info:
+            metadata["multiplexing_api"] = str(server_info["multiplexing_api"])
+        if "atomicvar_api" in server_info:
+            metadata["atomicvar_api"] = str(server_info["atomicvar_api"])
+        if "monotonic_clock" in server_info:
+            metadata["monotonic_clock"] = str(server_info["monotonic_clock"])
+
+        # Build information
+        if "redis_build_id" in server_info:
+            metadata["redis_build_id"] = str(server_info["redis_build_id"])
+        if "redis_git_dirty" in server_info:
+            metadata["redis_git_dirty"] = str(server_info["redis_git_dirty"])
+
+        # Process information
+        if "process_supervised" in server_info:
+            metadata["process_supervised"] = str(server_info["process_supervised"])
+
+        # Cloud/deployment information
+        if "availability_zone" in server_info and server_info["availability_zone"]:
+            metadata["availability_zone"] = str(server_info["availability_zone"])
+
+        # IO threads (performance relevant)
+        if "io_threads_active" in server_info:
+            metadata["io_threads_active"] = str(server_info["io_threads_active"])
+
+        # Server name and version info
+        if "server_name" in server_info and server_info["server_name"]:
+            metadata["server_name"] = str(server_info["server_name"])
+        if "redis_version" in server_info:
+            metadata["redis_version"] = str(server_info["redis_version"])
+        if "valkey_version" in server_info:
+            metadata["valkey_version"] = str(server_info["valkey_version"])
+        if "valkey_release_stage" in server_info:
+            metadata["valkey_release_stage"] = str(server_info["valkey_release_stage"])
+
+        # Configuration file info
+        if "config_file" in server_info and server_info["config_file"]:
+            metadata["config_file"] = str(server_info["config_file"])
+        else:
+            metadata["config_file"] = "none"
+
+        logging.info(f"Extracted {len(metadata)} server metadata fields for timeseries: {list(metadata.keys())}")
+
+        return metadata
+
+    except Exception as e:
+        logging.error(f"Failed to extract server metadata: {e}")
+        return {}
+
+
 def calculate_profile_duration(benchmark_duration_seconds: int) -> int:
     """
     Calculate profiling duration based on benchmark duration.

{redis_benchmarks_specification-0.1.282 → redis_benchmarks_specification-0.1.284}/redis_benchmarks_specification/__runner__/runner.py

@@ -1125,6 +1125,7 @@ def process_self_contained_coordinator_stream(
                     current_cpu_pos = args.cpuset_start_pos
                     temporary_dir_client = tempfile.mkdtemp(dir=home)
 
+                    # These will be updated after auto-detection
                     tf_github_org = args.github_org
                     tf_github_repo = args.github_repo
                     tf_triggering_env = args.platform_name
@@ -1157,6 +1158,56 @@ def process_self_contained_coordinator_stream(
                     )
                     setup_name = "oss-standalone"
                     r.ping()
+
+                    # Auto-detect server information if not explicitly provided
+                    from redis_benchmarks_specification.__runner__.remote_profiling import (
+                        extract_server_info_for_args,
+                        extract_server_metadata_for_timeseries
+                    )
+
+                    detected_info = extract_server_info_for_args(r)
+                    server_metadata = extract_server_metadata_for_timeseries(r)
+
+                    # Use detected values if arguments weren't explicitly provided
+                    github_org = args.github_org
+                    github_repo = args.github_repo
+
+                    # Auto-detect github_org if it's the default value
+                    if args.github_org == "redis" and detected_info["github_org"] != "redis":
+                        github_org = detected_info["github_org"]
+                        logging.info(f"Auto-detected github_org: {github_org}")
+
+                    # Auto-detect github_repo if it's the default value
+                    if args.github_repo == "redis" and detected_info["github_repo"] != "redis":
+                        github_repo = detected_info["github_repo"]
+                        logging.info(f"Auto-detected github_repo: {github_repo}")
+
+                    # Auto-detect version if it's the default value
+                    if args.github_version == "NA" and detected_info["github_version"] != "unknown":
+                        git_version = detected_info["github_version"]
+                        logging.info(f"Auto-detected github_version: {git_version}")
+
+                    # Auto-detect git hash from server info if available
+                    if git_hash == "NA":
+                        try:
+                            server_info = r.info("server")
+                            redis_git_sha1 = server_info.get("redis_git_sha1", "")
+                            redis_build_id = server_info.get("redis_build_id", "")
+
+                            # Use git_sha1 if available and not empty/zero
+                            if redis_git_sha1 and redis_git_sha1 not in ("", "0", "00000000"):
+                                git_hash = redis_git_sha1
+                                logging.info(f"Auto-detected git_hash from redis_git_sha1: {git_hash}")
+                            # Fallback to build_id if git_sha1 is not available
+                            elif redis_build_id and redis_build_id not in ("", "0"):
+                                git_hash = redis_build_id
+                                logging.info(f"Auto-detected git_hash from redis_build_id: {git_hash}")
+                        except Exception as e:
+                            logging.warning(f"Failed to auto-detect git hash: {e}")
+
+                    # Update tf_github_org and tf_github_repo with detected values
+                    tf_github_org = github_org
+                    tf_github_repo = github_repo
                     redis_conns = [r]
                     if oss_cluster_api_enabled:
                         redis_conns = []
@@ -1271,6 +1322,8 @@ def process_self_contained_coordinator_stream(
                     benchmark_tool_workdir = client_mnt_point
 
                     metadata = {}
+                    # Add server metadata from Redis INFO SERVER
+                    metadata.update(server_metadata)
                     test_tls_cacert = None
                     test_tls_cert = None
                     test_tls_key = None
@@ -1979,6 +2032,7 @@ def process_self_contained_coordinator_stream(
                         tf_triggering_env,
                         topology_spec_name,
                         default_metrics,
+                        git_hash,
                     )
                     test_result = True
                     total_test_suite_runs = total_test_suite_runs + 1