riemann-dash 0.0.3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Kyle Kingsbury
+
+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.markdown

@@ -0,0 +1,51 @@
+Riemann-Dash
+============
+
+An extensible Sinatra dashboard for Riemann. Connects to Riemann over the
+network and shows events matching the queries you configure.
+
+Get started
+==========
+
+``` bash
+gem install riemann-dash
+riemann-dash
+```
+
+Riemann-dash will connect to a local Riemann server on port 5555, and display a
+basic dashboard of all events in that server's index.
+
+Configuring
+===========
+
+Riemann-dash takes an optional config file, which you can specify as the first
+command-line argument. If none is given, it looks for a file in the local
+directory: config.rb. That file can override any configuration options on the
+Dash class (hence all Sinatra configuration) as well as the Riemann client
+options, etc.
+
+``` ruby
+set :port, 6000 # HTTP server on port 6000
+config[:client][:host] = 'my.ustate.server'
+```
+
+You'll probably want a more specific dashboard:
+
+``` ruby
+config[:view] = 'my/custom/view'
+```
+
+Then you can write your own index.erb (and other views too, if you like). I've
+provided an default stylesheet, layout, and dashboard in
+lib/riemann/dash/views--as well as an extensive set of functions for laying out
+events from a given query: see lib/riemann/dash/helper/renderer.rb.
+
+A long history with cacti, nagios, and the like has convinced me that a.) web
+configuration of dashboards is inevitably slower than just writing the code and
+b.) you're almost certainly going to want to need more functions than I can
+give you. My goal is to give you the tools to make it easier and get out of
+your way.
+
+An example config.rb, additional controllers, views, and public directory are
+all in doc/dash. Should give you ideas for extending the dashboard for your own
+needs.

data/bin/riemann-dash

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'riemann/dash'
+
+Riemann::Dash.load ARGV.first 
+Riemann::Dash.run!

data/lib/riemann/dash/controller/css.rb

@@ -0,0 +1,5 @@
+class Riemann::Dash
+  get '/css' do
+    scss :css, :layout => false
+  end
+end

data/lib/riemann/dash/controller/index.rb

@@ -0,0 +1,5 @@
+class Riemann::Dash
+  get '/' do
+    erb :index
+  end
+end

data/lib/riemann/dash/helper/renderer.rb

