fnordmetric 0.3.2

data/lib/fnordmetric/average_metric.rb

@@ -0,0 +1,7 @@
+class FnordMetric::AverageMetric < FnordMetric::Metric
+
+  def value_at(time_or_range)
+    5.23 #fixme
+  end
+
+end

data/lib/fnordmetric/cache.rb

@@ -0,0 +1,20 @@
+class FnordMetric::Cache
+  include Mongoid::Document
+
+  self.collection_name = 'fnordmetric_cache' 
+
+  field :cache_key, :type => String
+  field :data, :type => Hash
+
+  def self.store!(cache_key, data)
+    data = { :value => data } unless data.is_a?(Hash)
+    self.create(:cache_key => cache_key, :data => data)
+  end
+
+  def self.get(cache_key)
+    item = self.where(:cache_key => cache_key).last
+    return nil unless item
+    item.data.keys == ["value"] ? item.data["value"] : item.data
+  end
+
+end

data/lib/fnordmetric/combine_metric.rb

@@ -0,0 +1,7 @@
+class FnordMetric::CombineMetric < FnordMetric::Metric
+
+  def value_at(time_or_range)
+    @options[:combine].call(time_or_range)
+  end
+
+end

data/lib/fnordmetric/core.rb

@@ -0,0 +1,66 @@
+module FnordMetric
+
+  WIDGET_TYPES = %(timeline funnel numbers)
+  
+  @@metrics = {}
+  @@widgets = {}
+  @@dashboards = Array.new
+
+  def self.define(metric_name, options)
+    warn "FnordMetric.metric is deprecated, please use FnordMetric.metric instead"
+    self.metric(metric_name, options)
+  end
+
+  def self.metric(metric_name, options)
+    options.merge!(:name => metric_name)
+    @@metrics[metric_name] = FnordMetric::Metric.from_options(options)
+  end
+
+  def self.widget(widget_name, options)
+    options.merge!(:widget_name => widget_name)
+    raise "missing option: :type" unless options[:type]
+    klass = if FnordMetric::WIDGET_TYPES.include?(options[:type].to_s) 
+      "FnordMetric::#{options[:type].to_s.capitalize}Widget".constantize
+    else
+      raise "unknown widget type: #{options[:type]}"
+    end
+    [options[:metrics]].flatten.each do |m|
+      raise "unknown metric: #{m}" unless @@metrics[m]
+    end
+    @@widgets[widget_name] = klass.new(options)
+  end
+
+  def self.dashboard(title, options={}, &block)
+    options.merge!(:title => title)
+    @@dashboards << FnordMetric::Dashboard.new(options, block)
+  end
+
+  def self.track(event_name, event_data)
+    FnordMetric::Event.track!(event_name, event_data)
+  end
+
+  def self.report(options)  
+    FnordMetric::Report.new(metrics, options)
+  end
+  
+  def self.metrics
+    @@metrics
+  end
+
+  def self.widgets
+    @@widgets
+  end
+
+  def self.reset_metrics
+    @@metrics = {}
+  end
+
+  def self.reset_widgets
+    @@widgets = {}
+  end
+
+  def self.dashboards
+    @@dashboards
+  end
+
+end

data/lib/fnordmetric/count_metric.rb

@@ -0,0 +1,13 @@
+class FnordMetric::CountMetric < FnordMetric::Metric
+
+private
+
+  def value_at(time_or_range)
+  	# FIXME: value_at(my_time) is really slow, because it has to fetch all events that 
+  	# happened until that time (and this is not even cached, when time is in the future   	
+  	# or just now), so we should redirect the call to something like:
+  	# value_at(last_cache_since_my_time) + value_at(last_cache_since_my_time..my_time) 
+    events_at(time_or_range).count
+  end
+
+end

data/lib/fnordmetric/dashboard.rb

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

data/lib/fnordmetric/engine.rb

@@ -0,0 +1,3 @@
+class FnordMetric::Engine < Rails::Engine
+  endpoint FnordMetric::App
+end

data/lib/fnordmetric/event.rb

