async query()

in src/datasource.ts [56:155]

• 97 lines of code
• 24 McCabe index (conditional complexity)

  async query(options: DataQueryRequest<MyQuery>): Promise<DataQueryResponse> {
    const { range } = options;
    const from = range!.from.valueOf();
    const to = range!.to.valueOf();
    const  v =  {
      query: Fragments.utc,
      variables: {},
    };
    const resp = await this.doRequest(v);
    const utc = resp.data.getTimeInfo.timezone / 100;
    const dates = this.timeFormat([this.getLocalTime(utc, new Date(from)), this.getLocalTime(utc, new Date(to))]);
    const duration = {
      start: this.dateFormatStep(dates.start, dates.step),
      end: this.dateFormatStep(dates.end, dates.step),
      step: dates.step,
    };
    const promises = options.targets.map(async (target) => {
      const query = defaults(target, DEFAULT_QUERY);
      const layer = getTemplateSrv().replace(query.layer, options.scopedVars);
      const serviceName = getTemplateSrv().replace(query.service, options.scopedVars);
      if (!layer && !serviceName) {
        return [];
      }
      const nodeMetricsStr = getTemplateSrv().replace(query.nodeMetrics, options.scopedVars);
      const nodeMetrics = nodeMetricsStr ? this.parseMetrics(nodeMetricsStr) : [];
      const edgeMetricsStr = getTemplateSrv().replace(query.edgeMetrics, options.scopedVars);
      const edgeMetrics = edgeMetricsStr ? this.parseMetrics(edgeMetricsStr) : [];
      let services = [];
      // fetch services from api
      const  s =  {
        query: Fragments.services,
        variables: {duration, keyword: ''},
      };
      const resp = await this.doRequest(s);
      services = resp.data.services || [];

      const t: {
        query: string;
        variables: Recordable;
      } = {
        query: Fragments.servicesTopolgy,
        variables: { duration },
      };
      let serviceObj;
      if (serviceName) {
        serviceObj = services.filter((d: {name: string, id: string}) => d.name === serviceName);
      } else {
        serviceObj = services.filter((d: {layers: string[], id: string}) => d.layers.includes(layer));
      }
      t.variables.serviceIds = serviceObj.map((d: {layers: string[], id: string}) => d.id);
      // fetch topology data from api
      const res = await this.doRequest(t);
      const {nodes, calls} = this.setTopologyData({nodes: res.data.topology.nodes || [],  calls: res.data.topology.calls || []});
      const idsS = calls.filter((i: Call) => i.detectPoints.includes('SERVER')).map((b: Call) => b.id);
      const idsC = calls.filter((i: Call) => i.detectPoints.includes('CLIENT')).map((b: Call) => b.id);
      const serverMetrics = [];
      const clientMetrics = [];
      for (const m of edgeMetrics) {
        if (m.type === 'SERVER') {
          serverMetrics.push(m);
        } else {
          clientMetrics.push(m);
        }
      }
      const ids = nodes.map((d: Node) => d.id);
      // fetch topology metrics from api
      const nodeMetricsResp = nodeMetrics.length ? await this.queryMetrics(nodeMetrics, ids, duration) : null;
      const edgeServerMetricsResp = serverMetrics.length && idsS.length ? await this.queryMetrics(serverMetrics, idsS, duration) : null;
      const edgeClientMetricsResp = clientMetrics.length && idsC.length ? await this.queryMetrics(clientMetrics, idsC, duration) : null;
      const edgeMetricsResp: any = (edgeServerMetricsResp || edgeClientMetricsResp) ? {
        data: {...(edgeServerMetricsResp && edgeServerMetricsResp.data || {}), ...(edgeClientMetricsResp && edgeClientMetricsResp.data || {})}
      } : null;
      const fieldTypes = this.setFieldTypes({
        nodes,
        calls,
        nodeMetrics: nodeMetricsResp ? {...nodeMetricsResp, config: nodeMetrics} : undefined,
        edgeMetrics: edgeMetricsResp ? {...edgeMetricsResp, config: edgeMetrics} : undefined,
      });
      const nodeFrame =  new MutableDataFrame({
        name: 'Nodes',
        refId: target.refId,
        fields: fieldTypes.nodeFieldTypes,
        meta: {
          preferredVisualisationType: 'nodeGraph',
        }
      });
      const edgeFrame =  new MutableDataFrame({
        name: 'Edges',
        refId: target.refId,
        fields: fieldTypes.edgeFieldTypes,
        meta: {
          preferredVisualisationType: 'nodeGraph',
        }
      });

      return [nodeFrame, edgeFrame];
    });

    return Promise.all(promises).then(data => ({ data: data[0] }));
  }