benchmark-runner 1.0.789__py3-none-any.whl → 1.0.791__py3-none-any.whl

benchmark_runner/benchmark_operator/benchmark_operator_workloads_operations.py

@@ -70,10 +70,11 @@ class BenchmarkOperatorWorkloadsOperations:
         # get oc instance
         self._oc = self.get_oc(kubeadmin_password=self._kubeadmin_password)
         self._virtctl = Virtctl()
+        self._prometheus_result = {}
         # PrometheusSnapshot
         if self._enable_prometheus_snapshot:
             self._snapshot = PrometheusSnapshot(oc=self._oc, artifacts_path=self._run_artifacts_path, verbose=True)
-        self._prometheus_metrics_operation = PrometheusMetricsOperation()
+            self._prometheus_metrics_operation = PrometheusMetricsOperation()
         # Extract lso id for LSO workload
         if '_lso' in self._environment_variables_dict.get('workload'):
             self._oc.delete_available_released_pv()

benchmark_runner/benchmark_operator/hammerdb_pod.py

@@ -34,7 +34,8 @@ class HammerdbPod(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             self.__name = f"{self._workload.split('_')[0]}_{self._workload.split('_')[1]}"
             self.__database = self._workload.split('_')[2]
             if 'kata' in self._workload:
@@ -65,10 +66,11 @@ class HammerdbPod(BenchmarkOperatorWorkloadsOperations):
             self._oc.wait_for_ready(label='app=hammerdb_workload', workload=self.__workload_name)
             self.__status = self._oc.wait_for_pod_completed(label='app=hammerdb_workload', workload=self.__workload_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name, es_fetch_min_time=self.__es_fetch_min_time)
@@ -79,7 +81,7 @@ class HammerdbPod(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name), es_fetch_min_time=self.__es_fetch_min_time)
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, database=self.__database, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, database=self.__database, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=self._prometheus_result)
             # delete hammerdb
             self._oc.delete_pod_sync(
                 yaml=os.path.join(f'{self._run_artifacts_path}',  f'{self.__name}_{self.__database}.yaml'),

benchmark_runner/benchmark_operator/hammerdb_vm.py

@@ -33,7 +33,8 @@ class HammerdbVM(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             self.__name = f"{self._workload.split('_')[0]}_{self._workload.split('_')[1]}"
             self.__database = self._workload.split('_')[2]
             if self._run_type == 'test_ci':
@@ -51,10 +52,11 @@ class HammerdbVM(BenchmarkOperatorWorkloadsOperations):
             vm_name = self._create_vm_log(labels=[self.__workload_name])
             self.__status = self._oc.wait_for_vm_completed(workload=self.__workload_name, vm_name=vm_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name, es_fetch_min_time=self.__es_fetch_min_time)
@@ -65,7 +67,7 @@ class HammerdbVM(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name), es_fetch_min_time=self.__es_fetch_min_time)
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, database=self.__database, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, database=self.__database, prometheus_result=self._prometheus_result)
             self._oc.delete_vm_sync(
                 yaml=os.path.join(f'{self._run_artifacts_path}', f'{self.__name}_{self.__database}.yaml'),
                 vm_name=f'{self.__workload_name}-workload')

benchmark_runner/benchmark_operator/stressng_pod.py

@@ -30,7 +30,8 @@ class StressngPod(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             if 'kata' in self._workload:
                 self.__kind = 'kata'
                 self.__name = self._workload.replace('kata', 'pod')
@@ -48,10 +49,11 @@ class StressngPod(BenchmarkOperatorWorkloadsOperations):
             self._oc.wait_for_ready(label='app=stressng_workload', workload=self.__workload_name)
             self.__status = self._oc.wait_for_pod_completed(label='app=stressng_workload', workload=self.__workload_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name)
@@ -62,7 +64,7 @@ class StressngPod(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name))
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=self._prometheus_result)
             self._oc.delete_pod_sync(
                 yaml=os.path.join(f'{self._run_artifacts_path}', f'{self.__name}.yaml'),
                 pod_name=f'{self.__workload_name}-workload')