@@ -0,0 +1,28 @@
+class FnordMetric::Event  
+  include Mongoid::Document
+
+  self.collection_name = 'fnordmetric_event' 
+
+  field :type, :type => String
+  field :client, :type => Integer
+  field :data, :type => Hash
+
+  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)
+  end
+
+  def time
+    read_attribute(:time).to_i
+  end
+
+  def [](key)
+    send(key)
+  end
+
+  def method_missing(method)
+    data[method.to_s]
+  end
+
+end

data/lib/fnordmetric/funnel_widget.rb

@@ -0,0 +1,2 @@
+class FnordMetric::FunnelWidget < FnordMetric::Widget
+end

data/lib/fnordmetric/metric.rb

@@ -0,0 +1,80 @@
+class FnordMetric::Metric
+  
+  METRIC_TYPES = %w(count average sum combine)
+    
+  def self.from_options(options)
+    if (klass_name = METRIC_TYPES.detect{ |n| !!options[n.intern] })
+      klass = "FnordMetric::#{klass_name.classify}Metric".constantize
+      return klass.new(options)
+    end
+    raise "please provide one of these options: average, sum, count, combine"
+  end
+
+  def initialize(options)
+    @options = options
+  end
+
+  def current
+    self.at(Time.now)
+  end
+
+  def at(time_or_range)    
+    if cache_this?(time_or_range) && (_v=try_cache(time_or_range))
+      _v # cache hit
+    else # cache miss
+      value_at(time_or_range).tap do |_v| 
+        store_cache(time_or_range, _v) if cache_this?(time_or_range)
+      end
+    end
+  end
+
+  def token
+    @options[:name]
+  end
+
+  def events
+    _events = FnordMetric::Event
+    if @options[:types]
+      _events = _events.where(:type.in => [@options[:types]].flatten) 
+    end
+    _events
+  end
+
+  def events_at(time_or_range)
+    if time_or_range.is_a?(Range)
+      events.where(:time.lt => time_or_range.last.to_i).where(:time.gt => time_or_range.first.to_i)
+    else
+      events.where(:time.lt => time_or_range.to_i)
+    end
+  end
+
+private
+
+  def value_at(time_or_range)
+    raise "implemented in subclass"
+  end
+
+  def cache_this?(time_or_range)
+    ((!time_or_range.is_a?(Range) && time_or_range.to_i < Time.now.to_i) ||
+    (time_or_range.is_a?(Range) && time_or_range.last.to_i < Time.now.to_i))
+  end
+
+  def try_cache(time_or_range)
+    FnordMetric::Cache.get(cache_key(time_or_range))
+  end
+
+  def store_cache(time_or_range, value)
+    FnordMetric::Cache.store!(cache_key(time_or_range), value)
+  end
+
+  def cache_key(time_or_range)
+    time_part = if time_or_range.is_a?(Range) 
+      "r#{time_or_range.first.to_i}-#{time_or_range.last.to_i}"
+    else
+      "t#{time_or_range.to_i.to_s}"
+    end    
+    [self.token, time_part].join("|")
+  end
+
+
+end

data/lib/fnordmetric/metric_api.rb

@@ -0,0 +1,37 @@
+class FnordMetric::MetricAPI
+
+  def initialize(params)
+    @params = params.to_options   
+    @metric = FnordMetric.metrics.to_options[params[:name].to_sym] 
+  end
+
+  def render
+    return {:error => "metric not found"}.to_json unless @metric
+    data = if @params[:at] && @params[:at] =~ /^[0-9]+$/
+      { :value => @metric.at(Time.at(@params[:at].to_i)) }
+    elsif @params[:at] && @params[:at] =~ /^([0-9]+)-([0-9]+)$/ && @params[:tick]
+      { :values => tick_data }
+    elsif @params[:at] && @params[:at] =~ /^([0-9]+)-([0-9]+)$/
+      { :value => range_data }
+    else
+      { :value => @metric.at(Time.now) }
+    end    
+    data.to_json
+  end
+
+private
+
+  def range_data
+    start_ts, end_ts = @params[:at].split("-").map(&:to_i) 
+    @metric.at(start_ts..end_ts)
+  end
+  
+  def tick_data(tick_length=@params[:tick].to_i)
+    start_ts, end_ts = @params[:at].split("-").map(&:to_i)    
+    ticks = (start_ts..end_ts).step(tick_length)    
+    ticks.map do |tick| 
+      [tick, @metric.at(@params[:delta] ? (tick..tick+tick_length) : tick)]
+    end    
+  end
+
+end

