kibana-sinatra 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c47667fea1a8f40992e94933560d24476c55e5a
+  data.tar.gz: f61f2d585cb4f182ba696d5908992f3de1eaf842
+SHA512:
+  metadata.gz: 3210da00beeb85b4caafc21f75b2557408f0266ed719de1ac14dd4cabc0858525eac05f0ad227cb5fb1b468de47be1d4d7e0b9c4508275e8e5abf5e3eb32c5ce
+  data.tar.gz: 3cf521038c0e6bba9d4decaf8ae4f65e9dfa9d43ad203a421ab417786804b674f462c176ba8a93124eba7b086fed0316c89369e89575768d103a9880bb423081

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kibana-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ian Neubert
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Kibana::Sinatra
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kibana-sinatra'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kibana-sinatra
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/kibana-sinatra.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kibana/sinatra/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kibana-sinatra"
+  spec.version       = Kibana::Sinatra::VERSION
+  spec.authors       = ["Ian Neubert"]
+  spec.email         = ["ian@ianneubert.com"]
+  spec.description   = %q{This gem packages up Kibana 3 into a Sinatra app that can be used stand alone, or with Rails.}
+  spec.summary       = %q{This gem packages up Kibana 3 into a Sinatra app that can be used stand alone, or with Rails.}
+  spec.homepage      = "http://github.com/ianneub/kibana-sinatra"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sinatra", "~> 1.4"
+end

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

@@ -0,0 +1,140 @@
+/**
+ * main app level module
+ */
+define([
+  'angular',
+  'jquery',
+  'underscore',
+  'require',
+
+  'elasticjs',
+  'bootstrap',
+  'angular-sanitize',
+  'angular-strap',
+  'angular-dragdrop',
+  'extend-jquery'
+],
+function (angular, $, _, appLevelRequire) {
+  "use strict";
+
+  var app = angular.module('kibana', []),
+    // we will keep a reference to each module defined before boot, so that we can
+    // go back and allow it to define new features later. Once we boot, this will be false
+    pre_boot_modules = [],
+    // these are the functions that we need to call to register different
+    // features if we define them after boot time
+    register_fns = {};
+
+  /**
+   * Tells the application to watch the module, once bootstraping has completed
+   * the modules controller, service, etc. functions will be overwritten to register directly
+   * with this application.
+   * @param  {[type]} module [description]
+   * @return {[type]}        [description]
+   */
+  app.useModule = function (module) {
+    if (pre_boot_modules) {
+      pre_boot_modules.push(module);
+    } else {
+      _.extend(module, register_fns);
+    }
+    return module;
+  };
+
+  app.safeApply = function ($scope, fn) {
+    switch($scope.$$phase) {
+    case '$apply':
+      // $digest hasn't started, we should be good
+      $scope.$eval(fn);
+      break;
+    case '$digest':
+      // waiting to $apply the changes
+      setTimeout(function () { app.safeApply($scope, fn); }, 10);
+      break;
+    default:
+      // clear to begin an $apply $$phase
+      $scope.$apply(fn);
+      break;
+    }
+  };
+
+  app.config(function ($routeProvider, $controllerProvider, $compileProvider, $filterProvider, $provide) {
+    $routeProvider
+      .when('/dashboard', {
+        templateUrl: 'app/partials/dashboard.html',
+      })
+      .when('/dashboard/:kbnType/:kbnId', {
+        templateUrl: 'app/partials/dashboard.html',
+      })
+      .when('/dashboard/:kbnType/:kbnId/:params', {
+        templateUrl: 'app/partials/dashboard.html'
+      })
+      .otherwise({
+        redirectTo: 'dashboard'
+      });
+    // this is how the internet told me to dynamically add modules :/
+    register_fns.controller = $controllerProvider.register;
+    register_fns.directive  = $compileProvider.directive;
+    register_fns.factory    = $provide.factory;
+    register_fns.service    = $provide.service;
+    register_fns.filter     = $filterProvider.register;
+  });
+
+  var apps_deps = [
+    'elasticjs.service',
+    '$strap.directives',
+    'ngSanitize',
+    'ngDragDrop',
+    'kibana'
+  ];
+
+  _.each('controllers directives factories services filters'.split(' '),
+  function (type) {
+    var module_name = 'kibana.'+type;
+    // create the module
+    app.useModule(angular.module(module_name, []));
+    // push it into the apps dependencies
+    apps_deps.push(module_name);
+  });
+
+  app.panel_helpers = {
+    partial: function (name) {
+      return 'app/partials/'+name+'.html';
+    }
+  };
+
+  // load the core components
+  require([
+    'controllers/all',
+    'directives/all',
+    'filters/all'
+  ], function () {
+
+    // bootstrap the app
+    angular
+      .element(document)
+      .ready(function() {
+        $('body').attr('ng-controller', 'DashCtrl');
+        angular.bootstrap(document, apps_deps)
+          .invoke(['$rootScope', function ($rootScope) {
+            _.each(pre_boot_modules, function (module) {
+              _.extend(module, register_fns);
+            });
+            pre_boot_modules = false;
+
+            $rootScope.requireContext = appLevelRequire;
+            $rootScope.require = function (deps, fn) {
+              var $scope = this;
+              $scope.requireContext(deps, function () {
+                var deps = _.toArray(arguments);
+                $scope.$apply(function () {
+                  fn.apply($scope, deps);
+                });
+              });
+            };
+          }]);
+      });
+  });
+
+  return app;
+});

