fnordmetric 0.3.2 → 0.5.0

data/lib/fnordmetric/app.rb

@@ -1,7 +1,11 @@
+# encoding: utf-8
+
 class FnordMetric::App < Sinatra::Base
   
   @@sessions = Hash.new
   
+  Encoding.default_external = Encoding::UTF_8
+
   #use Rack::Reloader, 0
   
   enable :session
@@ -9,6 +13,17 @@ class FnordMetric::App < Sinatra::Base
   set :haml, :format => :html5 
   set :views, ::File.expand_path('../../../haml', __FILE__)
   set :public, ::File.expand_path('../../../pub', __FILE__)
+
+  def initialize(namespaces, opts)
+    @namespaces = {}
+    @redis = Redis.new
+    namespaces.each do |key, block|
+      @namespaces[key] = FnordMetric::Namespace.new(key, opts.clone)
+      @namespaces[key].instance_eval(&block)
+      @namespaces[key].ready!(@redis.clone)
+    end
+    super(nil)
+  end
   
   helpers do
     include Rack::Utils
@@ -18,6 +33,12 @@ class FnordMetric::App < Sinatra::Base
       request.env["SCRIPT_NAME"]
     end
 
+    def current_namespace          
+      @namespaces[@namespaces.keys.detect{ |k|
+        k.to_s == params[:namespace]
+      }.try(:intern)]
+    end
+
   end
 
   if ENV['RACK_ENV'] == "test"
@@ -25,24 +46,62 @@ class FnordMetric::App < Sinatra::Base
   end
 
   get '/' do
-  	redirect "#{request.env["SCRIPT_NAME"]}/dashboard/default"
+  	redirect "#{path_prefix}/#{@namespaces.keys.first}"
   end
 
-  get '/dashboard/:name' do
-    @dashboard = FnordMetric.dashboards.detect{|d| d.token == params[:name] }
-    @dashboard ||= FnordMetric.dashboards.first
+  get '/:namespace' do
     haml :app
   end
 
-  get '/metric/:name' do
-    content_type 'application/json'
-    FnordMetric::MetricAPI.new(params).render    
+  get '/favicon.ico' do
+    ""
+  end
+
+  #get '/metric/:name' do
+  #  content_type 'application/json'
+  #  FnordMetric::MetricAPI.new(params).render    
+  #end
+
+  #get '/widget/:name' do
+  #  @dashboard = FnordMetric.dashboards.first
+  #  @widget = @dashboard.widgets.first
+  #  haml :widget
+  #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])
+    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 '/widget/:name' do
-    @dashboard = FnordMetric.dashboards.first
-    @widget = @dashboard.widgets.first
-    haml :widget
+  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
+
+  get '/:namespace/dashboard/:dashboard' do
+    dashboard = current_namespace.dashboards.fetch(params[:dashboard])
+
+    dashboard.to_json
   end
 
   post '/events' do

data/lib/fnordmetric/cache.rb

@@ -1,10 +1,10 @@
 class FnordMetric::Cache
-  include Mongoid::Document
+#  include Mongoid::Document
 
-  self.collection_name = 'fnordmetric_cache' 
+#  self.collection_name = 'fnordmetric_cache' 
 
-  field :cache_key, :type => String
-  field :data, :type => Hash
+#  field :cache_key, :type => String
+#  field :data, :type => Hash
 
   def self.store!(cache_key, data)
     data = { :value => data } unless data.is_a?(Hash)

data/lib/fnordmetric/context.rb

@@ -0,0 +1,65 @@
+class FnordMetric::Context
+
+  include FnordMetric::GaugeModifiers
+
+  def initialize(opts, block)
+    @block = block
+  	@opts = opts    
+  end
+
+  def call(event, redis)
+    @redis = redis
+  	@event = event    
+  	self.instance_eval(&@block)
+  rescue Exception => e
+    raise e  if ENV['FNORDMETRIC_ENV'] == 'test'
+    puts "error: #{e.message}"
+  end
+
+private
+
+  def session_key
+    @event[:_session_key]
+  end
+
+  def data
+  	@event
+  end
+
+  def key(gauge)
+    fetch_gauge(gauge).key
+  end
+
+  def time
+    @event[:_time].to_i
+  end
+
+protected
+
+  def fetch_gauge(_gauge)
+    _gauge.is_a?(FnordMetric::Gauge) ? _gauge : @opts[:gauges].fetch(_gauge)
+  rescue
+    error! "error: gauge '#{_gauge}' is undefined"
+  end
+
+  def error!(msg)
+    FnordMetric.error!(msg)
+  end
+
+  def assure_two_dimensional!(gauge)
+    return true if gauge.two_dimensional?
+    error! "error: #{caller[0].split(" ")[-1]} can only be used with 2-dimensional gauges" 
+  end
+
+  def assure_three_dimensional!(gauge)
+    return true unless gauge.two_dimensional?
+    error! "error: #{caller[0].split(" ")[-1]} can only be used with 3-dimensional gauges" 
+  end
+
+  def assure_non_progressive!(gauge)
+    return true unless gauge.progressive?
+    error! "error: #{caller[0].split(" ")[-1]} can only be used with non-progressive gauges" 
+  end
+
+end
+    

