kibana-sinatra 0.0.1

data/lib/kibana/assets/app/services/fields.js

@@ -0,0 +1,96 @@
+define([
+  'angular',
+  'underscore',
+  'config'
+],
+function (angular, _, config) {
+  'use strict';
+
+  var module = angular.module('kibana.services');
+
+  module.service('fields', function(dashboard, $rootScope, $http, alertSrv) {
+    // Save a reference to this
+    var self = this;
+
+    this.list = ['_type'];
+    this.mapping = {};
+
+    $rootScope.$watch(function(){return dashboard.indices;},function(n) {
+      if(!_.isUndefined(n) && n.length) {
+        // Only get the mapping for indices we don't know it for
+        var indices = _.difference(n,_.keys(self.mapping));
+        // Only get the mapping if there are indices
+        if(indices.length > 0) {
+          self.map(indices).then(function(result) {
+            self.mapping = _.extend(self.mapping,result);
+            self.list = mapFields(self.mapping);
+          });
+        // Otherwise just use the cached mapping
+        } else {
+          self.list = mapFields(_.pick(self.mapping,n));
+        }
+      }
+    });
+
+    var mapFields = function (m) {
+      var fields = [];
+      _.each(m, function(types) {
+        _.each(types, function(v) {
+          fields = _.union(fields,_.keys(v));
+        });
+      });
+      return fields;
+    };
+
+    this.map = function(indices) {
+      var request = $http({
+        url: config.elasticsearch + "/" + indices.join(',') + "/_mapping",
+        method: "GET"
+      }).error(function(data, status) {
+        if(status === 0) {
+          alertSrv.set('Error',"Could not contact Elasticsearch at "+config.elasticsearch+
+            ". Please ensure that Elasticsearch is reachable from your system." ,'error');
+        } else {
+          alertSrv.set('Error',"No index found at "+config.elasticsearch+"/" +
+            indices.join(',')+"/_mapping. Please create at least one index."  +
+            "If you're using a proxy ensure it is configured correctly.",'error');
+        }
+      });
+
+      return request.then(function(p) {
+        var mapping = {};
+        _.each(p.data, function(v,k) {
+          mapping[k] = {};
+          _.each(v, function (v,f) {
+            mapping[k][f] = flatten(v);
+          });
+        });
+        return mapping;
+      });
+    };
+
+    var flatten = function(obj,prefix) {
+      var propName = (prefix) ? prefix :  '',
+        dot = (prefix) ? '.':'',
+        ret = {};
+      for(var attr in obj){
+        // For now only support multi field on the top level
+        // and if if there is a default field set.
+        if(obj[attr]['type'] === 'multi_field') {
+          ret[attr] = obj[attr]['fields'][attr] || obj[attr];
+          continue;
+        }
+        if (attr === 'properties') {
+          _.extend(ret,flatten(obj[attr], propName));
+        } else if(typeof obj[attr] === 'object'){
+          _.extend(ret,flatten(obj[attr], propName + dot + attr));
+        } else {
+          ret[propName] = obj;
+        }
+      }
+      return ret;
+    };
+
+  });
+
+});

data/lib/kibana/assets/app/services/filterSrv.js

