argus-alm 0.11.3__py3-none-any.whl → 0.11.6__py3-none-any.whl

argus/backend/controller/api.py

@@ -472,3 +472,15 @@ def resolve_artifact_size():
             "artifactSize": length,
         }
     }
+
+
+@bp.route("/user/jobs")
+@api_login_required
+def user_jobs():
+    service = ArgusService()
+    result = list(service.get_jobs_for_user(user=g.user))
+
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/controller/main.py

@@ -241,9 +241,7 @@ def update_password():
 @bp.route("/profile/jobs", methods=["GET"])
 @login_required
 def profile_jobs():
-    service = ArgusService()
-    jobs = service.get_jobs_for_user(g.user)
-    return render_template("profile_jobs.html.j2", runs=jobs)
+    return render_template("profile_jobs.html.j2")
 
 
 @bp.route("/profile/schedules", methods=["GET"])

argus/backend/controller/team.py

@@ -107,7 +107,7 @@ def user_teams(user_id: str):
 @api_login_required
 def user_jobs(user_id: str):
     user = User.get(id=UUID(user_id))
-    result = ArgusService().get_jobs_for_user(user)
+    result = list(ArgusService().get_jobs_for_user(user))
 
     return {
         "status": "ok",

argus/backend/controller/testrun_api.py

@@ -269,3 +269,19 @@ def sct_terminate_stuck_runs():
             "total": result
         }
     }
+
+
+@bp.route("/ignore_jobs", methods=["POST"])
+@api_login_required
+def ignore_jobs():
+    payload = get_payload(request)
+    service = TestRunService()
+
+    result = service.ignore_jobs(test_id=payload["testId"], reason=payload["reason"])
+
+    return {
+        "status": "ok",
+        "response": {
+            "affectedJobs": result
+        }
+    }

argus/backend/events/event_processors.py

@@ -30,4 +30,5 @@ EVENT_PROCESSORS = {
     ArgusEventTypes.TestRunIssueAdded: event_process_issue_added,
     ArgusEventTypes.TestRunIssueRemoved: event_process_issue_added,
     ArgusEventTypes.TestRunInvestigationStatusChanged: event_process_investigation_status_changed,
+    ArgusEventTypes.TestRunBatchInvestigationStatusChange: event_process_investigation_status_changed,
 }

argus/backend/models/web.py

@@ -190,6 +190,7 @@ class ArgusEventTypes(str, Enum):
     AssigneeChanged = "ARGUS_ASSIGNEE_CHANGE"
     TestRunStatusChanged = "ARGUS_TEST_RUN_STATUS_CHANGE"
     TestRunInvestigationStatusChanged = "ARGUS_TEST_RUN_INVESTIGATION_STATUS_CHANGE"
+    TestRunBatchInvestigationStatusChange = "ARGUS_TEST_RUN_INVESTIGATION_BATCH_STATUS_CHANGE"
     TestRunCommentPosted = "ARGUS_TEST_RUN_COMMENT_POSTED"
     TestRunCommentUpdated = "ARGUS_TEST_RUN_COMMENT_UPDATED"
     TestRunCommentDeleted = "ARGUS_TEST_RUN_COMMENT_DELETED"

argus/backend/plugins/core.py

@@ -109,11 +109,27 @@ class PluginModelBase(Model):
     def get_jobs_assigned_to_user(cls, user: User):
         cluster = ScyllaCluster.get()
         query = cluster.prepare("SELECT build_id, start_time, release_id, group_id, assignee, "
-                                f"test_id, id, status, investigation_status, build_job_url FROM {cls.table_name()} WHERE assignee = ?")
+                                f"test_id, id, status, investigation_status, build_job_url, scylla_version FROM {cls.table_name()} WHERE assignee = ?")
         rows = cluster.session.execute(query=query, parameters=(user.id,))
 
         return list(rows)
 
+    @classmethod
+    def get_jobs_meta_by_test_id(cls, test_id: UUID):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(f"SELECT build_id, start_time, id, test_id, release_id, group_id, status, investigation_status FROM {cls.table_name()} WHERE test_id = ?")
+        rows = cluster.session.execute(query=query, parameters=(test_id,))
+
+        return list(rows)
+
+    @classmethod
+    def prepare_investigation_status_update_query(cls, build_id: str, start_time: datetime, new_status: TestInvestigationStatus):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare(f"UPDATE {cls.table_name()} SET investigation_status = ? WHERE build_id = ? AND start_time = ?")
+        bound_query = query.bind(values=(new_status.value, build_id, start_time))
+
+        return bound_query
+
     @classmethod
     def get_stats_for_release(cls, release: ArgusRelease):
         cluster = ScyllaCluster.get()

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/backend/plugins/sct/controller.py

@@ -31,6 +31,23 @@ def sct_submit_screenshots(run_id: str):
     }
 
 
+@bp.route("/<string:run_id>/sct_runner/set", methods=["POST"])
+@api_login_required
+def sct_set_runner(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.set_sct_runner(
+        run_id=run_id,
+        public_ip=payload["public_ip"],
+        private_ip=payload["private_ip"],
+        region=payload["region"],
+        backend=payload["backend"]
+    )
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
 @bp.route("/<string:run_id>/resource/create", methods=["POST"])
 @api_login_required
 def sct_resource_create(run_id: str):
@@ -97,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/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/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__)
 
@@ -60,6 +68,24 @@ class SCTService:
 
         return "added"
 
+
+    @staticmethod
+    def set_sct_runner(run_id: str, public_ip: str, private_ip: str, region: str, backend: str):
+        try:
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            run.sct_runner_host = CloudInstanceDetails(
+                public_ip=public_ip,
+                private_ip=private_ip,
+                provider=backend,
+                region=region,
+            )
+            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 "updated"
+
     @staticmethod
     def submit_screenshots(run_id: str, screenshot_links: list[str]) -> str:
         try:
@@ -73,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/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,24 +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
-        primary_region = regions[0]
-
-        run.cloud_setup = ResourceSetup.get_resource_setup(backend=backend, sct_config=req.sct_config)
+        return run
 
-        run.sct_runner_host = CloudInstanceDetails(
-            public_ip=req.runner_public_ip,
-            private_ip=req.runner_private_ip,
-            provider=backend,
-            region=primary_region,
-        )
+    @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/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/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()