data/lib/fnordmetric/dashboard.rb

@@ -1,17 +1,15 @@
 class FnordMetric::Dashboard
 
-  attr_accessor :widgets, :report
+  attr_accessor :widgets
 
-  def initialize(options, _block=nil, &block)
-    @options = options.to_options
+  def initialize(options={})    
+    raise "please provide a :title" unless options[:title]        
     @widgets = Array.new
-    raise "please provide a :title" unless @options[:title]
-    (_block||block).call(self)
-    add_report(@options[:report]) if @options[:report]
+    @options = options
   end
 
   def add_widget(w)
-    @widgets << (w.is_a?(FnordMetric::Widget) ? w : FnordMetric.widgets.fetch(w))
+    @widgets << w
   end
 
   def title
@@ -21,10 +19,16 @@ class FnordMetric::Dashboard
   def token
     title.to_s.gsub(/[\W]/, '')
   end
-  
-  def add_report(report)
-    @report = report
-    @widgets.each{ |w| w.add_report(report) }
-  end
 
+  def to_json
+    {
+      :title => title,
+      :widgets => {}.tap { |wids|
+        @widgets.each do |w|
+          wids[w.token] = w.render
+        end
+      }
+    }.to_json
+  end
+  
 end

data/lib/fnordmetric/event.rb

@@ -1,28 +1,78 @@
 class FnordMetric::Event  
-  include Mongoid::Document
 
-  self.collection_name = 'fnordmetric_event' 
+  attr_accessor :time, :type, :event_id
 
-  field :type, :type => String
-  field :client, :type => Integer
-  field :data, :type => Hash
+  #def self.track!(event_type, event_data)
+  #end
 
-  def self.track!(event_type, event_data)
-    event_data.to_options!
-    event_time = (event_data.delete(:time) || Time.now.getutc).to_i
-    self.create(:type => event_type, :time => event_time, :data => event_data)
+  def self.all(opts)    
+    range_opts = { :withscores => true }
+    range_opts.merge!(:limit => [0,opts[:limit]]) if opts[:limit]
+    opts[:redis].zrevrangebyscore(
+      "#{opts[:namespace_prefix]}-timeline", 
+      '+inf', opts[:since]||'0',
+      range_opts
+    ).in_groups_of(2).map do |event_id, ts|
+      next if event_id.blank?
+      find(event_id, opts).tap{ |e| e.time = ts }
+    end
   end
 
-  def time
-    read_attribute(:time).to_i
+  def self.by_type(_type, opts)
+    opts[:redis].lrange(
+      "#{opts[:namespace_prefix]}-type-#{_type}", 
+      0, 200).map do |event_id|
+      next if event_id.blank?
+      find(event_id, opts).tap{ |e| }
+    end
   end
 
-  def [](key)
-    send(key)
+  def self.find(event_id, opts)
+    self.new(event_id, opts).tap do |event|
+      event.fetch!
+    end
   end
 
-  def method_missing(method)
-    data[method.to_s]
+  def initialize(event_id, opts)
+    @opts = opts
+    @event_id = event_id
+  end
+
+  def fetch!
+    @data = JSON.parse(fetch_json).tap do |event|
+      @type = event.delete("_type")
+    end
+  end
+
+  def fetch_json
+    @opts[:redis].get(redis_key) || "{}"
+  end
+
+  def redis_key
+    [@opts[:redis_prefix], :event, @event_id].join("-")
+  end
+
+  def session_key
+    @data["_session"] ? Digest::MD5.hexdigest(@data["_session"]) : nil
+  end
+
+  def id
+    @event_id
+  end
+  
+  def data(key=nil)
+    key ? @data[key.to_s] : @data
+  end
+
+  alias :[] :data
+
+  def to_json
+    @data.merge!(
+      :_type => @type, 
+      :_session_key => session_key,
+      :_eid => @event_id,
+      :_time => @time
+    )
   end
 
 end

