trailguide 0.1.31 → 0.2.0

data/lib/trail_guide/catalog.rb

@@ -35,15 +35,22 @@ module TrailGuide
             end
           end
 
+          expgoals = options[:goals]
+          # TODO is it worth parsing these out for complex funnels, etc.? or is
+          # it better to just force use of the DSL?
+
           DSL.experiment(name) do |config|
             expvars.each do |expvar|
               variant *expvar
             end
-            # TODO also map goals once they're real classes
+
+            expgoals.each do |expgoal|
+              goal expgoal
+            end
+
             config.control                    = options[:control] if options[:control]
-            config.metric                     = options[:metric] if options[:metric]
+            config.groups                     = options[:groups] if options[:groups]
             config.algorithm                  = options[:algorithm] if options[:algorithm]
-            config.goals                      = options[:goals] if options[:goals]
             config.combined                   = options[:combined] if options[:combined]
             config.reset_manually             = options[:reset_manually] if options.key?(:reset_manually)
             config.start_manually             = options[:start_manually] if options.key?(:start_manually)
@@ -51,6 +58,7 @@ module TrailGuide
             config.track_override             = options[:track_override] if options.key?(:track_override)
             config.allow_multiple_conversions = options[:allow_multiple_conversions] if options.key?(:allow_multiple_conversions)
             config.allow_multiple_goals       = options[:allow_multiple_goals] if options.key?(:allow_multiple_goals)
+            # TODO need to remember to update this with all the new config vars
           end
         end
       end
@@ -61,8 +69,8 @@ module TrailGuide
           name: name.to_s.underscore.to_sym,
           parent: combined,
           combined: [],
-          variants: combined.configuration.variants.map { |var| var.dup(experiment) }
-          # TODO also map goals once they're separate classes
+          variants: combined.configuration.variants.map { |var| var.dup(experiment) },
+          goals: combined.configuration.goals.map { |goal| goal.dup(experiment) }
         })
         experiment
       end
@@ -79,6 +87,10 @@ module TrailGuide
       experiments.each(&block)
     end
 
+    def groups
+      experiments.map(&:groups).flatten.uniq
+    end
+
     def all
       exploded = experiments.map do |exp|
         if exp.combined?
@@ -91,48 +103,86 @@ module TrailGuide
       self.class.new(exploded)
     end
 
+    def calibrating
+      self.class.new(to_a.select(&:calibrating?))
+    end
+
     def started
-      self.class.new(to_a.select(&:started?))
+      self.class.new(to_a.select { |e| e.started? && !e.winner? })
+    end
+
+    def scheduled
+      self.class.new(to_a.select { |e| e.scheduled? && !e.winner? })
     end
 
     def running
-      self.class.new(to_a.select(&:running?))
+      self.class.new(to_a.select { |e| e.running? && !e.winner? })
     end
 
     def paused
-      self.class.new(to_a.select(&:paused?))
+      self.class.new(to_a.select { |e| e.paused? && !e.winner? })
     end
 
     def stopped
-      self.class.new(to_a.select(&:stopped?))
+      self.class.new(to_a.select { |e| e.stopped? && !e.winner? })
     end
 
     def ended
       self.class.new(to_a.select(&:winner?))
     end
 
+    def unstarted
+      self.class.new(to_a.select { |e| !e.started? && !e.calibrating? && !e.scheduled? && !e.winner? })
+    end
+
     def not_running
       self.class.new(to_a.select { |e| !e.running? })
     end
 
     def by_started
       scoped = to_a.sort do |a,b|
-        if a.running? && !b.running?
-          1
-        elsif !a.running? && b.running?
+        if !(a.started? || a.scheduled? || a.winner?) && !(b.started? || b.scheduled? || b.winner?)
+          a.experiment_name.to_s <=> b.experiment_name.to_s
+        elsif !(a.started? || a.scheduled? || a.winner?)
           -1
+        elsif !(b.started? || b.scheduled? || b.winner?)
+          1
         else
-          if a.started? && !b.started?
+          if a.winner? && !b.winner?
             1
-          elsif !a.started? && b.started?
+          elsif !a.winner? && b.winner?
+            -1
+          elsif a.winner? && b.winner?
+            a.experiment_name.to_s <=> b.experiment_name.to_s
+          elsif a.running? && !b.running?
             -1
