pencil 0.2.10 → 0.3.0

data/bin/pencil

@@ -1,9 +1,5 @@
 #!/usr/bin/env ruby
-$: << File.dirname($0) + "/../lib"
+require 'pencil'
 
-require File.join(File.dirname(__FILE__), "..", "VERSION")
-require "dash"
+Pencil::App.run!
 
-STDOUT.puts "pencil v#{PENCIL_VERSION} on port #{Dash::App.port}, PID #{$$}"
-
-Rack::Handler::Mongrel.run(Dash::App, :Port => Dash::App.port)

data/docs/pencil_options.md

@@ -203,7 +203,9 @@ Most of these options take a single argument.
 * threshold
 * color
 
-Note: key is interpreted differently from the other options, which are more
+Note: key and color are applied after all other options are applied.
+
+key is interpreted differently from the other options, which are more
 simply translated.
 
 color's interpretation depends on whether :use_color is set.

data/lib/{config.rb → pencil/config.rb}

@@ -1,9 +1,9 @@
-require "rubygems"
-require "models"
+require 'map'
+require "pencil/models"
 
-module Dash
+module Pencil
   class Config
-    include Dash::Models
+    include Pencil::Models
 
     attr_reader :dashboards
     attr_reader :graphs
@@ -32,11 +32,31 @@ module Dash
     end
 
     def reload!
-      configs = Dir.glob("#{@confdir}/*.y{a,}ml")
-      configs.each { |c| @rawconfig.merge!(YAML.load(File.read(c))) }
+      configs = Dir.glob("#{@confdir}/**/*.y{a,}ml")
+      configs.each do |c|
+        yml = YAML.load(File.read(c))
+        next unless yml
+        @rawconfig[:config] = yml[:config] if yml[:config]
+        a = @rawconfig[:dashboards] 
+        b = yml[:dashboards] 
+        c = @rawconfig[:graphs]
+        d = yml[:graphs]
+
+        if a && b
+          a.merge!(b)
+        elsif b
+          @rawconfig[:dashboards] = b
+        end
+        if c && d
+          c.merge!(d)
+        elsif d
+          @rawconfig[:graphs] = d
+        end
+      end
+      @rawconfig = Map(@rawconfig)
 
       [:graphs, :dashboards, :config].each do |c|
-        if not @rawconfig[c]
+        if not @rawconfig[c.to_s]
           raise "Missing config name '#{c.to_s}'"
         end
       end
@@ -99,5 +119,5 @@ module Dash
       @dashboards, @graphs = dashboards_new, graphs_new
       @hosts, @clusters = hosts_new, clusters_new
     end
-  end # Dash::Config
-end # Dash
+  end # Pencil::Config
+end # Pencil

data/lib/pencil/config.ru

@@ -0,0 +1,2 @@
+require 'pencil'
+run Pencil::App

data/lib/pencil/helpers.rb