data/lib/fnordmetric/gauge.rb

@@ -0,0 +1,46 @@
+class FnordMetric::Gauge
+  
+  include FnordMetric::GaugeCalculations
+
+  def initialize(opts)
+    opts.fetch(:key) && opts.fetch(:key_prefix)
+    @opts = opts
+  end
+
+  def tick
+    (@opts[:tick] || 3600).to_i
+  end
+
+  def tick_at(time)    
+    (time/tick.to_f).floor*tick
+  end
+
+  def name
+    @opts[:key]
+  end
+  
+  def key(_append=nil)
+    [@opts[:key_prefix], "gauge", name, tick, _append].flatten.compact.join("-")
+  end
+
+  def tick_key(_time, _append=nil)
+    key([(progressive? ? :progressive : tick_at(_time).to_s), _append])
+  end
+
+  def two_dimensional?
+    !@opts[:three_dimensional]
+  end
+
+  def progressive?
+    !!@opts[:progressive]
+  end
+
+  def unique?
+    !!@opts[:unique]
+  end
+
+  def add_redis(_redis)
+    @opts[:redis] = _redis
+  end
+
+end

data/lib/fnordmetric/gauge_calculations.rb

@@ -0,0 +1,43 @@
+module FnordMetric::GaugeCalculations
+
+  @@avg_per_session_proc = proc{ |_v, _t|
+    #raise redis.get(tick_key(_t, :"sessions-count")).inspect
+    (_v.to_f / (redis.get(tick_key(_t, :"sessions-count"))||0).to_i)
+  }
+
+  def value_at(time, opts={}, &block)
+    _t = tick_at(time)
+    _v = redis.hget(key, _t)
+
+    calculate_value(_v, _t, opts, block)
+  end
+
+  def values_at(times, opts={}, &block)
+    times = times.map{ |_t| tick_at(_t) }
+    Hash.new.tap do |ret|
+      redis.hmget(key, *times).each_with_index do |_v, _n|
+        _t = times[_n]
+        ret[_t] = calculate_value(_v, _t, opts, block)
+      end
+    end
+  end
+
+  def values_in(range, opts={}, &block)
+    values_at((tick_at(range.first)..range.last).step(tick))
+  end
+
+  def calculate_value(_v, _t, opts, block)
+    block = @@avg_per_session_proc if opts[:avg_per_session]
+
+    if block
+      instance_exec(_v, _t, &block)
+    else
+      _v
+    end
+  end
+
+  def redis
+    @opts[:redis]
+  end
+
+end

data/lib/fnordmetric/gauge_modifiers.rb

@@ -0,0 +1,43 @@
+module FnordMetric::GaugeModifiers
+
+  def incr(gauge_name, value=1)
+    gauge = fetch_gauge(gauge_name)
+    assure_two_dimensional!(gauge)
+    if gauge.unique? 
+      incr_uniq(gauge, value)
+    else
+      incr_tick(gauge, value)
+    end
+  end
+
+  def incr_tick(gauge, value)
+    if gauge.progressive?      
+      @redis.incrby(gauge.key(:head), value).callback do |head|
+        @redis.hsetnx(gauge.key, gauge.tick_at(time), head).callback do |_new|
+          @redis.hincrby(gauge.key, gauge.tick_at(time), value) unless _new
+        end
+      end
+    else
+      @redis.hincrby(gauge.key, gauge.tick_at(time), value)    
+    end
+  end  
+
+  def incr_uniq(gauge, value)
+    return false unless session_key
+    @redis.sadd(gauge.tick_key(time, :sessions), session_key).callback do |_new|
+      @redis.expire(gauge.tick_key(time, :sessions), gauge.tick)
+      if _new
+        @redis.incr(gauge.tick_key(time, :"sessions-count")).callback do |sc|
+          incr_tick(gauge, value)
+        end
+      end
+    end
+  end
+
+  def incr_field(gauge_name, field_name, value=1)
+    gauge = fetch_gauge(gauge_name)
+    assure_three_dimensional!(gauge)
+    # here be dragons
+  end
+
+end