fnordmetric 0.3.2 → 0.5.0

data/lib/fnordmetric/inbound_stream.rb

@@ -0,0 +1,66 @@
+class FnordMetric::InboundStream < EventMachine::Connection 
+
+  @@opts = nil
+
+  def self.start(opts)
+    @@opts = opts
+    EM.start_server(*opts[:inbound_stream], self)    
+  end
+
+  def receive_data(chunk)        
+    @buffer << chunk         
+    EM.defer{ next_event }
+  end
+
+  def push_event(event_id, event_data)    
+    prefix = @@opts[:redis_prefix]
+        
+    @redis.hincrby "#{prefix}-stats",             "events_received", 1
+    @redis.set     "#{prefix}-event-#{event_id}", event_data
+    @redis.lpush   "#{prefix}-queue",             event_id       
+    @redis.expire  "#{prefix}-event-#{event_id}", @@opts[:event_queue_ttl]
+    
+    @events_buffered -= 1
+    close_connection?
+  end
+  
+  def next_event
+    read_next_event
+    push_next_event
+  end
+  
+  def read_next_event
+    while (event = @buffer.slice!(/^(.*)\n/))
+      @events_buffered += 1
+      @events << event
+    end 
+  end
+
+  def push_next_event
+    return true if @events.empty?
+    push_event(get_next_uuid, @events.pop) 
+    EM.next_tick(&method(:push_next_event))    
+  end
+
+  def get_next_uuid
+    rand(9999999999999999999).to_s # FIXME
+  end
+
+  def close_connection?
+    @redis.quit unless @streaming || (@events_buffered!=0) 
+  end
+
+  def post_init
+    @redis = Redis.new
+    @events_buffered = 0
+    @streaming = true
+    @buffer = ""
+    @events = []          
+  end
+
+  def unbind
+    @streaming = false
+    close_connection?
+  end
+
+end

data/lib/fnordmetric/logger.rb

@@ -0,0 +1,38 @@
+class FnordMetric::Logger
+
+  def self.start(logfile_path)    
+    require 'json'
+    event_ids = Queue.new
+    dump_file = File.open(logfile_path, 'a+')
+
+    fetcher = Thread.new do
+      redis = Redis.new
+      loop do
+        event_id = event_ids.pop
+        event_data = redis.get("fnordmetric-event-#{event_id}")        
+        event_hash = JSON.parse(event_data) rescue next
+
+        event_hash.merge!(:_time => Time.now.to_i)
+
+        dump_file.write(event_hash.to_json+"\n")
+        dump_file.flush
+
+        print "\033[1;34m" 
+        print event_hash.inspect
+        print "\033[0m\n"             
+      end
+    end
+
+    listener = Thread.new do  
+      redis = Redis.new
+      redis.subscribe("fnordmetric-announce") do |on|
+        on.message do |channel, event_id|      
+          event_ids << event_id
+        end
+      end
+    end
+
+    fetcher.join
+  end
+
+end

data/lib/fnordmetric/namespace.rb

