Skip to content

N
nexpie-grafana-theme
Commit e28c9b33 by Torkel Ödegaard
Options

cleanup(KairosDB): removed kairosdb from main repo, can easily be installed via… 

cleanup(KairosDB): removed kairosdb from main repo, can easily be installed via as plugin via its own plugin repo, https://github.com/grafana/datasource-plugin-kairosdb, closes #3524
parent 5335a6b6
Showing with 2 additions and 1224 deletions
CHANGELOG.md
......@@ -2,7 +2,8 @@
### Breaking changes
**InfluxDB 0.8.x** The data source for the old version of influxdb (0.8.x) is no longer included in default builds. Can easily be installed via plugin system, closes #3523
**InfluxDB 0.8.x** The data source for the old version of influxdb (0.8.x) is no longer included in default builds. Can easily be installed via improved plugin system, closes #3523
**KairosDB** The data source is no longer included in default builds. Can easily be installed via improved plugin system, closes #3524
# 2.6.1 (unrelased, 2.6.x branch)
......
public/app/plugins/datasource/kairosdb/datasource.js deleted 100644 → 0
define([
'angular',
'lodash',
'app/core/utils/datemath',
'app/core/utils/kbn',
'./queryCtrl',
'./directives',
],
function (angular, _, dateMath, kbn) {
'use strict';
var module = angular.module('grafana.services');
module.factory('KairosDBDatasource', function($q, backendSrv, templateSrv) {
function KairosDBDatasource(datasource) {
this.type = datasource.type;
this.url = datasource.url;
this.name = datasource.name;
this.supportMetrics = true;
}
// Called once per panel (graph)
KairosDBDatasource.prototype.query = function(options) {
var start = options.rangeRaw.from;
var end = options.rangeRaw.to;
var queries = _.compact(_.map(options.targets, _.partial(convertTargetToQuery, options)));
var plotParams = _.compact(_.map(options.targets, function(target) {
var alias = target.alias;
if (typeof target.alias === 'undefined' || target.alias === "") {
alias = target.metric;
}
if (!target.hide) {
return { alias: alias, exouter: target.exOuter };
}
else {
return null;
}
}));
var handleKairosDBQueryResponseAlias = _.partial(handleKairosDBQueryResponse, plotParams);
// No valid targets, return the empty result to save a round trip.
if (_.isEmpty(queries)) {
var d = $q.defer();
d.resolve({ data: [] });
return d.promise;
}
return this.performTimeSeriesQuery(queries, start, end).then(handleKairosDBQueryResponseAlias, handleQueryError);
};
KairosDBDatasource.prototype.performTimeSeriesQuery = function(queries, start, end) {
var reqBody = {
metrics: queries,
cache_time: 0
};
convertToKairosTime(start, reqBody, 'start');
convertToKairosTime(end, reqBody, 'end');
var options = {
method: 'POST',
url: this.url + '/api/v1/datapoints/query',
data: reqBody
};
return backendSrv.datasourceRequest(options);
};
/**
* Gets the list of metrics
* @returns {*|Promise}
*/
KairosDBDatasource.prototype._performMetricSuggestQuery = function(metric) {
var options = {
url: this.url + '/api/v1/metricnames',
method: 'GET'
};
return backendSrv.datasourceRequest(options).then(function(response) {
if (!response.data) {
return $q.when([]);
}
var metrics = [];
_.each(response.data.results, function(r) {
if (r.indexOf(metric) >= 0) {
metrics.push(r);
}
});
return metrics;
});
};
KairosDBDatasource.prototype._performMetricKeyLookup = function(metric) {
if(!metric) { return $q.when([]); }
var options = {
method: 'POST',
url: this.url + '/api/v1/datapoints/query/tags',
data: {
metrics: [{ name: metric }],
cache_time: 0,
start_absolute: 0
}
};
return backendSrv.datasourceRequest(options).then(function(result) {
if (!result.data) {
return $q.when([]);
}
var tagks = [];
_.each(result.data.queries[0].results[0].tags, function(tagv, tagk) {
if(tagks.indexOf(tagk) === -1) {
tagks.push(tagk);
}
});
return tagks;
});
};
KairosDBDatasource.prototype._performMetricKeyValueLookup = function(metric, key) {
if(!metric || !key) {
return $q.when([]);
}
var options = {
method: 'POST',
url: this.url + '/api/v1/datapoints/query/tags',
data: {
metrics: [{ name: metric }],
cache_time: 0,
start_absolute: 0
}
};
return backendSrv.datasourceRequest(options).then(function(result) {
if (!result.data) {
return $q.when([]);
}
return result.data.queries[0].results[0].tags[key];
});
};
KairosDBDatasource.prototype.performTagSuggestQuery = function(metric) {
var options = {
url: this.url + '/api/v1/datapoints/query/tags',
method: 'POST',
data: {
metrics: [{ name: metric }],
cache_time: 0,
start_absolute: 0
}
};
return backendSrv.datasourceRequest(options).then(function(response) {
if (!response.data) {
return [];
}
else {
return response.data.queries[0].results[0];
}
});
};
KairosDBDatasource.prototype.metricFindQuery = function(query) {
if (!query) { return $q.when([]); }
var interpolated;
try {
interpolated = templateSrv.replace(query);
}
catch (err) {
return $q.reject(err);
}
var responseTransform = function(result) {
return _.map(result, function(value) {
return {text: value};
});
};
var metrics_regex = /metrics\((.*)\)/;
var tag_names_regex = /tag_names\((.*)\)/;
var tag_values_regex = /tag_values\((.*),\s?(.*?)\)/;
var metrics_query = interpolated.match(metrics_regex);
if (metrics_query) {
return this._performMetricSuggestQuery(metrics_query[1]).then(responseTransform);
}
var tag_names_query = interpolated.match(tag_names_regex);
if (tag_names_query) {
return this._performMetricKeyLookup(tag_names_query[1]).then(responseTransform);
}
var tag_values_query = interpolated.match(tag_values_regex);
if (tag_values_query) {
return this._performMetricKeyValueLookup(tag_values_query[1], tag_values_query[2]).then(responseTransform);
}
return $q.when([]);
};
/////////////////////////////////////////////////////////////////////////
/// Formatting methods
////////////////////////////////////////////////////////////////////////
/**
* Requires a verion of KairosDB with every CORS defects fixed
* @param results
* @returns {*}
*/
function handleQueryError(results) {
if (results.data.errors && !_.isEmpty(results.data.errors)) {
var errors = {
message: results.data.errors[0]
};
return $q.reject(errors);
}
else {
return $q.reject(results);
}
}
function handleKairosDBQueryResponse(plotParams, results) {
var output = [];
var index = 0;
_.each(results.data.queries, function(series) {
_.each(series.results, function(result) {
var target = plotParams[index].alias;
var details = " ( ";
_.each(result.group_by, function(element) {
if (element.name === "tag") {
_.each(element.group, function(value, key) {
details += key + "=" + value + " ";
});
}
else if (element.name === "value") {
details += 'value_group=' + element.group.group_number + " ";
}
else if (element.name === "time") {
details += 'time_group=' + element.group.group_number + " ";
}
});
details += ") ";
if (details !== " ( ) ") {
target += details;
}
var datapoints = [];
for (var i = 0; i < result.values.length; i++) {
var t = Math.floor(result.values[i][0]);
var v = result.values[i][1];
datapoints[i] = [v, t];
}
if (plotParams[index].exouter) {
datapoints = new PeakFilter(datapoints, 10);
}
output.push({ target: target, datapoints: datapoints });
});
index++;
});
return { data: _.flatten(output) };
}
function convertTargetToQuery(options, target) {
if (!target.metric || target.hide) {
return null;
}
var query = {
name: templateSrv.replace(target.metric)
};
query.aggregators = [];
if (target.downsampling !== '(NONE)') {
if (target.downsampling === undefined) {
target.downsampling = 'avg';
target.sampling = '10s';
}
query.aggregators.push({
name: target.downsampling,
align_sampling: true,
align_start_time: true,
sampling: KairosDBDatasource.prototype.convertToKairosInterval(target.sampling || options.interval)
});
}
if (target.horizontalAggregators) {
_.each(target.horizontalAggregators, function(chosenAggregator) {
var returnedAggregator = {
name:chosenAggregator.name
};
if (chosenAggregator.sampling_rate) {
returnedAggregator.sampling = KairosDBDatasource.prototype.convertToKairosInterval(chosenAggregator.sampling_rate);
returnedAggregator.align_sampling = true;
returnedAggregator.align_start_time =true;
}
if (chosenAggregator.unit) {
returnedAggregator.unit = chosenAggregator.unit + 's';
}
if (chosenAggregator.factor && chosenAggregator.name === 'div') {
returnedAggregator.divisor = chosenAggregator.factor;
}
else if (chosenAggregator.factor && chosenAggregator.name === 'scale') {
returnedAggregator.factor = chosenAggregator.factor;
}
if (chosenAggregator.percentile) {
returnedAggregator.percentile = chosenAggregator.percentile;
}
query.aggregators.push(returnedAggregator);
});
}
if (_.isEmpty(query.aggregators)) {
delete query.aggregators;
}
if (target.tags) {
query.tags = angular.copy(target.tags);
_.forOwn(query.tags, function(value, key) {
query.tags[key] = _.map(value, function(tag) { return templateSrv.replace(tag); });
});
}
if (target.groupByTags || target.nonTagGroupBys) {
query.group_by = [];
if (target.groupByTags) {
query.group_by.push({
name: "tag",
tags: _.map(angular.copy(target.groupByTags), function(tag) { return templateSrv.replace(tag); })
});
}
if (target.nonTagGroupBys) {
_.each(target.nonTagGroupBys, function(rawGroupBy) {
var formattedGroupBy = angular.copy(rawGroupBy);
if (formattedGroupBy.name === 'time') {
formattedGroupBy.range_size = KairosDBDatasource.prototype.convertToKairosInterval(formattedGroupBy.range_size);
}
query.group_by.push(formattedGroupBy);
});
}
}
return query;
}
///////////////////////////////////////////////////////////////////////
/// Time conversion functions specifics to KairosDB
//////////////////////////////////////////////////////////////////////
KairosDBDatasource.prototype.convertToKairosInterval = function(intervalString) {
intervalString = templateSrv.replace(intervalString);
var interval_regex = /(\d+(?:\.\d+)?)([Mwdhmsy])/;
var interval_regex_ms = /(\d+(?:\.\d+)?)(ms)/;
var matches = intervalString.match(interval_regex_ms);
if (!matches) {
matches = intervalString.match(interval_regex);
}
if (!matches) {
throw new Error('Invalid interval string, expecting a number followed by one of "y M w d h m s ms"');
}
var value = matches[1];
var unit = matches[2];
if (value%1 !== 0) {
if (unit === 'ms') {
throw new Error('Invalid interval value, cannot be smaller than the millisecond');
}
value = Math.round(kbn.intervals_in_seconds[unit] * value * 1000);
unit = 'ms';
}
return {
value: value,
unit: convertToKairosDBTimeUnit(unit)
};
};
function convertToKairosTime(date, response_obj, start_stop_name) {
var name;
if (_.isString(date)) {
if (date === 'now') {
return;
}
else if (date.indexOf('now-') >= 0 && date.indexOf('/') === -1) {
date = date.substring(4);
name = start_stop_name + "_relative";
var re_date = /(\d+)\s*(\D+)/;
var result = re_date.exec(date);
if (result) {
var value = result[1];
var unit = result[2];
response_obj[name] = {
value: value,
unit: convertToKairosDBTimeUnit(unit)
};
return;
}
console.log("Unparseable date", date);
return;
}
date = dateMath.parse(date, start_stop_name === 'end');
}
name = start_stop_name + "_absolute";
response_obj[name] = date.valueOf();
}
function convertToKairosDBTimeUnit(unit) {
switch (unit) {
case 'ms':
return 'milliseconds';
case 's':
return 'seconds';
case 'm':
return 'minutes';
case 'h':
return 'hours';
case 'd':
return 'days';
case 'w':
return 'weeks';
case 'M':
return 'months';
case 'y':
return 'years';
default:
console.log("Unknown unit ", unit);
return '';
}
}
function PeakFilter(dataIn, limit) {
var datapoints = dataIn;
var arrLength = datapoints.length;
if (arrLength <= 3) {
return datapoints;
}
var LastIndx = arrLength - 1;
// Check first point
var prvDelta = Math.abs((datapoints[1][0] - datapoints[0][0]) / datapoints[0][0]);
var nxtDelta = Math.abs((datapoints[1][0] - datapoints[2][0]) / datapoints[2][0]);
if (prvDelta >= limit && nxtDelta < limit) {
datapoints[0][0] = datapoints[1][0];
}
// Check last point
prvDelta = Math.abs((datapoints[LastIndx - 1][0] - datapoints[LastIndx - 2][0]) / datapoints[LastIndx - 2][0]);
nxtDelta = Math.abs((datapoints[LastIndx - 1][0] - datapoints[LastIndx][0]) / datapoints[LastIndx][0]);
if (prvDelta >= limit && nxtDelta < limit) {
datapoints[LastIndx][0] = datapoints[LastIndx - 1][0];
}
for (var i = 1; i < arrLength - 1; i++) {
prvDelta = Math.abs((datapoints[i][0] - datapoints[i - 1][0]) / datapoints[i - 1][0]);
nxtDelta = Math.abs((datapoints[i][0] - datapoints[i + 1][0]) / datapoints[i + 1][0]);
if (prvDelta >= limit && nxtDelta >= limit) {
datapoints[i][0] = (datapoints[i - 1][0] + datapoints[i + 1][0]) / 2;
}
}
return datapoints;
}
return KairosDBDatasource;
});
});
public/app/plugins/datasource/kairosdb/directives.js deleted 100644 → 0
define([
'angular',
],
function (angular) {
'use strict';
var module = angular.module('grafana.directives');
module.directive('metricQueryEditorKairosdb', function() {
return {controller: 'KairosDBQueryCtrl', templateUrl: 'app/plugins/datasource/kairosdb/partials/query.editor.html'};
});
module.directive('metricQueryOptionsKairosdb', function() {
return {templateUrl: 'app/plugins/datasource/kairosdb/partials/query.options.html'};
});
});
public/app/plugins/datasource/kairosdb/partials/query.editor.html deleted 100644 → 0
<div class="tight-form">
<ul class="tight-form-list pull-right">
<li class="tight-form-item small" ng-show="target.datasource">
<em>{{target.datasource}}</em>
</li>
<li class="tight-form-item">
<div class="dropdown">
<a class="pointer dropdown-toggle" data-toggle="dropdown" tabindex="1">
<i class="fa fa-bars"></i>
</a>
<ul class="dropdown-menu pull-right" role="menu">
<li role="menuitem"><a tabindex="1" ng-click="duplicateDataQuery(target)">Duplicate</a></li>
<li role="menuitem"><a tabindex="1" ng-click="moveDataQuery($index, $index-1)">Move up</a></li>
<li role="menuitem"><a tabindex="1" ng-click="moveDataQuery($index, $index+1)">Move down</a></li>
</ul>
</div>
</li>
<li class="tight-form-item last">
<a class="pointer" tabindex="1" ng-click="removeDataQuery(target)">
<i class="fa fa-remove"></i>
</a>
</li>
</ul>
<ul class="tight-form-list">
<li class="tight-form-item" style="min-width: 15px; text-align: center">
{{target.refId}}
</li>
<li>
<a class="tight-form-item" ng-click="target.hide = !target.hide; targetBlur();" role="menuitem">
<i class="fa fa-eye"></i>
</a>
</li>
<li class="tight-form-item">
Metric
</li>
<li>
<input type="text" class="input-large tight-form-input"
ng-model="target.metric"
spellcheck="false"
bs-typeahead="suggestMetrics"
placeholder="metric name"
data-min-length=0 data-items=100
ng-blur="targetBlur()">
<a bs-tooltip="target.errors.metric"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.metric">
<i class="fa fa-warning"></i>
</a>
</li>
<li class="tight-form-item">
Alias
</li>
<li>
<input type="text" class="input-medium tight-form-input" ng-model="target.alias"
spellcheck='false' placeholder="alias" ng-blur="targetBlur()">
</li>
<li class="tight-form-item">
&nbsp;Peak filter
<input class="input-medium" type="checkbox" ng-model="target.exOuter" ng-change="targetBlur()">
</li>
</ul>
<div class="clearfix"></div>
</div>
<!-- TAGS -->
<div class="tight-form">
<ul class="tight-form-list" role="menu">
<li class="tight-form-item tight-form-align">
Tags
</li>
<li ng-repeat="(key, value) in target.tags track by $index" class="tight-form-item">
{{key}}&nbsp;=&nbsp;{{value}}
<a ng-click="removeFilterTag(key)">
<i class="fa fa-remove"></i>
</a>
</li>
<li class="tight-form-item" ng-hide="addFilterTagMode">
<a ng-click="addFilterTag()">
<i class="fa fa-plus"></i>
</a>
</li>
<li ng-show="addFilterTagMode">
<input type="text"
class="input-small tight-form-input"
spellcheck='false'
bs-typeahead="suggestTagKeys"
ng-change="validateFilterTag()"
data-min-length=0 data-items=100
ng-model="target.currentTagKey"
placeholder="key">
</li>
<li ng-show="addFilterTagMode">
<input type="text"
class="input-small tight-form-input"
spellcheck='false'
bs-typeahead="suggestTagValues"
ng-change="validateFilterTag()"
data-min-length=0 data-items=100
ng-model="target.currentTagValue"
placeholder="value">
<a bs-tooltip="target.errors.tags"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.tags">
<i class="fa fa-warning"></i>
</a>
<li class="tight-form-item" ng-show="addFilterTagMode">
<a ng-click="addFilterTag()">
<i ng-show="target.errors.tags" class="fa fa-remove"></i>
<i ng-hide="target.errors.tags" class="fa fa-plus-circle"></i>
</a>
</li>
</li>
</ul>
<div class="clearfix"></div>
</div>
<!-- GROUP BY -->
<div class="tight-form">
<ul class="tight-form-list" role="menu">
<li class="tight-form-item tight-form-align">
Group By
</li>
<li class="tight-form-item" ng-show="target.groupByTags">
tags:
</li>
<li ng-repeat="key in target.groupByTags track by $index" class="tight-form-item">
{{key}}
<a ng-click="removeGroupByTag($index)">
<i class="fa fa-remove"></i>
</a>
</li>
<li class="tight-form-item" ng-show="target.groupByTags && target.nonTagGroupBys">
and by:
</li>
<li ng-repeat="groupByObject in target.nonTagGroupBys track by $index" class="tight-form-item">
{{_.values(groupByObject)}}
<a ng-click="removeNonTagGroupBy($index)">
<i class="fa fa-remove"></i>
</a>
</li>
<li class="tight-form-item" ng-hide="addGroupByMode">
<a ng-click="addGroupBy()">
<i class="fa fa-plus"></i>
</a>
</li>
<li ng-show="addGroupByMode">
<select class="input-small tight-form-input"
ng-change="changeGroupByInput()"
ng-model="target.currentGroupByType"
ng-options="f for f in ['tag','value','time']"></select>
</li>
<li ng-show="isTagGroupBy">
<input type="text"
class="input-small tight-form-input"
spellcheck='false'
bs-typeahead="suggestTagKeys"
ng-change = "validateGroupBy()"
data-min-length=0 data-items=100
ng-model="target.groupBy.tagKey"
placeholder="key">
<a bs-tooltip="target.errors.groupBy.tagKey"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.groupBy.tagKey">
<i class="fa fa-warning"></i>
</a>
</li>
<li ng-show="isValueGroupBy">
<input type="text"
class="input-mini tight-form-input"
spellcheck='false'
ng-model="target.groupBy.valueRange"
placeholder="range"
bs-tooltip="'Range on which values are considered in the same group'"
ng-change = "validateGroupBy()" >
<a bs-tooltip="target.errors.groupBy.valueRange"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.groupBy.valueRange">
<i class="fa fa-warning"></i>
</a>
</li>
<li ng-show="isTimeGroupBy">
<input type="text"
class="input-mini tight-form-input"
ng-model="target.groupBy.timeInterval"
ng-init="target.groupBy.timeInterval='1s'"
placeholder="interval"
bs-tooltip="'Duration of time groups'"
spellcheck='false'
ng-change="validateGroupBy()">
<a bs-tooltip="target.errors.groupBy.timeInterval"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.groupBy.timeInterval">
<i class="fa fa-warning"></i>
</a>
</li>
<li ng-show="isTimeGroupBy">
<input type="text"
class="input-mini tight-form-input"
ng-model="target.groupBy.groupCount"
placeholder="Count"
bs-tooltip="'Number of time groups to be formed'"
spellcheck='false'
ng-change="validateGroupBy()">
<a bs-tooltip="target.errors.groupBy.groupCount"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.groupBy.groupCount">
<i class="fa fa-warning"></i>
</a>
</li>
<li class="tight-form-item" ng-show="addGroupByMode">
<a ng-click="addGroupBy()">
<i ng-hide="isGroupByValid" class="fa fa-remove"></i>
<i ng-show="isGroupByValid" class="fa fa-plus-circle"></i>
</a>
</li>
</ul>
<div class="clearfix"></div>
</div>
<!-- HORIZONTAL AGGREGATION -->
<div class="tight-form">
<ul class="tight-form-list" role="menu">
<li class="tight-form-item tight-form-align">
Aggregators
</li>
<li ng-repeat="aggregatorObject in target.horizontalAggregators track by $index" class="tight-form-item">
{{aggregatorObject.name}}&#40;
<span ng-repeat="aggKey in _.keys(_.omit(aggregatorObject,'name'))" bs-tooltip="aggKey">
{{$last?aggregatorObject[aggKey]:aggregatorObject[aggKey]+","}}
</span>
&#41;
<a ng-click="removeHorizontalAggregator($index)">
<i class="fa fa-remove"></i>
</a>
</li>
<li class="tight-form-item" ng-hide="addHorizontalAggregatorMode">
<a ng-click="addHorizontalAggregator()">
<i class="fa fa-plus"></i>
</a>
</li>
<li ng-show="addHorizontalAggregatorMode">
<select class="input-medium tight-form-input"
ng-change="changeHorAggregationInput()"
ng-model="target.currentHorizontalAggregatorName"
ng-options="f for f in ['avg','dev','max','min','rate','sampler','count','sum','least_squares','percentile','scale','div']"></select>
</li>
<!-- Different parameters -->
<li ng-show="hasSamplingRate" class="tight-form-item">
every
</li>
<li ng-show="hasSamplingRate">
<input type="text"
class="input-mini tight-form-input"
ng-model="target.horAggregator.samplingRate"
ng-init="target.horAggregator.samplingRate='1s'"
spellcheck='false'
ng-change="validateHorizontalAggregator()" >
<a bs-tooltip="target.errors.horAggregator.samplingRate"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.horAggregator.samplingRate">
<i class="fa fa-warning"></i>
</a>
</li>
<li ng-show="hasUnit" class="tight-form-item">
every
</li>
<li ng-show="hasUnit">
<select class="input-medium tight-form-input"
ng-model="target.horAggregator.unit"
ng-init="target.horAggregator.unit='millisecond'"
ng-options="f for f in ['millisecond','second','minute','hour','day','week','month','year']"></select>
</li>
<li ng-show="hasFactor" class="tight-form-item">
by
</li>
<li ng-show="hasFactor">
<input type="text"
class="input-mini tight-form-input"
ng-model="target.horAggregator.factor"
ng-init="target.horAggregator.factor='1'"
spellcheck='false'
ng-change="validateHorizontalAggregator()" >
<a bs-tooltip="target.errors.horAggregator.factor"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.horAggregator.factor">
<i class="fa fa-warning"></i>
</a>
</li>
<li ng-show="hasPercentile" class="tight-form-item">
percentile
</li>
<li ng-show="hasPercentile">
<input type="text"
class="input-mini tight-form-input"
ng-model="target.horAggregator.percentile"
ng-init="target.horAggregator.percentile='0.75'"
spellcheck='false'
ng-change="validateHorizontalAggregator()" >
<a bs-tooltip="target.errors.horAggregator.percentile"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.horAggregator.percentile">
<i class="fa fa-warning"></i>
</a>
</li>
<li class="tight-form-item" ng-show="addHorizontalAggregatorMode">
<a ng-click="addHorizontalAggregator()">
<i ng-hide="isAggregatorValid" class="fa fa-remove"></i>
<i ng-show="isAggregatorValid" class="fa fa-plus-circle"></i>
</a>
</li>
</ul>
<div class="clearfix"></div>
</div>
public/app/plugins/datasource/kairosdb/partials/query.options.html deleted 100644 → 0
<section class="grafana-metric-options" ng-controller="KairosDBQueryCtrl">
<div class="tight-form">
<ul class="tight-form-list">
<li class="tight-form-item tight-form-item-icon">
<i class="fa fa-wrench"></i>
</li>
<li class="tight-form-item">
Downsampling with
</li>
<li>
<select class="input-medium tight-form-input" ng-change="panelBlur()" ng-model="panel.downsampling" ng-options="f for f in ['(NONE)','avg', 'sum', 'min', 'max', 'dev']" ></select>
</li>
<!-- SAMPLING RATE -->
<li ng-hide="panel.downsampling=='(NONE)'" class="tight-form-item">
every
</li>
<li>
<input type="text"
ng-hide="panel.downsampling=='(NONE)'"
class="input-mini tight-form-input"
ng-model="panel.sampling"
placeholder="{{interval}}"
bs-tooltip="'Leave blank for auto handling based on time range and panel width'"
spellcheck='false'
ng-blur="panelBlur()" >
<a bs-tooltip="target.errors.sampling"
style="color: rgb(229, 189, 28)"
ng-show="target.errors.sampling">
<i class="fa fa-warning"></i>
</a>
</li>
</ul>
<div class="clearfix"></div>
</div>
</section>
public/app/plugins/datasource/kairosdb/plugin.json deleted 100644 → 0
{
"pluginType": "datasource",
"name": "KairosDB",
"type": "kairosdb",
"serviceName": "KairosDBDatasource",
"module": "app/plugins/datasource/kairosdb/datasource",
"partials": {
"config": "app/plugins/datasource/kairosdb/partials/config.html"
},
"metrics": true,
"annotations": false
}
public/app/plugins/datasource/kairosdb/queryCtrl.js deleted 100644 → 0
define([
'angular',
'lodash'
],
function (angular, _) {
'use strict';
var module = angular.module('grafana.controllers');
module.controller('KairosDBQueryCtrl', function($scope) {
$scope.init = function() {
$scope.panel.stack = false;
if (!$scope.panel.downsampling) {
$scope.panel.downsampling = 'avg';
}
if (!$scope.target.downsampling) {
$scope.target.downsampling = $scope.panel.downsampling;
$scope.target.sampling = $scope.panel.sampling;
}
$scope.target.errors = validateTarget($scope.target);
};
$scope.targetBlur = function() {
$scope.target.errors = validateTarget($scope.target);
if (!_.isEqual($scope.oldTarget, $scope.target) && _.isEmpty($scope.target.errors)) {
$scope.oldTarget = angular.copy($scope.target);
$scope.get_data();
}
};
$scope.panelBlur = function() {
_.each($scope.panel.targets, function(target) {
target.downsampling = $scope.panel.downsampling;
target.sampling = $scope.panel.sampling;
});
$scope.get_data();
};
$scope.getTextValues = function(metricFindResult) {
return _.map(metricFindResult, function(value) { return value.text; });
};
$scope.suggestMetrics = function(query, callback) {
$scope.datasource.metricFindQuery('metrics(' + query + ')')
.then($scope.getTextValues)
.then(callback);
};
$scope.suggestTagKeys = function(query, callback) {
$scope.datasource.metricFindQuery('tag_names(' + $scope.target.metric + ')')
.then($scope.getTextValues)
.then(callback);
};
$scope.suggestTagValues = function(query, callback) {
$scope.datasource.metricFindQuery('tag_values(' + $scope.target.metric + ',' + $scope.target.currentTagKey + ')')
.then($scope.getTextValues)
.then(callback);
};
// Filter metric by tag
$scope.addFilterTag = function() {
if (!$scope.addFilterTagMode) {
$scope.addFilterTagMode = true;
$scope.validateFilterTag();
return;
}
if (!$scope.target.tags) {
$scope.target.tags = {};
}
$scope.validateFilterTag();
if (!$scope.target.errors.tags) {
if (!_.has($scope.target.tags, $scope.target.currentTagKey)) {
$scope.target.tags[$scope.target.currentTagKey] = [];
}
$scope.target.tags[$scope.target.currentTagKey].push($scope.target.currentTagValue);
$scope.target.currentTagKey = '';
$scope.target.currentTagValue = '';
$scope.targetBlur();
}
$scope.addFilterTagMode = false;
};
$scope.removeFilterTag = function(key) {
delete $scope.target.tags[key];
if (_.size($scope.target.tags) === 0) {
$scope.target.tags = null;
}
$scope.targetBlur();
};
$scope.validateFilterTag = function() {
$scope.target.errors.tags = null;
if (!$scope.target.currentTagKey || !$scope.target.currentTagValue) {
$scope.target.errors.tags = "You must specify a tag name and value.";
}
};
//////////////////////////////
// GROUP BY
//////////////////////////////
$scope.addGroupBy = function() {
if (!$scope.addGroupByMode) {
$scope.addGroupByMode = true;
$scope.target.currentGroupByType = 'tag';
$scope.isTagGroupBy = true;
$scope.validateGroupBy();
return;
}
$scope.validateGroupBy();
// nb: if error is found, means that user clicked on cross : cancels input
if (_.isEmpty($scope.target.errors.groupBy)) {
if ($scope.isTagGroupBy) {
if (!$scope.target.groupByTags) {
$scope.target.groupByTags = [];
}
if (!_.contains($scope.target.groupByTags, $scope.target.groupBy.tagKey)) {
$scope.target.groupByTags.push($scope.target.groupBy.tagKey);
$scope.targetBlur();
}
$scope.target.groupBy.tagKey = '';
}
else {
if (!$scope.target.nonTagGroupBys) {
$scope.target.nonTagGroupBys = [];
}
var groupBy = {
name: $scope.target.currentGroupByType
};
if ($scope.isValueGroupBy) {groupBy.range_size = $scope.target.groupBy.valueRange;}
else if ($scope.isTimeGroupBy) {
groupBy.range_size = $scope.target.groupBy.timeInterval;
groupBy.group_count = $scope.target.groupBy.groupCount;
}
$scope.target.nonTagGroupBys.push(groupBy);
}
$scope.targetBlur();
}
$scope.isTagGroupBy = false;
$scope.isValueGroupBy = false;
$scope.isTimeGroupBy = false;
$scope.addGroupByMode = false;
};
$scope.removeGroupByTag = function(index) {
$scope.target.groupByTags.splice(index, 1);
if (_.size($scope.target.groupByTags) === 0) {
$scope.target.groupByTags = null;
}
$scope.targetBlur();
};
$scope.removeNonTagGroupBy = function(index) {
$scope.target.nonTagGroupBys.splice(index, 1);
if (_.size($scope.target.nonTagGroupBys) === 0) {
$scope.target.nonTagGroupBys = null;
}
$scope.targetBlur();
};
$scope.changeGroupByInput = function() {
$scope.isTagGroupBy = $scope.target.currentGroupByType === 'tag';
$scope.isValueGroupBy = $scope.target.currentGroupByType === 'value';
$scope.isTimeGroupBy = $scope.target.currentGroupByType === 'time';
$scope.validateGroupBy();
};
$scope.validateGroupBy = function() {
delete $scope.target.errors.groupBy;
var errors = {};
$scope.isGroupByValid = true;
if ($scope.isTagGroupBy) {
if (!$scope.target.groupBy.tagKey) {
$scope.isGroupByValid = false;
errors.tagKey = 'You must supply a tag name';
}
}
if ($scope.isValueGroupBy) {
if (!$scope.target.groupBy.valueRange || !isInt($scope.target.groupBy.valueRange)) {
errors.valueRange = "Range must be an integer";
$scope.isGroupByValid = false;
}
}
if ($scope.isTimeGroupBy) {
try {
$scope.datasource.convertToKairosInterval($scope.target.groupBy.timeInterval);
} catch (err) {
errors.timeInterval = err.message;
$scope.isGroupByValid = false;
}
if (!$scope.target.groupBy.groupCount || !isInt($scope.target.groupBy.groupCount)) {
errors.groupCount = "Group count must be an integer";
$scope.isGroupByValid = false;
}
}
if (!_.isEmpty(errors)) {
$scope.target.errors.groupBy = errors;
}
};
function isInt(n) {
return parseInt(n) % 1 === 0;
}
//////////////////////////////
// HORIZONTAL AGGREGATION
//////////////////////////////
$scope.addHorizontalAggregator = function() {
if (!$scope.addHorizontalAggregatorMode) {
$scope.addHorizontalAggregatorMode = true;
$scope.target.currentHorizontalAggregatorName = 'avg';
$scope.hasSamplingRate = true;
$scope.validateHorizontalAggregator();
return;
}
$scope.validateHorizontalAggregator();
// nb: if error is found, means that user clicked on cross : cancels input
if (_.isEmpty($scope.target.errors.horAggregator)) {
if (!$scope.target.horizontalAggregators) {
$scope.target.horizontalAggregators = [];
}
var aggregator = {
name:$scope.target.currentHorizontalAggregatorName
};
if ($scope.hasSamplingRate) {aggregator.sampling_rate = $scope.target.horAggregator.samplingRate;}
if ($scope.hasUnit) {aggregator.unit = $scope.target.horAggregator.unit;}
if ($scope.hasFactor) {aggregator.factor = $scope.target.horAggregator.factor;}
if ($scope.hasPercentile) {aggregator.percentile = $scope.target.horAggregator.percentile;}
$scope.target.horizontalAggregators.push(aggregator);
$scope.targetBlur();
}
$scope.addHorizontalAggregatorMode = false;
$scope.hasSamplingRate = false;
$scope.hasUnit = false;
$scope.hasFactor = false;
$scope.hasPercentile = false;
};
$scope.removeHorizontalAggregator = function(index) {
$scope.target.horizontalAggregators.splice(index, 1);
if (_.size($scope.target.horizontalAggregators) === 0) {
$scope.target.horizontalAggregators = null;
}
$scope.targetBlur();
};
$scope.changeHorAggregationInput = function() {
$scope.hasSamplingRate = _.contains(['avg','dev','max','min','sum','least_squares','count','percentile'],
$scope.target.currentHorizontalAggregatorName);
$scope.hasUnit = _.contains(['sampler','rate'], $scope.target.currentHorizontalAggregatorName);
$scope.hasFactor = _.contains(['div','scale'], $scope.target.currentHorizontalAggregatorName);
$scope.hasPercentile = 'percentile' === $scope.target.currentHorizontalAggregatorName;
$scope.validateHorizontalAggregator();
};
$scope.validateHorizontalAggregator = function() {
delete $scope.target.errors.horAggregator;
var errors = {};
$scope.isAggregatorValid = true;
if ($scope.hasSamplingRate) {
try {
$scope.datasource.convertToKairosInterval($scope.target.horAggregator.samplingRate);
} catch (err) {
errors.samplingRate = err.message;
$scope.isAggregatorValid = false;
}
}
if ($scope.hasFactor) {
if (!$scope.target.horAggregator.factor) {
errors.factor = 'You must supply a numeric value for this aggregator';
$scope.isAggregatorValid = false;
}
else if (parseInt($scope.target.horAggregator.factor) === 0 && $scope.target.currentHorizontalAggregatorName === 'div') {
errors.factor = 'Cannot divide by 0';
$scope.isAggregatorValid = false;
}
}
if ($scope.hasPercentile) {
if (!$scope.target.horAggregator.percentile ||
$scope.target.horAggregator.percentile<=0 ||
$scope.target.horAggregator.percentile>1) {
errors.percentile = 'Percentile must be between 0 and 1';
$scope.isAggregatorValid = false;
}
}
if (!_.isEmpty(errors)) {
$scope.target.errors.horAggregator = errors;
}
};
$scope.alert = function(message) {
alert(message);
};
// Validation
function validateTarget(target) {
var errs = {};
if (!target.metric) {
errs.metric = "You must supply a metric name.";
}
try {
if (target.sampling) {
$scope.datasource.convertToKairosInterval(target.sampling);
}
} catch (err) {
errs.sampling = err.message;
}
return errs;
}
});
});
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment