pencil 0.2.0 → 0.2.2

data/lib/models/dashboard.rb

@@ -0,0 +1,106 @@
+require "models/base"
+require "models/graph"
+require "models/host"
+require "set"
+
+module Dash::Models
+  class Dashboard < Base
+    attr_accessor :graphs
+    attr_accessor :graph_opts
+
+    def initialize(name, params={})
+      super
+
+      @graphs = []
+      @graph_opts = {}
+      params["graphs"].each do |name|
+        # graphs map to option hashes
+        if name.instance_of?(Hash)
+          g = Graph.find(name.keys.first) # should only be one key
+          @graph_opts[g] = name[name.keys.first]||{}
+        else
+          raise "Bad format for graph (must be a hash)"
+        end
+
+        @graphs << g if g
+      end
+
+    end
+
+    def clusters
+      clusters = Set.new
+      @graphs.each { |g| clusters += get_valid_hosts(g)[1] }
+      clusters.sort
+    end
+
+    def get_all_hosts(cluster=nil)
+      hosts = Set.new
+      clusters = Set.new
+      @graphs.each do |g|
+        h, c = get_valid_hosts(g, cluster)
+        hosts += h
+        clusters += c
+      end
+      return hosts, clusters
+    end
+
+    def get_valid_hosts(graph, cluster=nil)
+      clusters = Set.new
+      if cluster
+        hosts = Host.find_by_cluster(cluster)
+      else
+        hosts = Host.all
+        hosts.each { |h| clusters << h.cluster }
+      end
+
+      # filter by what matches the graph definition
+      hosts = hosts.select { |h| h.multi_match(graph["hosts"]) }
+
+      # filter if we have a dashboard-level 'hosts' filter
+      if @params["hosts"]
+        hosts = hosts.select { |h| h.multi_match(@params["hosts"]) }
+      end
+
+      hosts.each { |h| clusters << h.cluster }
+
+      return hosts, clusters
+    end
+
+    def render_cluster_graph(graph, clusters, opts={})
+      # FIXME: edge case where the dash filter does not filter to a subset of
+      # the hosts filter
+
+      hosts = get_host_wildcards(graph)
+      opts[:sum] = :cluster unless opts[:zoom]
+      graph_url = graph.render_url(hosts.to_a, clusters, opts)
+      return graph_url
+    end
+
+    def get_host_wildcards(graph)
+      return graph_opts[graph]["hosts"] || @params["hosts"] || graph["hosts"]
+    end
+
+    def render_global_graph(graph, opts={})
+      hosts = get_host_wildcards(graph)
+      _, clusters = get_valid_hosts(graph)
+
+      next_url = ""
+      type = opts[:zoom] ? :cluster : :global
+      options = opts.merge({:sum => type})
+      graph_url = graph.render_url(hosts, clusters, options)
+      return graph_url
+    end
+
+    def self.find_by_graph(graph)
+      ret = []
+      Dashboard.each do |name, dash|
+
+        if dash["graphs"].map { |x| x.keys.first }.member?(graph.name)
+          ret << dash
+        end
+      end
+
+      return ret
+    end
+  end # Dash::Models::Dashboard
+end # Dash::Models

data/lib/models/graph.rb