-          elsif a.started? && b.started?
+          elsif !a.running? && b.running?
+            1
+          elsif a.running? && b.running?
             a.started_at <=> b.started_at
+          elsif a.paused? && !b.paused?
+            -1
+          elsif !a.paused? && b.paused?
+            1
+          elsif a.paused? && b.paused?
+            a.paused_at <=> b.paused_at
+          elsif a.scheduled? && !b.scheduled?
+            -1
+          elsif !a.scheduled? && b.scheduled?
+            1
+          elsif a.scheduled? && b.scheduled?
+            a.started_at <=> b.started_at
+          elsif a.stopped? && !b.stopped?
+            -1
+          elsif !a.stopped? && b.stopped?
+            1
+          elsif a.stopped? && b.stopped?
+            a.stopped_at <=> b.stopped_at
           else
-            b.experiment_name.to_s <=> a.experiment_name.to_s
+            a.experiment_name.to_s <=> b.experiment_name.to_s
           end
         end
-      end.reverse
+      end
 
       self.class.new(scoped)
     end
@@ -143,7 +193,7 @@ module TrailGuide
       else
         experiment = experiments.find do |exp|
           exp.experiment_name == name.to_s.underscore.to_sym ||
-            exp.metric == name.to_s.underscore.to_sym ||
+            exp.groups.include?(name.to_s.underscore.to_sym) ||
             exp.name == name.to_s.classify
         end
         return experiment if experiment.present?
@@ -165,7 +215,7 @@ module TrailGuide
         # TODO we can be more efficient than mapping twice here
         selected = experiments.select do |exp|
           exp.experiment_name == name.to_s.underscore.to_sym ||
-            exp.metric == name.to_s.underscore.to_sym ||
+            exp.groups.include?(name.to_s.underscore.to_sym) ||
             exp.name == name.to_s.classify ||
             (exp.combined? && exp.combined.any? { |combo| combo.to_s.underscore.to_sym == name.to_s.underscore.to_sym })
         end.map do |exp|
@@ -185,6 +235,70 @@ module TrailGuide
       klass
     end
 
+    def deregister(key)
+      # TODO (mostly only useful for engine specs)
+    end
+
+    def export
+      map do |exp|
+        if exp.combined?
+          [exp.as_json].concat(exp.combined_experiments.map(&:as_json))
+        else
+          exp.as_json
+        end
+      end.flatten.reduce({}) { |red,exp| red.merge!(exp) }
+    end
+
+    def import(state)
+      state.each do |exp,est|
+        experiment = find(exp)
+        next unless experiment.present?
+
+        experiment.reset!
+        TrailGuide.redis.hsetnx(experiment.storage_key, 'name', experiment.experiment_name)
+        TrailGuide.redis.hset(experiment.storage_key, 'started_at', est['started_at']) if est['started_at'].present?
+        TrailGuide.redis.hset(experiment.storage_key, 'paused_at', est['paused_at']) if est['paused_at'].present?
+        TrailGuide.redis.hset(experiment.storage_key, 'stopped_at', est['stopped_at']) if est['stopped_at'].present?
+        TrailGuide.redis.hset(experiment.storage_key, 'winner', est['winner']) if est['winner'].present?
+
+        est['variants'].each do |var,vst|
+          variant = experiment.variants.find { |v| v == var }
+          next unless variant.present?
+
+          TrailGuide.redis.hincrby(variant.storage_key, 'participants', vst['participants'].to_i) if vst['participants'].to_i > 0
+          if vst['converted'].is_a?(Hash)
+            vst['converted'].each do |goal,gct|
+              TrailGuide.redis.hincrby(variant.storage_key, goal, gct.to_i) if gct.to_i > 0
+            end
+          else
+            TrailGuide.redis.hincrby(variant.storage_key, 'converted', vst['converted'].to_i) if vst['converted'].to_i > 0
+          end
+        end
+      end
+    end
+
+    def orphaned(key, trace)
+      added = TrailGuide.redis.sadd("orphans:#{key}", trace)
+      TrailGuide.redis.expire("orphans:#{key}", 15.minutes.seconds)
+      added
+    rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
+      false
+    end
+
+    def orphans
+      TrailGuide.redis.keys("orphans:*").reduce({}) do |h,key|
+        h.merge({ key.split(':').last => TrailGuide.redis.smembers(key) })
+      end
+    rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
+      {}
+    end
+
+    def adopted(key)
+      TrailGuide.redis.del("orphans:#{key}")
+    rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
+      false
+    end
+
     def method_missing(meth, *args, &block)
       return experiments.send(meth, *args, &block) if experiments.respond_to?(meth, true)
       super
