blackbeard 0.0.4.0 → 0.0.5.0

data/lib/blackbeard/metric_data/base.rb

@@ -1,32 +1,22 @@
 require 'blackbeard/metric_hour'
 require 'blackbeard/metric_date'
 require 'date'
+require 'blackbeard/chart'
+require 'blackbeard/metric_data/uid_generator'
+require 'blackbeard/chartable'
 
 module Blackbeard
   module MetricData
     class Base
       include ConfigurationMethods
-      attr_reader :metric, :group
 
-      def initialize(metric, group = nil)
+      attr_reader :metric, :group, :cohort
+
+      # TODO: refactor so you pass group and cohort in as options
+      def initialize(metric, group = nil, cohort = nil)
         @metric = metric
         @group = group
-      end
-
-      def recent_days(count=28, starting_on = tz.now.to_date)
-        Array(0..count-1).map do |offset|
-          date = starting_on - offset
-          result = 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 = result_for_hour(hour)
-          Blackbeard::MetricHour.new(hour, result)
-        end
+        @cohort = cohort
       end
 
       def hour_keys_for_day(date)
@@ -44,27 +34,18 @@ module Blackbeard
 
       def key
         @key ||= begin
-          lookup_hash = "metric_data_keys"
-          lookup_field = "metric-#{metric.id}"
-          lookup_field += "::group-#{group.id}" if group
-          uid = db.hash_get(lookup_hash, lookup_field)
-          if uid.nil?
-            uid = db.increment("metric_data_next_uid")
-            # write and read to avoid race conditional writes
-            db.hash_key_set_if_not_exists(lookup_hash, lookup_field, uid)
-            uid = db.hash_get(lookup_hash, lookup_field)
-          end
           "data::#{uid}"
         end
       end
 
+      def uid
+        uid = UidGenerator.new(self).uid
+      end
+
       def segments
-        if group && group.segments.any?
-          group.segments
-        else
-          [self.class::DEFAULT_SEGMENT]
-        end
+        [self.class::DEFAULT_SEGMENT]
       end
+
     private
 
       def generate_result_for_day(date)
@@ -75,7 +56,6 @@ module Blackbeard
         result
       end
 
-
       def hour_keys
         db.set_members(hours_set_key)
       end
@@ -93,7 +73,10 @@ module Blackbeard
       end
 
       def key_for_hour(time)
-        "#{key}::#{ time.strftime("%Y%m%d%H") }"
+        if time.kind_of?(Time)
+          time = time.strftime("%Y%m%d%H")
+        end
+        "#{key}::#{ time }"
       end
 
     end

data/lib/blackbeard/metric_data/total.rb

@@ -11,10 +11,11 @@ module Blackbeard
       end
 
       def add_at(time, uid, amount = 1, segment = DEFAULT_SEGMENT)
+        # TODO: ensure time is in correct timezone
         key = key_for_hour(time)
         db.set_add_member(hours_set_key, key)
         db.hash_increment_by_float(key, segment, amount.to_f)
-        #TODO: if not today, blow away rollup keys
+        # TODO: if not today, blow away rollup keys
       end
 
       def result_for_hour(time)

data/lib/blackbeard/metric_data/uid_generator.rb

@@ -0,0 +1,38 @@
+module Blackbeard
+  module MetricData
+    class UidGenerator
+      include ConfigurationMethods
+
+      def initialize(metric_data)
+        @metric = metric_data.metric
+        @group = metric_data.group
+        @cohort = metric_data.cohort
+      end
+
+      def uid
+        db.hash_get(lookup_hash, lookup_field) || generate_uid
+      end
+
+    private
+
+      def lookup_hash
+        "metric_data_keys"
+      end
+
+      def lookup_field
+        lookup_field = "metric-#{@metric.id}"
+        lookup_field += "::group-#{@group.id}" if @group
+        lookup_field += "::group-#{@cohort.id}" if @cohort
+        lookup_field
+      end
+
+      def generate_uid
+        uid = db.increment("metric_data_next_uid")
+        # write and read to avoid race conditional writes
+        db.hash_key_set_if_not_exists(lookup_hash, lookup_field, uid)
+        db.hash_get(lookup_hash, lookup_field)
+      end
+
+    end
+  end
+end