benchmark_runner/benchmark_operator/stressng_vm.py

@@ -29,7 +29,8 @@ class StressngVM(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             self.__name = self._workload
             if self._run_type == 'test_ci':
                 self.__es_index = 'stressng-test-ci-results'
@@ -44,10 +45,11 @@ class StressngVM(BenchmarkOperatorWorkloadsOperations):
             vm_name = self._create_vm_log(labels=[self.__workload_name])
             self.__status = self._oc.wait_for_vm_completed(workload=self.__workload_name, vm_name=vm_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name)
@@ -58,7 +60,7 @@ class StressngVM(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name))
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=self._prometheus_result)
             self._oc.delete_vm_sync(
                 yaml=os.path.join(f'{self._run_artifacts_path}', f'{self.__name}.yaml'),
                 vm_name=f'{self.__workload_name}-workload')

benchmark_runner/benchmark_operator/uperf_pod.py

@@ -30,7 +30,8 @@ class UperfPod(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             if 'kata' in self._workload:
                 self.__kind = 'kata'
                 self.__name = self._workload.replace('kata', 'pod')
@@ -61,10 +62,11 @@ class UperfPod(BenchmarkOperatorWorkloadsOperations):
             self._oc.wait_for_ready(label='app=uperf-bench-client', workload=self.__workload_name)
             self.__status = self._oc.wait_for_pod_completed(label='app=uperf-bench-client', workload=self.__workload_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name)
@@ -75,7 +77,7 @@ class UperfPod(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name))
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self.__kind, status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=self._prometheus_result)
             self._oc.delete_pod_sync(
                 yaml=os.path.join(f'{self._run_artifacts_path}', f'{self.__name}.yaml'),
                 pod_name=f'uperf-client')

benchmark_runner/benchmark_operator/uperf_vm.py

@@ -29,7 +29,8 @@ class UperfVM(BenchmarkOperatorWorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             self.__name = self._workload
             if self._run_type == 'test_ci':
                 self.__es_index = 'uperf-test-ci-results'
@@ -50,10 +51,11 @@ class UperfVM(BenchmarkOperatorWorkloadsOperations):
             vm_name = self._create_vm_log(labels=['uperf-server', 'uperf-client'])
             self.__status = self._oc.wait_for_vm_completed(workload=self.__workload_name, vm_name=vm_name)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # system metrics
             if environment_variables.environment_variables_dict['system_metrics']:
                 self.system_metrics_collector(workload=self.__workload_name)
@@ -64,7 +66,7 @@ class UperfVM(BenchmarkOperatorWorkloadsOperations):
                 ids = self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._oc.get_long_uuid(workload=self.__workload_name), timeout=10)
                 # update metadata
                 for id in ids:
-                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=prometheus_result)
+                    self._update_elasticsearch_index(index=self.__es_index, id=id, kind=self._environment_variables_dict.get('kind', ''), status=self.__status, run_artifacts_url=run_artifacts_url, prometheus_result=self._prometheus_result)
             self._oc.delete_vm_sync(yaml=os.path.join(f'{self._run_artifacts_path}', f'{self.__name}.yaml'),
                                     vm_name='uperf-server')
         except ElasticSearchDataNotUploaded as err:

benchmark_runner/workloads/bootstorm_vm.py