@@ -0,0 +1,120 @@
+class FnordMetric::Namespace
+  
+  attr_reader :handlers, :gauges, :opts, :key, :dashboards
+
+  @@opts = [:event, :gauge, :widget]
+
+  def initialize(key, opts)    
+    @gauges = Hash.new
+    @dashboards = Hash.new
+    @handlers = Hash.new                 
+    @opts = opts
+    @key = key      
+  end
+
+  def ready!(redis)
+    @redis = redis
+    @gauges.map{ |k,g| g.add_redis(@redis) }
+    self
+  end
+
+  def announce(event)                  
+    announce_to_timeline(event)
+    announce_to_typelist(event)
+    
+    if event[:_session]
+      event[:_session_key] = announce_to_session(event).session_key 
+    end
+
+    [
+      @handlers[event[:_type].to_s],
+      @handlers["*"]
+    ].flatten.compact.each do |context| 
+      context.call(event, @redis) 
+    end
+
+    self
+  end
+
+  def announce_to_session(event)
+    FnordMetric::Session.create(@opts.clone.merge(
+      :namespace_key => @key, 
+      :namespace_prefix => key_prefix,
+      :redis => @redis,
+      :event => event
+    )) 
+  end
+
+  def announce_to_timeline(event)
+    timeline_key = key_prefix(:timeline)
+    @redis.zadd(timeline_key, event[:_time], event[:_eid])
+  end
+
+  def announce_to_typelist(event)
+    typelist_key = key_prefix("type-#{event[:_type]}")
+    @redis.lpush(typelist_key, event[:_eid])
+  end
+
+
+  def key_prefix(append=nil)
+    [@opts[:redis_prefix], @key, append].compact.join("-")
+  end
+
+  def token
+    @key
+  end
+
+  def dashboards(name=nil)
+    return @dashboards unless name
+    @dashboards[name] ||= FnordMetric::Dashboard.new(
+      :title => name
+    )       
+  end
+
+  def sessions(_ids, opts={})
+    return FnordMetric::Session.all(extend_opts(opts)) if _ids == :all
+  end
+
+  def events(_ids, opts={})
+    return FnordMetric::Event.all(extend_opts(opts)) if _ids == :all
+    return FnordMetric::Event.by_type(opts.delete(:type), extend_opts(opts)) if _ids == :by_type
+  end
+
+  def method_missing(m, *args, &block)
+    raise "unknown option: #{m}" unless @@opts.include?(m)
+    send(:"opt_#{m}", *args, &block)
+  end
+
+  def opt_event(event_type, opts={}, &block)    
+    opts.merge!(:redis => @redis, :gauges => @gauges)   
+    FnordMetric::Context.new(opts, block).tap do |context|
+      @handlers[event_type.to_s] ||= []
+      @handlers[event_type.to_s] << context
+    end      
+  end
+
+  def opt_gauge(gauge_key, opts={})
+    opts.merge!(:key => gauge_key, :key_prefix => key_prefix)
+    @gauges[gauge_key] ||= FnordMetric::Gauge.new(opts)   
+  end
+
+  def opt_widget(dashboard, widget)
+    widget = build_widget(widget) if widget.is_a?(Hash)
+    dashboards(dashboard).add_widget(widget)
+  end
+
+  def build_widget(opts)
+    _gauges = [opts[:gauges]].flatten.map{ |g| @gauges.fetch(g) }
+    widget_klass = "FnordMetric::#{opts.fetch(:type).to_s.capitalize}Widget"
+    widget_klass.constantize.new(opts.merge(:gauges => _gauges))
+  end
+
+  def extend_opts(opts)
+    opts.merge(
+      :namespace_prefix => key_prefix,
+      :redis_prefix => @opts[:redis_prefix],
+      :redis => @redis
+    )
+  end
+
+end

data/lib/fnordmetric/numbers_widget.rb

@@ -1,18 +1,36 @@
-class FnordMetric::NumbersWidget  < FnordMetric::Widget
+class FnordMetric::NumbersWidget < FnordMetric::Widget
 
   def data
     super.merge(
-      :autoupdate => !!@options[:autoupdate],
-      :round_to => @options[:round_to]||2,
-      :metrics => metrics.map{ |m| m.token },
-      :intervals => {
-        "Current" => "",
-        "Today" => "at=#{1.day.ago.to_i}-#{Time.now.to_i}",
-        "Month" => "at=#{30.days.ago.to_i}-#{Time.now.to_i}"
-      },
-      :widget_url => "/fnordmetric/widget_numbers.js?#{(rand*999).to_i}",
-      :widget_height => 100
+      :offsets => offsets,
+      :gauges => data_gauges
     )
   end
 
+  def data_gauges
+    Hash.new.tap do |hash|
+      gauges.each do |g|
+        hash[g.name] = {
+          :values => data_gauge(g),
+          :title => g.name
+        }
+      end
+    end
+  end
+
+  def data_gauge(gauge)
+    offsets.map do |offset|
+      offset_time = Time.now.to_i - offset*gauge.tick
+      [gauge.tick_at(offset_time), gauge.value_at(offset_time)]
+    end
+  end
+
+  def has_tick?
+    false
+  end
+
+  def offsets
+    [0, 1, 30]
+  end
+
 end

data/lib/fnordmetric/session.rb