data/lib/kibana/assets/app/components/extend-jquery.js

@@ -0,0 +1,46 @@
+define(['jquery'],
+function ($) {
+  'use strict';
+
+  /**
+   * jQuery extensions
+   */
+  var $win = $(window);
+
+  $.fn.place_tt = (function () {
+    var defaults = {
+      offset: 5,
+      css: {
+        position : 'absolute',
+        top : -1000,
+        left : 0,
+        color : "#c8c8c8",
+        padding : '10px',
+        'font-size': '11pt',
+        'font-weight' : 200,
+        'background-color': '#1f1f1f',
+        'border-radius': '5px',
+      }
+    };
+
+    return function (x, y, opts) {
+      opts = $.extend(true, {}, defaults, opts);
+      return this.each(function () {
+        var $tooltip = $(this), width, height;
+
+        $tooltip.css(opts.css);
+        if (!$.contains(document.body, $tooltip[0])) {
+          $tooltip.appendTo(document.body);
+        }
+
+        width = $tooltip.outerWidth(true);
+        height = $tooltip.outerHeight(true);
+
+        $tooltip.css('left', x + opts.offset + width > $win.width() ? x - opts.offset - width : x + opts.offset);
+        $tooltip.css('top', y + opts.offset + height > $win.height() ? y - opts.offset - height : y + opts.offset);
+      });
+    };
+  })();
+
+  return $;
+});

data/lib/kibana/assets/app/components/kbn.js

