bp-fnordmetric 1.2.7

data/lib/fnordmetric/web/reactor.rb

@@ -0,0 +1,127 @@
+class FnordMetric::Reactor
+
+  def initialize
+    @redis = FnordMetric.mk_redis
+    @namespaces = FnordMetric.namespaces.dup
+  end
+
+  def ready!
+    @namespaces.each do |key, ns|
+      ns.ready!(@redis)
+    end
+  end
+
+  def execute(*args)
+    execute_unsafe(*args)
+  rescue Exception => e
+    FnordMetric.error("reactor crashed: " + e.to_s) 
+    puts (e.backtrace * "\n") if ENV["FNORDMETRIC_ENV"] == "dev"
+    []
+  end
+
+private
+
+  def execute_unsafe(socket, event, messages = [])
+    return [] unless event["namespace"]
+
+    unless ns = @namespaces[event["namespace"].to_sym]
+      return([{ "error" => "invalid namespace: #{event["namespace"]}" }])
+    end
+
+    messages << discover(ns) if event["type"] == "discover_request"
+    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 << 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)
+    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)
+    return false unless gauge = namespace.gauges[event["gauge"].to_sym]
+
+    {
+      :type    => "render_response",
+      :gauge   => gauge.name,
+      :payload => gauge.render_to_event(namespace, event)
+    }
+  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 }
+    end,
+    namespace.gauges.map do |gauge_key, gauge|
+      next unless gauge.renderable?
+      { "type" => "discover_response", "gauge_key" => gauge_key, "view" => "gauge",
+        "title" => gauge.title, "group" => gauge.group, "tick" => gauge.tick }
+    end.compact]
+  end
+
+  def active_users(namespace, event)
+    namespace.ready!(@redis)
+
+    events = if event["filter_by_type"]
+      namespace.events(:by_type, :type => event["type"])
+    elsif event["filter_by_session_key"]
+      namespace.events(:by_session_key, :session_key => params["session_key"])
+    else
+      find_opts = { :limit => 100 }
+      find_opts.merge!(:since => event["since"].to_i+1) if event["since"]
+      namespace.events(:all, find_opts)
+    end
+
+    sessions = namespace.sessions(:all, :limit => 100).map do |session|
+      session.fetch_data!
+      session.to_json
+    end
+
+    types_key = namespace.key_prefix("type-")
+    types = if event["first_poll"]
+      @redis.keys("#{types_key}*").map{ |k| k.gsub(types_key,'') }
+    else
+      []
+    end
+
+    {
+      :type => "active_users_response",
+      :sessions => sessions,
+      :events => events.map(&:to_json),
+      :types => types
+    }
+  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/web.rb

@@ -0,0 +1,59 @@
+class FnordMetric::Web
+
+  def initialize(opts)
+    @opts = opts
+
+    @opts[:server] ||= "thin"
+    @opts[:host]   ||= "0.0.0.0"
+    @opts[:port]   ||= "4242"
+
+    FnordMetric.register(self)
+  end
+
+  def initialized
+    server = @opts[:server].downcase
+
+    middleware_stack = @opts[:use] || []
+
+    websocket = FnordMetric::WebSocket.new
+
+    webapp = if FnordMetric.options[:http_websocket_only]
+      lambda { |env| [204, {}, [""]] }
+    else
+      FnordMetric::App.new(@opts)
+    end
+
+    dispatch  = Rack::Builder.app do
+      use Rack::CommonLogger
+      use Rack::ShowExceptions
+
+      map "/stream" do
+        run websocket
+      end
+
+      map "/" do
+        middleware_stack.each do |middleware| 
+          use(*middleware[0..1], &middleware[2])
+        end
+
+        run webapp
+      end
+
+    end
+
+    unless ["thin", "hatetepe"].include? server
+      raise "Need an EventMachine webserver, but #{server} isn't"
+    end
+
+    host = @opts[:host] 
+    port = @opts[:port]
+
+    Rack::Server.start(
+      :app => dispatch,
+      :server => server,
+      :Host => host, 
+      :Port => port
+    ) && FnordMetric.log("listening on http://#{host}:#{port}")
+  end
+
+end

data/lib/fnordmetric/web/websocket.rb

@@ -0,0 +1,41 @@
+require "eventmachine"
+require 'rack/websocket'
+require "em-hiredis"
+require "json"
+
+class FnordMetric::WebSocket < Rack::WebSocket::Application
+
+  def initialize
+    super
+
+    @reactor = FnordMetric::Reactor.new
+    @uuid = "websocket-#{get_uuid}"
+  end
+
+  def on_open(env)
+    @reactor.ready!
+  end
+
+  def on_message(env, message)
+    begin
+      message = JSON.parse(message)
+    rescue
+      puts "websocket: invalid json"
+    else
+      message["_eid"] ||= get_uuid
+      message["_sender"] = @uuid
+
+      @reactor.execute(self, message).each do |m|
+        send_data m.to_json
+      end
+    end
+  rescue Exception => e
+    FnordMetric.error("[WebSocket] #{e.to_s}")
+    puts e.backtrace.join("\n")
+  end
+
+  def get_uuid
+    rand(8**64).to_s(36)
+  end
+
+end