@@ -0,0 +1,211 @@
+module Pencil
+  module Helpers
+    include Pencil::Models
+
+    @@prefs = [["Start Time", "start"],
+               ["Duration", "duration"],
+               ["Width", "width"],
+               ["Height", "height"]]
+
+    # convert keys to symbols before lookup
+    def param_lookup(name)
+      sym_hash = {}
+      session.each { |k,v| sym_hash[k.to_sym] = v unless v.empty? }
+      params.each { |k,v| sym_hash[k.to_sym] = v unless v.empty? }
+      settings.config.global_config[:url_opts].merge(sym_hash)[name.to_sym]
+    end
+
+    def cluster_graph(g, cluster, title="wtf")
+      image_url = \
+      @dash.render_cluster_graph(g, cluster,
+                                 :title => title,
+                                 :dynamic_url_opts => merge_opts)
+      zoom_url = cluster_graph_link(@dash, g, cluster)
+      return image_url, zoom_url
+    end
+
+    def cluster_graph_link(dash, g, cluster)
+      link = dash.graph_opts[g]["click"] ||
+        "/dash/#{cluster}/#{dash.name}/#{g.name}"
+      return append_query_string(link)
+    end
+
+    def cluster_zoom_graph(g, cluster, host, title)
+      image_url = g.render_url([host.name], [cluster], :title => title,
+                               :dynamic_url_opts => merge_opts)
+      zoom_url = cluster_zoom_link(cluster, host)
+      return image_url, zoom_url
+    end
+
+    def cluster_zoom_link(cluster, host)
+      return append_query_string("/host/#{cluster}/#{host}")
+    end
+
+    def suggest_cluster_links(clusters, g)
+      links = []
+      clusters.each do |c|
+        href = append_query_string("/dash/#{c}/#{params[:dashboard]}/#{g.name}")
+        links << "<a href=\"#{href}\">#{c}</a>"
+      end
+      return "zoom (" + links.join(", ") + ")"
+    end
+
+    def suggest_dashboards_links(host, graph)
+      suggested = suggest_dashboards(host, graph)
+      return "" if suggested.length == 0
+
+      links = []
+      suggested.each do |d|
+        links << "<a href=\"/dash/#{host.cluster}/#{append_query_string(d)}\">" +
+          "#{d}</a>"
+      end
+      return "(" + links.join(", ") + ")"
+    end
+
+    # it's mildly annoying that when this set is empty there're no uplinks
+    # consider adding a link up to the cluster (which is best we can do)
+    def suggest_dashboards(host, graph)
+      ret = Set.new
+
+      host.graphs.each do |g|
+        Dashboard.find_by_graph(g).each do |d|
+          valid, _ = d.get_valid_hosts(g, host['cluster'])
+          ret << d.name if valid.member?(host)
+        end
+      end
+
+      return ret
+    end
+
+    # generate the input box fields, filled in to current parameters if specified
+    def input_boxes
+      @prefs = @@prefs
+      erb :'partials/input_boxes', :layout => false
+    end
+
+    def dash_link(dash, cluster)
+      return append_query_string("/dash/#{cluster}/#{dash.name}")
+    end
+
+    def cluster_link(cluster)
+      return append_query_string("/dash/#{cluster}")
+    end
+
+    # fixme this isn't used anymore, but should
+    def css_url
+      style = File.join(settings.root, "public/style.css")
+      mtime = File.mtime(style).to_i.to_s
+      return \
+      %Q[<link href="/style.css?#{mtime}" rel="stylesheet" type="text/css">]
+    end
+
+    def refresh
+      if settings.config.global_config[:refresh_rate] != false && nowish
+        rate = settings.config.global_config[:refresh_rate] || 60
+        return %Q[<meta http-equiv="refresh" content="#{rate}">]
+      end
+    end
+
+    def hosts_selector(hosts, print_clusters=false)
+      @print_clusters = print_clusters
+      @hosts = hosts
+      erb :'partials/hosts_selector', :layout => false
+    end
+
+    def append_query_string(str)
+      v = str.dup
+      (v << "?#{request.query_string}") unless request.query_string.empty?
+      return v
+    end
+
+    def merge_opts
+      static_opts = ["cluster", "dashboard", "zoom", "host", "session_id"]
+      opts = params.dup
+      session.merge(opts).delete_if { |k,v| static_opts.member?(k) || v.empty? }
+    end
+
+    def shortcuts(str)
+      @str = str
+      erb :'partials/shortcuts', :layout => false
+    end
+    def cluster_switcher(clusters)
+      @clusters = clusters
+      erb :'partials/cluster_switcher', :layout => false
+    end
+
+    def dash_switcher
+      erb :'partials/dash_switcher', :layout => false
+    end
+
+    def graph_switcher
+      erb :'partials/graph_switcher', :layout => false
+    end
+
+    def cluster_selector
+      @clusters = settings.config.clusters.sort + ["global"]
+      erb :'partials/cluster_selector', :layout => false
+    end
+
+    def host_uplink
+      link = "/dash/#{append_query_string(@host.cluster)}"
+      "zoom out: <a href=\"#{link}\">#{@host.cluster}</a>"
+    end
+
+    def graph_uplink
+      link = append_query_string(request.path.split("/")[0..-2].join("/"))
+      "zoom out: <a href=\"#{link}\">#{@dash}</a>"
+    end
+
+    def dash_uplink
+      link = append_query_string(request.path.split("/")[0..-2].join("/"))
+      "zoom out: <a href=\"#{link}\">#{@params[:cluster]}</a>"
+    end
+
+    # fixme this is a hack
+    def header(str)
+      <<-FOO
+  <div class="path_container">
+                <h2>#{@title}</h2>
+                  <span class="zoom">
+                  #{str}
+                  </span>
+              </div>
+              <div id="timeslice_container">
+                <h3 id="timeslice">#{range_string}</h3>
+                #{permalink unless @no_graphs}
+              </div>
+  FOO
+    end
+
+    def nowish
+      if settings.config.global_config[:now_threshold] == false
+        return false
+      end
+      threshold = settings.config.global_config[:now_threshold] || 300
+      return @request_time.to_i - @etime.to_i < threshold
+    end
+
+    def range_string
+      format = settings.config.global_config[:date_format] || "%X %x"
+      if @stime && @etime
+        if nowish
+          "timeslice: from #{@stime.strftime(format)}"
+        else
+          "timeslice: #{@stime.strftime(format)} - #{@etime.strftime(format)}"
+        end
+      else
+        "invalid time range"
+      end
+
+    end
+
+    def permalink
+      return "" unless @stime && @duration
+      format = "%F %T" # chronic REALLY understands this
+      url = request.path + "?"
+      url << "&start=#{@stime.strftime(format)}"
+      url << "&duration=#{ChronicDuration.output(@duration)}"
+      "<a id=\"permalink\" href=\"#{url}\">permalink</a>"
+    end
+  end
+end