@@ -0,0 +1,200 @@
+define([
+  'angular',
+  'underscore',
+  'config'
+], function (angular, _, config) {
+  'use strict';
+
+  var module = angular.module('kibana.services');
+
+  module.service('filterSrv', function(dashboard, ejsResource) {
+    // Create an object to hold our service state on the dashboard
+    dashboard.current.services.filter = dashboard.current.services.filter || {};
+
+    // Defaults for it
+    var _d = {
+      idQueue : [],
+      list : {},
+      ids : []
+    };
+
+    // For convenience
+    var ejs = ejsResource(config.elasticsearch);
+    var _f = dashboard.current.services.filter;
+
+    // Save a reference to this
+    var self = this;
+
+    // Call this whenever we need to reload the important stuff
+    this.init = function() {
+      // Populate defaults
+      _.defaults(dashboard.current.services.filter,_d);
+
+      // Accessors
+      self.list = dashboard.current.services.filter.list;
+      self.ids = dashboard.current.services.filter.ids;
+      _f = dashboard.current.services.filter;
+
+      _.each(self.getByType('time',true),function(time) {
+        self.list[time.id].from = new Date(time.from);
+        self.list[time.id].to = new Date(time.to);
+      });
+
+    };
+
+    // This is used both for adding filters and modifying them.
+    // If an id is passed, the filter at that id is updated
+    this.set = function(filter,id) {
+      _.defaults(filter,{mandate:'must'});
+      filter.active = true;
+      if(!_.isUndefined(id)) {
+        if(!_.isUndefined(self.list[id])) {
+          _.extend(self.list[id],filter);
+          return id;
+        } else {
+          return false;
+        }
+      } else {
+        if(_.isUndefined(filter.type)) {
+          return false;
+        } else {
+          var _id = nextId();
+          var _filter = {
+            alias: '',
+            id: _id
+          };
+          _.defaults(filter,_filter);
+          self.list[_id] = filter;
+          self.ids.push(_id);
+          return _id;
+        }
+      }
+    };
+
+    this.getBoolFilter = function(ids) {
+      // A default match all filter, just in case there are no other filters
+      var bool = ejs.BoolFilter().must(ejs.MatchAllFilter());
+      var either_bool = ejs.BoolFilter().must(ejs.MatchAllFilter());
+      _.each(ids,function(id) {
+        if(self.list[id].active) {
+          switch(self.list[id].mandate)
+          {
+          case 'mustNot':
+            bool = bool.mustNot(self.getEjsObj(id));
+            break;
+          case 'either':
+            either_bool = either_bool.should(self.getEjsObj(id));
+            break;
+          default:
+            bool = bool.must(self.getEjsObj(id));
+          }
+        }
+      });
+      return bool.must(either_bool);
+    };
+
+    this.getEjsObj = function(id) {
+      return self.toEjsObj(self.list[id]);
+    };
+
+    this.toEjsObj = function (filter) {
+      if(!filter.active) {
+        return false;
+      }
+      switch(filter.type)
+      {
+      case 'time':
+        return ejs.RangeFilter(filter.field)
+          .from(filter.from.valueOf())
+          .to(filter.to.valueOf());
+      case 'range':
+        return ejs.RangeFilter(filter.field)
+          .from(filter.from)
+          .to(filter.to);
+      case 'querystring':
+        return ejs.QueryFilter(ejs.QueryStringQuery(filter.query)).cache(true);
+      case 'field':
+        return ejs.QueryFilter(ejs.FieldQuery(filter.field,filter.query)).cache(true);
+      case 'terms':
+        return ejs.TermsFilter(filter.field,filter.value);
+      case 'exists':
+        return ejs.ExistsFilter(filter.field);
+      case 'missing':
+        return ejs.MissingFilter(filter.field);
+      default:
+        return false;
+      }
+    };
+
+    this.getByType = function(type,inactive) {
+      return _.pick(self.list,self.idsByType(type,inactive));
+    };
+
+    this.removeByType = function(type) {
+      var ids = self.idsByType(type);
+      _.each(ids,function(id) {
+        self.remove(id);
+      });
+      return ids;
+    };
+
+    this.idsByType = function(type,inactive) {
+      var _require = inactive ? {type:type} : {type:type,active:true};
+      return _.pluck(_.where(self.list,_require),'id');
+    };
+
+    // TOFIX: Error handling when there is more than one field
+    this.timeField = function() {
+      return _.pluck(self.getByType('time'),'field');
+    };
+
+    // This special function looks for all time filters, and returns a time range according to the mode
+    // No idea when max would actually be used
+    this.timeRange = function(mode) {
+      var _t = _.where(self.list,{type:'time',active:true});
+      if(_t.length === 0) {
+        return false;
+      }
+      switch(mode) {
+      case "min":
+        return {
+          from: new Date(_.max(_.pluck(_t,'from'))),
+          to: new Date(_.min(_.pluck(_t,'to')))
+        };
+      case "max":
+        return {
+          from: new Date(_.min(_.pluck(_t,'from'))),
+          to: new Date(_.max(_.pluck(_t,'to')))
+        };
+      default:
+        return false;
+      }
+    };
+
+    this.remove = function(id) {
+      if(!_.isUndefined(self.list[id])) {
+        delete self.list[id];
+        // This must happen on the full path also since _.without returns a copy
+        self.ids = dashboard.current.services.filter.ids = _.without(self.ids,id);
+        _f.idQueue.unshift(id);
+        _f.idQueue.sort(function(v,k){return v-k;});
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+
+    var nextId = function() {
+      if(_f.idQueue.length > 0) {
+        return _f.idQueue.shift();
+      } else {
+        return self.ids.length;
+      }
+    };
+
+    // Now init
+    self.init();
+  });
+
+});

data/lib/kibana/assets/app/services/kbnIndex.js

@@ -0,0 +1,101 @@
+define([
+  'angular',
+  'underscore',
+  'config',
+  'moment'
+],
+function (angular, _, config, moment) {
+  'use strict';
+
+  var module = angular.module('kibana.services');
+
+  module.service('kbnIndex', function($http, alertSrv) {
+    // returns a promise containing an array of all indices matching the index
+    // pattern that exist in a given range
+    this.indices = function(from,to,pattern,interval) {
+      var possible = [];
+      _.each(expand_range(fake_utc(from),fake_utc(to),interval),function(d){
+        possible.push(d.format(pattern));
+      });
+
+      return all_indices().then(function(p) {
+        var indices = _.intersection(possible,p);
+        indices.reverse();
+        return indices;
+      });
+    };
+
+    // returns a promise containing an array of all indices in an elasticsearch
+    // cluster
+    function all_indices() {
+      var something = $http({
+        url: config.elasticsearch + "/_aliases",
+        method: "GET"
+      }).error(function(data, status) {
+        if(status === 0) {
+          alertSrv.set('Error',"Could not contact Elasticsearch at "+config.elasticsearch+
+            ". Please ensure that Elasticsearch is reachable from your system." ,'error');
+        } else {
+          alertSrv.set('Error',"Could not reach "+config.elasticsearch+"/_aliases. If you"+
+          " are using a proxy, ensure it is configured correctly",'error');
+        }
+      });
+
+      return something.then(function(p) {
+        var indices = [];
+        _.each(p.data, function(v,k) {
+          indices.push(k);
+          // Also add the aliases. Could be expensive on systems with a lot of them
+          _.each(v.aliases, function(v, k) {
+            indices.push(k);
+          });
+        });
+        return indices;
+      });
+    }
+
+    // this is stupid, but there is otherwise no good way to ensure that when
+    // I extract the date from an object that I get the UTC date. Stupid js.
+    // I die a little inside every time I call this function.
+    // Update: I just read this again. I died a little more inside.
+    // Update2: More death.
+    function fake_utc(date) {
+      date = moment(date).clone().toDate();
+      return moment(new Date(date.getTime() + date.getTimezoneOffset() * 60000));
+    }
+
+    // Create an array of date objects by a given interval
+    function expand_range(start, end, interval) {
+      if(_.contains(['hour','day','week','month','year'],interval)) {
+        var range;
+        start = moment(start).clone();
+        range = [];
+        while (start.isBefore(end)) {
+          range.push(start.clone());
+          switch (interval) {
+          case 'hour':
+            start.add('hours',1);
+            break;
+          case 'day':
+            start.add('days',1);
+            break;
+          case 'week':
+            start.add('weeks',1);
+            break;
+          case 'month':
+            start.add('months',1);
+            break;
+          case 'year':
+            start.add('years',1);
+            break;
+          }
+        }
+        range.push(moment(end).clone());
+        return range;
+      } else {
+        return false;
+      }
+    }
+  });
+
+});

data/lib/kibana/assets/app/services/panelMove.js

@@ -0,0 +1,83 @@
+define([
+  'angular',
+  'underscore'
+],
+function (angular, _) {
+  'use strict';
+
+  var module = angular.module('kibana.services');
+
+  module.service('panelMove', function(dashboard, $rootScope, alertSrv) {
+
+    /* each of these can take event,ui,data parameters */
+
+    var notices = [];
+
+    this.onStart = function() {
+      dashboard.panelDragging =  true;
+      notices.push(alertSrv.set('Moving','Drop this panel into an available space, or on top of another panel','info'));
+      $rootScope.$apply();
+    };
+
+    this.onOver = function() {
+      notices.push(alertSrv.set('Add panel',
+          'Drop to add panel to this row. Panel will use row height, but retain their span','success'));
+      $rootScope.$apply();
+    };
+
+    this.onOut = function() {
+      clearNotices({severity:'success'});
+      $rootScope.$apply();
+    };
+
+    /*
+      Use our own drop logic. the $parent.$parent this is ugly.
+    */
+    this.onDrop = function(event,ui,data) {
+      var
+        dragRow = data.draggableScope.$parent.$parent.row.panels,
+        dropRow =  data.droppableScope.$parent.$parent.row.panels,
+        dragIndex = data.dragSettings.index,
+        dropIndex =  data.dropSettings.index;
+
+
+      // Remove panel from source row
+      dragRow.splice(dragIndex,1);
+
+      // Add to destination row
+      if(!_.isUndefined(dropRow)) {
+        dropRow.splice(dropIndex,0,data.dragItem);
+      }
+
+      dashboard.panelDragging = false;
+      // Cleanup nulls/undefined left behind
+      cleanup();
+      $rootScope.$apply();
+      $rootScope.$broadcast('render');
+    };
+
+    this.onStop = function() {
+      dashboard.panelDragging = false;
+      cleanup();
+      $rootScope.$apply();
+    };
+
+    var cleanup = function () {
+      _.each(notices, function(n){
+        alertSrv.clear(n);
+      });
+      _.each(dashboard.current.rows, function(row) {
+        row.panels = _.without(row.panels,{});
+        row.panels = _.compact(row.panels);
+      });
+    };
+
+    var clearNotices = function(options) {
+      _.each(_.where(notices,options), function(n) {
+        alertSrv.clear(n);
+      });
+    };
+
+  });
+
+});