@@ -0,0 +1,258 @@
+module Riemann
+  class Dash
+    helpers do
+      include ::Rack::Utils
+
+      alias_method :h, :escape_html
+
+      # Returns a scalar factor from 0.2 to 1, where 0.2 is "on the order of
+      # age_scale ago", and 1 is "very recent"
+      def age_fraction(time)
+        return 1 if time.nil?
+
+        x = 1 - ((Time.now.to_f - time) / Dash.config[:age_scale])
+        if x < 0.2
+          0.2
+        elsif x > 1
+          1
+        else
+          x
+        end
+      end
+
+      # Finds the longest common prefix of a list of strings.
+      # i.e. 'abc, 'ab', 'abdf' => 'ab'
+      def longest_common_prefix(strings, prefix = '')
+        return strings.first if strings.size <= 1
+
+        first = strings[0][0,1] or return prefix
+        tails = strings[1..-1].inject([strings[0][1..-1]]) do |tails, string|
+          if string[0,1] != first
+            return prefix
+          else
+            tails << string[1..-1]
+          end
+        end
+
+        longest_common_prefix(tails, prefix + first)
+      end
+
+      # An overview of states
+      def state_list(states)
+        ul(states.map { |s| state_short s })
+      end
+
+      def state_grid(states = Dash.client.query)
+        h2('States by Host') +
+        table(
+          *Event.partition(states, :host).map do |host, states|
+            tr(
+              th(host, class: 'host'),
+              *Event.sort(states, :service).map do |state|
+                state_short state
+              end
+            )
+          end
+        )
+      end
+
+      # Renders a state as the given HTML tag with a % width corresponding to
+      # metric / max.
+      def state_bar(s, opts = {})
+        opts = {tag: 'div', max: 1}.merge opts
+
+        return '' unless s
+        x = s.metric
+
+        # Text
+        text = case x
+        when Float
+          '%.2f' % x
+        when Integer
+          x.to_s
+        else
+          '?'
+        end
+
+        # Size
+        size = begin
+          (x || 0) * 100 / opts[:max]
+        rescue ZeroDivisionError
+          0
+        end
+        size = "%.2f" % size
+
+        tag opts[:tag], h(text), 
+          :class => "state #{s.state}", 
+          style: "opacity: #{age_fraction s.time}; width: #{size}%", 
+          title: s.description
+      end
+
+      # Renders a set of states in a chart. Each row is a given host, each
+      # service is a column. Each state is shown as a bar with an inferred
+      # maximum for the entire service, so you can readily compare multiple
+      # hosts.
+      #
+      # Takes a a set of states and options:
+      #   title: the title of the chart. Inferred to be the longest common
+      #          prefix of all services.
+      #   maxima: maps each service to the maximum value used to display its
+      #           bar.
+      #   service_names: maps each service to a friendly name. Default service
+      #                  names have common prefixes removed.
+      #   hosts: an array of hosts for rows. Default is every host present in
+      #          states, sorted.
+      #   transpose: Hosts go across, services go down. Enables :global_maxima.
+      #   global_maximum: Compute default maxima for services globally,
+      #                  instead of a different maximum for each service.
+      def state_chart(states, opts = {})
+        o = {
+          :maxima => {},
+          :service_names => {}
+        }.merge opts
+        if o[:transpose] and not o.include?(:global_maximum)
+          o[:global_maximum] = true
+        end
+
+        # Get all services
+        services = states.map { |s| s.service }.compact.uniq.sort
+
+        # Figure out what name to use for each service.
+        prefix = longest_common_prefix services
+        service_names = services.inject({}) do |names, service|
+          names[service] = service[prefix.length..-1]
+          names
+        end.merge o[:service_names]
+
+        # Compute maximum for each service
+        maxima = if o[:global_maximum]
+          max = states.map(&:metric).compact.max
+          services.inject({}) do |m, s|
+            m[s] = max
+            m
+          end.merge o[:maxima]
+        else
+          states.inject(Hash.new(0)) do |m, s|
+            if s.metric
+              m[s.service] = [s.metric, m[s.service]].max
+            end
+            m
+          end.merge o[:maxima]
+        end
+
+        # Compute union of all hosts for these states, if no
+        # list of hosts explicitly given.
+        hosts = o[:hosts] || states.map do |state|
+          state.host
+        end
+        hosts = hosts.uniq.sort { |a, b|
+          if !a
+            -1
+          elsif !b
+            1
+          else
+            a <=> b
+          end
+        }
+
+        # Construct index
+        by = states.inject({}) do |index, s|
+          index[[s.host, s.service]] = s
+          index
+        end
+
+        # Title
+        title = o[:title] || prefix.capitalize rescue 'Unknown'
+
+        if o[:transpose]
+          h2(title) +
+          table(
+            tr(
+              th,
+              *hosts.map do |host|
+                th host
+              end
+            ),
+            *services.map do |service|
+              tr(
+                th(service_names[service]),
+                *hosts.map do |host|
+                  s = by[[host, service]]
+                  td(
+                    s ? state_bar(s, max: maxima[service]) : nil
+                  )
+                end
+              )
+            end,
+            :class => 'chart'
+          )
+        else
+          h2(title) +
+          table(
+            tr(
+              th,
+              *services.map do |service|
+                th service_names[service]
+              end
+            ),
+            *hosts.map do |host|
+              tr(
+                th(host),
+                *services.map do |service|
+                  s = by[[host, service]]
+                  td(
+                    s ? state_bar(s, max: maxima[service]) : nil
+                  )
+                end
+              )
+            end,
+            :class => 'chart'
+          )
+        end
+      end
+
+      # Renders a state as a short tag.
+      def state_short(s, opts={tag: 'li'})
+        if s
+          "<#{opts[:tag]} class=\"state #{s.state}\" style=\"opacity: #{age_fraction s.time}\" title=\"#{h s.description}\">#{h s.host} #{h s.service}</#{opts[:tag]}>"
+        else
+          "<#{opts[:tag]} class=\"service\"></#{opts[:tag]}>"
+        end
+      end
+      
+      # Renders a time to an HTML tag.
+      def time(unix)
+        t = Time.at(unix)
+        "<time datetime=\"#{t.iso8601}\">#{t.strftime(Dash.config[:strftime])}</time>"
+      end
+
+      # Renders an HTML tag
+      def tag(tag, *a)
+        if Hash === a.last
+          opts = a.pop
+        else
+          opts = {}
+        end
+
+        attrs = opts.map do |k,v|
+          "#{k}=\"#{h v}\""
+        end.join ' '
+
+        content = if block_given?
+          a << yield
+        else
+          a
+        end.flatten.join("\n")
+
+        s = "<#{tag} #{attrs}>#{content}</#{tag}>"
+      end
+      
+      # Specific tag aliases
+      %w(div span h1 h2 h3 h4 h5 h6 ul ol li table th tr td u i b).each do |tag|
+        class_eval "def #{tag}(*a, &block)
+          tag #{tag.inspect}, *a, &block
+        end"
+      end
+    end 
+  end
+end

