fnordmetric 1.0.1 → 1.2.0

data/lib/fnordmetric/gauges/server_health_gauge.rb

@@ -0,0 +1,13 @@
+# ServerHealthGauge
+# here be dragons....
+#
+# This gauge listens for JSON events that look like this:
+#
+# {
+#   "hostname": "my-hostname",
+#   "uptime": 1231523,
+#   "load_avg": [0.32, 0.16, 0.13],
+#   "mem": { "total": 4069, "free": 1096 },
+#   "swap": { "total": 0, "free": 0 },
+#   "disk_usage": "43%"
+# }

data/lib/fnordmetric/namespace.rb

@@ -1,39 +1,54 @@
 class FnordMetric::Namespace
-  
+
   attr_reader :handlers, :gauges, :opts, :key, :dashboards, :flags
 
-  @@opts = [:event, :gauge, :widget, :set_title, :hide_active_users, :hide_overview, :dashboard]
+  @@opts = [:event, :gauge, :widget, :set_title, :hide_active_users, :hide_overview,
+            :hide_gauge_explorer, :dashboard]
+
   @@multi_gauges = [:timeseries_gauge, :toplist_gauge, :distribution_gauge]
 
   def initialize(key, opts)
     @gauges = Hash.new
     @dashboards = Hash.new
-    @handlers = Hash.new
-    @flags = Hash.new
+    @handlers = Hash.new.with_indifferent_access
     @title = key
-    @active_users_available = true
     @opts = opts
     @key = key
+
+    @flags = {
+      :hide_active_users => (FnordMetric.options[:enable_active_users] == false),
+      :hide_gauge_explorer => (FnordMetric.options[:enable_gauge_explorer] == false)
+    }
   end
 
-  def ready!(redis)
+  def ready!(redis, sync_redis = nil)
     @redis = redis
+    @sync_redis = sync_redis
+    load_gauges
     self
   end
 
   def announce(event)
-    announce_to_timeline(event)
-    announce_to_typelist(event)
+    if !@flags[:hide_active_users]
+      announce_to_timeline(event)
+      announce_to_typelist(event)
+    end
 
     if event[:_session]
       event[:_session_key] = announce_to_session(event).session_key 
     end
 
+    if FnordMetric::ZeroConfigGauge::TYPES.include?(event[:_type].to_sym)
+      ctx = FnordMetric::Context.new(opts, FnordMetric::ZeroConfigGauge::Handler)
+      ctx.call(event, @redis, self)
+      return self
+    end
+
     res = [
       @handlers[event[:_type].to_s],
       @handlers["*"]
     ].flatten.compact.each do |context|
-      context.call(event, @redis)
+      context.call(event, @redis, self)
     end.size
 
     if res == 0
@@ -75,10 +90,6 @@ class FnordMetric::Namespace
     @title
   end
 
-  def active_users_available
-    @active_users_available
-  end
-
   def dashboards(name=nil, opts = {})
     return @dashboards unless name
     dash = FnordMetric::Dashboard.new(opts.merge(:title => name))
@@ -105,6 +116,10 @@ class FnordMetric::Namespace
     @flags[:hide_active_users] = true
   end
 
+  def opt_hide_gauge_explorer
+    @flags[:hide_gauge_explorer] = true
+  end
+
   def opt_hide_overview
     @flags[:hide_overview] = true
   end
@@ -113,8 +128,7 @@ class FnordMetric::Namespace
     @title = title
   end
 
-  def opt_event(event_type, opts={}, &block)    
-    opts.merge!(:redis => @redis, :gauges => @gauges)   
+  def opt_event(event_type, opts={}, &block)
     FnordMetric::Context.new(opts, block).tap do |context|
       @handlers[event_type.to_s] ||= []
       @handlers[event_type.to_s] << context
@@ -122,7 +136,9 @@ class FnordMetric::Namespace
   end
 
   def opt_gauge(gauge_key, opts={})
-    opts.merge!(:key => gauge_key, :key_prefix => key_prefix)
+    opts.merge!(:key => gauge_key)
+    store_gauge(gauge_key, opts) if opts[:zero_config]
+    opts.merge!(:key_prefix => key_prefix)
     klass = "FnordMetric::#{(opts[:type] || "").to_s.camelize}Gauge".constantize
     @gauges[gauge_key] ||= klass.new(opts)
   end
