Only return predict result when all metrics have predict finished (#8)

Author: mrproliu

baseline/fetcher.py

@@ -169,7 +169,9 @@ def fetch_service_metrics_with_rangs(self, service_name: str, normal: bool, metr
 
         results = self.fetch_data(f"{self.base_address}/graphql", payload)['result']['results']
         if len(results) == 0:
+            logger.debug(f"No data found for {metric_name}(service: {service_name}) from {start} to {end}")
             return prev_data, 0
+        logger.debug(f"Fetch {len(results)} data points for {metric_name}(service: {service_name}) from {start} to {end}")
 
         if prev_data is None:
             df = pd.DataFrame()
@@ -213,7 +215,8 @@ def fetch_service_metrics_with_rangs(self, service_name: str, normal: bool, metr
                     df = pd.concat([df, pd.DataFrame([row])], ignore_index=True)
                     count += 1
             prev_data.df = df
-            logger.info(f"Fetched {count} data points for {metric_name}(service: {service_name}) from {min_date} to {max_date}")
+            logger.info(f"Fetched {count} data points for {metric_name}(service: {service_name}) from {min_date} to {max_date}, "
+                        f"original query time range({self.conf.server.down_sampling}): {start} to {end}")
             return prev_data, count
         elif prev_data.multiple is not None:
             df = prev_data.df
@@ -237,7 +240,8 @@ def fetch_service_metrics_with_rangs(self, service_name: str, normal: bool, metr
                     df = pd.concat([df, pd.DataFrame([row])])
                     count += 1
             prev_data.df = df
-            logger.info(f"Fetched {count} data points for {metric_name}(service: {service_name}) from {min_date} to {max_date}")
+            logger.info(f"Fetched {count} data points for {metric_name}(service: {service_name}) from {min_date} to {max_date}, "
+                        f"original query time range({self.conf.server.down_sampling}): {start} to {end}")
 
         return prev_data, count
 
@@ -258,6 +262,8 @@ def fetch_layer_services(self, layer: str) -> list[tuple[str, bool]]:
         names = []
         for service in services:
             names.append((service['label'], bool(service['normal'])))
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"Fetch {names} services from layer {layer}")
         return names
 
     def query_need_period(self) -> int:

baseline/query.py

@@ -66,12 +66,18 @@ async def queryPredictedMetrics(self, request: AlarmBaselineRequest, context):
         logger.info(
             f"receive query predict metrics query, total service with metrics count: {len(request.serviceMetricNames)}, "
             f"start time: {request.startTimeBucket}, end time: {request.endTimeBucket}, step: {request.step}")
+        # check the request metrics is supported
+        service_must_contains_metrics: dict[str, list[str]] = {}
+        for service_metrics in request.serviceMetricNames:
+            service_must_contains_metrics[service_metrics.serviceName] = list(set(service_metrics.metricNames).
+                                                                              intersection(self.support_metrics_names))
+
         if logger.isEnabledFor(logging.DEBUG):
             info = [{
                 'service': service_metrics.serviceName,
                 'metrics': [m for m in service_metrics.metricNames]
             } for service_metrics in request.serviceMetricNames]
-            logger.debug(f"total service with metrics: {info}")
+            logger.debug(f"total service with metrics ready to query: {info}")
 
         results: dict[str, dict[str, list[PredictMeterResult]]] = {}
         for serviceWithMetrics in request.serviceMetricNames:
@@ -93,6 +99,11 @@ async def queryPredictedMetrics(self, request: AlarmBaselineRequest, context):
             predictions = []
             for metric_name, result in metricsWithPredictValues.items():
                 predictions.append(convert_response_metrics(service, metric_name, result, request.step))
+
+            # if the predict metrics count not equals the request metrics count, we need to ignore it
+            if len(service_must_contains_metrics[service]) != len(predictions):
+                continue
+
             serviceMetrics.append(AlarmBaselineServiceMetric(
                 serviceName=service,
                 predictions=predictions