data/lib/fnordmetric/widget.rb

@@ -0,0 +1,82 @@
+class FnordMetric::Widget
+
+  attr_accessor :gauges, :tick
+
+  def initialize(opts={})
+    @opts = opts
+
+    unless opts.has_key?(:title)
+      error! "widget can't be initialized without a title"
+    end
+
+    add_gauges(opts.delete(:gauges))
+  end
+
+  def title
+    @opts[:title]
+  end
+
+  def token
+    token = title.to_s.gsub(/[\W]/, '').downcase
+    token = Digest::SHA1.hexdigest(title.to_s) if token.empty?
+    token
+  end
+
+  def add_gauges(gauges)
+    if gauges.blank? && has_tick?
+      error! "initializing a widget without gauges is void"
+    else
+      @gauges = gauges
+    end
+    
+    if (ticks = gauges.map{ |g| g.tick }).uniq.length == 1
+      @tick = ticks.first
+    elsif !!self.try(:has_tick?)
+      error! "you can't add gauges with different ticks to the same widget"
+    end
+  end
+
+  def error!(msg)
+    FnordMetric.error!(msg)
+  end
+
+  def range
+    ensure_has_tick!
+    #@opts[:range] || default_range # FIXME: allow custom ranges, but assure that the range-start is 'on a tick'
+    default_range
+  end
+
+  def ticks
+    ensure_has_tick!
+    range.step(@tick)
+  end
+
+  def default_range(now=Time.now)
+    ensure_has_tick!
+    te = gauges.first.tick_at(now.to_i)
+    te -= @tick unless include_current?
+    rs = (@opts[:ticks] || (@tick == 1.hour.to_i ? 24 : 30)).to_i
+    (te-(@tick*rs)..te)
+  end
+
+  def include_current?
+    !(@opts[:include_current] == false)
+  end
+    
+  def data
+    { 
+      :title => @opts[:title], 
+      :width => @opts[:width] || 100,
+      :klass => self.class.name.split("::").last 
+    }
+  end
+
+  def render
+    data
+  end
+
+  def ensure_has_tick!
+    error! "widget does not have_tick" unless has_tick?
+  end
+
+end

data/lib/fnordmetric/widgets/bars_widget.rb

@@ -0,0 +1,44 @@
+class FnordMetric::BarsWidget  < FnordMetric::Widget
+
+  def self.execute(namespace, event)
+    resp = if event["cmd"] == "values_for"
+      {
+        :cmd => :values_for,
+        :values => execute_values_for(namespace.gauges[event["gauge"].to_sym], event["until"])
+      }
+    end
+
+    return false unless resp
+
+    resp.merge(
+      :type => "widget_response",
+      :widget_key => event["widget_key"]
+    )
+  end
+
+  def self.execute_values_for(gauge, time)
+    gauge.field_values_at(time).sort do |a,b|
+      a.first.to_i <=> b.first.to_i
+    end.map do |a|
+      [a.first, a.second.to_i]
+    end
+  end
+
+  def data
+    super.merge(
+      :gauge => gauges.first.name,
+      :title => gauges.first.title,
+      :autoupdate => (@opts[:autoupdate] || 60),
+      :order_by => (@opts[:order_by] || 'value'),
+      :plot_style => (@opts[:plot_style] || 'vertical'),
+      :async_chart => true,
+      :color => FnordMetric::COLORS.last,
+      :tick => tick
+    )
+  end
+
+  def has_tick?
+    false
+  end
+
+end

data/lib/fnordmetric/widgets/html_widget.rb

@@ -0,0 +1,28 @@
+class FnordMetric::HtmlWidget < FnordMetric::Widget
+  def data
+    super.merge(
+      :html => @opts[:html]
+    )
+  end
+
+  def add_gauges(gauges)
+    @gauges = []
+    @tick   = 0
+    
+    if !gauges.blank?
+      error! "initializing a html widget with gauges is void"
+    end
+  end
+
+  def data_gauges
+    {}
+  end
+
+  def default_range(now=Time.now)
+    0..0
+  end
+
+  def has_tick?
+    false
+  end
+end

data/lib/fnordmetric/widgets/numbers_widget.rb

@@ -0,0 +1,80 @@
+class FnordMetric::NumbersWidget < FnordMetric::Widget
+
+  def self.execute(namespace, event)
+    resp = if event["cmd"] == "values_for"
+      execute_values_for(namespace.gauges[event["gauge"].to_sym], event) 
+    end
+
+    return false unless resp
+
+    resp.merge(
+      :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")
+          offset = 0
+          span = (gauge.tick * off.to_s[1..-1].to_i)
+          values = gauge.values_in((_t-span).._t+gauge.tick)
+          value = values.values.compact.map(&:to_i).sum
+        else
+          offset = off.to_i * gauge.tick
+          span = gauge.tick
+          value = gauge.value_at(_t-offset)
+        end
+
+        out["#{gauge.name}-#{offset}-#{span}"]  = { 
+          :value => value,
+          :desc  => "$formatOffset(#{offset}, #{span})"
+        }
+      end
+    end
+
+    { "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)
+    )
+  end
+
+  def has_tick?
+    false
+  end
+  
+end