@@ -143,11 +159,31 @@ class FnordMetric::Namespace
   end
 
   def build_widget(opts)
-    _gauges = [opts[:gauges]].flatten.map{ |g| @gauges.fetch(g) }
+    _gauges = [opts[:gauges]].flatten.map do |g|
+      @gauges[g] || FnordMetric::ZeroConfigGauge.new(g, self)
+    end
     widget_klass = "FnordMetric::#{opts.fetch(:type).to_s.capitalize}Widget"
     widget_klass.constantize.new(opts.merge(:gauges => _gauges))
   end
 
+  def store_gauge(gauge_key, opts)
+    gaugelist_key = key_prefix("zero-config-gauges")
+    sync_redis.hset(gaugelist_key, gauge_key, opts.to_json)
+  end
+
+  def load_gauges
+    gaugelist_key = key_prefix("zero-config-gauges")
+    sync_redis.hgetall(gaugelist_key).each do |gauge_key, gauge_opts|
+      gopts = JSON.parse(gauge_opts).symbolize_keys
+      gopts.delete(:zero_config)
+      opt_gauge(gauge_key.to_sym, gopts)
+    end
+  end
+
+  def sync_redis
+    @sync_redis || @redis
+  end
+
   def extend_opts(opts)
     opts.merge(
       :namespace_prefix => key_prefix,

data/lib/fnordmetric/util.rb

@@ -0,0 +1,25 @@
+class FnordMetric::Util
+
+  def self.parse_time(str)
+    str = str.downcase
+
+    if (str == "now")
+      Time.now.to_i
+    elsif str =~ /^([0-9]+(?:\.[0-9]+)?)$/
+      $1.to_i
+    elsif str =~ /^-([0-9]+(?:\.[0-9]+)?)$/
+      Time.now.to_i - $1.to_i
+    elsif str =~ /^-([0-9]+(?:\.[0-9]+)?)s(ec(ond)?(s?))?$/
+      Time.now.to_i - $1.to_f
+    elsif str =~ /^-([0-9]+(?:\.[0-9]+)?)m(in(ute)?(s?))?$/
+      Time.now.to_i - ($1.to_f * 60)
+    elsif str =~ /^-([0-9]+(?:\.[0-9]+)?)h(our(s?))?$/
+      Time.now.to_i - ($1.to_f * 3600)
+    elsif str =~ /^-([0-9]+(?:\.[0-9]+)?)d(ay(s?))?$/
+      Time.now.to_i - ($1.to_i * 86400)
+    else 
+      raise "invalid time specifiation: #{str}"
+    end
+  end
+
+end

data/lib/fnordmetric/version.rb

@@ -1,3 +1,3 @@
 module FnordMetric
-  VERSION = "1.0.1"
+  VERSION = "1.2.0"
 end

data/lib/fnordmetric/web/app.rb

@@ -22,6 +22,11 @@ class FnordMetric::App < Sinatra::Base
     include FnordMetric::AppHelpers
   end
 
+  %w(fnordmetric-ui.js fnordmetric-ui.css fnordmetric-core.css fnordmetric-core.js).each do |f|
+    next if ::File.exists?(::File.expand_path("../../../../web/#{f}", __FILE__))
+    raise "error: file 'web/#{f}' does not exist, please run build.sh in web/"
+  end
+
   def initialize(opts = {})
     @opts = FnordMetric.default_options(opts)
 
@@ -37,10 +42,12 @@ class FnordMetric::App < Sinatra::Base
 
   get '/:namespace' do
     pass unless current_namespace
+    current_namespace.ready!(@redis)
     haml :app
   end
 
   post '/events' do
+    params = JSON.parse(request.body.read) unless params
     halt 400, 'please specify the event_type (_type)' unless params["_type"]
     track_event((8**32).to_s(36), parse_params(params))
   end
@@ -52,71 +59,5 @@ class FnordMetric::App < Sinatra::Base
     dashboard.to_json
   end
 
-
-  # get '/favicon.ico' do
-  #   ""
-  # end
-
-  # get '/:namespace/gauge/:name' do
-  #   gauge = if params[:name].include?("++")
-  #     parts = params[:name].split("++")
-  #     current_namespace.gauges[parts.first.to_sym].fetch_gauge(parts.last, params[:tick].to_i)
-  #   else
-  #     current_namespace.gauges[params[:name].to_sym]
-  #   end
-
-  #   if !gauge
-  #     status 404
-  #     return ""
-  #   end
-
-  #   data = if gauge.three_dimensional?
-  #     _t = (params[:at] || Time.now).to_i
-  #     { :count => gauge.field_values_total(_t), :values => gauge.field_values_at(_t) }
-  #   elsif params[:at] && params[:at] =~ /^[0-9]+$/
-  #     { (_t = gauge.tick_at(params[:at].to_i)) => gauge.value_at(_t) }
-  #   elsif params[:at] && params[:at] =~ /^([0-9]+)-([0-9]+)$/
-  #     _range = params[:at].split("-").map(&:to_i)
-  #     _values = gauge.values_in(_range.first.._range.last)
-  #     params[:sum] ? { :sum => _values.values.compact.map(&:to_i).sum } : _values
-  #   else
-  #     { (_t = gauge.tick_at(Time.now.to_i-gauge.tick)) => gauge.value_at(_t) }
-  #   end
-
-  #   data.to_json
-  # end
-
-  # get '/:namespace/sessions' do
-  #   sessions = current_namespace.sessions(:all, :limit => 100).map do |session|
-  #     session.fetch_data!
-  #     session.to_json
-  #   end
-
-  #   { :sessions => sessions }.to_json
-  # end
-
-  # get '/:namespace/events' do
-  #   events = if params[:type]
-  #     current_namespace.events(:by_type, :type => params[:type])
-  #   elsif params[:session_key]
-  #     current_namespace.events(:by_session_key, :session_key => params[:session_key])
-  #   else 
-  #     find_opts = { :limit => 100 }
-  #     find_opts.merge!(:since => params[:since].to_i+1) if params[:since]
-  #     current_namespace.events(:all, find_opts)
-  #   end
-
-  #   { :events => events.map(&:to_json) }.to_json
-  # end
-
-  # get '/:namespace/event_types' do
-  #   types_key = current_namespace.key_prefix("type-")
-  #   keys = @redis.keys("#{types_key}*").map{ |k| k.gsub(types_key,'') }
-
-  #   { :types => keys }.to_json
-  # end
-
-
-
 end
 

data/lib/fnordmetric/web/reactor.rb

@@ -22,11 +22,23 @@ private
     messages << widget(ns, event) if event["type"] == "widget_request"
     messages << gauge(ns, event) if event["type"] == "render_request"
     messages << active_users(ns, event) if event["type"] == "active_users_request"
-    messages.flatten.compact
+    messages << gauge_list(ns, event) if event["type"] == "gauge_list_request"
+
+    messages.flatten.compact.map do |m|
+      m["namespace"] = event["namespace"]; m
+    end
   end
 
   def widget(namespace, event)
-    "FnordMetric::#{event["klass"]}".constantize.execute(namespace, event) # FIXPAUL
+    klass = if event["klass"] == "generic" && event["cmd"] == "values_for"
+      FnordMetric::NumbersWidget
+    elsif event["klass"] == "generic" && event["cmd"] == "values_at"
+      FnordMetric::TimeseriesWidget
+    else
+      "FnordMetric::#{event["klass"]}".constantize
+    end
+
+    klass.execute(namespace, event)
   end
 
   def gauge(namespace, event)
@@ -40,6 +52,8 @@ private
   end
 
   def discover(namespace)
+    namespace.ready!(@redis)
+
     [namespace.dashboards.map do |dash_key, dash|
       { "type" => "discover_response", "gauge_key" => dash_key, "view" => "dashboard",
         "group" => dash.group }
@@ -84,4 +98,20 @@ private
     }
   end
 
+  def gauge_list(namespace, event)
+    namespace.ready!(@redis)
+
+    gauges = namespace.gauges.map do |name, gauge|
+      {
+        "key" => gauge.name,
+        "title" => gauge.title
+      }
+    end
+
+    {
+      :type   => "gauge_list_response",
+      :gauges => gauges
+    }
+  end
+
 end

data/lib/fnordmetric/web/websocket.rb

@@ -35,4 +35,4 @@ class FnordMetric::WebSocket < Rack::WebSocket::Application
     rand(8**64).to_s(36)
   end
 
-end
+end

data/lib/fnordmetric/widgets/bars_widget.rb

@@ -11,7 +11,7 @@ class FnordMetric::BarsWidget  < FnordMetric::Widget
     return false unless resp
 
     resp.merge(
-      :class => "widget_response",
+      :type => "widget_response",
       :widget_key => event["widget_key"]
     )
   end

data/lib/fnordmetric/widgets/numbers_widget.rb

@@ -8,14 +8,36 @@ class FnordMetric::NumbersWidget < FnordMetric::Widget
     return false unless resp
 
     resp.merge(
-      :class => "widget_response",
+      :type => "widget_response",
       :widget_key => event["widget_key"]
     )
   end
 
   def self.execute_values_for(gauge, event)
+    unless gauge
+      return { "error" => "gauge not found..." }
+    end
+
     _t = Time.now.to_i
 
+    if at = event["at"]
+      value = if at =~ /sum\((.+)\)/
+        vals = gauge.values_in(FnordMetric::Util.parse_time($1).._t+gauge.tick)
+        vals.values.compact.map(&:to_f).inject(&:+)
+      elsif at =~ /avg\((.+)\)/
+        vals = gauge.values_in(FnordMetric::Util.parse_time($1).._t+gauge.tick)
+        (vals.values.compact.map(&:to_f).inject(&:+) || 0) / vals.size.to_f
+      else
+        gauge.value_at(FnordMetric::Util.parse_time(at)).to_i
+      end
+
+      return({
+        "cmd" => "values_for",
+        "at" => event["at"],
+        "gauge" => gauge.name,
+        "value" => value })
+    end
+
     values = {}.tap do |out|
       event["offsets"].each do |off|
         if off.to_s.starts_with?("s")
@@ -36,14 +58,16 @@ class FnordMetric::NumbersWidget < FnordMetric::Widget
       end
     end
 
-    { "cmd" => "values_for", 
-      "series" => gauge.name, 
+    { "cmd" => "values_for",
+      "gauge" => gauge.name,
       "values" => values }
   end
 
   def data
     super.merge(
       :series => gauges.map(&:name),
+      :series_titles => gauges.map(&:title),
+      :series_units => Hash[gauges.map{ |g| [g.name, g.unit] }],
       :offsets => (@opts[:offsets] || [0, 1, "s30"]),
       :autoupdate => (@opts[:autoupdate] || 60)
     )
@@ -53,4 +77,4 @@ class FnordMetric::NumbersWidget < FnordMetric::Widget
     false
   end
   
-end
+end

data/lib/fnordmetric/widgets/timeseries_widget.rb

@@ -5,8 +5,16 @@ class FnordMetric::TimeseriesWidget < FnordMetric::Widget
       {
         :cmd => :values_at,
         :gauges => event["gauges"].map{ |gkey|
-          vals = namespace.gauges[gkey.to_sym].values_in(event["since"]..event["until"])
-          { :key => gkey, :vals => vals }
+          _gauge = namespace.gauges[gkey.to_sym]
+          unless _gauge
+            return { :error => "gauge not found: #{gkey}" }
+          end
+
+          t_since = FnordMetric::Util.parse_time(event["since"].to_s)
+          t_until = FnordMetric::Util.parse_time(event["until"].to_s)
+
+          vals = _gauge.values_in(t_since..t_until)
+          { :key => gkey, :vals => vals, :title => _gauge.title }
         }
       }
     end
@@ -14,17 +22,18 @@ class FnordMetric::TimeseriesWidget < FnordMetric::Widget
     return false unless resp
 
     resp.merge(
-      :class => "widget_response",
+      :type => "widget_response",
       :widget_key => event["widget_key"]
     )
   end
 
-  def data    
+  def data
     super.merge(
       :series => series,
       :gauges => gauges.map(&:name),
       :start_timestamp => ticks.first,
       :end_timestamp => ticks.last,
+      :xticks => (@opts[:xticks] || 30),
       :autoupdate => (@opts[:autoupdate] || 60),
       :include_current => !!@opts[:include_current],
       :default_style => (@opts[:plot_style] || 'line'),
@@ -35,12 +44,13 @@ class FnordMetric::TimeseriesWidget < FnordMetric::Widget
 
   def series
     colors = FnordMetric::COLORS.dup
-    
+
     gauges.map do |gauge|
-      { 
-        :name => gauge.name, 
-        :data => [{:x => ticks.first, :y => 0}], 
-        :color => colors.unshift(colors.pop).first 
+      {
+        :name => gauge.name,
+        :title => gauge.title,
+        :data => [{:x => ticks.first, :y => 0}],
+        :color => colors.unshift(colors.pop).first
       }
     end
   end