casseo 0.1.0

data/README.md

@@ -0,0 +1,77 @@
+Casseo
+======
+
+A Graphite dashboard viewable without ever leaving the command line. Configuration and concept very similar to [Tasseo](tasseo).
+
+Install via Rubygems:
+
+    gem install casseo
+
+Or if you're really concerned about Rubygems' speed, clone the reposistory and create a standalone version (Ruby 1.9 satisfies all of Casseo's dependencies):
+
+    git clone https://github.com/brandur/casseo.git
+    cd casseo
+    rake standalone
+    mv casseo ~/bin/casseo
+
+Configuration
+-------------
+
+Casseo expects to be able to find your Graphite credentials at `~/.casseorc`:
+
+    echo '{ graphite_auth: "graphite:my_secret_api_key", graphite_url: "https://graphite.example.com:8080" }' > ~/.casseorc
+    chmod 600 ~/.casseorc
+
+Other allowed configuration options are:
+
+    * `compressed_chart:` whether to include a space between chart symbols
+    * `dashboard_default:` name of the dashboard to load if none is specified
+    * `interval:` Graphite update interval in seconds
+
+Dashboards
+----------
+
+Dashboards are configured via simple Ruby in a manner reminiscent of Tasseo. All `*.rb` files in `~/.casseo/dashboards` or in any of its subdirectories are loaded automatically at startup. Dashboards are assigned names so that they can be referenced and opened like so:
+
+    casseo home
+
+An example dashboard that can be saved to `~/.casseo/dashboards/home.rb`:
+
+``` ruby
+Casseo::Dashboard.define(:api) do |d|
+  d.metric "custom.api.production.requests.per-sec", display: "req/sec"
+  d.blank
+  d.metric "custom.api.production.requests.500.per-min", display: "req 500/min"
+  d.metric "custom.api.production.requests.502.per-min", display: "req 502/min"
+  d.metric "custom.api.production.requests.503.per-min", display: "req 503/min"
+  d.metric "custom.api.production.requests.504.per-min", display: "req 504/min"
+  d.blank
+  d.metric "custom.api.production.requests.user-errors.per-min", display: "req user err/min"
+  d.blank
+  d.metric "custom.api.production.requests.latency.avg", display: "req latency"
+end
+```
+
+Get a list of all known dashboards:
+
+    casseo --list
+
+Casseo also takes a file as its first parameter:
+
+    casseo ~/.casseo/dashboards/home.rb
+
+Key Bindings
+------------
+
+For now, there are no options on key bindings. Here's what you get:
+
+    * `j` page down
+    * `k` page up
+    * `q` quit
+    * `1` 5 minute range
+    * `2` 60 minute range
+    * `3` 3 hour range
+    * `4` 24 hour range
+    * `5` 7 day range
+
+[tasseo]: https://github.com/obfuscurity/tasseo

data/Rakefile

@@ -0,0 +1,2 @@
+task :standalone
+end

data/bin/casseo

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "curses"
+require "json"
+require "net/https"
+require "timeout"
+require "uri"
+
+require_relative "../lib/casseo"
+
+# load all user dashboards
+dir = "#{File.expand_path("~")}/.casseo/dashboards"
+if File.exists?(dir)
+  # clever hack to get symlinks working properly
+  Dir["#{dir}/**{,/*/**}/*.rb"].each do |d|
+    require d
+  end
+end
+
+$exit_message = nil
+
+["TERM", "INT"].each do |s|
+  Signal.trap(s) do
+    $exit_message = "Caught deadly signal"
+    Kernel.exit(0)
+  end
+end
+
+begin
+  Curses.cbreak      # no need for a newline to get type chars
+  Curses.curs_set(1) # invisible
+  Curses.noecho      # don't echo character on a getch
+
+  Curses.init_screen
+
+  # fail fast on missing required config
+  Casseo::Config.required
+
+  if ARGV.count > 0 && File.exists?(ARGV.first)
+    require ARGV.first
+  elsif ARGV.count > 0 && ["-l", "--list"].include?(ARGV.first)
+    $exit_message = Casseo::Dashboard.index.sort.join("\n")
+  elsif ARGV.first
+    Casseo::Dashboard.run(ARGV.first.to_sym)
+  else
+    Casseo::Dashboard.run(Casseo::Config.dashboard_default)
+  end
+rescue Casseo::ConfigError, Casseo::DashboardNotFound => e
+  $exit_message = e.message
+ensure
+  Curses.close_screen
+  puts $exit_message if $exit_message
+end

data/lib/casseo.rb

@@ -0,0 +1,4 @@
+require_relative "casseo/config"
+require_relative "casseo/index"
+require_relative "casseo/dashboard"
+require_relative "casseo/version"

data/lib/casseo/config.rb

@@ -0,0 +1,49 @@
+module Casseo
+  module Config
+    extend self
+
+    # whether an extra space is inserted between chart characters
+    def compressed_chart
+      config(:compressed_chart)
+    end
+
+    def dashboard_default
+      config(:dashboard_default) || :home
+    end
+
+    def graphite_auth
+      config!(:graphite_auth)
+    end
+
+    def graphite_url
+      config!(:graphite_url)
+    end
+
+    # seconds
+    def interval
+      config(:interval) || 2.0
+    end
+
+    def required
+      [ Casseo::Config.graphite_auth,
+        Casseo::Config.graphite_url ]
+    end
+
+    private
+
+    def casseorc
+      @@casseorc ||= eval(File.read(File.expand_path("~/.casseorc")))
+    end
+
+    def config(sym)
+      casseorc[sym]
+    end
+
+    def config!(sym)
+      casseorc[sym] or raise ConfigError.new(":#{sym} not found in ~/.casseorc")
+    end
+  end
+
+  class ConfigError < StandardError
+  end
+end

data/lib/casseo/dashboard.rb

@@ -0,0 +1,166 @@
+# encoding: utf-8
+
+module Casseo
+  class Dashboard
+    CHART_CHARS = [" "] + %w(▁ ▂ ▃ ▄ ▅ ▆ ▇)
+
+    extend Index
+
+    def initialize
+      @confs = []
+      @data = nil
+      @page = 0
+      @period = 5 # minutes
+    end
+
+    def blank
+      @confs << nil
+    end
+
+    def metric(metric, conf = {})
+      @confs << conf.merge(metric: metric)
+    end
+
+    def run
+      @longest_display = @confs.compact.
+        map { |c| c[:display] || c[:metric] }.map { |c| c.length }.max
+
+      # no data yet, but force drawing of stats to the screen
+      show(true)
+
+      Thread.new do
+        # one initial fetch where we don't suppress errors so that the user can
+        # verify that their credentials are right
+        fetch(false)
+        sleep(Config.interval)
+
+        loop do
+          fetch
+          sleep(Config.interval)
+        end
+      end
+
+      loop do
+        show
+        begin
+          Timeout::timeout(Config.interval) do
+            handle_key_presses
+          end
+        rescue Timeout::Error
+        end
+      end
+    end
+
+    private
+
+    def clamp(n, min, max)
+      if n < min
+        min
+      elsif n > max
+        max
+      else
+        n
+      end
+    end
+
+    def fetch(suppress_errors=true)
+      metrics = @confs.compact.map { |c| c[:metric] }
+      targets = metrics.map { |m| "target=#{URI.encode(m)}" }.join("&")
+      uri = URI.parse("#{Config.graphite_url}/render/?#{targets}&from=-#{@period}minutes&format=json")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request.basic_auth(*Config.graphite_auth.split(":"))
+
+      @data = begin
+        response = http.request(request)
+        JSON.parse(response.body)
+      rescue
+        raise unless suppress_errors
+        nil
+      end
+    end
+
+    def handle_key_presses
+      loop do
+        new_page   = nil
+        new_period = nil
+
+        case Curses.getch
+        when Curses::KEY_RESIZE then show
+        when ?j then new_page = clamp(@page + 1, 0, num_pages)
+        when ?k then new_page = clamp(@page - 1, 0, num_pages)
+        when ?q then Kernel.exit(0)
+        when ?1 then new_period = 5
+        when ?2 then new_period = 60
+        when ?3 then new_period = 60 * 3
+        when ?4 then new_period = 60 * 24
+        when ?5 then new_period = 60 * 24 * 7
+        end
+
+        if new_page && new_page != @page
+          @page = new_page
+          Curses.clear
+          show
+        end
+
+        if new_period && new_period != @period
+          @period = new_period
+          # will update the next time the fetch loop runs
+        end
+      end
+    end
+
+    def num_pages
+      (@confs.count / Curses.lines).ceil
+    end
+
+    def show(force_draw=false)
+      # force us through the method
+      @data = @data || [] if force_draw
+
+      # failed to fetch on this cycle
+      return unless @data
+
+      @confs.each_with_index do |conf, i|
+        next unless conf
+        next unless i >= @page * Curses.lines && i < (@page + 1) * Curses.lines
+
+        data_points = @data.detect { |d| d["target"] == conf[:metric] }
+        data_points = data_points ? data_points["datapoints"] : []
+
+        # show left to right latest to oldest
+        data_points.reverse!
+
+        max = data_points.
+          select { |p| p[0] != nil }.
+          max { |p1, p2| p1[0] <=> p2[0] }
+        max = max ? max[0] : nil
+
+        latest = data_points.detect { |p| p[0] != nil }
+        latest = latest ? latest[0] : 0.0
+
+        current = nil
+        chart = ""
+        if max && max > 0
+          data_points.each do |p|
+            current = p[0] || current
+            next unless current
+            index = (current.to_f / max * CHART_CHARS.count).to_i - 1
+            chart += CHART_CHARS[index]
+            chart += " " unless Config.compressed_chart
+          end
+        end
+
+        unit = conf[:unit] || " "
+        str = "%-#{@longest_display}s %8.1f%s %s" %
+          [conf[:display] || conf[:metric], latest, unit, chart]
+        str = str[0...Curses.cols]
+        Curses.setpos(i % Curses.lines, 0)
+        Curses.addstr(str)
+      end
+      Curses.refresh
+    end
+  end
+end

data/lib/casseo/index.rb

@@ -0,0 +1,27 @@
+module Casseo
+  module Index
+    @@index = {}
+
+    def define(name)
+      dashboard = Dashboard.new
+      yield(dashboard)
+      @@index[name] = dashboard
+      dashboard
+    end
+
+    def index
+      @@index.keys
+    end
+
+    def run(name)
+      if @@index.key?(name)
+        @@index[name].run
+      else
+        raise DashboardNotFound.new("#{name} is not a known dashboard")
+      end
+    end
+  end
+
+  class DashboardNotFound < StandardError
+  end
+end

data/lib/casseo/version.rb

@@ -0,0 +1,3 @@
+module Casseo
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: casseo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Brandur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-01 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: brandur@mutelight.org
+executables:
+- casseo
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- !binary |-
+  YmluL2Nhc3Nlbw==
+- lib/casseo/config.rb
+- lib/casseo/dashboard.rb
+- lib/casseo/index.rb
+- lib/casseo/version.rb
+- lib/casseo.rb
+homepage: https://github.com/brandur/casseo
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Graphite dashboard for the command line.
+test_files: []