argus-alm 0.11.4__tar.gz → 0.11.6__tar.gz

{argus_alm-0.11.4 → argus_alm-0.11.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.11.4
+Version: 0.11.6
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/driver_matrix_tests/model.py

@@ -58,6 +58,10 @@ class DriverTestRun(PluginModelBase):
         run.build_id = req.job_name
         run.build_job_url = req.job_url
         run.assign_categories()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except Exception:  # pylint: disable=broad-except
+            run.assignee = None
         for key, value in req.test_environment.items():
             env_info = EnvironmentInfo()
             env_info.key = key
@@ -102,7 +106,7 @@ class DriverTestRun(PluginModelBase):
                 collection.suites.append(suite)
             run.test_collection.append(collection)
 
-        run.status = run._determine_run_status()
+        run.status = run._determine_run_status().value
         run.save()
         return run
 

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/sct/controller.py

@@ -114,6 +114,36 @@ def sct_events_submit(run_id: str):
     }
 
 
+@bp.route("/<string:run_id>/gemini/submit", methods=["POST"])
+@api_login_required
+def sct_gemini_results_submit(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.submit_gemini_results(run_id=run_id, gemini_data=payload["gemini_data"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/performance/submit", methods=["POST"])
+@api_login_required
+def sct_performance_results_submit(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.submit_performance_results(run_id=run_id, performance_results=payload["performance_results"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/performance/history", methods=["GET"])
+@api_login_required
+def sct_get_performance_history(run_id: str):
+    result = SCTService.get_performance_history_for_test(run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
 @bp.route("/release/<string:release_name>/kernels", methods=["GET"])
 @api_login_required
 def sct_get_kernel_report(release_name: str):

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/sct/plugin.py

@@ -12,6 +12,7 @@ from argus.backend.plugins.sct.udt import (
     NemesisRunInfo,
     NodeDescription,
     PackageVersion,
+    PerformanceHDRHistogram,
 )
 
 
@@ -31,5 +32,6 @@ class PluginInfo(PluginInfoBase):
         CloudSetupDetails,
         CloudNodesInfo,
         CloudInstanceDetails,
-        PackageVersion
+        PackageVersion,
+        PerformanceHDRHistogram,
     ]

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/sct/service.py

@@ -1,7 +1,12 @@
 from dataclasses import dataclass
+from functools import reduce
 import logging
+import math
 from time import time
-from argus.backend.plugins.sct.testrun import SCTTestRun
+from flask import g
+from argus.backend.models.web import ArgusEventTypes
+from argus.backend.plugins.sct.testrun import SCTTestRun, SubtestType
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
 from argus.backend.plugins.sct.udt import (
     CloudInstanceDetails,
     CloudResource,
@@ -9,8 +14,11 @@ from argus.backend.plugins.sct.udt import (
     NemesisRunInfo,
     NodeDescription,
     PackageVersion,
+    PerformanceHDRHistogram,
 )
-from argus.backend.util.enums import NemesisStatus, ResourceState
+from argus.backend.service.event_service import EventService
+from argus.backend.util.common import get_build_number
+from argus.backend.util.enums import NemesisStatus, ResourceState, TestStatus
 
 LOGGER = logging.getLogger(__name__)
 
@@ -91,6 +99,154 @@ class SCTService:
 
         return "submitted"
 
+    @staticmethod
+    def submit_gemini_results(run_id: str, gemini_data: GeminiResultsRequest) -> str:
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            run.subtest_name = SubtestType.GEMINI.value
+            run.oracle_nodes_count = gemini_data.get("oracle_nodes_count")
+            run.oracle_node_ami_id = gemini_data.get("oracle_node_ami_id")
+            run.oracle_node_instance_type = gemini_data.get("oracle_node_instance_type")
+            run.oracle_node_scylla_version = gemini_data.get("oracle_node_scylla_version")
+            run.gemini_command = gemini_data.get("gemini_command")
+            run.gemini_version = gemini_data.get("gemini_version")
+            run.gemini_status = gemini_data.get("gemini_status")
+            run.gemini_seed = str(gemini_data.get("gemini_seed"))
+            run.gemini_write_ops = gemini_data.get("gemini_write_ops")
+            run.gemini_write_errors = gemini_data.get("gemini_write_errors")
+            run.gemini_read_ops = gemini_data.get("gemini_read_ops")
+            run.gemini_read_errors = gemini_data.get("gemini_read_errors")
+            run.save()
+
+            if run.gemini_status != "PASSED":
+                run.status = TestStatus.FAILED
+                EventService.create_run_event(kind=ArgusEventTypes.TestRunStatusChanged, body={
+                        "message": "[{username}] Setting run status to {status} due to Gemini reporting following status: {gemini_status}",
+                        "username": g.user.username,
+                        "status": TestStatus.FAILED.value,
+                        "gemini_status": run.gemini_status,
+                }, user_id=g.user.id, run_id=run_id, release_id=run.release_id, test_id=run.test_id)
+                run.save()
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+        return "submitted"
+
+    @staticmethod
+    def submit_performance_results(run_id: str, performance_results: PerformanceResultsRequest):
+        # pylint: disable=too-many-statements
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            run.subtest_name = SubtestType.PERFORMANCE.value
+            run.perf_op_rate_average = performance_results.get("perf_op_rate_average")
+            run.perf_op_rate_total = performance_results.get("perf_op_rate_total")
+            run.perf_avg_latency_99th = performance_results.get("perf_avg_latency_99th")
+            run.perf_avg_latency_mean = performance_results.get("perf_avg_latency_mean")
+            run.perf_total_errors = performance_results.get("perf_total_errors")
+            run.stress_cmd = performance_results.get("stress_cmd")
+            run.test_name = performance_results.get("test_name")
+            run.save()
+
+            is_latency_test = "latency" in run.test_name
+            threshold_negative = -10
+
+            def cmp(lhs, rhs):
+                delta = rhs - lhs
+                change = int(math.fabs(delta) * 100 / rhs)
+                return change if delta >= 0 else change * -1
+
+            previous_runs = SCTTestRun.get_perf_results_for_test_name(run.build_id, run.start_time, run.test_name)
+            metrics_to_check = ["perf_avg_latency_99th", "perf_avg_latency_mean"] if is_latency_test else ["perf_op_rate_total"]
+
+            older_runs_by_version = {}
+            for prev_run in previous_runs:
+                if not older_runs_by_version.get(prev_run["scylla_version"]):
+                    older_runs_by_version[prev_run["scylla_version"]] = []
+                older_runs_by_version[prev_run["scylla_version"]].append(prev_run)
+
+            regression_found = False
+            regression_info = {
+                "version": None,
+                "delta": None,
+                "id": None,
+                "metric": None,
+                "job_url": None,
+            }
+
+            if performance_results["histograms"]:
+                for histogram in performance_results["histograms"]:
+                    run.histograms = { k: PerformanceHDRHistogram(**v) for k, v in histogram.items() }
+
+            for version, runs in older_runs_by_version.items():
+                for metric in metrics_to_check:
+                    # pylint: disable=cell-var-from-loop
+                    best_run = sorted(runs, reverse=(not is_latency_test), key=lambda v: v[metric])[0]
+                    last_run = runs[0]
+
+                    metric_to_best = cmp(run[metric], best_run[metric])
+                    metric_to_last = cmp(run[metric], last_run[metric])
+                    if metric_to_last < threshold_negative:
+                        regression_found = True
+                        regression_info["metric"] = metric
+                        regression_info["version"] = version
+                        regression_info["job_url"] = last_run["build_job_url"]
+                        regression_info["id"] = str(last_run["id"])
+                        regression_info["delta"] = metric_to_last
+                        break
+
+                    if metric_to_best < threshold_negative:
+                        regression_found = True
+                        regression_info["metric"] = metric
+                        regression_info["version"] = version
+                        regression_info["job_url"] = best_run["build_job_url"]
+                        regression_info["id"] = str(best_run["id"])
+                        regression_info["delta"] = metric_to_best
+                        break
+
+                if regression_found:
+                    break
+
+            if regression_found:
+                run.status = TestStatus.FAILED.value
+                run.save()
+                EventService.create_run_event(kind=ArgusEventTypes.TestRunStatusChanged, body={
+                        "message": "[{username}] Setting run status to {status} due to performance metric '{metric}' falling "
+                                   "below allowed threshold ({threshold_negative}): {delta}% compared to "
+                                   "<a href='/test/{test_id}/runs?additionalRuns[]={base_run_id}&additionalRuns[]={previous_run_id}'>This {version} (#{build_number}) run</a>",
+                        "username": g.user.username,
+                        "status": TestStatus.FAILED.value,
+                        "metric": regression_info["metric"],
+                        "threshold_negative": threshold_negative,
+                        "delta": regression_info["delta"],
+                        "test_id": str(run.test_id),
+                        "base_run_id": str(run.id),
+                        "previous_run_id": regression_info["id"],
+                        "version": regression_info["version"],
+                        "build_number": get_build_number(regression_info["job_url"])
+                }, user_id=g.user.id, run_id=run_id, release_id=run.release_id, test_id=run.test_id)
+            else:
+                # NOTE: This will override status set by SCT Events.
+                run.status = TestStatus.PASSED.value
+                run.save()
+
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+        return "submitted"
+
+    @staticmethod
+    def get_performance_history_for_test(run_id: str):
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            rows = run.get_perf_results_for_test_name(build_id=run.build_id, start_time=run.start_time, test_name=run.test_name)
+            return rows
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+
     @staticmethod
     def create_resource(run_id: str, resource_details: dict) -> str:
         instance_details = CloudInstanceDetails(**resource_details.pop("instance_details"))

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/sct/testrun.py

@@ -1,6 +1,8 @@
+from enum import Enum
 import logging
 from datetime import datetime
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Optional
 from uuid import UUID
 
 from cassandra.cqlengine import columns
@@ -16,6 +18,7 @@ from argus.backend.plugins.sct.udt import (
     EventsBySeverity,
     NemesisRunInfo,
     PackageVersion,
+    PerformanceHDRHistogram
 )
 
 LOGGER = logging.getLogger(__name__)
@@ -31,6 +34,11 @@ SCT_REGION_PROPERTY_MAP = {
 }
 
 
+class SubtestType(str, Enum):
+    GEMINI = "gemini"
+    PERFORMANCE = "performance"
+
+
 @dataclass(init=True, repr=True, frozen=True)
 class SCTTestRunSubmissionRequest():
     schema_version: str
@@ -39,9 +47,9 @@ class SCTTestRunSubmissionRequest():
     job_url: str
     started_by: str
     commit_id: str
-    runner_public_ip: str
-    runner_private_ip: str
-    sct_config: dict
+    sct_config: dict | None
+    runner_public_ip: Optional[str] = field(default=None)
+    runner_private_ip: Optional[str] = field(default=None)
 
 
 class SCTTestRun(PluginModelBase):
@@ -49,6 +57,7 @@ class SCTTestRun(PluginModelBase):
     _plugin_name = "scylla-cluster-tests"
 
     # Test Details
+    test_name = columns.Text()
     scm_revision_id = columns.Text()
     started_by = columns.Text()
     config_files = columns.List(value_type=columns.Text())
@@ -69,6 +78,33 @@ class SCTTestRun(PluginModelBase):
     nemesis_data = columns.List(value_type=columns.UserDefinedType(user_type=NemesisRunInfo))
     screenshots = columns.List(value_type=columns.Text())
 
+    # Subtest
+    subtest_name = columns.Text()
+
+    # Gemini-related fields
+    oracle_nodes_count = columns.Integer()
+    oracle_node_ami_id = columns.Text()
+    oracle_node_instance_type = columns.Text()
+    oracle_node_scylla_version = columns.Text()
+    gemini_command = columns.Text()
+    gemini_version = columns.Text()
+    gemini_status = columns.Text()
+    gemini_seed = columns.Text()
+    gemini_write_ops = columns.Integer()
+    gemini_write_errors = columns.Integer()
+    gemini_read_ops = columns.Integer()
+    gemini_read_errors = columns.Integer()
+
+    # Performance fields
+    perf_op_rate_average = columns.Double()
+    perf_op_rate_total = columns.Double()
+    perf_avg_latency_99th = columns.Double()
+    perf_avg_latency_mean = columns.Double()
+    perf_total_errors = columns.Double()
+    stress_cmd = columns.Text()
+
+    histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
+
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
@@ -102,7 +138,17 @@ class SCTTestRun(PluginModelBase):
         return list(rows)
 
     @classmethod
-    def from_sct_config(cls, req: SCTTestRunSubmissionRequest):
+    def get_perf_results_for_test_name(cls, build_id: str, start_time: float, test_name: str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(f"SELECT build_id, packages, scylla_version, test_name, perf_op_rate_average, perf_op_rate_total, "
+                                "perf_avg_latency_99th, perf_avg_latency_mean, perf_total_errors, id, start_time, build_job_url"
+                                f" FROM {cls.table_name()} WHERE build_id = ? AND start_time < ? AND test_name = ? ALLOW FILTERING")
+        rows = cluster.session.execute(query=query, parameters=(build_id, start_time, test_name))
+
+        return list(rows)
+
+    @classmethod
+    def init_sct_run(cls, req: SCTTestRunSubmissionRequest):
         run = cls()
         run.build_id = req.job_name
         run.assign_categories()
@@ -116,16 +162,35 @@ class SCTTestRun(PluginModelBase):
         run.started_by = req.started_by
         run.build_job_url = req.job_url
 
-        backend = req.sct_config.get("cluster_backend")
-        region_key = SCT_REGION_PROPERTY_MAP.get(backend, SCT_REGION_PROPERTY_MAP["default"])
-        raw_regions = req.sct_config.get(region_key) or "undefined_region"
-        regions = raw_regions.split() if isinstance(raw_regions, str) else raw_regions
+        return run
 
-        run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
+    @classmethod
+    def from_sct_config(cls, req: SCTTestRunSubmissionRequest):
+        try:
+            run = cls.get(id=req.run_id)
+        except cls.DoesNotExist:
+            run = cls.init_sct_run(req)
+            run.save()
+
+        if req.sct_config:
+            backend = req.sct_config.get("cluster_backend")
+            region_key = SCT_REGION_PROPERTY_MAP.get(backend, SCT_REGION_PROPERTY_MAP["default"])
+            raw_regions = req.sct_config.get(region_key) or "undefined_region"
+            regions = raw_regions.split() if isinstance(raw_regions, str) else raw_regions
+            primary_region = regions[0]
+            if req.runner_public_ip:  # NOTE: Legacy support, not needed otherwise
+                run.sct_runner_host = CloudInstanceDetails(
+                    public_ip=req.runner_public_ip,
+                    private_ip=req.runner_private_ip,
+                    provider=backend,
+                    region=primary_region,
+                )
+            run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
+
+            run.config_files = req.sct_config.get("config_files")
+            run.region_name = regions
+            run.save()
 
-        run.config_files = req.sct_config.get("config_files")
-        run.region_name = regions
-        run.save()
         return run
 
     def get_resources(self) -> list[CloudResource]:

argus_alm-0.11.6/argus/backend/plugins/sct/types.py

@@ -0,0 +1,38 @@
+from typing import TypedDict
+
+class RawHDRHistogram(TypedDict):
+    start_time: int
+    percentile_90: float
+    percentile_50: float
+    percentile_99_999: float
+    percentile_95: float
+    end_time: float
+    percentile_99_99: float
+    percentile_99: float
+    stddev: float
+    percentile_99_9: float
+
+class GeminiResultsRequest(TypedDict):
+    oracle_nodes_count: int
+    oracle_node_ami_id: str
+    oracle_node_instance_type: str
+    oracle_node_scylla_version: str
+    gemini_command: str
+    gemini_version: str
+    gemini_status: str
+    gemini_seed: str
+    gemini_write_ops: int
+    gemini_write_errors: int
+    gemini_read_ops: int
+    gemini_read_errors: int
+
+class PerformanceResultsRequest(TypedDict):
+    test_name: str
+    stress_cmd: str
+    perf_op_rate_average: float
+    perf_op_rate_total: float
+    perf_avg_latency_99th: float
+    perf_avg_latency_mean: float
+    perf_total_errors: str
+
+    histograms: list[dict[str, RawHDRHistogram]] | None

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/plugins/sct/udt.py

@@ -78,3 +78,16 @@ class NemesisRunInfo(UserType):
     start_time = columns.Integer()
     end_time = columns.Integer()
     stack_trace = columns.Text()
+
+
+class PerformanceHDRHistogram(UserType):
+    start_time = columns.Integer()
+    percentile_90 = columns.Float()
+    percentile_50 = columns.Float()
+    percentile_99_999 = columns.Float()
+    percentile_95 = columns.Float()
+    end_time = columns.Float()
+    percentile_99_99 = columns.Float()
+    percentile_99 = columns.Float()
+    stddev = columns.Float()
+    percentile_99_9 = columns.Float()

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/service/build_system_monitor.py

@@ -78,7 +78,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
     def collect(self):
         click.echo("Collecting new tests from jenkins")
         all_jobs = self._jenkins.get_all_jobs()
-        all_monitored_folders = [job for job in all_jobs if job["name"] in self._monitored_releases]
+        all_monitored_folders = [job for job in all_jobs if job["fullname"] in self._monitored_releases]
         for release in all_monitored_folders:
             LOGGER.info("Processing release %s", release["name"])
             try:
@@ -89,8 +89,23 @@ class JenkinsMonitor(ArgusTestsMonitor):
                 saved_release = self.create_release(release["name"])
                 self._existing_releases.append(saved_release)
 
-            groups = self.collect_groups_for_release(release["jobs"])
+            try:
+                groups = self.collect_groups_for_release(release["jobs"])
+            except KeyError:
+                LOGGER.error("Empty release!\n %s", release)
+                continue
             folder_stack = [dict(parent_name="", parent_display_name="", group=g) for g in reversed(groups)]
+            root_folder = {
+                "parent_name": "",
+                "parent_display_name": "",
+                "group":  {
+                    "name": f"{release['fullname']}-root",
+                    "displayName": "-- root directory --",
+                    "fullname": release["fullname"],
+                    "jobs": self.collect_root_folder_jobs(release["jobs"]),
+                }
+            }
+            folder_stack.append(root_folder)
             while len(folder_stack) != 0:
                 group_dict = folder_stack.pop()
                 group = group_dict["group"]
@@ -104,7 +119,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
                     LOGGER.warning(
                         "Group %s for release %s doesn't exist, creating...", group_name, saved_release.name)
                     try:
-                        display_name = self._jenkins.get_job_info(name=group["fullname"])["displayName"]
+                        display_name = group.get("displayName", self._jenkins.get_job_info(name=group["fullname"])["displayName"])
                         display_name = display_name if not group_dict[
                             "parent_display_name"] else f"{group_dict['parent_display_name']} - {display_name}"
                     except Exception:
@@ -138,3 +153,6 @@ class JenkinsMonitor(ArgusTestsMonitor):
         groups = [group for group in groups if self.check_filter(group["name"])]
 
         return groups
+
+    def collect_root_folder_jobs(self, jobs):
+        return [job for job in jobs if "WorkflowJob" in job["_class"]]

argus_alm-0.11.6/argus/backend/service/event_service.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+import json
+from argus.backend.models.web import ArgusEvent, ArgusEventTypes
+
+
+class EventService:
+    @staticmethod
+    def create_run_event(kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
+        event = ArgusEvent()
+        event.release_id = release_id
+        event.group_id = group_id
+        event.test_id = test_id
+        event.user_id = user_id
+        event.run_id = run_id
+        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
+        event.kind = kind.value
+        event.created_at = datetime.utcnow()
+        event.save()

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/service/stats.py

@@ -76,6 +76,70 @@ class ComparableTestStatus:
         return self._get_prio() <= __o._get_prio()
 
 
+class ComparableTestInvestigationStatus:
+    PRIORITY_MAP = {
+        TestInvestigationStatus.NOT_INVESTIGATED: 10,
+        TestInvestigationStatus.IN_PROGRESS: 9,
+        TestInvestigationStatus.INVESTIGATED: 8,
+        TestInvestigationStatus.IGNORED: 7,
+    }
+
+    def __init__(self, status: TestInvestigationStatus):
+        self._status = status
+
+    def _get_prio(self):
+        return self.PRIORITY_MAP.get(self._status, 0)
+
+    def __eq__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() == __o._get_prio()
+
+    def __ne__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return not self.__eq__(__o)
+
+    def __lt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() < __o._get_prio()
+
+    def __gt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() > __o._get_prio()
+
+    def __ge__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() >= __o._get_prio()
+
+    def __le__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() <= __o._get_prio()
+
+
+def generate_field_status_map(
+        last_runs: list[TestRunStatRow],
+        field_name = "status",
+        container_class = TestStatus,
+        cmp_class = ComparableTestStatus
+    ) -> dict[int, str]:
+
+    status_map = {}
+    for run in last_runs:
+        run_number = get_build_number(run["build_job_url"])
+        match status := status_map.get(run_number):
+            case str():
+                if cmp_class(container_class(status)) < cmp_class(container_class(run[field_name])):
+                    status_map[run_number] = run[field_name]
+            case _:
+                status_map[run_number] = run[field_name]
+    return status_map
+
+
 class ReleaseStats:
     def __init__(self, release: ArgusRelease) -> None:
         self.release = release
@@ -227,18 +291,6 @@ class TestStats:
             "hasComments": self.has_comments
         }
 
-    def _generate_status_map(self, last_runs: list[TestRunStatRow]) -> dict[int, str]:
-        status_map = {}
-        for run in last_runs:
-            run_number = get_build_number(run["build_job_url"])
-            match status := status_map.get(run_number):
-                case str():
-                    if ComparableTestStatus(TestStatus(status)) < ComparableTestStatus(TestStatus(run["status"])):
-                        status_map[run_number] = run["status"]
-                case _:
-                    status_map[run_number] = run["status"]
-        return status_map
-
     def collect(self, limited=False):
 
         # TODO: Parametrize run limit
@@ -252,10 +304,12 @@ class TestStats:
             self.status = TestStatus.NOT_RUN if self.is_scheduled else TestStatus.NOT_PLANNED
             self.parent_group.increment_status(status=self.status)
             return
-        status_map = self._generate_status_map(last_runs)
+        status_map = generate_field_status_map(last_runs)
+        investigation_status_map = generate_field_status_map(
+            last_runs, "investigation_status", TestInvestigationStatus, ComparableTestInvestigationStatus)
 
         self.status = status_map.get(get_build_number(last_run["build_job_url"]))
-        self.investigation_status = TestInvestigationStatus(last_run["investigation_status"])
+        self.investigation_status = investigation_status_map.get(get_build_number(last_run["build_job_url"]))
         self.start_time = last_run["start_time"]
 
         self.parent_group.increment_status(status=self.status)
@@ -300,7 +354,7 @@ class ReleaseStatsCollector:
 
         if self.release_version:
             self.release_rows = list(
-                filter(lambda row: row["scylla_version"] == self.release_version, self.release_rows))
+                filter(lambda row: row["scylla_version"] == self.release_version or not row["scylla_version"], self.release_rows))
 
         self.release_stats = ReleaseStats(release=self.release)
         self.release_stats.collect(rows=self.release_rows, limited=limited, force=force)

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/service/testrun.py

@@ -30,7 +30,9 @@ from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
 
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.events.event_processors import EVENT_PROCESSORS
+from argus.backend.service.event_service import EventService
 from argus.backend.service.notification_manager import NotificationManagerService
+from argus.backend.service.stats import ComparableTestStatus
 from argus.backend.util.common import get_build_number, strip_html_tags
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
@@ -80,6 +82,8 @@ class TestRunService:
         for row in last_runs:
             row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
+        last_runs = sorted(last_runs, reverse=True, key=lambda run: (run["build_number"], ComparableTestStatus(TestStatus(run["status"]))))
+
         return last_runs
 
     def get_runs_by_id(self, test_id: UUID, runs: list[UUID]):  # FIXME: Not needed, use get_run and individual polling
@@ -108,7 +112,7 @@ class TestRunService:
         run.status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Status was changed from {old_status} to {new_status} by {username}",
@@ -136,7 +140,7 @@ class TestRunService:
         run.investigation_status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Investigation status was changed from {old_status} to {new_status} by {username}",
@@ -175,7 +179,7 @@ class TestRunService:
                 LOGGER.warning("Non existent assignee was present on the run %s for test %s: %s",
                                run_id, test_id, old_assignee)
                 old_assignee = None
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.AssigneeChanged,
             body={
                 "message": "Assignee was changed from \"{old_user}\" to \"{new_user}\" by {username}",
@@ -244,7 +248,7 @@ class TestRunService:
                 content_params=params
             )
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
             "message": "A comment was posted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=release.id, test_id=test.id)
@@ -257,7 +261,7 @@ class TestRunService:
             raise Exception("Unable to delete other user comments")
         comment.delete()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
             "message": "A comment was deleted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
@@ -273,25 +277,13 @@ class TestRunService:
         comment.mentions = mentions
         comment.save()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
             "message": "A comment was edited by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
 
         return self.get_run_comments(run_id=run_id)
 
-    def create_run_event(self, kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
-        event = ArgusEvent()
-        event.release_id = release_id
-        event.group_id = group_id
-        event.test_id = test_id
-        event.user_id = user_id
-        event.run_id = run_id
-        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
-        event.kind = kind.value
-        event.created_at = datetime.utcnow()
-        event.save()
-
     def get_run_events(self, run_id: UUID):
         response = {}
         all_events = ArgusEvent.filter(run_id=run_id).all()
@@ -358,7 +350,7 @@ class TestRunService:
         new_issue.last_status = issue_state.get("state")
         new_issue.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueAdded,
             body={
                 "message": "An issue titled \"{title}\" was added by {username}",
@@ -409,7 +401,7 @@ class TestRunService:
     def delete_github_issue(self, issue_id: UUID) -> dict:
         issue: ArgusGithubIssue = ArgusGithubIssue.get(id=issue_id)
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueRemoved,
             body={
                 "message": "An issue titled \"{title}\" was removed by {username}",
@@ -448,7 +440,7 @@ class TestRunService:
             run.status = TestStatus.ABORTED.value
             run.save()
 
-            self.create_run_event(
+            EventService.create_run_event(
                 kind=ArgusEventTypes.TestRunStatusChanged,
                 body={
                     "message": "Run was automatically terminated due to not responding for more than 45 minutes "

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/backend/util/encoders.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
@@ -6,6 +7,8 @@ import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
 
+LOGGER = logging.getLogger(__name__)
+
 class ArgusJSONEncoder(JSONEncoder):
     def default(self, o):
         match o:

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/client/driver_matrix_tests/client.py

@@ -16,6 +16,7 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 
 LOGGER = logging.getLogger(__name__)
 
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
 
 class AdaptedXUnitData(TypedDict):
     timestamp: str
@@ -52,6 +53,14 @@ def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
     }
 
 
+def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
 def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
     return {
         "timestamp": datetime.utcnow().isoformat()
@@ -66,6 +75,7 @@ class ArgusDriverMatrixClient(ArgusClient):
         "java": java_driver_matrix_adapter,
         "cpp": cpp_driver_matrix_adapter,
         "python": python_driver_matrix_adapter,
+        "gocql": gocql_driver_matrix_adapter,
     }
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
@@ -107,8 +117,11 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return raw_cases
 
-    def get_driver_info(self, xml_name: str) -> dict[str, str]:
-        filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
+    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
+        if test_type == "cpp":
+            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)\.xml"
+        else:
+            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
 
         match = re.match(filename_re, xml_name)
 
@@ -124,14 +137,14 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return total - errors - skipped - failures
 
-    def parse_result_xml(self, xml_path: Path, test_type:  Literal['java', 'cpp', 'python']) -> RawMatrixTestResult:
+    def parse_result_xml(self, xml_path: Path, test_type:  TestTypeType) -> RawMatrixTestResult:
         with xml_path.open(mode="rt", encoding="utf-8") as xml_file:
             xml = ElementTree.parse(source=xml_file)
             LOGGER.info("%s", pformat(xml))
         testsuites = xml.getroot()
         adapted_data = self.TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
 
-        driver_info = self.get_driver_info(xml_path.name)
+        driver_info = self.get_driver_info(xml_path.name, test_type)
         test_collection = {
             "timestamp": adapted_data["timestamp"],
             "name": xml_path.stem,
@@ -171,7 +184,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             "suites": all_suites
         }
 
-    def get_results(self, result_path: str, test_type: Literal['java', 'cpp', 'python']) -> list[RawMatrixTestResult]:
+    def get_results(self, result_path: str, test_type: TestTypeType) -> list[RawMatrixTestResult]:
         xmls = glob(f"{result_path}/**/*.xml", recursive=True)
         LOGGER.info("Will use following XMLs: %s", pformat(xmls))
         results = []
@@ -180,7 +193,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             results.append(result)
         return results
 
-    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: Literal['java', 'cpp', 'python']):
+    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: TestTypeType):
         env = self.parse_build_environment(env_path)
         results = self.get_results(result_path, test_type)
 

{argus_alm-0.11.4 → argus_alm-0.11.6}/argus/client/sct/client.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from dataclasses import asdict
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
 from argus.backend.util.enums import ResourceState, TestStatus
 from argus.client.base import ArgusClient
 from argus.client.sct.types import EventsInfo, LogLink, Package
@@ -17,6 +18,8 @@ class ArgusSCTClient(ArgusClient):
         SET_SCT_RUNNER  = "/sct/$id/sct_runner/set"
         UPDATE_SHARDS_FOR_RESOURCE = "/sct/$id/resource/$name/shards"
         SUBMIT_NEMESIS = "/sct/$id/nemesis/submit"
+        SUBMIT_GEMINI_RESULTS = "/sct/$id/gemini/submit"
+        SUBMIT_PERFORMANCE_RESULTS = "/sct/$id/performance/submit"
         FINALIZE_NEMESIS = "/sct/$id/nemesis/finalize"
         SUBMIT_EVENTS = "/sct/$id/events/submit"
 
@@ -113,6 +116,34 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+    def submit_gemini_results(self, gemini_data: GeminiResultsRequest) -> None:
+        """
+            Submits gemini results such as oracle node information and gemini command & its results
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_GEMINI_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "gemini_data": gemini_data,
+            }
+        )
+        self.check_response(response)
+
+    def submit_performance_results(self, performance_results: PerformanceResultsRequest) -> None:
+        """
+            Submits results of a performance run. Things such as throughput stats, overall and per op
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_PERFORMANCE_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "performance_results": performance_results,
+            }
+        )
+        self.check_response(response)
+
     def create_resource(self, name: str, resource_type: str, public_ip: str, private_ip: str,
                         region: str, provider: str, shards_amount: int, state=ResourceState.RUNNING) -> None:
         """

{argus_alm-0.11.4 → argus_alm-0.11.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "argus-alm"
-version = "0.11.4"
+version = "0.11.6"
 description = "Argus"
 authors = ["Alexey Kartashov <alexey.kartashov@scylladb.com>"]
 license = "Apache-2.0"

argus_alm-0.11.4/setup.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['argus',
- 'argus.backend',
- 'argus.backend.controller',
- 'argus.backend.events',
- 'argus.backend.models',
- 'argus.backend.plugins',
- 'argus.backend.plugins.driver_matrix_tests',
- 'argus.backend.plugins.sct',
- 'argus.backend.plugins.sirenada',
- 'argus.backend.service',
- 'argus.backend.util',
- 'argus.client',
- 'argus.client.driver_matrix_tests',
- 'argus.client.sct',
- 'argus.client.sirenada',
- 'argus.db']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['requests>=2.26.0,<3.0.0']
-
-setup_kwargs = {
-    'name': 'argus-alm',
-    'version': '0.11.4',
-    'description': 'Argus',
-    'long_description': '# Argus\n\n## Description\n\nArgus is a test tracking system intended to provide observability into automated test pipelines which use long-running resources. It allows observation of a test status, its events and its allocated resources. It also allows easy comparison between particular runs of a specific test.\n\n## Installation notes\n\n### Prerequisites\n\n- Python >=3.10.0 (system-wide or pyenv)\n\n- NodeJS >=16 (with npm)\n\n- Yarn (can be installed globally with `npm -g install yarn`)\n\n- nginx\n\n- poetry >=1.2.0b1\n\n### From source\n\n#### Production\n\nPerform the following steps:\n\nCreate a user that will be used by uwsgi:\n\n```bash\nuseradd -m -s /bin/bash argus\nsudo -iu argus\n```\n\n(Optional) Install pyenv and create a virtualenv for this user:\n\n```bash\npyenv install 3.10.0\npyenv virtualenv argus\npyenv activate argus\n```\n\nClone the project into a directory somewhere where user has full write permissions\n\n```bash\ngit clone https://github.com/scylladb/argus ~/app\ncd ~/app\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`\n\n```bash\nyarn webpack\n```\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* variables with their respective values.\n\nCopy nginx configuration file from `docs/configs/argus.nginx.conf` to nginx virtual hosts directory:\n\nUbuntu:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/sites-available/argus\nsudo ln -s /etc/nginx/sites-enabled/argus /etc/nginx/sites-available/argus\n```\n\nRHEL/Centos/Alma/Fedora:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/conf.d/argus.conf\n```\n\nAdjust the webhost settings in that file as necessary, particularly `listen` and `server_name` directives.\n\nCopy systemd service file from `docs/config/argus.service` to `/etc/systemd/system` directory:\n\n```bash\nsudo cp docs/config/argus.service /etc/systemd/system\n```\n\nOpen it and adjust the path to the `start_argus.sh` script in the `ExecStart=` directive and the user/group, then reload systemd daemon configuration and enable (and optionally start) the service.\n\nWARNING: `start_argus.sh` assumes pyenv is installed into `~/.pyenv`\n\n```bash\nsudo systemctl daemon-reload\nsudo systemctl enable --now argus.service\n```\n\n#### Development\n\nClone the project into a directory somewhere\n\n```bash\ngit clone https://github.com/scylladb/argus\ncd argus\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`. Add --watch to recompile files on change.\n\n```bash\nyarn webpack --watch\n```\n##### Configuration\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\nSee `Production` section for more details.\nTo configure Github authentication follow steps:\n1. Authorize OAuth App\n   1. go to your Account Settings (top right corner) -> Developer settings (left pane) -> OAuth Apps\n   2. Click Create New OAuth App button\n   3. Fill the fields (app name: `argus-dev`, homepage URL `http://localhost:5000`, Auth callback URL: `http://localhost:5000/profile/oauth/github`)\n   4. Confirm and get the tokens/ids required for config\n2. Create Jenkins token for your account\n   1. Go to `Configure` in top right corner\n   2. Click `Add new Token`\n   3. Get it and paste to config to `JENKINS_API_TOKEN` param\n##### Database Initialization\n\nYou can initialize a scylla cluster in any way you like, either using docker image with docker-compose or using cassandra cluster manager. You will need to create the keyspace manually before you can sync database models.\n\nCreate keyspace according to your configuration.\ne.g. (need to test if it works with RF=1 if not, make it 3)\n```\nCREATE KEYSPACE argus WITH replication = {\'class\': \'SimpleStrategy\', \'replication_factor\' : 1}\n```\n\nInitial sync can be done as follows:\n\n```py\nfrom argus.backend.db import ScyllaCluster\nfrom argus.db.testrun import TestRun\ndb = ScyllaCluster.get()\n\ndb.sync_models() # Syncronizes Object Mapper models\nTestRun.init_own_table() # Syncronizes TestRun table (separate from python-driver Object Mapper)\n\n```\n\nYou can also use `flask sync-models` afterwards during development when making small changes to models.\n\nIt is recommended to set up jenkins api key and run `flask scan-jenkins` afterwards to get basic release/group/test structure.\n\nThere are scripts in `./scripts` directory that can be used to download data from production, upload them into your dev db and fix their relations to other models in your instance of the application. Specifically, `download_runs_from_prod.py` requires additional config, `argus.local.prod.yaml` which is the config used to connect to the production cluster. The scripts are split to prevent mistakes and accidentally affecting production cluster.\n\n##### Configuration\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* and JENKINS_* variables with their respective values.\n\nRun the application from CLI using:\n\n```bash\nFLASK_ENV="development" FLASK_APP="argus_backend:start_server" FLASK_DEBUG=1 CQLENG_ALLOW_SCHEMA_MANAGEMENT=1 flask run\n```\n\nOmit `FLASK_DEBUG` if running your own debugger (pdb, pycharm, vscode)\n',
-    'author': 'Alexey Kartashov',
-    'author_email': 'alexey.kartashov@scylladb.com',
-    'maintainer': 'None',
-    'maintainer_email': 'None',
-    'url': 'https://github.com/scylladb/argus',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.10,<4.0',
-}
-
-
-setup(**setup_kwargs)