@@ -0,0 +1,304 @@
+require "models/base"
+require "uri"
+
+module Dash::Models
+  class Graph < Base
+    def initialize(name, params={})
+      super
+
+      @params["hosts"] ||= ["*"]
+      @params["title"] ||= name
+
+      if not @params["targets"]
+        raise ArgumentError, "graph #{name} needs a 'targets' map"
+      end
+    end
+
+    # fixme parameters in general
+    def width(opts={})
+      opts["width"] || @params[:url_opts][:width]
+    end
+
+    # translate STR into graphite-speak for applying FUNC to STR
+    # graphite functions take zero or one argument
+    # pass passes STR through, instead of raising an error if FUNC isn't
+    # recognized
+    def translate(func, str, arg=nil, pass=false)
+      # puts "calling translate"
+      # puts "func => #{func}"
+      # puts "str => #{str}"
+      # puts "arg => #{arg}"
+      # procs and lambdas don't support default arguments in 1.8, so I have to
+      # do this
+      z = lambda { |*body| "#{func}(#{body[0]||str})" }
+      y = "#{str}, #{arg}"
+      x = lambda { z.call(y) }
+
+      return \
+      case func.to_s
+        # comb
+      when "sumSeries", "averageSeries", "minSeries", "maxSeries", "group"
+        z.call
+        # transform
+      when "scale", "offset"
+        # perhaps .to_f
+        x.call
+      when "derivative", "integral"
+        z.call
+      when "nonNegativeDerivative"
+        z.call("#{str}#{', ' + arg if arg}")
+      when "log", "timeShift", "summarize", "hitcount",
+        # calculate
+        "movingAverage", "stdev", "asPercent"
+        x.call
+      when "diffSeries", "ratio"
+        z.call
+        # filters
+      when "mostDeviant"
+        z.call("#{arg}, #{str}")
+      when "highestCurrent", "lowestCurrent", "nPercentile", "currentAbove",
+        "currentBelow", "highestAverage", "lowestAverage", "averageAbove",
+        "averageBelow", "maximumAbove", "maximumBelow"
+        x.call
+      when "sortByMaxima", "minimalist"
+        z.call
+      when "limit", "exclude"
+        x.call
+      when "key", "alias"
+        "alias(#{str}, \"#{arg}\")"
+      when "cumulative", "drawAsInfinite"
+        z.call
+      when "lineWidth"
+        x.call
+      when "dashed", "keepLastValue"
+        z.call
+      when "substr", "threshold"
+        x.call
+      when "color"
+        str #color is handled elsewhere
+      else
+        raise "BAD FUNC #{func}" unless pass
+        str
+      end
+    end
+
+    # inner means we're dealing with a complex key; @params will be applied
+    # later on
+    def handle_metric(name, opts, inner=false)
+      ret = name.dup
+      if inner
+        @params.each do |k, v|
+          ret = translate(k, ret, v, true)
+        end
+      end
+      (opts||{}).each do |k, v|
+        #puts "#{k} => #{v}"
+        ret = translate(k, ret, v)
+      end
+      ret
+    end
+
+    def render_url(hosts, clusters, opts={})
+      opts = {
+        :sum => nil,
+        :title => @params["title"],
+      }.merge(opts)
+
+      if ! [:global, :cluster, nil].member?(opts[:sum])
+        raise ArgumentError, "render graph #{name}: invalid :sum - #{opts[:sum]}"
+      end
+
+      sym_hash = {}
+      (opts[:dynamic_url_opts]||[]).each do |k,v|
+        sym_hash[k.to_sym] = v
+      end
+
+      # fixme key checking may be necessary
+      url_opts = {
+        :title => opts[:title],
+      }.merge(@params[:url_opts]).merge(sym_hash)
+
+      url_opts[:from] = url_opts.delete(:stime) || ""
+      url_opts[:until] = url_opts.delete(:etime) || ""
+      url_opts.delete(:start)
+      url_opts.delete(:duration)
+
+      graphite_opts = [ "vtitle", "yMin", "yMax", "lineWidth", "areaMode",
+        "template", "lineMode", "bgcolor", "graphOnly", "hideAxes", "hideGrid",
+        "hideLegend", "fgcolor", "fontSize", "fontName", "fontItalic",
+        "fontBold" ]
+
+      @params.each do |k, v|
+        if graphite_opts.member?(k)
+          url_opts[k.to_sym] = v
+        end
+      end
+
+      target = []
+      colors = []
+      #fixme code duplication
+      if opts[:sum] == :global
+        @params["targets"].each do |stat_name, opts|
+          z = opts.dup
+          # opts['key'] ||= stat_name
+          z[:key] ||= stat_name
+          #######################
+          if stat_name.instance_of?(Array)
+            metric = stat_name.map do |m|
+              mm = compose_metric(m.keys.first, clusters.to_a.join(","),
+                           hosts.to_a.join(","))
+              handle_metric(mm, m[m.keys.first], true)
+            end.join(",")
+          else
+            metric = "#{stat_name}.{#{clusters.to_a.join(',')}}" +
+              ".{#{hosts.to_a.join(',')}}"
+            metric = handle_metric(metric, {}, true)
+          end
+          #######################
+          z[:key] = "global #{z[:key]}"
+          target << handle_metric("sumSeries(#{metric})", z)
+          colors << next_color(colors, z[:color])
+        end # @params["targets"].each
+      elsif opts[:sum] == :cluster # one line per cluster/metric
+        clusters.each do |cluster|
+          @params["targets"].each do |stat_name, opts|
+            z = opts.dup
+            metrics = []
+            hosts.each do |host|
+              #######################
+              if stat_name.instance_of?(Array)
+                metrics << stat_name.map do |m|
+                  mm = compose_metric(m.keys.first, cluster, host)
+                  handle_metric(mm, m[m.keys.first], true)
+                end.join(",")
+              else
+                metrics << handle_metric(compose_metric(stat_name, cluster, host), {}, true)
+              end
+              #######################
+            end # hosts.each
+
+            z[:key] = "#{cluster} #{z[:key]}"
+            target << handle_metric("sumSeries(#{metrics.join(',')})", z)
+            colors << next_color(colors, z[:color])
+          end # metrics.each
+        end # clusters.each
+      else # one line per {metric,host,colo}
+        @params["targets"].each do |stat_name, opts|
+          clusters.each do |cluster|
+            hosts.each do |host|
+              label = "#{host} #{opts[:key]}"
+              #################
+              if stat_name.instance_of?(Array)
+                metric = stat_name.map do |m|
+                  mm = compose_metric(m.keys.first, cluster, host)
+                  handle_metric(mm, m[m.keys.first], true)
+                end.join(",")
+              else
+                metric = handle_metric(compose_metric(stat_name, cluster, host), {}, true)
+              end
+              #################
+
+              if label =~ /\*/
+                # for this particular type of graph, don't display a legend
+                url_opts[:hideLegend] = true
+                z = opts.dup
+                # fixme proper labeling... maybe
+                # With wildcards let graphite construct the legend (or not).
+                # Since we're handling wildcards we don't know how many
+                # hosts will match, so just put in the default color list.
+                # technically we do know, so this can be fixed
+                z.delete(:key)
+                target << handle_metric(metric, z)
+                colors.concat(@params[:default_colors]) if colors.empty?
+              else
+                z = opts.dup
+                z[:key] = "#{host}/#{cluster} #{opts[:key]}"
+                target << handle_metric(metric, z)
+                colors << next_color(colors, opts[:color])
+              end
+            end
+          end
+        end # @params["targets"].each
+      end # if opts[:sum]
+
+      url_opts[:target] = target
+      url_opts[:colorList] = colors.join(",")
+
+      url = URI.join(@params[:graphite_url], "/render/?").to_s
+      url_parts = []
+      url_opts.each do |k, v|
+        [v].flatten.each do |v|
+          url_parts << "#{URI.escape(k.to_s)}=#{URI.escape(v.to_s)}"
+        end
+      end
+      url += url_parts.join("&")
+      return url
+    end
+
+    # return an array of all metrics matching the specifications in
+    # @params["targets"]
+    # metrics are arrays of fields (once delimited by periods)
+    def expand
+      url = URI.join(@params[:graphite_url], "/metrics/expand/?query=").to_s
+      metrics = []
+
+      @params["targets"].each do |metric|
+        if metric.first.instance_of?(Array)
+          metric.first.each do |m|
+            composed = compose_metric(m.first.first, "*", "*")
+            query = open("#{url}#{composed}").read
+            metrics << JSON.parse(query)["results"]
+          end
+        else
+          composed = compose_metric(metric.first.first, "*", "*")
+          query = open("#{url}#{composed}").read
+          metrics << JSON.parse(query)["results"]
+        end
+      end
+
+      return metrics.flatten.map { |x| x.split(".") }
+    end
+
+    def hosts_clusters
+      metrics = expand
+      clusters = Set.new
+
+      # field -1 is the host name, and -2 is its cluster
+      hosts = metrics.map do |x|
+        Host.new(x[-1], @params.merge({ "cluster" => x[-2] }))
+      end.uniq
+
+      # filter by what matches the graph definition
+      hosts = hosts.select { |h| h.multi_match(@params["hosts"]) }
+      hosts.each { |h| clusters << h.cluster }
+
+      return hosts, clusters
+    end
+
+    private
+    def next_color(colors, preferred_color=nil)
+      default_colors = @params[:default_colors].clone
+
+      if preferred_color and !colors.member?(preferred_color)
+        return preferred_color
+      end
+
+      if preferred_color and ! default_colors.member?(preferred_color)
+        default_colors << preferred_color
+      end
+
+      weights = Hash.new { |h, k| h[k] = 0 }
+      colors.each do |c|
+        weights[c] += 1
+      end
+
+      i = 0
+      loop do
+        default_colors.each do |c|
+          return c if weights[c] == i
+        end
+        i += 1
+      end
+    end
+  end # Dash::Models::Graph
+end # Dash::Models