@@ -92,7 +92,9 @@ class BootstormVM(WorkloadsOperations):
         """
         if vm_node:
             delta = round((time.time() - self._bootstorm_start_time[vm_name]) * self.MILLISECONDS, 3)
-            return {'vm_name': vm_name, 'node': vm_node, 'bootstorm_time': delta, 'vm_ssh': int(bool(vm_node)),}
+            data = {'vm_name': vm_name, 'node': vm_node, 'bootstorm_time': delta, 'vm_ssh': int(bool(vm_node)),}
+            logger.info(data)
+            return data
         return {}
 
     def _create_vm_scale(self, vm_num: str):
@@ -113,13 +115,14 @@ class BootstormVM(WorkloadsOperations):
         self._status = 'complete' if self._data_dict else 'failed'
         # update total vm run time
         if not self._verification_only:
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+                self._data_dict.update(self._prometheus_result)
             total_run_time = self._get_bootstorm_vm_total_run_time()
             self._data_dict.update({'total_run_time': total_run_time})
-            self._data_dict.update(prometheus_result)
         # Google drive run_artifacts_url folder path
         if self._google_drive_path and self.get_run_artifacts_google_drive():
             self._data_dict.update({'run_artifacts_url': self.get_run_artifacts_google_drive()})
@@ -372,7 +375,8 @@ class BootstormVM(WorkloadsOperations):
         """
         Initialize prometheus start time, vm name, kind and create benchmark-runner namespace for bootstorm vms
         """
-        self._prometheus_metrics_operation.init_prometheus()
+        if self._enable_prometheus_snapshot:
+            self._prometheus_metrics_operation.init_prometheus()
         self._name = self._workload
         self._workload_name = self._workload.replace('_', '-')
         self._vm_name = f'{self._workload_name}-{self._trunc_uuid}'

benchmark_runner/workloads/vdbench_pod.py

@@ -6,7 +6,6 @@ from multiprocessing import Process
 from benchmark_runner.common.logger.logger_time_stamp import logger_time_stamp, logger
 from benchmark_runner.common.elasticsearch.elasticsearch_exceptions import ElasticSearchDataNotUploaded
 from benchmark_runner.workloads.workloads_operations import WorkloadsOperations
-from benchmark_runner.common.prometheus.prometheus_metrics_operations import PrometheusMetricsOperation
 
 
 class VdbenchPod(WorkloadsOperations):
@@ -58,16 +57,18 @@ class VdbenchPod(WorkloadsOperations):
             self._oc.wait_for_ready(label=f'app=vdbench-{self._trunc_uuid}-{pod_num}', label_uuid=False)
             self.__status = self._oc.wait_for_pod_completed(label=f'app=vdbench-{self._trunc_uuid}-{pod_num}', label_uuid=False, job=False)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # save run artifacts logs
             result_list = self._create_pod_run_artifacts(pod_name=f'{self.__pod_name}-{pod_num}', log_type='.csv')
             if self._es_host:
                 # upload several run results
                 for result in result_list:
-                    result.update(prometheus_result)
+                    if self._enable_prometheus_snapshot:
+                        result.update(self._prometheus_result)
                     self._upload_to_elasticsearch(index=self.__es_index, kind=self.__kind, status=self.__status, result=result)
                 # verify that data upload to elastic search according to unique uuid
                 self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._uuid)
@@ -94,7 +95,8 @@ class VdbenchPod(WorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             if 'kata' in self._workload:
                 self.__kind = 'kata'
                 self.__name = self._workload.replace('kata', 'pod')
@@ -119,16 +121,18 @@ class VdbenchPod(WorkloadsOperations):
                 self._oc.wait_for_ready(label=f'app=vdbench-{self._trunc_uuid}', label_uuid=False)
                 self.__status = self._oc.wait_for_pod_completed(label=f'app=vdbench-{self._trunc_uuid}', label_uuid=False, job=False)
                 self.__status = 'complete' if self.__status else 'failed'
-                # prometheus queries
-                self._prometheus_metrics_operation.finalize_prometheus()
-                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-                prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+                if self._enable_prometheus_snapshot:
+                    # prometheus queries
+                    self._prometheus_metrics_operation.finalize_prometheus()
+                    metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                    self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
                 # save run artifacts logs
                 result_list = self._create_pod_run_artifacts(pod_name=self.__pod_name, log_type='.csv')
                 if self._es_host:
                     # upload several run results
                     for result in result_list:
-                        result.update(prometheus_result)
+                        if self._enable_prometheus_snapshot:
+                            result.update(self._prometheus_result)
                         self._upload_to_elasticsearch(index=self.__es_index, kind=self.__kind, status=self.__status, result=result)
                     # verify that data upload to elastic search according to unique uuid
                     self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._uuid)

benchmark_runner/workloads/vdbench_vm.py

@@ -62,16 +62,18 @@ class VdbenchVM(WorkloadsOperations):
             self.__vm_name = self._create_vm_log(labels=[f'{self.__workload_name}-{self._trunc_uuid}-{vm_num}'])
             self.__status = self._oc.wait_for_vm_log_completed(vm_name=self.__vm_name, end_stamp=self.END_STAMP)
             self.__status = 'complete' if self.__status else 'failed'
-            # prometheus queries
-            self._prometheus_metrics_operation.finalize_prometheus()
-            metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-            prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+            if self._enable_prometheus_snapshot:
+                # prometheus queries
+                self._prometheus_metrics_operation.finalize_prometheus()
+                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
             # save run artifacts logs
             result_list = self._create_vm_run_artifacts(vm_name=f'{self.__workload_name}-{self._trunc_uuid}-{vm_num}', start_stamp=self.START_STAMP, end_stamp=self.END_STAMP, log_type='.csv')
             if self._es_host:
                 # upload several run results
                 for result in result_list:
-                    result.update(prometheus_result)
+                    if self._enable_prometheus_snapshot:
+                        result.update(self._prometheus_result)
                     self._upload_to_elasticsearch(index=self.__es_index, kind=self.__kind, status=self.__status, result=result)
                 # verify that data upload to elastic search according to unique uuid
                 self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._uuid)
@@ -101,7 +103,8 @@ class VdbenchVM(WorkloadsOperations):
         :return:
         """
         try:
-            self._prometheus_metrics_operation.init_prometheus()
+            if self._enable_prometheus_snapshot:
+                self._prometheus_metrics_operation.init_prometheus()
             self.__name = self._workload
             if self._run_type == 'test_ci':
                 self.__es_index = 'vdbench-test-ci-results'
@@ -122,14 +125,16 @@ class VdbenchVM(WorkloadsOperations):
                 self.__status = 'complete' if self.__status else 'failed'
                 # save run artifacts logs
                 result_list = self._create_vm_run_artifacts(vm_name=self.__vm_name, start_stamp=self.START_STAMP, end_stamp=self.END_STAMP, log_type='.csv')
-                # prometheus queries
-                self._prometheus_metrics_operation.finalize_prometheus()
-                metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
-                prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
+                if self._enable_prometheus_snapshot:
+                    # prometheus queries
+                    self._prometheus_metrics_operation.finalize_prometheus()
+                    metric_results = self._prometheus_metrics_operation.run_prometheus_queries()
+                    self._prometheus_result = self._prometheus_metrics_operation.parse_prometheus_metrics(data=metric_results)
                 if self._es_host:
                     # upload several run results
                     for result in result_list:
-                        result.update(prometheus_result)
+                        if self._enable_prometheus_snapshot:
+                            result.update(self._prometheus_result)
                         self._upload_to_elasticsearch(index=self.__es_index, kind=self.__kind, status=self.__status, result=result)
                     # verify that data upload to elastic search according to unique uuid
                     self._verify_elasticsearch_data_uploaded(index=self.__es_index, uuid=self._uuid)

benchmark_runner/workloads/workloads_operations.py

@@ -96,6 +96,7 @@ class WorkloadsOperations:
         self._virtctl = Virtctl()
 
         # Prometheus Snapshot