@@ -199,6 +313,7 @@ module TrailGuide
         klass = opts.delete(:class) || TrailGuide::Experiment
         Class.new(klass) do
           configure opts.merge({name: name}), &block
+          register!
         end
       end
     end

data/lib/trail_guide/combined_experiment.rb

@@ -10,6 +10,10 @@ module TrailGuide
         @configuration ||= Experiments::CombinedConfig.new(self)
       end
 
+      def is_combined?
+        true
+      end
+
       # TODO if just I delegate on this inheriting class, will that override the 
       # defined methods on the base class? and will they interplay nicely? like
       # with `started?` calling `started_at`, etc.?
@@ -44,12 +48,13 @@ module TrailGuide
       end
     end
 
-    delegate :parent, to: :class
-    delegate :running?, :started?, :started_at, :start!, to: :parent
+    def parent
+      @parent ||= self.class.parent.new(participant.participant)
+    end
 
     # use the parent experiment as the algorithm and map to the matching variant
     def algorithm_choose!(metadata: nil)
-      variant = parent.new(participant.participant).choose!(metadata: metadata)
+      variant = parent.choose!(metadata: metadata)
       variants.find { |var| var == variant.name }
     end
   end

data/lib/trail_guide/config.rb

@@ -4,7 +4,8 @@ module TrailGuide
       :logger, :redis, :disabled, :override_parameter,
       :allow_multiple_experiments, :adapter, :on_adapter_failover,
       :filtered_ip_addresses, :filtered_user_agents, :request_filter,
-      :include_helpers, :cleanup_participant_experiments, :unity_ttl
+      :include_helpers, :cleanup_participant_experiments, :unity_ttl,
+      :ignore_orphaned_groups
     ].freeze
 
     def initialize(*args, **opts, &block)
@@ -28,6 +29,10 @@ module TrailGuide
       end
     end
 
+    def ignore_orphaned_groups?
+      !!self[:ignore_orphaned_groups]
+    end
+
     def filtered_user_agents
       @filtered_user_agents ||= begin
         uas = self[:filtered_user_agents]

data/lib/trail_guide/engine.rb

@@ -6,6 +6,8 @@ module TrailGuide
       g.test_framework = :rspec
     end
 
+    paths["config/routes.rb"] = "config/routes/engine.rb"
+
     initializer "trailguide" do |app|
       TrailGuide::Catalog.load_experiments!
       if TrailGuide.configuration.include_helpers

data/lib/trail_guide/errors.rb

@@ -1,7 +1,36 @@
 module TrailGuide
   class InvalidGoalError < ArgumentError; end
   class UnsupportedContextError < NoMethodError; end
-  class NoExperimentsError < ArgumentError; end
   class TooManyExperimentsError < ArgumentError; end
   class NoVariantMethodError < NoMethodError; end
+
+  class NoExperimentsError < ArgumentError
+    def initialize(key)
+      super("Could not find any experiments matching '#{key}'")
+    end
+  end
+
+  module Calculators
+    class NoBetaDistributionLibrary < LoadError
+      def initialize(type=nil)
+        if type
+          super("Beta distribution library not found: #{type.to_s}! You must add the '#{type.to_s}' gem to your Gemfile in order to run this analysis with it.")
+        else
+          super("No beta distribution library found! You must add either the 'distribution' or 'rubystats' gems to your Gemfile in order to run this analysis.")
+        end
+      end
+    end
+
+    class UnknownBetaDistributionLibrary < ArgumentError
+      def initialize(type)
+        super("Unknown beta distribution library: #{type.to_s}! The libraries available for calculating beta distribution are 'rubystats' (default) or 'distribution'.")
+      end
+    end
+
+    class NoIntegrationLibrary < LoadError
+      def initialize(msg=nil)
+        super(msg || "No integration library found! You must add the 'integration' gem to your gemfile in order to run this analysis.")
+      end
+    end
+  end
 end

data/lib/trail_guide/experiment.rb

@@ -5,7 +5,6 @@ module TrailGuide
 
     def self.inherited(child)
       child.instance_variable_set :@configuration, Experiments::Config.new(child, inherit: self.configuration)
-      TrailGuide.catalog.register(child)
     end
   end
 end