argus-alm 0.12.7__tar.gz → 0.12.8__tar.gz

{argus_alm-0.12.7 → argus_alm-0.12.8}/PKG-INFO

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

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/controller/api.py

@@ -4,7 +4,7 @@ import requests
 from flask import (
     Blueprint,
     g,
-    request
+    request, Response
 )
 from flask.json import jsonify
 from argus.backend.error_handlers import handle_api_exception
@@ -382,18 +382,21 @@ def test_info():
         "response": info
     }
 
-@bp.route("/test-results", methods=["GET"])
+@bp.route("/test-results", methods=["GET", "HEAD"])
 @api_login_required
 def test_results():
     test_id = request.args.get("testId")
     if not test_id:
         raise Exception("No testId provided")
     service = ResultsService()
-    info = service.get_results(test_id=UUID(test_id))
+    if request.method == 'HEAD':
+        exists = service.is_results_exist(test_id=UUID(test_id))
+        return Response(status=200 if exists else 404)
+    graphs, ticks = service.get_test_graphs(test_id=UUID(test_id))
 
     return {
         "status": "ok",
-        "response": info
+        "response": {"graphs": graphs, "ticks": ticks}
     }
 
 @bp.route("/test_run/comment/get", methods=["GET"])  # TODO: remove

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/controller/client_api.py

@@ -105,8 +105,4 @@ def run_finalize(run_type: str, run_id: str):
 @api_login_required
 def submit_results(run_type: str, run_id: str):
     payload = get_payload(request)
-    result = ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)
-    return {
-        "status": "ok",
-        "response": result
-    }
+    return ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/controller/testrun_api.py