+        self._prometheus_result = {}
         if self._enable_prometheus_snapshot:
             self._snapshot = PrometheusSnapshot(oc=self._oc, artifacts_path=self._run_artifacts_path, verbose=True)
         self._prometheus_snap_interval = self._environment_variables_dict.get('prometheus_snap_interval', '')

{benchmark_runner-1.0.789.dist-info → benchmark_runner-1.0.791.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: benchmark-runner
-Version: 1.0.789
+Version: 1.0.791
 Summary: Benchmark Runner Tool
 Home-page: https://github.com/redhat-performance/benchmark-runner
 Author: Red Hat

{benchmark_runner-1.0.789.dist-info → benchmark_runner-1.0.791.dist-info}/RECORD

@@ -2,13 +2,13 @@ benchmark_runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 benchmark_runner/benchmark_operator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmark_runner/benchmark_operator/benchmark_operator_exceptions.py,sha256=5BCKcvLBMLFW4-XgZ7uXrja7uOE0UaplxAsdkKTpmek,1668
 benchmark_runner/benchmark_operator/benchmark_operator_workloads.py,sha256=dL09ni6x4yaNFHs5djEebe4KE7M4n_rupWH7ngHpJwc,1425
-benchmark_runner/benchmark_operator/benchmark_operator_workloads_operations.py,sha256=enJr5Syq1UFJAVPfUsFfBZ39IKqAgR7DoP3JYjkf1JU,25021
-benchmark_runner/benchmark_operator/hammerdb_pod.py,sha256=Xe3ZDHnbxQgUx9DAkjyeCI9rLqzuVV69GiC8J_FUvKc,8127
-benchmark_runner/benchmark_operator/hammerdb_vm.py,sha256=bG7nb07cL0GuB7-oxf3jFx8bkolD_MujYykUacWqJOM,5785
-benchmark_runner/benchmark_operator/stressng_pod.py,sha256=wOPjETpeUfS7Ey6bpmmYVQas9vtlmyujLf0swemaP4g,5268
-benchmark_runner/benchmark_operator/stressng_vm.py,sha256=QxYUQh6qTZKrg5sMYOAKQYEeDqWNRb6S_Mbgns08iPA,5077
-benchmark_runner/benchmark_operator/uperf_pod.py,sha256=Ak0RuBkPHebT1MUOByQsFIVf-fZ5jT7SBX11zznLr40,6000
-benchmark_runner/benchmark_operator/uperf_vm.py,sha256=Y01L8wEmsj5hVMHDxAJy5EULth47mRej5CVnWhhGvI0,5316
+benchmark_runner/benchmark_operator/benchmark_operator_workloads_operations.py,sha256=WLubpoEtKU6G1DJ45jRW4stQGLOx_K2jq66Fk7DY9zg,25062
+benchmark_runner/benchmark_operator/hammerdb_pod.py,sha256=3wrjXW0XZwhWKamk_Yw82ibo5RmTUva4rpmcVogXqF8,8257
+benchmark_runner/benchmark_operator/hammerdb_vm.py,sha256=0FhgEvfgbKwUyLEK3be9LYoishOkM4VZqhcTp6zIUr8,5915
+benchmark_runner/benchmark_operator/stressng_pod.py,sha256=4K8PGSv-OCfyBMelJjscVtsCtuvhEx1AuO0biewGF5Q,5398
+benchmark_runner/benchmark_operator/stressng_vm.py,sha256=WtnHxus-LCLZvAwg4NDc_ur2qQFPQMFPtplbj3cKThQ,5207
+benchmark_runner/benchmark_operator/uperf_pod.py,sha256=6_4fiZ8ZjNzgzc8qyVoXGL8kp4qRksI0dujE0NmSsCQ,6130
+benchmark_runner/benchmark_operator/uperf_vm.py,sha256=jiF-Fj_QoF86MOuOO4sboztTg_lIXhw7R0CF_cZLYHc,5446
 benchmark_runner/clusterbuster/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmark_runner/clusterbuster/clusterbuster_exceptions.py,sha256=KwtlsmnCDtbYX8mNoo1T4Djszz_kgc5aup-FUA_Y1SY,754
 benchmark_runner/clusterbuster/clusterbuster_workloads.py,sha256=Ep_jhk9T4NnOKDbWrxjHEaGNKnFFnMDnpm_ZcaOuJvk,6736
@@ -166,15 +166,15 @@ benchmark_runner/main/environment_variables_exceptions.py,sha256=UR0Ith0P0oshsDZ
 benchmark_runner/main/main.py,sha256=A744O550wQh37hhk10H0HlT28LZ_2EOaRlJyWG6Pras,14083
 benchmark_runner/main/temporary_environment_variables.py,sha256=ODSHkfhgvdr_b2e3XyvykW21MVjSdyqimREyMc2klRE,957
 benchmark_runner/workloads/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-benchmark_runner/workloads/bootstorm_vm.py,sha256=C0V4hfWSW_-kXLkC3MeW_Ie5myLfhDk3myu-e8eGhNs,19900
-benchmark_runner/workloads/vdbench_pod.py,sha256=OcmxVr5QlbkhAgY37wsZ7xJUjs9HI-qMVDex1HdL2P0,9778
-benchmark_runner/workloads/vdbench_vm.py,sha256=Yhoz-GbvZwA8q6qGIeSUsYhEIERj8SmJB1yjetwsGow,9449
+benchmark_runner/workloads/bootstorm_vm.py,sha256=ykpr__vdOPssp1E6Z3kGWuJbPhgLFMlWR7-ZdYy9ISY,20084
+benchmark_runner/workloads/vdbench_pod.py,sha256=feu3lvNumfBCD-An6__xS5Kt9nA50A_-0FmqTXuU9iw,10011
+benchmark_runner/workloads/vdbench_vm.py,sha256=4rRbE-jAbmNrhP-k8F_OREkJ59VfQ7wLrfRQPwDneJg,9786
 benchmark_runner/workloads/windows_vm.py,sha256=qFVD3qBFMnVpYXnrpam-7H5-0Yzvx6qtaEEZx4T-ex4,2415
 benchmark_runner/workloads/workloads.py,sha256=F9fnk4h715tq7ANSCbDH0jktB8fpr_u3YG61Kdi5_os,1422
 benchmark_runner/workloads/workloads_exceptions.py,sha256=u7VII95iPRF_YhfpGH1U1RmgiIYESMOtbSF1dz7_ToE,1858
-benchmark_runner/workloads/workloads_operations.py,sha256=nHwy61d-CyyW03HsgPJZ73SKuq2rY0aLaRL6R4V0eLc,25324
-benchmark_runner-1.0.789.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-benchmark_runner-1.0.789.dist-info/METADATA,sha256=WliGrtbb6nGLtemvwvmitKavx6ywUJjCowiKrHFJ_mg,11520
-benchmark_runner-1.0.789.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-benchmark_runner-1.0.789.dist-info/top_level.txt,sha256=MP7UbTCzu59D53uKCZl5VsQeM_vheyMc7FmryczJQbk,17
-benchmark_runner-1.0.789.dist-info/RECORD,,
+benchmark_runner/workloads/workloads_operations.py,sha256=788ZqnMsNHcU2jK8SXy5bJFrkDBJrHogzFWZeWQr8FQ,25361
+benchmark_runner-1.0.791.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+benchmark_runner-1.0.791.dist-info/METADATA,sha256=gXZ4irZCjjDt56XR8c9PcfeEEH33YU9kYDQuAKqxq2o,11520
+benchmark_runner-1.0.791.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+benchmark_runner-1.0.791.dist-info/top_level.txt,sha256=MP7UbTCzu59D53uKCZl5VsQeM_vheyMc7FmryczJQbk,17
+benchmark_runner-1.0.791.dist-info/RECORD,,