data/lib/blackbeard/metric_data/unique.rb

@@ -10,6 +10,7 @@ module Blackbeard
       end
 
       def add_at(time, uid, amount = nil, segment = DEFAULT_SEGMENT)
+        #TODO: unsure time is in proper timezone
         key = key_for_hour(time)
         segment_key = segment_key(key, segment)
 
@@ -55,4 +56,3 @@ module Blackbeard
     end
   end
 end
-

data/lib/blackbeard/metric_date.rb

@@ -1,5 +1,6 @@
 module Blackbeard
   class MetricDate
+    #TODO refactor with MetricHour to be compaosed
     attr_reader :date, :result
 
     def initialize(date, result)
@@ -7,5 +8,14 @@ module Blackbeard
       @result = result
     end
 
+    def results_for(segments)
+      segments.map{|s| result[s].to_f }
+    end
+
+    def result_rows(segments)
+      [@date] + results_for(segments)
+    end
+
+
   end
 end

data/lib/blackbeard/metric_hour.rb

@@ -7,6 +7,14 @@ module Blackbeard
       @result = result
     end
 
+    def results_for(segments)
+      segments.map{|s| result[s].to_f }
+    end
+
+    def result_rows(segments)
+      [@hours] + results_for(segments)
+    end
+
   private
 
     def round_to_beginning_of_hour(t)

data/lib/blackbeard/pirate.rb

@@ -6,6 +6,7 @@ require "blackbeard/test"
 require "blackbeard/errors"
 require "blackbeard/group"
 require "blackbeard/feature"
+require "blackbeard/cohort"
 
 module Blackbeard
   class Pirate
@@ -13,16 +14,22 @@ module Blackbeard
       @metrics = {}
       @tests = {}
       @features = {}
+      @cohorts = {}
     end
 
     def metric(type, type_id)
       @metrics["#{type}::#{type_id}"] ||= Metric.find_or_create(type, type_id)
     end
 
+    # TODO: abstract out memoization to a cache class
     def test(id)
       @tests[id] ||= Test.find_or_create(id)
     end
 
+    def cohort(id)
+      @cohorts[id] ||= Cohort.find_or_create(id)
+    end
+
     def feature(id)
       @features[id] ||= Feature.find_or_create(id)
     end
@@ -39,6 +46,7 @@ module Blackbeard
       @set_context = nil
     end
 
+    # TODO: metaprogram all the context delegators
     def add_unique(id)
       return self unless @set_context
       @set_context.add_unique(id)
@@ -49,6 +57,16 @@ module Blackbeard
       @set_context.add_total(id, amount)
     end
 
+    def add_to_cohort(id, timestamp = nil)
+      return self unless @set_context
+      @set_context.add_to_cohort(id, timestamp)
+    end
+
+    def add_to_cohort!(id, timestamp = nil)
+      return self unless @set_context
+      @set_context.add_to_cohort!(id, timestamp)
+    end
+
     def ab_test(id, options)
       return self unless @set_context
       @set_context.ab_test(id, options)

data/lib/blackbeard/redis_store.rb

@@ -16,6 +16,7 @@ module Blackbeard
 
 
     # Hash commands
+    # TODO: rename to hash_set_if_not_exisits
     def hash_key_set_if_not_exists(hash_key, field, value)
       redis.hsetnx(hash_key, field, value)
     end
@@ -28,6 +29,10 @@ module Blackbeard
       redis.mapped_hmset(hash_key, hash) unless hash.empty?
     end
 
+    def hash_multi_get(hash_key, *fields)
+      redis.hmget(hash_key, *fields) unless fields.empty?
+    end
+
     def hash_length(hash_key)
       redis.hlen(hash_key)
     end