data/lib/models/host.rb

@@ -0,0 +1,82 @@
+require "models/base"
+require "models/graph"
+
+module Dash::Models
+  class Host < Base
+    attr_accessor :graphs
+
+    def initialize(name, params={})
+      super
+
+      @graphs = []
+      Graph.each do |graph_name, graph|
+        graph["hosts"].each do |h|
+          if match(h)
+            @graphs << graph
+            break
+          end
+        end # graph["hosts"].each
+      end # Graph.each
+    end
+
+    def cluster
+      return @params["cluster"]
+    end
+
+    def key
+      "#{@cluster}#{@name}"
+    end
+
+    def eql?(other)
+      key == other.key
+    end
+
+    def ==(other)
+      key == other.key
+    end
+
+    def <=>(other)
+      if @params[:host_sort] == "builtin"
+        return key <=> other.key
+      elsif @params[:host_sort] == "numeric"
+        regex = /\d+/
+        match = @name.match(regex)
+        match2 = other.name.match(regex)
+        if match.pre_match != match2.pre_match
+          return match.pre_match <=> match2.pre_match
+        else
+          return match[0].to_i <=> match2[0].to_i
+        end
+      else
+        # http://www.bofh.org.uk/2007/12/16/comprehensible-sorting-in-ruby
+        sensible = lambda do |k|
+          k.to_s.split(
+                 /((?:(?:^|\s)[-+])?(?:\.\d+|\d+(?:\.\d+?(?:[eE]\d+)?(?:$|(?![eE\.])))?))/ms
+                 ).map { |v| Float(v) rescue v.downcase }
+        end
+        return sensible.call(self) <=> sensible.call(other)
+      end
+    end
+
+    def hash
+      key.hash
+    end
+
+    def self.find_by_name_and_cluster(name, cluster)
+      Host.each do |host_name, host|
+        next unless host_name = name
+        return host if host.cluster == cluster
+      end
+      return nil
+    end
+
+    def self.find_by_cluster(cluster)
+      ret = []
+      Host.each do |name, host|
+        ret << host if host.cluster == cluster
+      end
+      return ret
+    end
+
+  end # Dash::Models::Host
+end # Dash::Models

