Fix bug 1258: metrics not properly collected in some Openstacks

[osm/MON.git] / osm_mon / collector / vnf_collectors / openstack.py

diff --git a/osm_mon/collector/vnf_collectors/openstack.py b/osm_mon/collector/vnf_collectors/openstack.py
index 1bb0fc8..df0424b 100644 (file)
--- a/osm_mon/collector/vnf_collectors/openstack.py
+++ b/osm_mon/collector/vnf_collectors/openstack.py
@@ -123,25 +123,33 @@ class OpenstackCollector(BaseVimCollector):
                             vdur['name'], vnf_member_index, nsr_id)
                         continue
                     try:
+                        log.info("Collecting metric type: %s and metric_name: %s and resource_id %s and "
+                                 "interface_name: %s", metric_type, metric_name, resource_id, interface_name)
                         value = self.backend.collect_metric(metric_type, openstack_metric_name, resource_id,
                                                             interface_name)
                         if value is not None:
+                            log.info("value: %s", value)
                             if interface_name:
                                 tags['interface'] = interface_name
                             metric = VnfMetric(nsr_id, vnf_member_index, vdur['name'], metric_name, value, tags)
                             metrics.append(metric)
-                    except Exception:
+                        else:
+                            log.info("metric value is empty")
+                    except Exception as e:
                         log.exception("Error collecting metric %s for vdu %s" % (metric_name, vdur['name']))
+                        log.info("Error in metric collection: %s" % e)
         return metrics
 
     def _get_backend(self, vim_account: dict):
         try:
             ceilometer = CeilometerBackend(vim_account)
             ceilometer.client.capabilities.get()
+            log.info("Using ceilometer backend to collect metric")
             return ceilometer
         except (HTTPException, EndpointNotFound):
             gnocchi = GnocchiBackend(vim_account)
             gnocchi.client.metric.list(limit=1)
+            log.info("Using gnocchi backend to collect metric")
             return gnocchi
 
     def _get_metric_type(self, metric_name: str, interface_name: str) -> MetricType:
@@ -224,17 +232,36 @@ class GnocchiBackend(OpenstackBackend):
         try:
             aggregation = METRIC_AGGREGATORS.get(openstack_metric_name)
 
-            measures = self.client.metric.get_measures(openstack_metric_name,
-                                                       aggregation=aggregation,
-                                                       start=time.time() - 1200,
-                                                       resource_id=resource_id)
-            # measures[-1][0] is the time of the reporting interval
-            # measures[-1][1] is the durcation of the reporting interval
-            # measures[-1][2] is the value of the metric
-            if measures:
-                value = measures[-1][2]
+            try:
+                measures = self.client.metric.get_measures(openstack_metric_name,
+                                                           aggregation=aggregation,
+                                                           start=time.time() - 1200,
+                                                           resource_id=resource_id)
+                if measures:
+                    value = measures[-1][2]
+            except gnocchiclient.exceptions.NotFound as e:
+                # CPU metric in previous Openstack versions do not support rate:mean aggregation method
+                if openstack_metric_name == "cpu":
+                    log.debug("No metric %s found for instance %s: %s", openstack_metric_name, resource_id, e)
+                    log.debug("Retrying to get metric %s for instance %s without aggregation",
+                              openstack_metric_name, resource_id)
+                    measures = self.client.metric.get_measures(openstack_metric_name,
+                                                               resource_id=resource_id,
+                                                               limit=1)
+                else:
+                    raise e
+                # measures[-1] is the last measure
+                # measures[-2] is the previous measure
+                # measures[x][2] is the value of the metric
+                if measures and len(measures) >= 2:
+                    value = measures[-1][2] - measures[-2][2]
+            if value:
+                # measures[-1][0] is the time of the reporting interval
+                # measures[-1][1] is the duration of the reporting interval
                 if aggregation:
                     # If this is an aggregate, we need to divide the total over the reported time period.
+                    # Even if the aggregation method is not supported by Openstack, the code will execute it
+                    # because aggregation is specified in METRIC_AGGREGATORS
                     value = value / measures[-1][1]
                 if openstack_metric_name in METRIC_MULTIPLIERS:
                     value = value * METRIC_MULTIPLIERS[openstack_metric_name]