data/lib/riemann/dash/rack/static.rb

@@ -0,0 +1,16 @@
+class Riemann::Dash::Static
+  def initialize(app, options = {})
+    @app = app
+    @root = options[:root] or raise ArgumentError, "no root"
+    @file_server = ::Rack::File.new(@root)
+  end
+
+  def call(env)
+    r = @file_server.call env
+    if r[0] == 404   
+      @app.call env
+    else
+      r
+    end
+  end
+end

data/lib/riemann/dash/version.rb

@@ -0,0 +1,4 @@
+module Riemann; end
+class Riemann::Dash
+  VERSION = '0.0.3'
+end

data/lib/riemann/dash/views/css.scss

@@ -0,0 +1,39 @@
+html,table {
+  font-family: Helvetica Nueue, Helvetica, sans;
+  font-size: 8pt;
+}
+h1 {
+  margin-bottom: 0.2em;
+}
+h2 {
+  margin-top: 0;
+  margin-bottom: 0.1em;
+}
+
+.box {
+  float: left;
+  margin: 4px;
+}
+
+.ok {
+  background: #B8F1BC;
+}
+.warning {
+  background: #F7D18E;
+}
+.critical {
+  background: #FF3C43;
+}
+
+.chart {
+  width: 140px;
+  border: 1px solid #ccc;
+}
+.chart td {
+  min-width: 40px;
+  overflow: hidden;
+}
+.chart th {
+  width: 1px;
+  text-align: left;
+}

data/lib/riemann/dash/views/index.erubis

@@ -0,0 +1,8 @@
+<h2>Problems</h2>
+<div class="box"><%= state_list query('state != "ok"') %></div>
+
+<div class="box">
+<%= state_chart query('service = "cpu" or service = "memory" or service =~ "disk%" or service = "load"'), title: "Health" %>
+</div>
+
+<div class="box"><%= state_chart query('true'), title: "Everything" %></div>

data/lib/riemann/dash/views/layout.erubis

@@ -0,0 +1,21 @@
+<html>
+<head>
+  <title>Dashboard</title>
+  <link rel="stylesheet" type="text/css" href="/css" />
+
+  <script type="text/javascript">
+    setTimeout(function() {
+      location.reload(true);
+    }, 10000);
+  </script>
+</head>
+
+<body onload="refresh();">
+  <div>
+    <h1>Dashboard</h1>
+    <span style="position: absolute; top: 4px; right: 4px;">(as of <%= time Time.now.to_i %>)</span>
+  </div>
+  
+  <%= yield %>
+</body>
+</html>

data/lib/riemann/dash.rb

