Handle db connection response on the backend

src/datasource-zabbix/datasource.ts

@@ -15,8 +15,18 @@ import problemsHandler from './problemsHandler';
 import { Zabbix } from './zabbix/zabbix';
 import { ZabbixAPIError } from './zabbix/connectors/zabbix_api/zabbixAPIConnector';
 import { ZabbixMetricsQuery, ZabbixDSOptions, VariableQueryTypes, ShowProblemTypes, ProblemDTO } from './types';
-import { getBackendSrv, getTemplateSrv, toDataQueryError, toDataQueryResponse } from '@grafana/runtime';
-import { DataFrame, DataQueryRequest, DataQueryResponse, DataSourceApi, DataSourceInstanceSettings, FieldType, isDataFrame, LoadingState } from '@grafana/data';
+import {BackendSrvRequest, getBackendSrv, getTemplateSrv, toDataQueryError, toDataQueryResponse} from '@grafana/runtime';
+import {
+  DataFrame,
+  dataFrameFromJSON,
+  DataQueryRequest,
+  DataQueryResponse,
+  DataSourceApi,
+  DataSourceInstanceSettings,
+  FieldType,
+  isDataFrame,
+  LoadingState
+} from '@grafana/data';
 
 export class ZabbixDatasource extends DataSourceApi<ZabbixMetricsQuery, ZabbixDSOptions> {
   name: string;
@@ -284,36 +294,58 @@ export class ZabbixDatasource extends DataSourceApi<ZabbixMetricsQuery, ZabbixDS
       console.log(`Datasource::Performance Query Time (${this.name}): ${queryEnd - queryStart}`);
     }
 
-    const valueMappings = await this.zabbix.getValueMappings();
-
-    const dataFrames = result.map(s => responseHandler.seriesToDataFrame(s, target, valueMappings));
-    return dataFrames;
+    const frames = [];
+    for (const frameJSON of result) {
+      const frame = dataFrameFromJSON(frameJSON);
+      frames.push(frame);
+    }
+    return frames;
+    // const valueMappings = await this.zabbix.getValueMappings();
+    //
+    // const dataFrames = (result as any).map(s => responseHandler.seriesToDataFrame(s, target, valueMappings));
+    // return dataFrames;
   }
 
   /**
    * Query history for numeric items
    */
-  queryNumericDataForItems(items, target: ZabbixMetricsQuery, timeRange, useTrends, options) {
-    let getHistoryPromise;
+  async queryNumericDataForItems(items, target: ZabbixMetricsQuery, timeRange, useTrends, options) {
+    let history;
     options.valueType = this.getTrendValueType(target);
     options.consolidateBy = getConsolidateBy(target) || options.valueType;
     const disableDataAlignment = this.disableDataAlignment || target.options?.disableDataAlignment;
 
     if (useTrends) {
-      getHistoryPromise = this.zabbix.getTrends(items, timeRange, options)
-      .then(timeseries => {
-        return !disableDataAlignment ? this.fillTrendTimeSeriesWithNulls(timeseries) : timeseries;
-      });
+      history = await this.zabbix.getTrends(items, timeRange, options);
+      // .then(timeseries => {
+      //   return !disableDataAlignment ? this.fillTrendTimeSeriesWithNulls(timeseries) : timeseries;
+      // });
     } else {
-      getHistoryPromise = this.zabbix.getHistoryTS(items, timeRange, options)
-      .then(timeseries => {
-        return !disableDataAlignment ? this.alignTimeSeriesData(timeseries) : timeseries;
-      });
+      history = await this.zabbix.getHistoryTS(items, timeRange, options);
+      // .then(timeseries => {
+      //   return !disableDataAlignment ? this.alignTimeSeriesData(timeseries) : timeseries;
+      // });
     }
 
-    return getHistoryPromise
-    .then(timeseries => this.applyDataProcessingFunctions(timeseries, target))
-    .then(timeseries => downsampleSeries(timeseries, options));
+    const requestOptions: BackendSrvRequest = {
+      url: `/api/datasources/${this.datasourceId}/resources/db-connection-post`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      hideFromInspector: false,
+      data: {
+        query: target,
+        series: history,
+      },
+    };
+
+    const response: any = await getBackendSrv().fetch<any>(requestOptions).toPromise();
+    return response.data;
+
+    // return getHistoryPromise
+    // .then(timeseries => this.applyDataProcessingFunctions(timeseries, target))
+    // .then(timeseries => downsampleSeries(timeseries, options));
   }
 
   getTrendValueType(target) {
@@ -453,10 +485,10 @@ export class ZabbixDatasource extends DataSourceApi<ZabbixMetricsQuery, ZabbixDS
     return this.zabbix.getItemsByIDs(itemids)
     .then(items => {
       return this.queryNumericDataForItems(items, target, timeRange, useTrends, options);
-    })
-    .then(result => {
-      return result.map(s => responseHandler.seriesToDataFrame(s, target));
     });
+    // .then(result => {
+    //   return (result as any).map(s => responseHandler.seriesToDataFrame(s, target));
+    // });
   }
 
   /**

src/datasource-zabbix/responseHandler.ts

@@ -2,7 +2,19 @@ import _ from 'lodash';
 import TableModel from 'grafana/app/core/table_model';
 import * as c from './constants';
 import * as utils from './utils';
-import { ArrayVector, DataFrame, Field, FieldType, MutableDataFrame, MutableField, TIME_SERIES_TIME_FIELD_NAME, TIME_SERIES_VALUE_FIELD_NAME } from '@grafana/data';
+import {
+  ArrayVector,
+  DataFrame,
+  dataFrameFromJSON,
+  DataFrameJSON,
+  Field,
+  FieldType,
+  getTimeField,
+  MutableDataFrame,
+  MutableField,
+  TIME_SERIES_TIME_FIELD_NAME,
+  TIME_SERIES_VALUE_FIELD_NAME,
+} from '@grafana/data';
 import { ZabbixMetricsQuery } from './types';
 
 /**
@@ -141,6 +153,51 @@ export function seriesToDataFrame(timeseries, target: ZabbixMetricsQuery, valueM
   return mutableFrame;
 }
 
+export function dataResponseToTimeSeries(response: DataFrameJSON[], items) {
+  const series = [];
+  if (response.length === 0) {
+    return [];
+  }
+
+  for (const frameJSON of response) {
+    const frame = dataFrameFromJSON(frameJSON);
+    const { timeField, timeIndex } = getTimeField(frame);
+    for (let i = 0; i < frame.fields.length; i++) {
+      const field = frame.fields[i];
+      if (i === timeIndex || !field.values || !field.values.length) {
+        continue;
+      }
+
+      const s = [];
+      for (let j = 0; j < field.values.length; j++) {
+        const v = field.values.get(j);
+        if (v !== null) {
+          s.push({ time: timeField.values.get(j) / 1000, value: v });
+        }
+      }
+
+      const itemid = field.name;
+      const item = _.find(items, {'itemid': itemid});
+      let interval = utils.parseItemInterval(item.delay);
+      if (interval === 0) {
+        interval = null;
+      }
+      const timeSeriesData = {
+        ts: s,
+        meta: {
+          name: item.name,
+          item,
+          interval,
+        }
+      };
+
+      series.push(timeSeriesData);
+    }
+  }
+
+  return series;
+}
+
 export function isConvertibleToWide(data: DataFrame[]): boolean {
   if (!data || data.length < 2) {
     return false;
@@ -441,6 +498,7 @@ export default {
   handleTriggersResponse,
   sortTimeseries,
   seriesToDataFrame,
+  dataResponseToTimeSeries,
   isConvertibleToWide,
   convertToWide,
   alignFrames,

src/datasource-zabbix/zabbix/connectors/dbConnector.js

@@ -1,5 +1,6 @@
 import _ from 'lodash';
 import { getDataSourceSrv } from '@grafana/runtime';
+import responseHandler from "../../responseHandler";
 
 export const DEFAULT_QUERY_LIMIT = 10000;
 export const HISTORY_TO_TABLE_MAP = {
@@ -92,10 +93,6 @@ export class DBConnector {
   getTrends() {
     throw new ZabbixNotImplemented('getTrends()');
   }
-
-  handleGrafanaTSResponse(history, items, addHostName = true) {
-    return convertGrafanaTSResponse(history, items, addHostName);
-  }
 }
 
 // Define Zabbix DB Connector exception type for non-implemented methods
@@ -111,6 +108,12 @@ export class ZabbixNotImplemented {
   }
 }
 
+export function handleDBDataSourceResponse(response, items) {
+  const series = responseHandler.dataResponseToTimeSeries(response, items);
+  // return convertGrafanaTSResponse(series, items, addHostName);
+  return series;
+}
+
 /**
  * Converts time series returned by the data source into format that Grafana expects
  * time_series is Array of series:
@@ -121,7 +124,11 @@ export class ZabbixNotImplemented {
  * }]
  * ```
  */
-function convertGrafanaTSResponse(time_series, items, addHostName) {
+export function convertGrafanaTSResponse(time_series, items, addHostName) {
+  if (time_series.length === 0) {
+    return [];
+  }
+
   //uniqBy is needed to deduplicate
   const hosts = _.uniqBy(_.flatten(_.map(items, 'hosts')), 'hostid');
   let grafanaSeries = _.map(_.compact(time_series), series => {

src/datasource-zabbix/zabbix/connectors/sql/sqlConnector.js

@@ -109,7 +109,7 @@ export class SQLConnector extends DBConnector {
     };
 
     return getBackendSrv().datasourceRequest({
-      url: '/api/tsdb/query',
+      url: '/api/ds/query',
       method: 'POST',
       data: {
         queries: [queryDef],
@@ -118,7 +118,7 @@ export class SQLConnector extends DBConnector {
     .then(response => {
       let results = response.data.results;
       if (results['A']) {
-        return results['A'].series;
+        return results['A'].frames;
       } else {
         return null;
       }

src/datasource-zabbix/zabbix/zabbix.ts

@@ -5,7 +5,7 @@ import * as utils from '../utils';
 import responseHandler from '../responseHandler';
 import { CachingProxy } from './proxy/cachingProxy';
 // import { ZabbixNotImplemented } from './connectors/dbConnector';
-import { DBConnector } from './connectors/dbConnector';
+import { DBConnector, handleDBDataSourceResponse } from './connectors/dbConnector';
 import { ZabbixAPIConnector } from './connectors/zabbix_api/zabbixAPIConnector';
 import { SQLConnector } from './connectors/sql/sqlConnector';
 import { InfluxDBConnector } from './connectors/influxdb/influxdbConnector';
@@ -432,7 +432,7 @@ export class Zabbix implements ZabbixConnector {
     const [timeFrom, timeTo] = timeRange;
     if (this.enableDirectDBConnection) {
       return this.getHistoryDB(items, timeFrom, timeTo, options)
-      .then(history => this.dbConnector.handleGrafanaTSResponse(history, items));
+      .then(history => handleDBDataSourceResponse(history, items));
     } else {
       return this.zabbixAPI.getHistory(items, timeFrom, timeTo)
       .then(history => responseHandler.handleHistory(history, items));
@@ -443,7 +443,7 @@ export class Zabbix implements ZabbixConnector {
     const [timeFrom, timeTo] = timeRange;
     if (this.enableDirectDBConnection) {
       return this.getTrendsDB(items, timeFrom, timeTo, options)
-      .then(history => this.dbConnector.handleGrafanaTSResponse(history, items));
+      .then(history => handleDBDataSourceResponse(history, items));
     } else {
       const valueType = options.consolidateBy || options.valueType;
       return this.zabbixAPI.getTrend(items, timeFrom, timeTo)