blackbeard 0.0.4.0 → 0.0.5.0

data/lib/blackbeard/chart.rb

@@ -0,0 +1,65 @@
+module Blackbeard
+  class Chart
+    attr_reader :dom_id
+
+    def initialize(options)
+      [:dom_id, :height, :title].each{|m| instance_variable_set("@#{m}", options[m]) }
+      [:rows, :columns].each{|m| instance_variable_set("@#{m}", options[m] || []) }
+    end
+
+    def options
+      {:title => @title, :height => height}
+    end
+
+    def data
+      {:rows => rows, :cols => columns}
+    end
+
+private
+
+    def height
+      @height || 300
+    end
+
+    def rows
+      @rows.map{ |r| row(r) }
+    end
+
+    def row(r)
+      { :c => r.map{ |c| row_cell(c) } }
+    end
+
+    def row_cell(cell_value)
+      { :v => cell_value }
+    end
+
+    def columns
+      types = column_types
+      @columns.map{ |label| column(label,types.shift) }
+    end
+
+    def column_types
+      @rows.first.map{ |cell_value| cell_type(cell_value) }
+    end
+
+    def cell_type(value)
+      case value.class.name
+      when 'Fixnum'
+        'number'
+      when 'Float'
+        'number'
+      when 'String'
+        'string'
+      when 'Date'
+        'string'
+      else
+        'string'
+      end
+    end
+
+    def column(label, type)
+      {:label => label, :type => type}
+    end
+
+  end
+end

data/lib/blackbeard/chartable.rb

@@ -0,0 +1,47 @@
+module Blackbeard
+  module Chartable
+
+    # In your class define 3 methods:
+    #   * chartable_segments
+    #   * chartable_result_for_hour
+    #   * chartable_result_for_day
+
+    def recent_days(count=28, starting_on = tz.now.to_date)
+      Array(0..count-1).map do |offset|
+        date = starting_on - offset
+        result = chartable_result_for_day(date)
+        Blackbeard::MetricDate.new(date, result)
+      end
+    end
+
+    def recent_hours(count = 24, starting_at = tz.now)
+      Array(0..count-1).map do |offset|
+        hour = starting_at - (offset * 3600)
+        result = chartable_result_for_hour(hour)
+        Blackbeard::MetricHour.new(hour, result)
+      end
+    end
+
+    def recent_hours_chart(count = 24, starting_at = tz.now)
+      data = recent_hours(count, starting_at)
+      title = "Last #{count} Hours"
+      Chart.new(
+        :dom_id => 'recent_hour_chart',
+        :title => title,
+        :columns => ['Hour']+chartable_segments,
+        :rows => data.map{ |metric_hour| metric_hour.result_rows(chartable_segments) }
+      )
+    end
+
+    def recent_days_chart(count = 28, starting_on = tz.now.to_date)
+      data = recent_days(count, starting_on)
+      Chart.new(
+        :dom_id => 'recent_days_chart',
+        :title => "Last #{count} Days",
+        :columns => ['Day']+chartable_segments,
+        :rows => data.map{ |metric_date| metric_date.result_rows(chartable_segments) }
+      )
+    end
+
+  end
+end

data/lib/blackbeard/cohort.rb

@@ -0,0 +1,48 @@
+require 'blackbeard/storable'
+require 'blackbeard/cohort_data'
+
+module Blackbeard
+  class Cohort < Storable
+    include Chartable
+
+    set_master_key :cohorts
+    string_attributes :name, :description
+
+    def add(context, timestamp = nil, force = false)
+      save if new_record?
+      uid = context.unique_identifier
+      #TODO: Make sure timestamp is in correct tz
+      timestamp ||= tz.now
+      return (force) ? data.add_with_force(uid, timestamp) : data.add_without_force(uid, timestamp)
+    end
+
+    def data
+      @data ||= CohortData.new(self)
+    end
+
+    def name
+      storable_attributes_hash['name'] || id
+    end
+
+    def metric_data(metric)
+      CohortMetric.new(self,metric).metric_data
+    end
+
+    def hour_id_for_participant(uid)
+      data.hour_id_for_participant(uid)
+    end
+
+    def chartable_segments
+      ['participants']
+    end
+
+    def chartable_result_for_hour(hour)
+      {'participants' => data.participants_for_hour(hour) }
+    end
+
+    def chartable_result_for_day(date)
+      {'participants' => data.participants_for_day(date) }
+    end
+
+  end
+end

data/lib/blackbeard/cohort_data.rb