@@ -8,6 +8,7 @@ from flask import (
 from argus.backend.error_handlers import handle_api_exception
 from argus.backend.models.web import ArgusTest
 from argus.backend.service.jenkins_service import JenkinsService
+from argus.backend.service.results_service import ResultsService
 from argus.backend.service.testrun import TestRunService
 from argus.backend.service.user import api_login_required
 from argus.backend.util.common import get_payload
@@ -67,7 +68,7 @@ def test_run_activity(run_id: str):
 @bp.route("/run/<string:test_id>/<string:run_id>/fetch_results", methods=["GET"])
 @api_login_required
 def fetch_results(test_id: str, run_id: str):
-    tables = TestRunService().fetch_results(test_id=UUID(test_id), run_id=UUID(run_id))
+    tables = ResultsService().get_run_results(test_id=UUID(test_id), run_id=UUID(run_id))
     return {
         "status": "ok",
         "tables": tables

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/models/result.py

@@ -1,14 +1,17 @@
 from cassandra.cqlengine import columns
 from cassandra.cqlengine.models import Model
 from cassandra.cqlengine.usertype import UserType
-from enum import Enum
 
+class BestResult(UserType):
+    date = columns.DateTime()
+    value = columns.Double()
+    run_id = columns.UUID()
 
-class Status(Enum):
-    PASS = 0
-    WARNING = 1
-    ERROR = 2
-
+class ValidationRules(UserType):
+    higher_is_better = columns.Boolean()
+    margin_percent = columns.Double()
+    margin_value = columns.Double()
+    limit = columns.Double()
 
 class ColumnMetadata(UserType):
     name = columns.Ascii()
@@ -22,10 +25,14 @@ class ArgusGenericResultMetadata(Model):
     name = columns.Text(required=True, primary_key=True)
     description = columns.Text()
     columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    validation_rules = columns.Map(key_type=columns.Ascii(), value_type=columns.List(value_type=columns.UserDefinedType(ValidationRules)))
+    best_results = columns.Map(key_type=columns.Ascii(), value_type=columns.UserDefinedType(BestResult))
     rows_meta = columns.List(value_type=columns.Ascii())
 
     def __init__(self, **kwargs):
         kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        kwargs["best_results"] = {k: [BestResult(**z) for z in v] for k, v in kwargs.pop('best_results', {}).items()}
+        kwargs["validation_rules"] = {k: ValidationRules(**v) for k, v in kwargs.pop('validation_rules', {}).items()}
         super().__init__(**kwargs)
 
     def update_if_changed(self, new_data: dict) -> None:
@@ -44,6 +51,10 @@ class ArgusGenericResultMetadata(Model):
                     if row not in self.rows_meta:
                         added_rows.append(row)
                 value = self.rows_meta + added_rows
+            elif field == "best_results":
+                value = {k: [BestResult(**z) for z in v] for k, v in value.items()}
+            elif field == "validation_rules":
+                value = {k: ValidationRules(**v) for k, v in value.items()}
             if getattr(self, field) != value:
                 setattr(self, field, value)
                 updated = True
@@ -60,4 +71,5 @@ class ArgusGenericResultData(Model):
     row = columns.Ascii(primary_key=True, index=True)
     sut_timestamp = columns.DateTime()  # for sorting
     value = columns.Double()
+    value_text = columns.Text()
     status = columns.Ascii()

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/plugins/sct/testrun.py

@@ -1,6 +1,6 @@
 from enum import Enum
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from dataclasses import dataclass, field
 from typing import Optional
 from uuid import UUID
@@ -254,8 +254,12 @@ class SCTTestRun(PluginModelBase):
     def sut_timestamp(self) -> float:
         """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
         scylla versions from the same day. It's not perfect, but we don't know exact version time."""
-        scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
-        return (datetime.strptime(scylla_package.date, '%Y%m%d').timestamp()
+        try:
+            scylla_package_upgraded = [package for package in self.packages if package.name == "scylla-server-upgraded"][0]
+        except IndexError:
+            scylla_package_upgraded = None
+        scylla_package = scylla_package_upgraded or [package for package in self.packages if package.name == "scylla-server"][0]
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').replace(tzinfo=timezone.utc).timestamp()
                 + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
 
 

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/service/client_service.py

@@ -79,9 +79,15 @@ class ClientService:
 
         return "Finalized"
 
-    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> dict[str, str]:
         model = self.get_model(run_type)
-        run = model.load_test_run(UUID(run_id))
+        try:
+            run = model.load_test_run(UUID(run_id))
+        except model.DoesNotExist:
+            return {"status": "error", "response": {
+            "exception": "DoesNotExist",
+            "arguments": [run_id]
+        }}
         existing_table = ArgusGenericResultMetadata.objects(test_id=run.test_id, name=results["meta"]["name"]).first()
         if existing_table:
             existing_table.update_if_changed(results["meta"])
@@ -98,4 +104,4 @@ class ClientService:
                                    sut_timestamp=sut_timestamp,
                                    **cell
                                    ).save()
-        return "Submitted"
+        return {"status": "ok", "message": "Results submitted"}

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/service/results_service.py

@@ -67,12 +67,12 @@ colors = [
 ]
 
 
-def get_sorted_data_for_column_and_row(data: List[Dict[str, Any]], column: str, row: str) -> List[Dict[str, Any]]:
+def get_sorted_data_for_column_and_row(data: List[ArgusGenericResultData], column: str, row: str) -> List[Dict[str, Any]]:
     return sorted([{"x": entry.sut_timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'),
                     "y": entry.value,
                     "id": entry.run_id}
-                   for entry in data if entry['column'] == column and entry['row'] == row],
-                  key=lambda x: x['x'])
+                   for entry in data if entry.column == column and entry.row == row],
+                  key=lambda point: point["x"])
 
 
 def get_min_max_y(datasets: List[Dict[str, Any]]) -> (float, float):
