benchmark-runner 1.0.789__tar.gz → 1.0.791__tar.gz

{benchmark_runner-1.0.789/benchmark_runner.egg-info → benchmark_runner-1.0.791}/PKG-INFO

@@ -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 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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-1.0.789 → benchmark_runner-1.0.791}/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 → benchmark_runner-1.0.791/benchmark_runner.egg-info}/PKG-INFO

@@ -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 → benchmark_runner-1.0.791}/setup.py

@@ -4,7 +4,7 @@ from os import path
 from setuptools import setup, find_packages
 
 
-__version__ = '1.0.789'  # update also .bumpversion.cfg
+__version__ = '1.0.791'  # update also .bumpversion.cfg
 
 
 here = path.abspath(path.dirname(__file__))