datasource.js

'use strict';

System.register(['lodash', './showdown.min.js', './query_builder'], function (_export, _context) {
  "use strict";

  var _, showdown, queryBuilder, _createClass, DataDogDatasource;

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  /*
   * Convert tags to key-value pairs
   * [region:east, region:nw] => {region: [east, nw]}
   */
  function mapTagsToKVPairs(tags) {
    var kv_tags = _.filter(tags, function (tag) {
      return tag.indexOf(':') !== -1;
    });

    var kv_pairs = kv_tags.map(function (tag) {
      return tag.split(':', 2); // Limit to 2
    });

    var kv_object = {};
    kv_pairs.forEach(function (pair) {
      var key = pair[0];
      var val = pair[1];

      if (kv_object[key]) {
        kv_object[key].push(val);
      } else {
        kv_object[key] = [val];
      }
    });

    return kv_object;
  }

  /*
   * Convert DataDog event text from markdown to pure HTML
   * http://docs.datadoghq.com/guides/markdown/
   */
  function convertDataDogMdToHtml(str) {
    var MD_START = '%%%\n';
    var MD_END = '\n%%%';

    var md_start_index = str.indexOf(MD_START) + MD_START.length;
    var md_end_index = str.indexOf(MD_END);
    var md = str.substring(md_start_index, md_end_index);
    md = removeImagesFromDataDogMarkdown(md);

    var converter = new showdown.Converter();
    return converter.makeHtml(md);
  }

  function isDataDogMarkdown(str) {
    var MD_START = '%%%\n';
    return str.indexOf(MD_START) >= 0;
  }

  function removeImagesFromDataDogMarkdown(str) {
    var dataDogImagePattern = /\[{0,1}\!\[.*\]\(https{0,1}\:\/\/p\.datadoghq\.com\/snapshot.+\)/g;
    return str.replace(dataDogImagePattern, '');
  }

  function dataDogTagFormat(value) {
    if (_.isArray(value)) {
      return value.join(',');
    }
    return value;
  }
  return {
    setters: [function (_lodash) {
      _ = _lodash.default;
    }, function (_showdownMinJs) {
      showdown = _showdownMinJs.default;
    }, function (_query_builder) {
      queryBuilder = _query_builder;
    }],
    execute: function () {
      _createClass = function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();

      _export('DataDogDatasource', DataDogDatasource = function () {
        function DataDogDatasource(instanceSettings, backendSrv, templateSrv) {
          _classCallCheck(this, DataDogDatasource);

          this.type = instanceSettings.type;
          this.url = instanceSettings.url;
          this.name = instanceSettings.name;
          this.api_key = instanceSettings.jsonData.api_key;
          this.application_key = instanceSettings.jsonData.app_key;
          this.supportMetrics = true;
          this.backendSrv = backendSrv;
          this.templateSrv = templateSrv;
          this._cached_metrics = false;
        }

        // Function to check Datasource health


        _createClass(DataDogDatasource, [{
          key: 'testDatasource',
          value: function testDatasource() {
            return this.invokeDataDogApiRequest('/downtime').then(function () {
              return {
                status: "success",
                title: "Success",
                message: "Data source is working"
              };
            }).catch(function (error) {
              var message = "Connection error";
              if (error && error.message) {
                message = error.message;
              }

              return {
                status: "error",
                title: "Error",
                message: message
              };
            });
          }
        }, {
          key: 'tagFindQuery',
          value: function tagFindQuery() {
            return this.getTagsFromCache().then(function (tags) {
              return _.map(tags, function (hosts, tag) {
                return {
                  text: tag,
                  value: tag
                };
              });
            });
          }
        }, {
          key: 'metricFindQuery',
          value: function metricFindQuery(query) {
            var _this = this;

            if (query === 'tag') {
              return this.tagFindQuery();
            }

            if (this._cached_metrics) {
              return Promise.resolve(this._cached_metrics);
            }

            if (this.fetching) {
              return this.fetching;
            }

            var d = new Date();
            d.setDate(d.getDate() - 1);
            var from = Math.floor(d.getTime() / 1000);

            this.fetching = this.getMetrics(from).then(function (metrics) {
              _this._cached_metrics = _.map(metrics, function (metric) {
                return {
                  text: metric,
                  value: metric
                };
              });

              return _this._cached_metrics;
            });

            return this.fetching;
          }
        }, {
          key: 'getTagKeys',
          value: function getTagKeys() {
            return this.getTagsFromCache().then(function (tagsHosts) {
              var tags = Object.keys(tagsHosts);
              var kv = mapTagsToKVPairs(tags);
              var grafanaTags = Object.keys(kv);

              return grafanaTags.map(function (tag) {
                return {
                  text: tag,
                  value: tag
                };
              });
            });
          }
        }, {
          key: 'getTagValues',
          value: function getTagValues(options) {
            return this.getTagsFromCache().then(function (tagsHosts) {
              var tags = Object.keys(tagsHosts);
              var kv = mapTagsToKVPairs(tags);
              var grafanaValues = kv[options.key];
              return grafanaValues.map(function (val) {
                return {
                  text: val,
                  value: val
                };
              });
            });
          }
        }, {
          key: 'query',
          value: function query(options) {
            var from = Math.floor(options.range.from.valueOf() / 1000);
            var to = Math.floor(options.range.to.valueOf() / 1000);

            var targets = options.targets.filter(function (t) {
              return !t.hide;
            });

            if (targets.length <= 0) {
              return Promise.resolve({ data: [] });
            }

            // add global adhoc filters
            var adhocFilters = this.templateSrv.getAdhocFilters(this.name);

            var queries = _.map(targets, function (target) {
              var query = void 0;
              if (target.rawQuery) {
                query = target.query;
              } else {
                query = queryBuilder.buildQuery(target, adhocFilters);
              }
              return query;
            });

            var queryString = queries.join(',');
            queryString = this.templateSrv.replace(queryString, options.scopedVars, dataDogTagFormat);

            var params = {
              from: from,
              to: to,
              query: queryString
            };

            return this.invokeDataDogApiRequest('/query', params).then(function (result) {
              var dataResponse = _.map(result.series, function (series, i) {
                var target = targets[i];
                return {
                  'target': target.alias || series.expression,
                  'datapoints': _.map(series.pointlist, function (point) {
                    return [point[1], point[0]];
                  })
                };
              });

              return { data: dataResponse };
            });
          }
        }, {
          key: 'annotationQuery',
          value: function annotationQuery(options) {
            var timeFrom = Math.floor(options.range.from.valueOf() / 1000);
            var timeTo = Math.floor(options.range.to.valueOf() / 1000);
            var _options$annotation = options.annotation,
                priority = _options$annotation.priority,
                sources = _options$annotation.sources,
                tags = _options$annotation.tags;


            return this.getEventStream(timeFrom, timeTo, priority, sources, tags).then(function (eventStreams) {
              var eventAnnotations = eventStreams.map(function (eventStream) {
                var allEvents = eventStream.children;
                var filteredEvents = _.filter(allEvents, function (event) {
                  return event.alert_type !== 'success';
                });

                return _.map(filteredEvents, function (event) {
                  var renderedText = eventStream.text;
                  if (isDataDogMarkdown(eventStream.text)) {
                    renderedText = convertDataDogMdToHtml(eventStream.text);
                  }

                  return {
                    annotation: options.annotation,
                    time: event.date_happened * 1000,
                    title: eventStream.title,
                    text: renderedText,
                    tags: eventStream.tags
                  };
                });
              });

              return _.flatten(eventAnnotations);
            });
          }
        }, {
          key: 'getHosts',
          value: function getHosts() {
            return this.searchEntities('hosts');
          }
        }, {
          key: 'searchEntities',
          value: function searchEntities(entity) {
            var params = { q: '' };
            if (entity) {
              params.q = entity + ':';
            }

            return this.invokeDataDogApiRequest('/search', params).then(function (result) {
              if (result && result.results) {
                return result.results[entity];
              }
            });
          }
        }, {
          key: 'getMetrics',
          value: function getMetrics(timeFrom) {
            var params = {};

            if (timeFrom) {
              params.from = timeFrom;
            }

            return this.invokeDataDogApiRequest('/metrics', params).then(function (result) {
              if (result.metrics) {
                return result.metrics;
              } else {
                return [];
              }
            });
          }
        }, {
          key: 'getTagsHosts',
          value: function getTagsHosts() {
            return this.invokeDataDogApiRequest('/tags/hosts').then(function (result) {
              if (result && result.tags) {
                return result.tags;
              }
            });
          }
        }, {
          key: 'getTagsFromCache',
          value: function getTagsFromCache() {
            var _this2 = this;

            var getTags = void 0;
            if (this._cached_tags && this._cached_tags.length) {
              getTags = Promise.resolve(this._cached_tags);
            } else {
              getTags = this.getTagsHosts().then(function (tags) {
                _this2._cached_tags = tags;
                return tags;
              });
            }

            return getTags;
          }
        }, {
          key: 'getEventStream',
          value: function getEventStream(timeFrom, timeTo, priority, sources, tags) {
            var params = {
              start: timeFrom,
              end: timeTo
            };
            if (priority) {
              params.priority = priority;
            }
            if (sources) {
              params.sources = sources;
            }
            if (tags) {
              params.tags = tags;
            }

            return this.invokeDataDogApiRequest('/events', params).then(function (result) {
              if (result.events) {
                return result.events;
              } else {
                return [];
              }
            });
          }
        }, {
          key: 'invokeDataDogApiRequest',
          value: function invokeDataDogApiRequest(url) {
            var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            // Set auth params
            params.api_key = this.api_key;
            params.application_key = this.application_key;

            return this.backendSrv.datasourceRequest({
              method: 'GET',
              url: this.url + url,
              params: params
            }).then(function (response) {
              if (response.data) {
                return response.data;
              } else {
                throw { message: 'DataDog API request error' };
              }
            }).catch(function (error) {
              var message = 'DataDog API request error';
              if (error.statusText) {
                message = error.status + ' ' + error.statusText;
                throw { message: message };
              } else if (error.err.statusText) {
                throw { message: error.err.statusText };
              } else {
                throw { message: message };
              }
            });
          }
        }]);

        return DataDogDatasource;
      }());

      _export('DataDogDatasource', DataDogDatasource);
    }
  };
});
//# sourceMappingURL=datasource.js.map