Merge pull request #52 from CorpGlory/kentik-custom-dimensions-suppor…

…t-#46

Kentik custom dimensions support #46

specs/datasource/datasource.test.ts

@@ -1,20 +1,60 @@
-import { Datasource } from '../../src/datasource/module';
+import {Datasource} from '../../src/datasource/module';
+import {KentikAPI} from '../../src/datasource/kentikAPI';
+import {KentikProxy} from '../../src/datasource/kentikProxy';
 
 describe('KentikDatasource', () => {
   let ctx: any = {};
 
-  beforeEach(function () {
-    ctx.kentikProxySrv = {};
-    ctx.templateSrv = {};
-
-    let instanceSettings = {};
-    ctx.ds = new Datasource(instanceSettings, {}, ctx.templateSrv);
-  });
+  const data = {
+    customDimensions: [
+      {
+        display_name: 'just-testing', name: 'c_test',
+        populators: [
+          { value: 'value1' }, { value: 'value2' }
+        ]
+      },
+      {
+        display_name: 'just-testing-2', name: 'c_test_2',
+        populators: [
+          { value: 'value3' }, { value: 'value4' }
+        ]
+      }
+    ],
+    rows: [
+      { src_geo_city: 'city' }
+    ]
+  };
+  beforeEach(() => createDatasourceInstance(ctx, data));
 
   describe('When querying Kentik data', () => {
-    it('pass', (done) => {
-      done();
+    it('Should return tag values for default dimensions', async () => {
+      const tagValues = await ctx.ds.getTagValues({ key: 'Source City' });
+      expect(tagValues).toHaveLength(1);
+      expect(tagValues[0]).toEqual({ text: 'city' });
+    });
+
+    it('Should return tag values for custom dimensions', async () => {
+      const tagValues = await ctx.ds.getTagValues({ key: 'Custom just-testing-2' });
+      expect(tagValues).toHaveLength(2);
+      expect(tagValues[0]).toEqual({ text: 'value3' });
+      expect(tagValues[1]).toEqual({ text: 'value4' });
     });
   });
-
 });
+
+function createDatasourceInstance(ctx, data) {
+  ctx.instanceSettings = {};
+  ctx.templateSrv = {};
+  ctx.backendSrv = {
+    datasourceRequest: function () {
+      return Promise.resolve({
+        status: 200, data
+      });
+    }
+  };
+
+  ctx.kentikAPI = new KentikAPI(ctx.backendSrv);
+  ctx.kentikProxy = new KentikProxy({}, ctx.kentikAPI);
+
+  ctx.ds = new Datasource(ctx.instanceSettings, ctx.templateSrv, ctx.kentikProxy);
+}

specs/datasource/kentikProxy.test.ts

@@ -0,0 +1,56 @@
+import {KentikAPI} from '../../src/datasource/kentikAPI';
+import {KentikProxy} from '../../src/datasource/kentikProxy';
+
+describe('KentikProxy', () => {
+  let ctx: any = {};
+
+  describe('When getting custom dimensions', () => {
+    const data = {
+      customDimensions: [
+        {
+          display_name: 'just-testing', name: 'c_test',
+          populators: [
+            { value: 'value1' }, { value: 'value2' }
+          ]
+        },
+        {
+          display_name: 'just-testing-2', name: 'c_test_2',
+          populators: [
+            { value: 'value3' }, { value: 'value4' }
+          ]
+        }
+      ]
+    };
+    beforeEach(() => getKentikProxyInstance(ctx, data));
+
+    it('Should parse it properly', async () => {
+      const dimensions = await ctx.kentikProxy.getCustomDimensions();
+      expect(dimensions).toHaveLength(2);
+      expect(dimensions[0]).toEqual({
+        text: 'Custom just-testing',
+        value: 'c_test',
+        field: 'c_test',
+        values: ['value1', 'value2'],
+      });
+      expect(dimensions[1]).toEqual({
+        text: 'Custom just-testing-2',
+        value: 'c_test_2',
+        field: 'c_test_2',
+        values: ['value3', 'value4'],
+      });
+    });
+  });
+});
+
+function getKentikProxyInstance(ctx, data) {
+  ctx.backendSrv = {
+    datasourceRequest: function () {
+      return Promise.resolve({
+        status: 200, data
+      });
+    }
+  };
+
+  ctx.kentikAPI = new KentikAPI(ctx.backendSrv);
+  ctx.kentikProxy = new KentikProxy({}, ctx.kentikAPI);
+}

src/datasource/datasource.ts

@@ -27,7 +27,7 @@ class KentikDatasource {
     return value.join(',');
   }
 
-  query(options) {
+  async query(options) {
     if (!options.targets || options.targets.length === 0) {
       return Promise.resolve({ data: [] });
     }
@@ -40,7 +40,8 @@ class KentikDatasource {
     );
 
     let kentikFilters = this.templateSrv.getAdhocFilters(this.name);
-    kentikFilters = queryBuilder.convertToKentikFilterGroup(kentikFilters);
+    const customDimensions = await this.kentik.getCustomDimensions();
+    kentikFilters = queryBuilder.convertToKentikFilterGroup(kentikFilters, customDimensions);
 
     const queryOptions = {
       deviceNames: deviceNames,
@@ -64,7 +65,7 @@ class KentikDatasource {
       });
   }
 
-  processResponse(query, mode, options, data) {
+  async processResponse(query, mode, options, data) {
     if (!data.results) {
       return Promise.reject({ message: 'no kentik data' });
     }
@@ -74,7 +75,12 @@ class KentikDatasource {
       return [];
     }
 
-    const metricDef = _.find(metricList, { value: query.dimension[0] });
+    const extendedMetricList = await this._getExtendedDimensionsList(metricList);
+    const metricDef = _.find(
+      extendedMetricList,
+      { value: query.dimension[0] }
+    );
+
     const unitDef = _.find(unitList, { value: query.metric });
 
     if (mode === 'table') {
@@ -141,12 +147,12 @@ class KentikDatasource {
     return [table];
   }
 
-  metricFindQuery(query) {
+  async metricFindQuery(query) {
     if (query === 'metrics()') {
-      return Promise.resolve(metricList);
+      return this._getExtendedDimensionsList(metricList);
     }
     if (query === 'units()') {
-      return Promise.resolve(unitList);
+      return unitList;
     }
 
     return this.kentik.getDevices().then(devices => {
@@ -156,22 +162,35 @@ class KentikDatasource {
     });
   }
 
-  getTagKeys() {
-    return Promise.resolve(filterFieldList);
+  async getTagKeys() {
+    return this._getExtendedDimensionsList(filterFieldList);
   }
 
-  getTagValues(options) {
+  async getTagValues(options) {
     if (options) {
-      const field = _.find(filterFieldList, { text: options.key }).field;
-      return this.kentik.getFieldValues(field).then(result => {
-        return result.rows.map(row => {
-          return { text: row[field].toString() };
+      const filter = _.find(filterFieldList, { text: options.key });
+
+      if (filter === undefined) {
+        const customDimensions = await this.kentik.getCustomDimensions();
+        const dimension = _.find(customDimensions, { text: options.key });
+        return dimension.values.map(value => ({ text: value }));
+      } else {
+        const field = filter.field;
+        return this.kentik.getFieldValues(field).then(result => {
+          return result.rows.map(row => {
+            return { text: row[field].toString() };
+          });
         });
-      });
+      }
     } else {
-      return Promise.resolve([]);
+      return [];
     }
   }
+
+  private async _getExtendedDimensionsList(list: Array<any>) {
+    const customDimensions = await this.kentik.getCustomDimensions();
+    return _.concat(list, customDimensions);
+  }
 }
 
 export { KentikDatasource };

src/datasource/kentikAPI.ts

@@ -1,6 +1,6 @@
 import angular from 'angular';
 
-class KentikAPI {
+export class KentikAPI {
   baseUrl: string;
 
   /** @ngInject */
@@ -23,6 +23,11 @@ class KentikAPI {
     return this.invokeSQLQuery(query);
   }
 
+  async getCustomDimensions() {
+    const data = await this._get('/api/v5/customdimensions');
+    return data.data.customDimensions;
+  }
+
   invokeTopXDataQuery(query) {
     const kentikV5Query = {
       queries: [{ query: query, bucketIndex: 0 }],

src/datasource/kentikProxy.ts

@@ -28,7 +28,7 @@ function getMaxRefreshInterval(query) {
   }
 }
 
-class KentikProxy {
+export class KentikProxy {
   kentikAPI: any;
   cache: any;
   cacheUpdateInterval: number;
@@ -113,6 +113,26 @@ class KentikProxy {
       });
     }
   }
+
+  async getCustomDimensions() {
+    if (this.cache.customDimensions === undefined) {
+      const customDimensions = await this.kentikAPI.getCustomDimensions();
+      this.cache.customDimensions = customDimensions.map(dimension => ({
+        values: this._getDimensionPopulatorsValues(dimension),
+        text: `Custom ${dimension.display_name}`,
+        value: dimension.name,
+        field: dimension.name
+      }));
+    }
+    return this.cache.customDimensions;
+  }
+
+  private _getDimensionPopulatorsValues(dimension) {
+    return dimension.populators.reduce((values, populator) => {
+      values.push(populator.value);
+      return values;
+    }, []);
+  }
 }
 
 angular.module('grafana.services').service('kentikProxySrv', KentikProxy);

src/datasource/query_builder.ts

@@ -123,15 +123,16 @@ function buildTopXdataQuery(options) {
   return query;
 }
 
-function convertToKentikFilter(filterObj) {
+function convertToKentikFilter(filterObj, customDimensions: Array<any>) {
   // Use Kentik 'not equal' style
   if (filterObj.operator === '!=') {
     filterObj.operator = '<>';
   }
 
   // If no field definition found assume that custom field is used.
   let filterField;
-  const filterFieldDef = _.find(filterFieldList, { text: filterObj.key });
+  const filterFieldDefExtended = _.concat(filterFieldList, customDimensions);
+  const filterFieldDef = _.find(filterFieldDefExtended, { text: filterObj.key });
   if (filterFieldDef) {
     filterField = filterFieldDef.field;
   } else {
@@ -145,9 +146,9 @@ function convertToKentikFilter(filterObj) {
   };
 }
 
-function convertToKentikFilterGroup(filters) {
+function convertToKentikFilterGroup(filters, customDimensions = []) {
   if (filters.length) {
-    const kentikFilters = _.map(filters, convertToKentikFilter);
+    const kentikFilters = _.map(filters, filter => convertToKentikFilter(filter, customDimensions));
     let connector = 'All';
     if (
       filters[0].condition &&