data/lib/pencil/models/base.rb

@@ -0,0 +1,78 @@
+module Pencil
+  module Models
+    class Base
+      @@objects = Hash.new { |h, k| h[k] = Hash.new }
+      attr_reader :name
+
+      def initialize(name, params={})
+        @name = name
+        @match_name = name
+        @params = params
+        @@objects[self.class.to_s][name] = self
+      end
+
+      def self.find(name)
+        return @@objects[self.name][name] rescue []
+      end
+
+      def self.each(&block)
+        h = @@objects[self.name] rescue {}
+        h.each { |k, v| yield(k, v) }
+      end
+
+      def self.all
+        return @@objects[self.name].values
+      end
+
+      def [](key)
+        return @params[key] rescue []
+      end
+
+      def match(glob)
+        return true if glob == '*'
+        # convert glob to a regular expression
+        glob_re = /^#{Regexp.escape(glob).gsub('\*', '.*').gsub('\#', '\d+')}$/
+        return @match_name.match(glob_re)
+      end
+
+      def multi_match(globs)
+        ret = false
+
+        globs.each do |glob|
+          ret = match(glob)
+          break if ret
+        end
+
+        return ret
+      end
+
+      def to_s
+        return @name
+      end
+
+      def <=>(other)
+        return to_s <=> other.to_s
+      end
+
+      def update_params(hash)
+        @params.merge!(hash)
+      end
+
+      # compose a metric using a :metric_format
+      # format string with %c for metric, %c for cluster, and %h for host
+      def compose_metric (m, c, h)
+        @params[:metric_format].dup.gsub("%m", m).gsub("%c", c).gsub("%h", h)
+      end
+
+      # used to make sure partial metrics are not considered
+      # e.g. foo.bar.baz.colo1.host1 but not
+      #      foo.bar.baz.subkey.subkey2[.colo1.host1]
+      # where the latter is returned by the graphite expand api but not as a full
+      # metric
+      # essentially equivalent to matching like /[:METRIC:]$/
+      def compose_metric2 (m, c, h)
+        compose_metric(m, c, h) + ".*"
+      end
+    end # Pencil::Models::Base
+  end
+end # Pencil::Models

data/lib/pencil/models/dashboard.rb

@@ -0,0 +1,124 @@
+require "pencil/models/base"
+require "pencil/models/graph"
+require "pencil/models/host"
+require "set"
+
+module Pencil
+  module 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.respond_to?(:keys) # could be YAML::Omap
+            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-y; #{name.class}:#{name.inspect} is not)"
+          end
+
+          @graphs << g if g
+        end
+
+        @valid_hosts_table = {} # cache calls to get_valid_hosts
+      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)
+        if @valid_hosts_table[[graph, cluster]]
+          return @valid_hosts_table[[graph, cluster]]
+        end
+
+        clusters = Set.new
+        if cluster
+          hosts = Host.find_by_cluster(cluster)
+        else
+          hosts = Host.all
+        end
+
+        # filter as:
+        #   - the dashboard graph hosts definition
+        #   - the dashboard hosts definition
+        #   - the graph hosts definition
+        # this is new behavior: before the filters were additive
+        filter = graph_opts[graph]["hosts"] || @params["hosts"] || graph["hosts"]
+        if filter
+          hosts = hosts.select { |h| h.multi_match(filter) }
+        end
+
+        hosts.each { |h| clusters << h.cluster }
+
+        @valid_hosts_table[[graph, cluster]] = [hosts, clusters]
+        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)
+
+        # graphite doesn't support strict matching (as /\d+/), so we need to
+        # enumerate the hosts if a "#" wildcard is found
+        if ! (filter = hosts.select { |h| h =~ /#/ }).empty?
+          hosts_new = hosts - filter
+          hosts2 = Host.all.select { |h| h.multi_match(filter) }
+          hosts = (hosts2.map {|h| h.name } + hosts_new).sort.uniq.join(',')
+        end
+
+        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 # Pencil::Models::Dashboard
+  end
+end # Pencil::Models