@@ -44,8 +49,12 @@ module Blackbeard
       redis.hgetall(hash_key)
     end
 
+    def hash_increment_by(hash_key, field, int)
+      redis.hincrby(hash_key, field, int.to_i)
+    end
+
     def hash_increment_by_float(hash_key, field, float)
-      redis.hincrbyfloat(hash_key, field, float)
+      redis.hincrbyfloat(hash_key, field, float.to_f)
     end
 
     def hash_field_exists(hash_key, field)

data/lib/blackbeard/storable.rb

@@ -104,6 +104,7 @@ module Blackbeard
         @new_record = false
       end
       self.class.on_save_methods.each{ |m| self.send(m) }
+      true
     end
 
     def reload

data/lib/blackbeard/version.rb

@@ -1,3 +1,3 @@
 module Blackbeard
-  VERSION = "0.0.4.0"
+  VERSION = "0.0.5.0"
 end

data/spec/chart_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+  describe Chart do
+    let(:title) { 'This is a title' }
+    let(:chart){
+      Chart.new(
+        :title => title,
+        :columns=>["Date","Total","Uniques"],
+        :rows=>[
+            [Date.today, 10.5, 12],
+            [Date.today+1, 11.5, 13],
+            [Date.today+2, 0, 1],
+        ])
+    }
+    it "should put title and height in options" do
+      chart.options.should == {:title => title, :height => 300}
+    end
+
+    describe "data" do
+      it "should have cols" do
+        chart.data[:cols].should ==  [
+          {:label=>"Date", :type=>"string"},
+          {:label=>"Total", :type=>"number"},
+          {:label=>"Uniques", :type=>"number"}
+        ]
+      end
+      it "should have rows" do
+        chart.data[:rows].should == [
+          {:c=>[{:v=>Date.today}, {:v=>10.5}, {:v=>12}]},
+          {:c=>[{:v=>Date.today+1}, {:v=>11.5}, {:v=>13}]},
+          {:c=>[{:v=>Date.today+2}, {:v=>0}, {:v=>1}]}
+        ]
+      end
+    end
+
+  end
+end

data/spec/chartable_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+  module MetricData
+    describe Chartable do
+
+      class ExampleChartable
+        include Chartable
+
+        def chartable_result_for_day(day)
+          {'segment1' => 0}
+        end
+
+        def chartable_result_for_hour(hour)
+          {'segment1' => 0}
+        end
+
+        def chartable_segments
+          ['segment1']
+        end
+
+      end
+
+      let(:example){ ExampleChartable.new }
+
+      describe "recent_hours" do
+        let(:start_at) { Time.new(2014,1,1,12,0,0) }
+
+        it "should return results for recent hours" do
+          example.recent_hours(3, start_at).should have(3).metric_hours
+        end
+      end
+
+      describe "recent_days" do
+        let(:start_on) { Date.new(2014,1,3) }
+
+        it "should return results for recent days" do
+          example.recent_days(3, start_on).should have(3).metric_days
+        end
+      end
+
+      describe "recent_hours_chart" do
+        it "should return a chart obj" do
+          example.recent_hours_chart.should be_a(Chart)
+        end
+      end
+
+      describe "recent_days_chart" do
+        it "should return a chart obj" do
+          example.recent_days_chart.should be_a(Chart)
+        end
+      end
+
+    end
+  end
+end