data/lib/fnordmetric/numbers_widget.rb

@@ -0,0 +1,18 @@
+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
+    )
+  end
+
+end

data/lib/fnordmetric/report.rb

@@ -0,0 +1,29 @@
+class FnordMetric::Report
+
+  attr_accessor :events, :metrics
+
+  def initialize(_metrics, options)
+    @options = options
+    @metrics = Hash.new
+    @events = Array.new
+    _metrics.each{ |k,m| self.add_metric!(m) }
+  end
+
+  def add_metric!(metric)
+    @metrics[metric.token] = metric
+    add_helper_methods(metric)
+  end
+
+  def metaclass
+    class << self; self; end
+  end
+
+private
+
+  def add_helper_methods(metric)
+    self.metaclass.send(:define_method, metric.token) do 
+      @metrics[metric.token]
+    end
+  end
+
+end

data/lib/fnordmetric/sum_metric.rb

@@ -0,0 +1,13 @@
+class FnordMetric::SumMetric < FnordMetric::Metric
+
+private
+
+  def value_at(time_or_range)
+    # FIXME: value_at(my_time) is really slow, because it has to fetch all events that 
+    # happened until that time (and this is not even cached, when time is in the future     
+    # or just now), so we should redirect the call to something like:
+    # value_at(last_cache_since_my_time) + value_at(last_cache_since_my_time..my_time) 
+    events_at(time_or_range).sum(:"data.#{@options[:sum]}")
+  end
+
+end

data/lib/fnordmetric/timeline_widget.rb

@@ -0,0 +1,17 @@
+class FnordMetric::TimelineWidget  < FnordMetric::Widget
+
+  def data
+    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
+    )
+  end
+
+end

data/lib/fnordmetric/widget.rb

@@ -0,0 +1,75 @@
+class FnordMetric::Widget
+
+  attr_accessor :report
+
+  def initialize(options={})
+    @options = options
+    add_report(@options[:report]) if @options[:report]
+  end
+
+  def title
+    @options[:title]
+  end
+
+  def metrics
+    [@options[:metrics]].flatten.map{ |m|
+      m.is_a?(FnordMetric::Metric) ? m : FnordMetric.metrics.fetch(m)
+    }
+  end
+
+  def tick
+    @options[:tick] || 1.day
+  end
+
+  def range
+    @options[:range] || default_range
+  end
+
+  def range_to_i
+    (range.first.to_i..range.last.to_i)
+  end
+
+  def ticks
+    range_to_i.step(tick.to_i).map{ |ts|
+      (Time.at(ts)..Time.at(ts+tick.to_i))
+    }.compact
+  end
+
+  def default_range(now=Time.now)
+    if tick.to_i == 1.day.to_i
+      now = now+1.day
+      te = Time.utc(now.year, now.month, now.day) 
+      (te-30.days)..(te-1.second)
+    elsif tick.to_i == 1.hour.to_i
+      te = Time.utc(now.year, now.month, now.day, now.hour) 
+      (te-24.hours)..(te-1.second)
+    else
+      (now-(tick*30))..now
+    end
+  end
+    
+  def add_report(report)
+    @report = report
+  end
+
+  def data
+    { :title => @options[:title] }
+  end
+
+  def data_json
+    data.to_json.gsub('"', '\'')
+  end
+
+  def include_current?
+    !(@options[:current] == false)
+  end
+
+  def render(elem_id)
+    %Q{      
+      <script type='text/javascript'>
+        FnordMetric.render('#{elem_id}', #{data_json});
+      </script>
+    }
+  end
+
+end