@@ -0,0 +1,131 @@
+class FnordMetric::Session
+ 
+  attr_accessor :updated_at, :name, :picture
+
+  @@meta_attributes = %w(name picture)
+
+  def self.create(opts)        
+    redis = opts.fetch(:redis)
+    event = opts[:event]   
+
+    hash = Digest::MD5.hexdigest(event[:_session])
+    set_key = "#{opts[:namespace_prefix]}-session"
+
+    self.new(hash).tap do |session|
+      session.add_redis(redis, set_key)      
+      session.add_event(event)    
+      session.expire(opts[:session_data_ttl])
+    end    
+  end
+
+  def self.find(session_key, opts)
+    set_key = "#{opts[:namespace_prefix]}-session"
+    self.new(session_key, [opts[:redis], set_key])
+  end
+
+  def self.all(opts)    
+    set_key = "#{opts[:namespace_prefix]}-session"
+    limit = (opts[:limit].try(:to_i)||0)-1
+    session_ids = opts[:redis].zrevrange(set_key, 0, limit, :withscores => true)
+    session_ids.in_groups_of(2).map do |session_key, ts|
+      find(session_key, opts).tap{ |s| s.updated_at = ts }
+    end
+  end
+
+  def initialize(session_key, redis_opts=nil)
+    @session_key = session_key
+    add_redis(*redis_opts) if redis_opts
+  end
+
+  def session_key
+    @session_key
+  end
+
+  def picture
+    @picture
+  end
+
+  def name
+    @name
+  end
+
+  def data(key=nil)
+    key ? @data[key] : @data 
+  end
+
+  def event_ids
+    @event_ids || []
+  end
+
+  def events
+    [] 
+  end
+
+  def to_json
+    { :session_key => session_key }.tap do |hash| 
+      hash.merge!(:_picture => @picture) if @picture
+      hash.merge!(:_name => @name) if @name
+      hash.merge!(:_updated_at => @updated_at) if @updated_at
+    end
+  end
+
+  def redis_key(append=nil)
+    [@redis_prefix, @session_key, append].compact.join("-")
+  end
+
+  def add_redis(redis, prefix)
+    @redis_prefix = prefix
+    @redis = redis
+  end
+
+  def touch(time=Time.now.to_i)      
+    @redis.zadd(@redis_prefix, time, @session_key)
+  end
+
+  def expire(time)
+    @redis.expire(redis_key(:events), time)
+    @redis.expire(redis_key(:data), time)
+  end
+
+  def add_event(event)    
+    @redis.zadd(redis_key(:events), event[:_time], event[:_eid])    
+    add_data(:_picture, event[:url]) if event[:_type] == "_set_picture"    
+    add_data(:_name, event[:name]) if event[:_type] == "_set_name"    
+    add_event_data(event) if event[:_type] == "_set_data" 
+    touch(event[:_time])
+  end
+
+  def add_event_data(event)
+    event.each do |key,value|
+      add_data(key, value) unless key[0]=="_"
+    end
+  end
+
+  def add_data(key, value)    
+    @redis.hset(redis_key(:data), key, value)
+  end
+  
+  def fetch_data!
+    @data = Hash.new
+    @redis.hgetall(redis_key(:data)).each do |key, value|    
+      if key[0]=="_" 
+        fetch_meta_key(key, value)
+      else      
+        @data[key.intern] = value 
+      end
+    end
+  end
+
+  def fetch_meta_key(key, value)
+    meta_key = key[1..-1]
+    if @@meta_attributes.include?(meta_key)
+      instance_variable_set(:"@#{meta_key}", value)
+    end
+  end
+
+  def fetch_event_ids!(since=-1)
+    # FIXME: use WITHSCORE to get the timestamps and return event objects
+    @event_ids = @redis.zrange(redis_key(:events), 0, since)
+  end
+
+end

data/lib/fnordmetric/standalone.rb

@@ -0,0 +1,31 @@
+require 'rake'
+require 'redis'
+
+task :run do  
+  FnordMetric.run
+end
+
+task :log do
+  FnordMetric::Logger.start(dump_file_path)
+end
+
+task :import do
+  puts 'not yet implemented :('
+end
+
+task :help do
+  puts "usage: #{$0} {run|log|import} [DUMP_FILE=fm_dump.json]"
+end
+
+task :default => :help
+
+def dump_file_path
+  if ENV["DUMP_FILE"].blank?
+  	Rake::Task[:help].execute; exit!
+  else
+  	::File.expand_path(ENV["DUMP_FILE"], ::File.dirname($0))
+  end
+end
+
+Rake.application.init('fnordmetric')
+Rake.application.top_level

data/lib/fnordmetric/timeline_widget.rb

@@ -1,17 +1,37 @@
 class FnordMetric::TimelineWidget  < FnordMetric::Widget
 
+  def data_labels
+    ticks.map do |t|
+      Time.at(t).strftime('%d.%m.%y %H:%M')
+    end
+  end
+
+  def data_series
+    gauges.map do |gauge|
+      { 
+        :color => next_series_colour,
+        :data => ticks.map{ |t| gauge.value_at(t)||0 }
+      }
+    end
+  end
+
+  def next_series_colour
+    @series_colors.pop.tap do |color|
+      @series_colors.unshift(color)
+    end
+  end
+
   def data
+    @series_colors = ["#FACE4F", "#42436B", "#CD645A", "#2F635E"]
+
     super.merge(
-      :start_timestamp => range_to_i.first,
-      :end_timestamp => range_to_i.last,
-      :tick => tick.to_i,
-      :delta => !!@options[:delta],
-      :autoupdate => !!@options[:autoupdate],
-      :metrics => metrics.map{ |m| m.token },
-      :widget_url => "/fnordmetric/widget_timeline.js?#{(rand*999).to_i}",
-      :chart_type => (@options[:chart] || "line"),
-      :widget_height => 320
+      :labels => data_labels,
+      :series => data_series
     )
   end
 
+  def has_tick?
+    true
+  end
+
 end