@@ -0,0 +1,126 @@
+require 'riemann/client'
+require 'sinatra/base'
+
+module Riemann
+  class Dash < Sinatra::Base
+    # A little dashboard sinatra application.
+    
+    require 'yaml'
+    require 'find'
+    require 'erubis'
+    require 'sass'
+    
+    def self.config
+      @config ||= {
+        client: {},
+        age_scale: 60 * 30,
+        state_order: {
+          'critical' => 3,
+          'warning' => 2,
+          'ok' => 1
+        },
+        strftime: '%H:%M:%S',
+        controllers: [File.join(File.dirname(__FILE__), 'dash', 'controller')],
+        helpers: [File.join(File.dirname(__FILE__), 'dash', 'helper')],
+        views: File.join(File.dirname(__FILE__), 'dash', 'views')
+      }
+    end
+
+    def self.client
+      @client ||= Riemann::Client.new(config[:client])
+    end
+
+    def self.load(filename)
+      unless load_config(filename || 'config.rb')
+        # Configuration failed; load a default view.
+        puts "No configuration loaded; using defaults."
+      end
+
+      config[:controllers].each { |d| load_controllers d }
+      config[:helpers].each { |d| load_helpers d }
+      set :views, File.expand_path(config[:views])
+    end
+
+    # Executes the configuration file.
+    def self.load_config(filename)
+      begin 
+        instance_eval File.read(filename)
+        true
+      rescue Errno::ENOENT
+        false
+      end
+    end
+
+    # Load controllers.
+    # Controllers can be regular old one-file-per-class, but if you prefer a little
+    # more modularity, this method will allow you to define all controller methods
+    # in their own files.  For example, get "/posts/*/edit" can live in
+    # controller/posts/_/edit.rb. The sorting system provided here requires
+    # files in the correct order to handle wildcards appropriately.
+    def self.load_controllers(dir)
+      rbs = []
+      Find.find(
+        File.expand_path(dir)
+      ) do |path|
+        rbs << path if path =~ /\.rb$/
+      end
+
+      # Sort paths with _ last, becase those are wildcards.
+      rbs.sort! do |a, b|
+        as = a.split File::SEPARATOR
+        bs = b.split File::SEPARATOR
+
+        # Compare common subpaths
+        l = [as.size, bs.size].min
+        catch :x do
+          (0...l).each do |i|
+            a, b = as[i], bs[i]
+            if a[/^_/] and not b[/^_/]
+              throw :x, 1
+            elsif b[/^_/] and not a[/^_/]
+              throw :x, -1
+            elsif ord = (a <=> b) and ord != 0
+              throw :x, ord
+            end
+          end
+
+          # All subpaths are identical; sort longest first
+          if as.size > bs.size
+            throw :x, -1
+          elsif as.size < bs.size
+            throw :x, -1
+          else
+            throw :x, 0
+          end
+        end
+      end
+
+      rbs.each do |r|
+        require r
+      end 
+    end 
+
+    # Load helpers
+    def self.load_helpers(dir)
+      Find.find(
+        File.expand_path(dir)
+      ) do |path|
+        require path if path =~ /\.rb$/
+      end
+    end
+
+    # Add an additional public directory.
+    def self.public_dir(dir)
+      require 'riemann/dash/rack/static'
+      use Riemann::Dash::Static, :root => dir
+    end
+
+    def client
+      self.class.client
+    end
+
+    def query(*a)
+      self.class.client.query(*a).events || []
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: riemann-dash
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Kyle Kingsbury
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: riemann-client
+  requirement: &9900960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *9900960
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: &9900240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *9900240
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &9899640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *9899640
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: &9898820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.14
+  type: :runtime
+  prerelease: false
+  version_requirements: *9898820
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &9898320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *9898320
+description: 
+email: aphyr@aphyr.com
+executables:
+- riemann-dash
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/riemann/dash.rb
+- lib/riemann/dash/version.rb
+- lib/riemann/dash/rack/static.rb
+- lib/riemann/dash/views/index.erubis
+- lib/riemann/dash/views/layout.erubis
+- lib/riemann/dash/views/css.scss
+- lib/riemann/dash/controller/index.rb
+- lib/riemann/dash/controller/css.rb
+- lib/riemann/dash/helper/renderer.rb
+- bin/riemann-dash
+- LICENSE
+- README.markdown
+homepage: https://github.com/aphyr/riemann-dash
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: riemann-dash
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: HTTP dashboard for the distributed event system Riemann.
+test_files: []