data/lib/models.rb

@@ -0,0 +1,3 @@
+require "models/dashboard"
+require "models/graph"
+require "models/host"

data/lib/namespace.rb

@@ -0,0 +1,4 @@
+module Dash
+  module Models
+  end
+end

data/lib/public/style.css

@@ -0,0 +1,97 @@
+h2 {
+    color: #ADFF2F;
+}
+
+h3 {
+    color: #32cd32;
+}
+
+.graphtitle {
+    text-shadow: 1px 1px 1px #333333;
+}
+
+.dashlinks {
+    color: green;
+    font-size: small;
+}
+
+a {
+    color: #15317E;
+}
+
+a:visited {
+    color: #15317E;
+}
+
+.graphsection {
+    border: dotted 2px #333333;
+    width: 500;
+    margin-left: 5px;
+    margin-top: 10px;
+}
+
+div#wrap {
+    width: 100%;
+    margin-top: 10px;
+    margin-bottom: 10px;
+    margin-left: auto;
+    margin-right: auto;
+    padding: 0px;
+}
+
+div#header {
+    padding: 15px;
+    margin: 0px;
+    margin-left: 23%;
+}
+
+div#nav {
+    width: 20%;
+    padding: 10px;
+    margin-top: 1px;
+    float: left;
+    color: green;
+}
+
+div#main {
+    margin-left: 23%;
+    margin-top: 1px;
+    padding: 10px;
+    color: #4CBB17;
+}
+
+div#footer {
+    padding: 15px;
+    margin: 0px;
+    border-top: thin solid #808080;
+}
+
+table {
+    color: green;
+}
+
+input {
+    border: solid 1px #15317E;
+    color: green;
+    background-color: #1f1f1f;
+    font-size: small;
+}
+
+.invisible {
+    display: none;
+}
+
+select {
+    border: solid 1px #15317E;
+    color: green;
+    background-color: #1f1f1f;
+}
+
+.select2 {
+    color: #4CBB17;
+    font-size: large;
+}
+
+.error {
+    color: red;
+}

