Cloudwatch: Fix duplicate metric data (#28642)

* Cloudwatch: Fix duplicate metric data

* Refactor reduce function to for of

public/app/plugins/datasource/cloudwatch/datasource.test.ts

-import { CloudWatchDatasource } from './datasource';
-import { TemplateSrv } from '../../../features/templating/template_srv';
+import { DataQueryResponse, dateTime, DefaultTimeRange } from '@grafana/data';
 import { setBackendSrv } from '@grafana/runtime';
-import { DataQueryResponse, DefaultTimeRange } from '@grafana/data';
+import { TemplateSrv } from '../../../features/templating/template_srv';
+import { CloudWatchDatasource } from './datasource';
 
 describe('datasource', () => {
   describe('query', () => {
@@ -35,6 +35,33 @@ describe('datasource', () => {
     });
   });
 
+  describe('performTimeSeriesQuery', () => {
+    it('should return the same length of data as result', async () => {
+      const { datasource } = setup();
+      const awsRequestMock = jest.spyOn(datasource, 'awsRequest');
+      const buildCloudwatchConsoleUrlMock = jest.spyOn(datasource, 'buildCloudwatchConsoleUrl');
+      buildCloudwatchConsoleUrlMock.mockImplementation(() => '');
+      awsRequestMock.mockImplementation(async () => {
+        return {
+          results: {
+            a: { refId: 'a', series: [{ name: 'cpu', points: [1, 1] }], meta: { gmdMeta: '' } },
+            b: { refId: 'b', series: [{ name: 'memory', points: [2, 2] }], meta: { gmdMeta: '' } },
+          },
+        };
+      });
+      const response: DataQueryResponse = await datasource.performTimeSeriesQuery(
+        {
+          queries: [
+            { datasourceId: 1, refId: 'a' },
+            { datasourceId: 1, refId: 'b' },
+          ],
+        } as any,
+        { from: dateTime(), to: dateTime() } as any
+      );
+      expect(response.data.length).toEqual(2);
+    });
+  });
+
   describe('describeLogGroup', () => {
     it('replaces region correctly in the query', async () => {
       const { datasource, datasourceRequestMock } = setup();

public/app/plugins/datasource/cloudwatch/datasource.ts

@@ -595,26 +595,23 @@ export class CloudWatchDatasource extends DataSourceApi<CloudWatchQuery, CloudWa
         return { data: [] };
       }
 
-      return Object.values(request.queries).reduce(
-        ({ data, error }: any, queryRequest: any) => {
-          const queryResult = res.results[queryRequest.refId];
+      const data = dataframes.map(frame => {
+        const queryResult = res.results[frame.refId!];
+        const error = queryResult.error ? { message: queryResult.error } : null;
         if (!queryResult) {
-            return { data, error };
+          return { frame, error };
         }
 
+        const requestQuery = request.queries.find(q => q.refId === frame.refId!) as any;
+
         const link = this.buildCloudwatchConsoleUrl(
-            queryRequest,
+          requestQuery!,
           from.toISOString(),
           to.toISOString(),
-            queryRequest.refId,
+          frame.refId!,
           queryResult.meta.gmdMeta
         );
 
-          return {
-            error: error || queryResult.error ? { message: queryResult.error } : null,
-            data: [
-              ...data,
-              ...dataframes.map(frame => {
         if (link) {
           for (const field of frame.fields) {
             field.config.links = [
@@ -626,13 +623,17 @@ export class CloudWatchDatasource extends DataSourceApi<CloudWatchQuery, CloudWa
             ];
           }
         }
-                return frame;
-              }),
-            ],
+        return { frame, error };
+      });
+
+      return {
+        data: data.map(o => o.frame),
+        error: data
+          .map(o => o.error)
+          .reduce((err, error) => {
+            return err || error;
+          }, null),
       };
-        },
-        { data: [], error: null }
-      );
     } catch (err) {
       if (/^Throttling:.*/.test(err.data.message)) {
         const failedRedIds = Object.keys(err.data.results);