@@ -105,6 +105,9 @@ def round_datasets_to_min_max(datasets: List[Dict[str, Any]], min_y: float, max_
 def create_chartjs(table, data):
     graphs = []
     for column in table.columns_meta:
+        if column.type == "TEXT":
+            # skip text columns
+            continue
         datasets = [
             {"label": row,
              "borderColor": colors[idx % len(colors)],
@@ -118,7 +121,7 @@ def create_chartjs(table, data):
             continue
         options = copy.deepcopy(default_options)
         options["plugins"]["title"]["text"] = f"{table.name} - {column.name}"
-        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]"
+        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]" if column.unit else ""
         options["scales"]["y"]["min"] = min_y
         options["scales"]["y"]["max"] = max_y
         graphs.append({"options": options, "data":
@@ -126,15 +129,73 @@ def create_chartjs(table, data):
     return graphs
 
 
-class ResultsService:
+def calculate_graph_ticks(graphs: List[Dict]) -> dict[str, str]:
+    min_x, max_x = None, None
+
+    for graph in graphs:
+        for dataset in graph["data"]["datasets"]:
+            if not dataset["data"]:
+                continue
+            first_x = dataset["data"][0]["x"]
+            last_x = dataset["data"][-1]["x"]
+            if min_x is None or first_x < min_x:
+                min_x = first_x
+            if max_x is None or last_x > max_x:
+                max_x = last_x
+    return {"min": min_x[:10], "max": max_x[:10]}
 
-    def __init__(self, database_session=None):
-        self.session = database_session if database_session else ScyllaCluster.get_session()
 
-    def get_results(self, test_id: UUID):
+class ResultsService:
+    
+    def __init__(self):
+        self.cluster = ScyllaCluster.get()
+    
+    def _get_tables_metadata(self, test_id: UUID) -> list[ArgusGenericResultMetadata]:
+        query_fields = ["name", "description", "columns_meta", "rows_meta"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_metadata_v1 WHERE test_id = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self.cluster.session.execute(query=query, parameters=(test_id,))
+        return [ArgusGenericResultMetadata(**table) for table in tables_meta]
+
+    def get_run_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
+        query_fields = ["column", "row", "value", "value_text", "status"]
+        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(status) as ordering"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = self.cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
+            if not cells:
+                continue
+            cells = [dict(cell.items()) for cell in cells]
+            tables.append({'meta': {
+                'name': table.name,
+                'description': table.description,
+                'columns_meta': table.columns_meta,
+                'rows_meta': table.rows_meta,
+            },
+                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
+                'order': min([cell['ordering'] for cell in cells] or [0])})
+        return sorted(tables, key=lambda x: x['order'])
+
+    def get_test_graphs(self, test_id: UUID):
+        query_fields = ["run_id", "column", "row", "value", "status", "sut_timestamp"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND name = ? LIMIT 2147483647")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
         graphs = []
-        res = ArgusGenericResultMetadata.objects(test_id=test_id).all()
-        for table in res:
-            data = ArgusGenericResultData.objects(test_id=test_id, name=table.name).all()
+        for table in tables_meta:
+            data = self.cluster.session.execute(query=query, parameters=(test_id, table.name))
+            data = [ArgusGenericResultData(**cell) for cell in data]
+            if not data:
+                continue
             graphs.extend(create_chartjs(table, data))
-        return graphs
+        ticks = calculate_graph_ticks(graphs)
+        return graphs, ticks
+
+    def is_results_exist(self, test_id: UUID):
+        """Verify if results for given test id exist at all."""
+        return bool(ArgusGenericResultMetadata.objects(test_id=test_id).only(["name"]).limit(1))

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/backend/service/testrun.py

@@ -307,28 +307,6 @@ class TestRunService:
         }
         return response
 
-    def fetch_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
-        cluster = ScyllaCluster.get()
-        query_fields = ["column", "row", "value", "status"]
-        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(value) as ordering "
-                     f"FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
-        query = cluster.prepare(raw_query)
-        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
-        tables = []
-        for table in tables_meta:
-            cells = cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
-            if not cells:
-                continue
-            cells = [dict(cell.items()) for cell in cells]
-            tables.append({'meta': {
-                'name': table.name,
-                'description': table.description,
-                'columns_meta': table.columns_meta,
-                'rows_meta': table.rows_meta,
-            },
-                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
-                'order': min([cell['ordering'] for cell in cells] or [0])})
-        return sorted(tables, key=lambda x: x['order'])
 
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()

{argus_alm-0.12.7 → argus_alm-0.12.8}/argus/client/generic_result.py

@@ -7,6 +7,7 @@ class Status(Enum):
     PASS = auto()
     WARNING = auto()
     ERROR = auto()
+    UNSET = auto()
 
     def __str__(self):
         return self.name
@@ -16,6 +17,7 @@ class ResultType(Enum):
     INTEGER = auto()
     FLOAT = auto()
     DURATION = auto()
+    TEXT = auto()
 
     def __str__(self):
         return self.name
@@ -44,7 +46,7 @@ class ResultTableMeta(type):
             cls_instance.name = meta.name
             cls_instance.description = meta.description
             cls_instance.columns = meta.Columns
-            cls_instance.column_names = {column.name for column in cls_instance.columns}
+            cls_instance.column_types = {column.name: column.type for column in cls_instance.columns}
             cls_instance.rows = []
         return cls_instance
 
@@ -57,12 +59,13 @@ class Cell:
     status: Status
 
     def as_dict(self) -> dict:
-        return {
+        cell = {"value_text": self.value} if isinstance(self.value, str) else {"value": self.value}
+        cell.update({
             "column": self.column,
             "row": self.row,
-            "value": self.value,
             "status": str(self.status)
-        }
+        })
+        return cell
 
 
 @dataclass
@@ -94,6 +97,8 @@ class GenericResultTable(metaclass=ResultTableMeta):
         }
 
     def add_result(self, column: str, row: str, value: Union[int, float, str], status: Status):
-        if column not in self.column_names:
+        if column not in self.column_types:
             raise ValueError(f"Column {column} not found in the table")
+        if isinstance(value, str) and self.column_types[column] != ResultType.TEXT:
+            raise ValueError(f"Column {column} is not of type TEXT")
         self.results.append(Cell(column=column, row=row, value=value, status=status))

argus_alm-0.12.8/argus/client/generic_result_old.py

@@ -0,0 +1,143 @@
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Tuple, Union, Type
+from uuid import UUID
+from enum import Enum
+import json
+
+
+
+class Status(Enum):
+    PASS = 1
+    WARNING = 2
+    ERROR = 3
+
+
+class ResultType(Enum):
+    INTEGER = int
+    FLOAT = float
+    TEXT = str
+
+
+@dataclass
+class ColumnMetadata:
+    id: int
+    unit: str
+    type: ResultType
+
+
+@dataclass
+class Result:
+    value: Union[int, float, str]
+    status: Status
+
+
+class ResultTableMeta(type):
+    def __new__(cls, name, bases, dct):
+        cls_instance = super().__new__(cls, name, bases, dct)
+        meta = dct.get('Meta')
+
+        if meta:
+            cls_instance.table_name = meta.table_name
+            cls_instance.columns_map = {col_name: ColumnMetadata(id=col_id, unit=unit, type=result_type)
+                                        for col_name, (col_id, unit, result_type) in meta.Columns.items()}
+            cls_instance.rows_map = {row_name: row_id
+                                     for row_name, row_id in meta.Rows.items()}
+        return cls_instance
+
+
+class Row:
+    def __init__(self, columns_map: Dict[str, ColumnMetadata]):
+        self.columns_map = columns_map
+        self.data: Dict[str, Result] = {}
+
+    def __getitem__(self, column_name: str) -> Result:
+        return self.data[column_name]
+
+    def __setitem__(self, column_name: str, result: Result):
+        if column_name not in self.columns_map:
+            raise ValueError(f"Column name '{column_name}' not found in columns_map.")
+        column_metadata = self.columns_map[column_name]
+        if not isinstance(result.value, column_metadata.type.value):
+            raise ValueError(f"Value {result.value} for column '{column_name}' is not of type {column_metadata.type.name}")
+        self.data[column_name] = result
+
+
+@dataclass
+class BaseResultTable(metaclass=ResultTableMeta):
+    results: Dict[str, Row] = field(default_factory=dict)
+
+    def as_dict(self) -> dict:
+        results_list = []
+        for row_name, row in self.results.items():
+            row_id = self.rows_map.get(row_name)
+            for column_name, result in row.data.items():
+                column_metadata = self.columns_map.get(column_name)
+                results_list.append({
+                    "column_id": column_metadata.id,
+                    "row_id": row_id,
+                    "result": result.value,
+                    "status": result.status.value
+                })
+
+        meta_info = {
+            "table_name": self.table_name,
+            "columns": {name: {"id": meta.id, "unit": meta.unit, "type": meta.type.name} for name, meta in self.columns_map.items()},
+            "rows": self.rows_map
+        }
+        return {
+            "meta": meta_info,
+            "results": results_list
+        }
+
+    def to_json(self) -> str:
+        dict_result = self.as_dict()
+        return json.dumps(dict_result, default=str)
+
+    def __getitem__(self, row_name: str) -> Row:
+        if row_name not in self.rows_map:
+            raise ValueError(f"Row name '{row_name}' not found in rows_map.")
+        if row_name not in self.results:
+            self.results[row_name] = Row(self.columns_map)
+        return self.results[row_name]
+
+
+# Example of a specific result table with its own metadata
+class LatencyResultTable(BaseResultTable):
+    class Meta:
+        table_name = "latency_percentile_write"
+        Columns = {
+            "latency": (1, "ms", ResultType.FLOAT),
+            "op_rate": (2, "ops", ResultType.INTEGER)
+        }
+        Rows = {
+            "mean": 1,
+            "p99": 2
+        }
+
+
+# Client code example
+if __name__ == "__main__":
+    class LatencyResultTable(BaseResultTable):
+        class Meta:
+            table_name = "latency_percentile_write"
+            Columns = {
+                "latency": (1, "ms", ResultType.FLOAT),
+                "op_rate": (2, "ops", ResultType.INTEGER)
+            }
+            Rows = {
+                "mean": 1,
+                "p99": 2
+            }
+
+    result_table = LatencyResultTable()
+
+    result_table["mean"]["latency"] = Result(value=1.1, status=Status.WARNING)
+    result_table["mean"]["op_rate"] = Result(value=59988, status=Status.ERROR)
+    result_table["p99"]["latency"] = Result(value=2.7, status=Status.PASS)
+    result_table["p99"]["op_rate"] = Result(value=59988, status=Status.WARNING)
+
+    from argus.client.sct.client import ArgusSCTClient
+
+    run_id = UUID("24e09748-bba4-47fd-a615-bf7ea2c425eb")
+    client = ArgusSCTClient(run_id, auth_token="UO+2GXL9XqSgcVJijWk5WnbPXPit5ot5nfkLAHAr7SaqROfSCWycabpp/wxyY8+I", base_url="http://localhost:5000")
+    client.submit_results(result_table)

{argus_alm-0.12.7 → argus_alm-0.12.8}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "argus-alm"
-version = "0.12.7"
+version = "0.12.8"
 description = "Argus"
-authors = ["Alexey Kartashov <alexey.kartashov@scylladb.com>"]
+authors = ["Alexey Kartashov <alexey.kartashov@scylladb.com>", "Łukasz Sójka <lukasz.sojka@scylladb.com>"]
 license = "Apache-2.0"
 repository = "https://github.com/scylladb/argus"
 readme = "README.md"