data/spec/cohort_data_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+  describe Cohort do
+    let(:uid){ "an id" }
+    let(:hour){ Time.new(2014,3,5,1) }
+    let(:hour_id){ data.send(:hour_id, hour)}
+    let(:different_hour){ Time.new(2014,3,5,2) }
+    let(:different_hour_id){ data.send(:hour_id, different_hour)}
+    let(:cohort) { Cohort.new(:happy) }
+    let(:data) { cohort.data }
+
+    describe "#add with force" do
+      context "no pre-existing cohort" do
+        it "should call add without force" do
+          data.should_receive(:add_without_force).with(uid, hour)
+          data.add_with_force(uid, hour)
+        end
+        it "should return true" do
+          data.add_with_force(uid, hour).should be_true
+        end
+      end
+
+      context "already in same cohort" do
+        before :each do
+          data.add_without_force(uid, hour)
+        end
+        it "should not increment the hours" do
+          expect{
+            data.add_with_force(uid, hour)
+          }.to_not change{ data.participants_for_hour(hour) }
+        end
+        it "should not update the participants" do
+          expect{
+            data.add_with_force(uid, hour)
+          }.to_not change{ data.hour_id_for_participant(uid) }
+        end
+        it "should return true" do
+          data.add_with_force(uid, hour).should be_true
+        end
+      end
+
+      context "already in different cohort" do
+        before :each do
+          data.add_without_force(uid, different_hour)
+        end
+        it "should de-increment the existing hour field" do
+          expect{
+            data.add_with_force(uid, hour)
+          }.to change{ data.participants_for_hour(different_hour) }.by(-1)
+        end
+        it "should increment the new hour field" do
+          expect{
+            data.add_with_force(uid, hour)
+          }.to change{ data.participants_for_hour(hour) }.by(1)
+        end
+        it "should update the participant to the current hour" do
+          expect{
+            data.add_with_force(uid, hour)
+          }.to change{ data.hour_id_for_participant(uid) }.from(different_hour_id).to(hour_id)
+        end
+      end
+    end
+
+    describe "#add without force" do
+      context "already in cohort" do
+        before :each do
+          data.add_without_force(uid, different_hour)
+        end
+        it "should not update the paricipant to the current hour" do
+          expect{
+            data.add_without_force(uid, hour)
+          }.to_not change{ data.hour_id_for_participant(uid) }
+        end
+        it "should not increment the new hour field" do
+          expect{
+            data.add_without_force(uid, hour)
+          }.to_not change{ data.participants_for_hour(hour) }
+        end
+        it "should return false" do
+          data.add_without_force(uid, hour).should be_false
+        end
+      end
+
+      context "not in cohort" do
+        it "should update the participant to the current hour" do
+          expect{
+            data.add_without_force(uid, hour)
+          }.to change{ data.hour_id_for_participant(uid) }.from(nil).to(hour_id)
+        end
+        it "should increment the new hour field" do
+          expect{
+            data.add_without_force(uid, hour)
+          }.to change{ data.participants_for_hour(hour) }.by(1)
+        end
+        it "should return true" do
+          data.add_without_force(uid, hour).should be_true
+        end
+      end
+    end
+
+    describe "countint participants" do
+      let(:aug22) { Date.new(2003,8,22) }
+      let(:aug22_1pm) { Time.new(2003,8,22,13) }
+      let(:aug22_11am) { Time.new(2003,8,22,11) }
+      let(:aug22_9am) { Time.new(2003,8,22,9) }
+      let(:aug23_3pm) { Time.new(2003,8,23,15) }
+      let(:context1) { double :unique_identifier => '1' }
+      let(:context2) { double :unique_identifier => '2' }
+      let(:context3) { double :unique_identifier => '3' }
+      let(:context4) { double :unique_identifier => '4' }
+
+      before :each do
+        cohort.add(context1, aug22_1pm)
+        cohort.add(context2, aug22_1pm)
+        cohort.add(context3, aug22_11am)
+        cohort.add(context4, aug23_3pm)
+      end
+
+      describe "participants for hour" do
+        it "should return the count for each hour" do
+          data.participants_for_hour(aug22_1pm).should == 2
+          data.participants_for_hour(aug22_11am).should == 1
+          data.participants_for_hour(aug22_9am).should == 0
+        end
+      end
+
+      describe "participants for hours" do
+        it "should return the count for each hour" do
+          data.participants_for_hours([aug22_9am, aug22_11am, aug22_1pm]).should == [0,1,2]
+        end
+      end
+
+      describe "participants for day" do
+        it "should sum the day" do
+          data.participants_for_day(aug22).should == 3
+        end
+      end
+
+    end
+  end
+end