@@ -0,0 +1,332 @@
+define(['jquery', 'underscore'],
+function($, _) {
+  'use strict';
+
+  var kbn = {};
+
+  kbn.get_object_fields = function(obj) {
+    var field_array = [];
+    obj = kbn.flatten_json(obj._source);
+    for (var field in obj) {
+      field_array.push(field);
+    }
+    return field_array.sort();
+  };
+
+  kbn.get_all_fields = function(data) {
+    var fields = [];
+    _.each(data,function(hit) {
+      fields = _.uniq(fields.concat(_.keys(hit)));
+    });
+    // Remove stupid angular key
+    fields = _.without(fields,'$$hashKey');
+    return fields;
+  };
+
+  kbn.has_field = function(obj,field) {
+    var obj_fields = kbn.get_object_fields(obj);
+    if (_.inArray(obj_fields,field) < 0) {
+      return false;
+    } else {
+      return true;
+    }
+  };
+
+  kbn.get_related_fields = function(docs,field) {
+    var field_array = [];
+    _.each(docs, function(doc) {
+      var keys = _.keys(doc);
+      if(_.contains(keys,field)) {
+        field_array = field_array.concat(keys);
+      }
+    });
+    var counts = _.countBy(_.without(field_array,field),function(field){return field;});
+    return counts;
+  };
+
+  kbn.recurse_field_dots = function(object,field) {
+    var value = null;
+    var nested;
+    if (typeof object[field] !== 'undefined') {
+      value = object[field];
+    }
+    else if (nested = field.match(/(.*?)\.(.*)/)) {
+      if(typeof object[nested[1]] !== 'undefined') {
+        value = (typeof object[nested[1]][nested[2]] !== 'undefined') ?
+          object[nested[1]][nested[2]] : kbn.recurse_field_dots(
+            object[nested[1]],nested[2]);
+      }
+    }
+
+    return value;
+  };
+
+  kbn.top_field_values = function(docs,field,count,grouped) {
+    var all_values = _.pluck(docs,field),
+      groups = {},
+      counts,
+      hasArrays;
+    // manually grouping into pairs allows us to keep the original value,
+    _.each(all_values, function (value) {
+      var k;
+      if(_.isArray(value)) {
+        hasArrays =  true;
+      }
+      if(_.isArray(value) && !grouped) {
+        k = value;
+      } else {
+        k = _.isUndefined(value) ? '' : [value.toString()];
+      }
+      _.each(k, function(key) {
+        if (_.has(groups, key)) {
+          groups[key][1] ++;
+        } else {
+          groups[key] = [(grouped ? value : key), 1];
+        }
+      });
+    });
+
+    counts = _.values(groups).sort(function(a, b) {
+      return a[1] - b[1];
+    }).reverse().slice(0,count);
+
+    return {
+      counts: counts,
+      hasArrays : hasArrays
+    };
+  };
+
+   /**
+     * Calculate a graph interval
+     *
+     * from::           Date object containing the start time
+     * to::             Date object containing the finish time
+     * size::           Calculate to approximately this many bars
+     * user_interval::  User specified histogram interval
+     *
+     */
+  kbn.calculate_interval = function(from,to,size,user_interval) {
+    if(_.isObject(from)) {
+      from = from.valueOf();
+    }
+    if(_.isObject(to)) {
+      to = to.valueOf();
+    }
+    return user_interval === 0 ? kbn.round_interval((to - from)/size) : user_interval;
+  };
+
+  kbn.round_interval = function(interval) {
+    switch (true) {
+    // 0.5s
+    case (interval <= 500):
+      return 100;       // 0.1s
+    // 5s
+    case (interval <= 5000):
+      return 1000;      // 1s
+    // 7.5s
+    case (interval <= 7500):
+      return 5000;      // 5s
+    // 15s
+    case (interval <= 15000):
+      return 10000;     // 10s
+    // 45s
+    case (interval <= 45000):
+      return 30000;     // 30s
+    // 3m
+    case (interval <= 180000):
+      return 60000;     // 1m
+    // 9m
+    case (interval <= 450000):
+      return 300000;    // 5m
+    // 20m
+    case (interval <= 1200000):
+      return 600000;    // 10m
+    // 45m
+    case (interval <= 2700000):
+      return 1800000;   // 30m
+    // 2h
+    case (interval <= 7200000):
+      return 3600000;   // 1h
+    // 6h
+    case (interval <= 21600000):
+      return 10800000;  // 3h
+    // 24h
+    case (interval <= 86400000):
+      return 43200000;  // 12h
+    // 48h
+    case (interval <= 172800000):
+      return 86400000;  // 24h
+    // 1w
+    case (interval <= 604800000):
+      return 86400000;  // 24h
+    // 3w
+    case (interval <= 1814400000):
+      return 604800000; // 1w
+    // 2y
+    case (interval < 3628800000):
+      return 2592000000; // 30d
+    default:
+      return 31536000000; // 1y
+    }
+  };
+
+  kbn.secondsToHms = function(seconds){
+    var numyears = Math.floor(seconds / 31536000);
+    if(numyears){
+      return numyears + 'y';
+    }
+    var numdays = Math.floor((seconds % 31536000) / 86400);
+    if(numdays){
+      return numdays + 'd';
+    }
+    var numhours = Math.floor(((seconds % 31536000) % 86400) / 3600);
+    if(numhours){
+      return numhours + 'h';
+    }
+    var numminutes = Math.floor((((seconds % 31536000) % 86400) % 3600) / 60);
+    if(numminutes){
+      return numminutes + 'm';
+    }
+    var numseconds = (((seconds % 31536000) % 86400) % 3600) % 60;
+    if(numseconds){
+      return numseconds + 's';
+    }
+    return 'less then a second'; //'just now' //or other string you like;
+  };
+
+  kbn.to_percent = function(number,outof) {
+    return Math.floor((number/outof)*10000)/100 + "%";
+  };
+
+  kbn.addslashes = function(str) {
+    str = str.replace(/\\/g, '\\\\');
+    str = str.replace(/\'/g, '\\\'');
+    str = str.replace(/\"/g, '\\"');
+    str = str.replace(/\0/g, '\\0');
+    return str;
+  };
+
+  kbn.interval_regex = /(\d+(?:\.\d+)?)([Mwdhmsy])/;
+
+  // histogram & trends
+  kbn.intervals_in_seconds = {
+    y: 31536000,
+    M: 2592000,
+    w: 604800,
+    d: 86400,
+    h: 3600,
+    m: 60,
+    s: 1
+  };
+
+  kbn.describe_interval = function (string) {
+    var matches = string.match(kbn.interval_regex);
+    if (!matches || !_.has(kbn.intervals_in_seconds, matches[2])) {
+      throw new Error('Invalid interval string, expexcting a number followed by one of "Mwdhmsy"');
+    } else {
+      return {
+        sec: kbn.intervals_in_seconds[matches[2]],
+        type: matches[2],
+        count: parseInt(matches[1], 10)
+      };
+    }
+  };
+
+  kbn.interval_to_ms = function(string) {
+    var info = kbn.describe_interval(string);
+    return info.sec * 1000 * info.count;
+  };
+
+  kbn.interval_to_seconds = function (string) {
+    var info = kbn.describe_interval(string);
+    return info.sec * info.count;
+  };
+
+  // This should go away, moment.js can do this
+  kbn.time_ago = function(string) {
+    return new Date(new Date().getTime() - (kbn.interval_to_ms(string)));
+  };
+
+  // LOL. hahahahaha. DIE.
+  kbn.flatten_json = function(object,root,array) {
+    if (typeof array === 'undefined') {
+      array = {};
+    }
+    if (typeof root === 'undefined') {
+      root = '';
+    }
+    for(var index in object) {
+      var obj = object[index];
+      var rootname = root.length === 0 ? index : root + '.' + index;
+      if(typeof obj === 'object' ) {
+        if(_.isArray(obj)) {
+          if(obj.length > 0 && typeof obj[0] === 'object') {
+            var strval = '';
+            for (var objidx = 0, objlen = obj.length; objidx < objlen; objidx++) {
+              if (objidx > 0) {
+                strval = strval + ', ';
+              }
+
+              strval = strval + JSON.stringify(obj[objidx]);
+            }
+            array[rootname] = strval;
+          } else if(obj.length === 1 && _.isNumber(obj[0])) {
+            array[rootname] = parseFloat(obj[0]);
+          } else {
+            array[rootname] = typeof obj === 'undefined' ? null : obj;
+          }
+        } else {
+          kbn.flatten_json(obj,rootname,array);
+        }
+      } else {
+        array[rootname] = typeof obj === 'undefined' ? null : obj;
+      }
+    }
+    return kbn.sortObj(array);
+  };
+
+  kbn.xmlEnt = function(value) {
+    if(_.isString(value)) {
+      var stg1 = value.replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/\r\n/g, '<br/>')
+        .replace(/\r/g, '<br/>')
+        .replace(/\n/g, '<br/>')
+        .replace(/\t/g, '&nbsp;&nbsp;&nbsp;&nbsp;')
+        .replace(/  /g, '&nbsp;&nbsp;')
+        .replace(/&lt;del&gt;/g, '<del>')
+        .replace(/&lt;\/del&gt;/g, '</del>');
+      return stg1;
+    } else {
+      return value;
+    }
+  };
+
+  kbn.sortObj = function(arr) {
+    // Setup Arrays
+    var sortedKeys = [];
+    var sortedObj = {};
+    var i;
+    // Separate keys and sort them
+    for (i in arr) {
+      sortedKeys.push(i);
+    }
+    sortedKeys.sort();
+
+    // Reconstruct sorted obj based on keys
+    for (i in sortedKeys) {
+      sortedObj[sortedKeys[i]] = arr[sortedKeys[i]];
+    }
+    return sortedObj;
+  };
+
+  kbn.query_color_dot = function (color, diameter) {
+    return '<div class="icon-circle" style="' + [
+        'display:inline-block',
+        'color:' + color,
+        'font-size:' + diameter + 'px',
+      ].join(';') + '"></div>';
+  };
+
+  return kbn;
+});