data/lib/views/cluster.erb

@@ -0,0 +1,23 @@
+<h2>List of dashboards for <%= cluster_selector %></h2>
+
+<% hosts = Host.all.select { |h| h.cluster == @cluster }
+   boards = @dashboards.select { |d| d.clusters.member?(@cluster) }
+   seen_hosts = Set.new %>
+
+<% boards.each do |b| %>
+<h2><a href="/dash/<%= "#{@cluster}/#{append_query_string(b.name)}" %>"><%= b.name %></a>
+  <% dash_hosts = b.get_all_hosts(@cluster)[0]
+     seen_hosts += dash_hosts %>
+  <%= hosts_selector(dash_hosts) %>
+</h2>
+<%= b.graphs.collect do |g|
+    href = append_query_string("/dash/#{@cluster}/#{b.name}/#{g}")
+    "<li><a href=\"#{href}\">#{g}</a><br></li>"
+    end %>
+<br>
+<% end %>
+<h3>Other Hosts (not associated with a dashboard)</h3>
+<%= (hosts.to_set - seen_hosts).sort.collect do |h|
+    href = append_query_string("/host/#{@cluster}/#{h}")
+    "<li><a href=\"#{href}\">#{h}</a></li>"
+    end %>

data/lib/views/dash-cluster-zoom.erb

@@ -0,0 +1,36 @@
+<% hosts = @dash.get_valid_hosts(@zoom, @cluster)[0].sort %>
+
+<%= cluster_switcher %>
+<%= graph_switcher %>
+<%= graph_uplink %>
+<br>
+<br>
+<a href="#by_host">by_host</a>
+<%= hosts.collect { |h| "<a href=\"##{h}\">#{h}</a>" }.join(" ") %>
+
+<div class="graphsection" style="width:<%= @zoom.width(merge_opts) %>;">
+  <span class="graphtitle"><%= @zoom.name %> / <%= @cluster %> :: summary</span>
+  <div class="graph">
+    <img src="<%= @dash.render_cluster_graph(@zoom, @cluster, :dynamic_url_opts => merge_opts) %>">
+  </div>
+</div>
+
+<div class="graphsection" style="width:<%= @zoom.width(merge_opts) %>;">
+  <a name="by_host">
+    <span class="graphtitle"><%= @zoom.name %> / <%= @cluster %> :: by host</span>
+    <div class="graph">
+      <img src="<%= @dash.render_cluster_graph(@zoom, @cluster, :zoom => true, :dynamic_url_opts => merge_opts) %>">
+    </div>
+</div>
+
+<% hosts.each do |host| %>
+<div class="graphsection" style="width:<%= @zoom.width(merge_opts) %>;">
+  <a name="<%= host %>">
+    <% image_url, zoom_url = cluster_zoom_graph(@zoom, @cluster, host, "#{@zoom.name} / #{@cluster} / #{host}") %>
+    <span class="graphtitle"><%= @zoom.name %> / <%= @cluster %> / <%= host %></span>
+    <span class="dashlinks">(<a href="<%= zoom_url %>">host</a>)</span>
+    <div class="graph">
+      <a href="<%= zoom_url %>"><img src="<%= image_url %>"></a>
+    </div>
+</div>
+<% end %>

data/lib/views/dash-cluster.erb

@@ -0,0 +1,18 @@
+<%= cluster_switcher %>
+<%= dash_switcher %>
+<%= dash_uplink %>
+<br>
+<br>
+<%= @dash.graphs.collect { |g| "<a href=\"##{g.name}\">#{g.name}</a>" }.join(" ") %>
+
+<% @dash.graphs.each do |g| %>
+<div class="graphsection" style="width:<%= g.width(merge_opts) %>;">
+  <a name="<%= g.name %>">
+    <% image_url, zoom_url = cluster_graph(g, @cluster, "#{g.name} / #{@cluster}") %>
+    <span class="graphtitle"><%= g.name %></span>
+    <span class="dashlinks">(<a href="<%= zoom_url %>">zoom</a>)</span>
+    <div class="graph">
+      <a href="<%= zoom_url %>"><img src="<%= image_url %>"></a>
+    </div>
+</div>
+<% end %>