dasht 0.1.0

data/assets/plugins/map.html

@@ -0,0 +1,4 @@
+{{#title}}
+<div class="title">{{title}}</div>
+{{/title}}
+<div class="map"></div>

data/assets/plugins/map.js

@@ -0,0 +1,125 @@
+Dasht.map_geocoder_cache = {}
+
+Dasht.map_plot_address = function(map, markers, geocoder, address) {
+    // Maybe pull the location from cache.
+    var location;
+    if (location = Dasht.map_geocoder_cache[address]) {
+        Dasht.map_plot_location(map, markers, address, location);
+        return;
+    }
+
+    geocoder.geocode({ "address": address }, function(results, status) {
+        // Don't plot if the lookup failed.
+        if (status != google.maps.GeocoderStatus.OK) return;
+        var location = results[0].geometry.location;
+        Dasht.map_geocoder_cache[address] = location;
+        Dasht.map_plot_location(map, markers, address, location);
+    });
+}
+
+Dasht.map_plot_ip = function(map, markers, ip) {
+    // Maybe pull the location from cache.
+    var location;
+    if (location = Dasht.map_geocoder_cache[ip]) {
+        Dasht.map_plot_location(map, markers, ip, location);
+        return;
+    }
+
+    // http://freegeoip.net/json/
+    jQuery.ajax({
+        url: 'http://104.236.251.84/json/' + ip,
+        type: 'POST',
+        dataType: 'jsonp',
+        success: function(response) {
+            var location = new google.maps.LatLng(response.latitude, response.longitude);
+            Dasht.map_geocoder_cache[ip] = location;
+            Dasht.map_plot_location(map, markers, ip, location);
+        },
+        error: function (xhr, ajaxOptions, thrownError) {
+            alert("Failed!");
+        }
+    });
+}
+
+Dasht.map_plot_location = function(map, markers, address_or_ip, location) {
+    var location_exists = _.any(_.values(markers), function(marker) {
+        return _.isEqual(marker.position, location);
+    });
+    if (location_exists) return;
+
+    // Drop a pin.
+    var marker = new google.maps.Marker({
+        map: map,
+        animation: google.maps.Animation.DROP,
+        position: location
+    });
+
+    // Keep track of markers.
+    markers[address_or_ip] = marker;
+}
+
+Dasht.map_init = function(el, options) {
+    // Initialize.
+    var old_data = undefined;
+    var styles = [
+        {
+            stylers: [
+                { hue: "#ffffff" },
+                { saturation: -100 },
+                { lightness: 20 },
+                { gamma: 0.5 }
+            ]
+        },
+        {
+            featureType: "water",
+            stylers: [
+                { hue: "#ffffff" },
+                { saturation: 80 },
+                { lightness: 100 },
+                { gamma: 0.43 }
+            ]
+        }
+    ];
+
+    var mapOptions = {
+        zoom: 4,
+        center: new google.maps.LatLng(39.8282, -98.5795),
+        styles: styles,
+        disableDefaultUI: true
+    };
+
+    var map_el = $(el).find(".map").get()[0];
+    var num_entries = options["n"] || 10;
+    var map = new google.maps.Map(map_el, mapOptions);
+    var markers = {};
+    var geocoder = new google.maps.Geocoder();
+    var ip_regex = /\d+\.\d+\.\d+\.\d+/;
+
+    Dasht.fill_tile($(el).find(".map"));
+
+    // Update values.
+    setTimeout(function() {
+        Dasht.get_value(options, function(new_data) {
+            new_data = new_data[0];
+            if (_.isEqual(old_data, new_data)) return;
+
+            // Remove old markers.
+            var old_markers = _.difference(_.keys(markers), new_data);
+            _.each(old_markers, function(address) {
+                markers[address].setMap(null);
+                delete markers[address];
+            });
+
+            // Plot each marker.
+            _.each(new_data, function(item, index) {
+                if (item.search(ip_regex) >= 0) {
+                    Dasht.map_plot_ip(map, markers, item);
+                } else {
+                    Dasht.map_plot_address(map, markers, geocoder, item);
+                }
+            });
+
+            old_data = new_data;
+        });
+    }, 1000);
+}

data/assets/plugins/scroll.css

@@ -0,0 +1,2 @@
+@media (max-width: 640px) {
+}

data/assets/plugins/scroll.html

@@ -0,0 +1,2 @@
+<div class="title">{{title}}</div>
+<div class="metric" data-metric="{{metric}}" data-resolution="{{resolution}}" data-refresh="{{refresh}}" />

data/assets/plugins/scroll.js

@@ -0,0 +1,14 @@
+Dasht.scroll_init = function(el, options) {
+    var old_value = undefined;
+    var num_entries = options["n"] || 10;
+    var metric = $(el).find(".metric");
+    $(el).on('update', function(event, value) {
+        value = value.slice(-1 * num_entries);
+        if (_.isEqual(old_value, value)) return;
+        metric.animate({ opacity: 0.8 }, 0, function() {
+            metric.html(value.join("<br />"));
+            metric.animate({ opacity: 1.0 }, 400);
+        });
+        old_value = value;
+    });
+}

data/assets/plugins/value.css

@@ -0,0 +1,18 @@
+.value-tile .value {
+    font-family: 'Lato', sans-serif;
+    color: rgba(255, 255, 255, 0.9);
+    margin: auto;
+    font-size: 80px;
+    font-weight: bold;
+    margin: 20px 20px 0px 20px;
+    display: flex;
+    align-items: center;
+}
+
+@media (max-width: 640px) {
+    .value-tile .value {
+        margin-top: 20px;
+        margin-bottom: 20px;
+        font-size: 30px;
+    }
+}

data/assets/plugins/value.html

@@ -0,0 +1,4 @@
+{{#title}}
+<div class="title">{{title}}</div>
+{{/title}}
+<div class="value fontsize-large" />

data/assets/plugins/value.js

@@ -0,0 +1,26 @@
+Dasht.value_update = function(el, value) {
+    $(el).css("opacity", 0.7);
+    $(el).html(value.toLocaleString());
+    $(el).animate({ "opacity": 1.0 });
+}
+
+Dasht.value_init = function(el, options) {
+    // Initialize.
+    var value = $(el).find(".value");
+    var value_el = value.get()[0];
+    var old_data = undefined;
+
+    // Set the value height to be tile height minus title height.
+    Dasht.fill_tile($(el).find(".title"), true, false);
+    Dasht.fill_tile(value);
+
+    // Update values.
+    setTimeout(function() {
+        Dasht.get_value(options, function(new_data) {
+            new_data = new_data[0];
+            if (_.isEqual(old_data, new_data)) return;
+            Dasht.value_update(value, new_data);
+            old_data = new_data;
+        });
+    }, 1000);
+}

data/examples/simple_heroku_dashboard.rb

@@ -0,0 +1,34 @@
+require 'dasht'
+
+application = ARGV[0]
+
+dasht do |d|
+  # Consume Heroku logs.
+  d.start "heroku logs --tail --app #{application}" do |l|
+    # Track some metrics.
+    l.count :lines, /.+/
+
+    l.count :bytes, /.+/ do |match|
+      match[0].length
+    end
+
+    l.append :visitors, /Started GET .* for (\d+\.\d+\.\d+\.\d+) at/ do |matches|
+      matches[1]
+    end
+  end
+
+  counter = 0
+  d.interval :counter do
+    sleep 1
+    counter += 1
+  end
+
+  # Publish a board.
+  d.board do |b|
+    b.value :counter,  :title => "Counter"
+    b.value :lines,    :title => "Number of Lines"
+    b.value :bytes,    :title => "Number of Bytes"
+    b.chart :bytes,    :title => "Chart of Bytes", :periods => 10
+    b.map   :visitors, :title => "Visitors", :width => 12, :height => 9
+  end
+end

data/lib/dasht.rb

@@ -0,0 +1,25 @@
+require 'rack'
+require 'thread'
+require 'erb'
+require 'json'
+
+require 'dasht/array_monkeypatching'
+require 'dasht/reloader'
+require 'dasht/board'
+require 'dasht/list'
+require 'dasht/metric'
+require 'dasht/collector'
+require 'dasht/rack_app'
+require 'dasht/log_thread'
+require 'dasht/base'
+
+class DashtSingleton
+  def self.run(&block)
+    @@instance ||= Dasht::Base.new
+    @@instance.run(&block)
+  end
+end
+
+def dasht(&block)
+  DashtSingleton.run(&block)
+end

data/lib/dasht/array_monkeypatching.rb

@@ -0,0 +1,5 @@
+class Array
+  def dasht_sum
+    self.compact.inject(:+) || 0;
+  end
+end

data/lib/dasht/base.rb

@@ -0,0 +1,117 @@
+module Dasht
+  class Base
+    attr_accessor :metrics
+    attr_accessor :rack_app
+    attr_accessor :reloader
+    attr_accessor :boards
+
+    # Settings.
+    attr_accessor :port
+    attr_accessor :background
+    attr_accessor :default_resolution
+    attr_accessor :default_refresh
+    attr_accessor :default_width
+    attr_accessor :default_height
+    attr_accessor :history
+
+    def initialize
+      @boards      = {}
+      @log_threads = {}
+      @metrics     = Metrics.new(self)
+      @reloader    = Reloader.new(self)
+      @rack_app    = RackApp.new(self)
+    end
+
+    def log(s)
+      if s.class < Exception
+        print "\n#{s}\n"
+        print s.backtrace.join("\n")
+      else
+        print "\r#{s}\n"
+      end
+    end
+
+    ### DATA INGESTION ###
+
+    def start(command, &block)
+      log_thread = @log_threads[command] = LogThread.new(self, command)
+      yield(log_thread) if block
+      log_thread
+    end
+
+    def tail(path)
+      start("tail -F -n 0 \"#{path}\"")
+    end
+
+    def interval(metric, &block)
+      Thread.new do
+        begin
+          while true
+            value = block.call
+            set(metric, value, :last) if value
+          end
+        rescue => e
+          log e
+          raise e
+        end
+      end
+    end
+
+    ### DASHBOARD ###
+
+    def views_path
+      File.join(File.dirname(__FILE__), "..", "..", "views")
+    end
+
+    def system_plugins_path
+      File.join(File.dirname(__FILE__), "..", "..", "assets", "plugins")
+    end
+
+    def user_plugins_path
+      File.join(File.dirname($PROGRAM_NAME), "plugins")
+    end
+
+    def board(name = "default", &block)
+      name = name.to_s
+      board = @boards[name] = Board.new(self, name)
+      yield(board) if block
+      board
+    end
+
+    ### RUN & RELOAD ###
+
+    def run(&block)
+      if @already_running
+        begin
+          reload(&block)
+        rescue => e
+          log e
+        end
+        return
+      end
+
+      @already_running = true
+      @reloader.run
+
+      block.call(self)
+
+      @log_threads.values.map(&:run)
+      @rack_app.run(port)
+    end
+
+    def reload(&block)
+      @boards = {}
+      @log_threads.values.map(&:terminate)
+      @log_threads = {}
+
+      begin
+        block.call(self)
+      rescue => e
+        log e
+        raise e
+      end
+
+      @log_threads.values.map(&:run)
+    end
+  end
+end

data/lib/dasht/board.rb

@@ -0,0 +1,108 @@
+module Dasht
+  class Board
+    attr_accessor :parent
+    attr_accessor :name
+    attr_accessor :tiles
+    attr_accessor :background
+    attr_accessor :default_resolution
+    attr_accessor :default_refresh
+    attr_accessor :default_width
+    attr_accessor :default_height
+
+    def initialize(parent, name)
+      @parent = parent
+      @name  = name
+      @tiles = []
+    end
+
+    def to_html
+      # Load the erb.
+      path = File.join(parent.views_path, "dashboard.erb")
+      @erb = ERB.new(IO.read(path))
+      @erb.result(binding)
+    end
+
+    def emit_plugin_css
+      _emit_css(parent.system_plugins_path)
+    end
+
+    def emit_plugin_html
+      _emit_html(parent.system_plugins_path)
+    end
+
+    def emit_plugin_js
+      _emit_js(parent.system_plugins_path)
+    end
+
+    def method_missing(method, *args, &block)
+      begin
+        metric = args.shift
+        options = args.pop || {}
+        @tiles << {
+          :type       => method,
+          :metric     => metric,
+          :resolution => self.default_resolution || parent.default_resolution || 60,
+          :refresh    => self.default_refresh    || parent.default_refresh    || 5,
+          :width      => self.default_width      || parent.default_width      || 3,
+          :height     => self.default_height     || parent.default_height     || 3,
+          :extra_args => args
+        }.merge(options)
+      rescue => e
+        super(method, *args, &block)
+      end
+    end
+
+    private
+
+    def emit_tile_js
+      s = "<script>\n"
+      s += "$(function() {\n";
+      @tiles.map do |options|
+        s += "Dasht.add_tile(#{options.to_json});\n"
+      end
+      s += "});"
+      s += "</script>\n"
+      s
+    end
+
+    def emit_board_js
+      s = "<script>"
+      if background = self.background || parent.background
+        s += "$('body').css('background', #{background.to_json});\n"
+      end
+      s += "</script>\n"
+      s
+    end
+
+    def _emit_css(plugin_path)
+      s = ""
+      Dir[File.join(plugin_path, "*.css")].each do |path|
+        name = File.basename(path)
+        s += "<link rel='stylesheet' type='text/css' href='/assets/plugins/#{name}'>\n"
+      end
+      return s
+    end
+
+    def _emit_html(plugin_path)
+      s = ""
+      Dir[File.join(plugin_path, "*.html")].each do |path|
+        name = File.basename(path).gsub(".html", "")
+        s += "<script id='#{name}-template' type='x-tmpl-mustache'>\n"
+        s += "<div class='tile #{name}-tile width-{{width}} height-{{height}}'>\n"
+        s += IO.read(path)
+        s += "</div>\n"
+        s += "</script>\n"
+      end
+      return s
+    end
+
+    def _emit_js(plugin_path)
+      s = ""
+      Dir[File.join(plugin_path, "*.js")].each do |path|
+        name = File.basename(path)
+        s += "<script src='/assets/plugins/#{name}'></script>\n"
+      end
+      s
+    end
+  end
+end