@@ -0,0 +1,72 @@
+require 'date'
+
+module Blackbeard
+  class CohortData
+    include ConfigurationMethods
+
+    def initialize(cohort)
+      @cohort = cohort
+    end
+
+    def hour_id_for_participant(uid)
+      db.hash_get(participants_hash_key, uid)
+    end
+
+    def participants_for_hour(time)
+      db.hash_get(hours_hash_key, hour_id(time)).to_i
+    end
+
+    def participants_for_day(date)
+      start_of_day = date.to_time
+      hours_in_day = Array(0..23).map{|x| start_of_day + (3600 * x) }
+      participants_by_hour = participants_for_hours(hours_in_day)
+      participants_by_hour.reduce(:+)
+    end
+
+    def participants_for_hours(hours)
+      hour_ids = hours.map{ |hour| hour_id(hour) }
+      db.hash_multi_get(hours_hash_key, *hour_ids).map{|s| s.to_i }
+    end
+
+    def add_with_force(uid, hour)
+      prior_hour_id = db.hash_get(participants_hash_key, uid)
+
+      # Force not necessary
+      return add_without_force(uid, hour) unless prior_hour_id
+
+      hour_id = hour_id(hour)
+      # No change in cohort status
+      return true if prior_hour_id == hour_id
+
+      # Deincrement old, increment new
+      db.hash_increment_by(hours_hash_key, prior_hour_id, -1)
+      db.hash_increment_by(hours_hash_key, hour_id, 1)
+      db.hash_set(participants_hash_key, uid, hour_id)
+      true
+    end
+
+    def add_without_force(uid, hour)
+      hour_id = hour_id(hour)
+      # Check if uid is alreaty in cohort
+      return false unless db.hash_key_set_if_not_exists(participants_hash_key, uid, hour_id)
+      db.hash_increment_by(hours_hash_key, hour_id, 1)
+      true
+    end
+
+private
+
+    def hour_id(time)
+      time.strftime("%Y%m%d%H")
+    end
+
+    def hours_hash_key
+      "#{@cohort.key}::hours"
+    end
+
+    def participants_hash_key
+      "#{@cohort.key}::participants"
+    end
+
+
+  end
+end

data/lib/blackbeard/cohort_metric.rb

@@ -0,0 +1,47 @@
+module Blackbeard
+  class CohortMetric
+    include Chartable
+
+    attr_reader :cohort, :metric
+
+    def initialize(cohort, metric)
+      @cohort = cohort
+      @metric = metric
+    end
+
+    def type
+      metric.type
+    end
+
+    def add(context, amount)
+      uid = context.unique_identifier
+      hour_id = cohort.hour_id_for_participant(uid)
+      metric_data.add_at(hour_id, uid, amount) unless hour_id.nil?
+    end
+
+    def metric_data
+      @metric_data ||= MetricData.const_get(type.capitalize).new(metric, nil, cohort)
+    end
+
+    def chartable_segments
+      metric_data.map{|s| "avg #{s}" }
+    end
+
+    def chartable_result_for_hour(hour)
+      participants = cohort.data.participants_for_hour(hour)
+      result_per_participant( metric_data.result_for_hour(hour), participants)
+    end
+
+    def chartable_result_for_day(date)
+      participants = cohort.data.participants_for_day(date)
+      result_per_participant( metric_data.result_for_day(date), participants)
+    end
+
+    def result_per_participant(result, participants)
+      participants = participants.to_f
+      result.keys.each{|k| result[k] = result[k].to_f / participants }
+      result
+    end
+
+  end
+end

data/lib/blackbeard/context.rb

@@ -6,6 +6,7 @@ module Blackbeard
     attr_reader :controller, :user
 
     def initialize(pirate, user, controller = nil)
+      # TODO: remove pirate. access cache via separate cache class
       @pirate = pirate
       @controller = controller
       @user = user
@@ -37,12 +38,20 @@ module Blackbeard
       end
     end
 
+    def add_to_cohort(id, timestamp = nil, force = false)
+      @pirate.cohort(id.to_s).add(self, timestamp, force)
+    end
+
+    def add_to_cohort!(id, timestamp = nil)
+      add_to_cohort(id, timestamp, true)
+    end
+
     def feature_active?(id)
       @pirate.feature(id.to_s).reload.active_for?(self)
     end
 
     def unique_identifier
-      @user.nil? ? "b#{visitor_id}" : "a#{@user.id}"
+      @unique_identifier ||= @user.nil? ? "b#{visitor_id}" : "a#{@user.id}"
     end
 
     def user_id
@@ -50,7 +59,7 @@ module Blackbeard
     end
 
     def visitor_id
-      controller.request.cookies[:bbd] ||= generate_visitor_id
+      @visitor_id ||= controller.request.cookies[:bbd] ||= generate_visitor_id
     end
 
 private

data/lib/blackbeard/dashboard.rb

@@ -9,6 +9,7 @@ require 'routes/groups'
 require 'routes/metrics'
 require 'routes/tests'
 require 'routes/features'
+require 'routes/cohorts'
 
 module Blackbeard
   class Dashboard < Sinatra::Base
@@ -21,8 +22,6 @@ module Blackbeard
     use DashboardRoutes::Tests
     use DashboardRoutes::Groups
     use DashboardRoutes::Features
+    use DashboardRoutes::Cohorts
   end
 end
-
-
-

data/lib/blackbeard/dashboard_helpers.rb

@@ -3,27 +3,5 @@ module Blackbeard
     def url(path = '')
       env['SCRIPT_NAME'].to_s + '/' + path
     end
-
-    def js_date(date)
-      "new Date(#{ date.year }, #{ date.month - 1}, #{ date.day } )"
-    end
-
-    def js_hour(hour)
-      "new Date(#{ hour.year}, #{hour.month - 1 }, #{hour.day}, #{hour.hour})"
-    end
-
-    def js_metric_date(segments, d)
-      row = [js_date(d.date)]
-      segments.each{|s| row.push d.result[s].to_f }
-      "[" + row.join(',') + "]"
-    end
-
-    def js_metric_hour(segments, h)
-      row = [js_hour(h.hour)]
-      segments.each{|s| row.push h.result[s].to_f }
-      "[" + row.join(',') + "]"
-    end
-
   end
 end
-

data/lib/blackbeard/errors.rb

@@ -1,8 +1,10 @@
 module Blackbeard
   class GroupNotInMetric < StandardError; end
+  class CohortNotInMetric < StandardError; end
   class StorableMasterKeyUndefined < StandardError; end
   class StorableNotFound < StandardError; end
   class StorableDuplicateKey < StandardError; end
   class StorableNotSaved < StandardError; end
   class UserIdNotDivisable < StandardError; end
+  class InvalidMetricData < StandardError; end
 end

data/lib/blackbeard/group.rb

@@ -31,5 +31,8 @@ module Blackbeard
       config.group_definitions[self.id.to_sym]
     end
 
+    def metric_data(metric)
+      GroupMetric.new(self,metric).metric_data
+    end
   end
 end

data/lib/blackbeard/group_metric.rb

@@ -0,0 +1,39 @@
+module Blackbeard
+  class GroupMetric
+    include Chartable
+
+    attr_reader :group, :metric
+
+    def initialize(group, metric)
+      @group = group
+      @metric = metric
+    end
+
+    def type
+      metric.type
+    end
+
+    def add(context, amount)
+      uid = context.unique_identifier
+      segment = group.segment_for(context)
+      metric_data.add(uid, amount, segment) unless segment.nil?
+    end
+
+    def metric_data
+      @metric_data ||= MetricData.const_get(type.capitalize).new(metric, group, nil)
+    end
+
+    def chartable_segments
+      group.segments
+    end
+
+    def chartable_result_for_hour(hour)
+      metric_data.result_for_hour(hour)
+    end
+
+    def chartable_result_for_day(date)
+      metric_data.result_for_day(date)
+    end
+
+  end
+end

data/lib/blackbeard/metric.rb

@@ -1,13 +1,20 @@
 require "blackbeard/storable"
 require 'blackbeard/metric_data/total'
 require 'blackbeard/metric_data/unique'
+require 'blackbeard/cohort'
+require 'blackbeard/group'
+require 'blackbeard/group_metric'
+require 'blackbeard/cohort_metric'
 
 module Blackbeard
   class Metric < Storable
+    include Chartable
+
     attr_reader :type, :type_id
     set_master_key :metrics
     string_attributes :name, :description
     has_many :groups => Group
+    has_many :cohorts => Cohort
 
     def self.create(type, type_id, options = {})
       super("#{type}::#{type_id}", options)
@@ -41,29 +48,23 @@ module Blackbeard
       end
     end
 
-    def recent_hours
-      metric_data.recent_hours
+    def group_metrics
+      groups.map{ |g| GroupMetric.new(g, self) }
     end
 
-    def recent_days
-      metric_data.recent_days
+    def cohort_metrics
+      cohorts.map{ |c| CohortMetric.new(c, self) }
     end
 
     def add(context, amount)
       uid = context.unique_identifier
       metric_data.add(uid, amount)
-      groups.each do |group|
-        segment = group.segment_for(context)
-        metric_data(group).add(uid, amount, segment) unless segment.nil?
-      end
+      group_metrics.each { |gm| gm.add(context, amount) }
+      cohort_metrics.each { |cm| cm.add(context, amount) }
     end
 
-    def metric_data(group = nil)
-      @metric_data ||= {}
-      @metric_data[group] ||= begin
-        raise GroupNotInMetric unless group.nil? || has_group?(group)
-        MetricData.const_get(type.capitalize).new(self, group)
-      end
+    def metric_data
+      @metric_data ||= MetricData.const_get(type.capitalize).new(self, nil, nil)
     end
 
     def name
@@ -74,6 +75,21 @@ module Blackbeard
       Group.all.reject{ |g| group_ids.include?(g.id) }
     end
 
+    def addable_cohorts
+      Cohort.all.reject{ |c| cohort_ids.include?(c.id) }
+    end
+
+    def chartable_segments
+      metric_data.segments
+    end
+
+    def chartable_result_for_hour(hour)
+      metric_data.result_for_hour(hour)
+    end
+
+    def chartable_result_for_day(date)
+      metric_data.result_for_day(date)
+    end
 
   end
 end