mixpanel 2.2.0 → 3.0.1

data/lib/mixpanel/person.rb

@@ -0,0 +1,41 @@
+module Mixpanel::Person
+  PERSON_PROPERTIES = %w{email created first_name last_name last_login username country_code}
+  PERSON_URL = 'http://api.mixpanel.com/engage/'
+  
+  def set(distinct_id, properties={}, options={})
+    engage :set, distinct_id, properties, options
+  end
+  
+  def increment(distinct_id, properties={}, options={})
+    engage :add, distinct_id, properties, options
+  end
+  
+  def append_set(properties={})
+    append 'people.set', properties_hash(properties, PERSON_PROPERTIES)
+  end
+  
+  def append_increment(property, increment=1)
+    append 'people.increment', property, increment
+  end
+  
+  def append_register(properties={})
+    append 'register', properties_hash(properties, PERSON_PROPERTIES)
+  end
+  
+  def append_identify(distinct_id)
+    append 'identify', distinct_id
+  end
+  
+  protected
+  
+  def engage(action, distinct_id, properties, options)
+    options.reverse_merge! :async => @async, :url => PERSON_URL
+    data = build_person action, distinct_id, properties
+    url = "#{options[:url]}?data=#{encoded_data(data)}"
+    parse_response request(url, options[:async])
+  end
+  
+  def build_person(action, distinct_id, properties)
+    { "$#{action}".to_sym => properties_hash(properties, PERSON_PROPERTIES), :$token => @token, :$distinct_id => distinct_id }
+  end
+end

data/lib/mixpanel/subprocess.rb

@@ -0,0 +1,27 @@
+require 'open-uri'
+require 'thread'
+
+module Mixpanel
+  class Subprocess
+    Q = Queue.new
+    ENDMARKER = Object.new
+
+    Thread.abort_on_exception = true
+    producer = Thread.new do 
+      STDIN.each_line() do |url|
+        STDERR.puts("Dropped: #{url}") && next if Q.length > 10000
+        Q << url
+      end
+      Q << ENDMARKER
+    end
+
+    loop do
+      url = Q.pop
+      break if(url == ENDMARKER)
+      url.chomp!
+      next if(url.empty?) #for testing
+      open(url).read
+    end
+    producer.join
+  end
+end

data/lib/mixpanel/tracker.rb

@@ -2,171 +2,74 @@ require "open-uri"
 require 'base64'
 require 'json'
 require 'thread'
-require 'mixpanel/tracker/middleware'
 
 module Mixpanel
   class Tracker
+    require 'mixpanel/async'
+    require 'mixpanel/event'
+    require 'mixpanel/person'
+  
+    extend Mixpanel::Async
+    include Mixpanel::Event
+    include Mixpanel::Person
+  
+    def initialize(token, options={})
+      @token = token
+      @async = !!options.fetch(:async, false)
+      @persist = !!options.fetch(:persist, false)
+      @env = options.fetch :env, {}
+      @api_key = options.fetch :api_key, nil
     
-    MIXPANEL_API_URL  = 'http://api.mixpanel.com'.freeze
-    TRACK_ENDPOINT    = '/track/?data='.freeze
-    ENGAGE_ENDPOINT   = '/engage/?data='.freeze
-    IMPORT_ENDPOINT   = '/import/?data='.freeze
-    
-    PERSON_PROPERTIES = %w(email first_name last_name created last_login username country_code).freeze
-    
-    def initialize(token, env, options = {})
-      @token    = token
-      @api_key  = options.fetch(:api_key, "")
-      @env      = env
-      @async    = options.fetch(:async, false)
-      @import   = options.fetch(:import, false)
-      @url      = options.fetch(:url, MIXPANEL_API_URL)
-      @persist  = options.fetch(:persist, false)
-
+      # Make sure queue object is instantiated to an array.  If not persisted, set queue object to empty array.
       if @persist
-        @env["rack.session"]["mixpanel_events"] ||= []
-      else
-        clear_queue
-      end
-    end
-
-    def append_event(event, properties = {})
-      append_api('track', event, properties)
-    end
-
-    def append_person_event(properties = {})
-      append_api('people.set', person_properties(properties))
-    end
-
-    def append_person_increment_event(property, increment=1)
-      append_api('people.increment', property, increment)
-    end
-
-    def append_api(type, *args)
-      queue << [type, args.map {|arg| arg.to_json}]
-    end
-
-    def track_event(event, properties = {})
-      options = { :time => Time.now.utc.to_i, :ip => ip }
-      options.merge!( :token => @token ) if @token
-      parse_response request(:track,
-        :event      => event,
-        :properties => options.merge(properties)
-      )
-    end
-    
-    def engage(action, distinct_id, properties = {})
-      options = { }
-      options.merge!( :$token => @token ) if @token
-      parse_response request(:engage, options.merge(
-        :$distinct_id       => distinct_id, 
-        "$#{action}".to_sym => person_properties(properties)
-      ))
-    end
-    
-    def engage_set(distinct_id, properties = {})
-      engage(:set, distinct_id, properties)
-    end
-    
-    def engage_add(distinct_id, properties = {})
-      engage(:add, distinct_id, properties)
-    end
-    
-    def ip
-      if @env.has_key?("HTTP_X_FORWARDED_FOR")
-        @env["HTTP_X_FORWARDED_FOR"].split(",").last
-      elsif @env.has_key?("REMOTE_ADDR")
-        @env["REMOTE_ADDR"]
+        @env['rack.session'] ||= {}
+        @env['rack.session']['mixpanel_events'] ||= []
       else
-        ""
+        @env['mixpanel_events'] = []
       end
     end
-
+  
     def queue
-      if @persist
-        return @env["rack.session"]["mixpanel_events"]
-      else
-        return @env["mixpanel_events"]
+      @persist ? @env['rack.session']['mixpanel_events'] : @env['mixpanel_events']
+    end
+  
+    def append(type, *args)
+      queue << [type, args.collect {|arg| arg.to_json}]
+    end
+  
+    protected
+  
+    # Walk through each property and see if it is in the special_properties.  If so, change the key to have a $ in front of it.
+    def properties_hash(properties, special_properties)
+      properties.inject({}) do |props, (key, value)|
+        key = "$#{key}" if special_properties.include?(key.to_s)
+        props[key.to_sym] = value
+        props
       end
     end
-
-    def clear_queue
-      if @persist
-        @env["rack.session"]["mixpanel_events"] = []
-      else
-        @env["mixpanel_events"] = []
-      end
+  
+    def encoded_data(parameters)
+      Base64.encode64(JSON.generate(parameters)).gsub(/\n/,'')
     end
-
-    class << self
-      WORKER_MUTEX = Mutex.new
-
-      def worker
-        WORKER_MUTEX.synchronize do
-          @worker || (@worker = IO.popen(self.cmd, 'w'))
-        end
-      end
-
-      def dispose_worker(w)
-        WORKER_MUTEX.synchronize do
-          if(@worker == w)
-            @worker = nil
-            w.close
-          end
-        end
-      end
-
-      def cmd
-        @cmd || begin
-          require 'escape'
-          require 'rbconfig'
-          interpreter = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
-          subprocess  = File.join(File.dirname(__FILE__), 'tracker/subprocess.rb')
-          @cmd = Escape.shell_command([interpreter, subprocess])
-        end
-      end
-    end
-
-    private
-    
-    def person_properties(properties = {})
-      properties.inject({}) do |out, (k, v)|
-        if PERSON_PROPERTIES.member?(k.to_s)
-          out["$#{k}".to_sym] = v
-        else
-          out[k] = v
-        end
-        out
-      end
+  
+    def request(url, async)
+      async ? send_async(url) : open(url).read
     end
-
+  
     def parse_response(response)
-      response == "1" ? true : false
-    end
-
-    def request(mode, params)
-      data = Base64.encode64(JSON.generate(params)).gsub(/\n/,'')
-      
-      mode = :import if @import
-      endpoint = case mode
-        when :track   then TRACK_ENDPOINT
-        when :engage  then ENGAGE_ENDPOINT
-        when :import  then IMPORT_ENDPOINT
-      end
-      url = "#{@url}#{endpoint}#{data}"
-      url += "&api_key=#{@api_key}" if mode == :import
-      
-      if(@async)
-        w = Tracker.worker
-        begin
-          url << "\n"
-          w.write(url)
-        rescue Errno::EPIPE => e
-          Tracker.dispose_worker(w)
-        end
-      else
-        open(url).read
+      response.to_i == 1
+    end
+  
+    def send_async(url)
+      w = Mixpanel::Tracker.worker
+      begin
+        url << "\n"
+        w.write url
+        1
+      rescue Errno::EPIPE => e
+        Mixpanel::Tracker.dispose_worker w
+        0
       end
     end
   end
-end
+end

data/lib/mixpanel.rb

@@ -1,4 +1,5 @@
 require 'mixpanel/tracker'
+require 'mixpanel/middleware'
 
 module Mixpanel
 end

data/mixpanel.gemspec

@@ -2,7 +2,7 @@ files = ['README.md', 'LICENSE', 'Rakefile', 'mixpanel.gemspec', '{spec,lib}/**/
 
 spec = Gem::Specification.new do |s|
   s.name = "mixpanel"
-  s.version = "2.2.0"
+  s.version = "3.0.1"
   s.rubyforge_project = "mixpanel"
   s.description = "Simple lib to track events in Mixpanel service. It can be used in any rack based framework."
   s.author = "Alvaro Gil"
@@ -17,6 +17,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency 'json'
   s.add_dependency 'rack'
   s.add_dependency 'escape'
+  s.add_development_dependency 'active_support'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rack-test'
   s.add_development_dependency 'fakeweb'

data/spec/mixpanel/{tracker/middleware_spec.rb → middleware_spec.rb}

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 def exec_default_appends_on(mixpanel)
-  mixpanel.append_event("Visit", {:article => 1})
-  mixpanel.append_event("Sign in")
-  mixpanel.append_person_event(:first_name => "foo", :last_name => "bar", :username => "foobar")
-  mixpanel.append_person_increment_event(:sign_in_rate)
+  mixpanel.append_track("Visit", {:article => 1})
+  mixpanel.append_track("Sign in")
+  mixpanel.append_set(:first_name => "foo", :last_name => "bar", :username => "foobar")
+  mixpanel.append_increment(:sign_in_rate)
 end
 
 def check_for_default_appends_on(txt)
-  txt.should =~ /mixpanel\.track\("Visit",\s?\{"article":1\}\)/
-  txt.should =~ /mixpanel\.track\("Sign in",\s?\{\}\)/
+  txt.should =~ /mixpanel\.track\("Visit",\s?\{.*"article":1[\{|,]/
+  txt.should =~ /mixpanel\.track\("Sign in",\s?\{.*"time":.*\}/
   txt.should =~ /mixpanel\.people\.set\(.*\);\nmixpanel.people.increment\(\"sign_in_rate\",\s?1\);/
   match = txt.match(/mixpanel\.people\.set\((.*\));/)
   match[1].should =~ /\"\$first_name\":\"foo\"/
@@ -18,9 +18,9 @@ def check_for_default_appends_on(txt)
   txt.should =~ /mixpanel\.people\.increment\(\"sign_in_rate\"\s?,\s?1\)/
 end
 
-describe Mixpanel::Tracker::Middleware do
+describe Mixpanel::Middleware do
   include Rack::Test::Methods
-
+  
   describe "Dummy apps, no text/html" do
     before do
       setup_rack_application(DummyApp, :body => html_document, :headers => {})
@@ -198,7 +198,7 @@ describe Mixpanel::Tracker::Middleware do
 
   describe "Tracking async appended events" do
     before do
-      @mixpanel = Mixpanel::Tracker.new(MIX_PANEL_TOKEN, {})
+      @mixpanel = Mixpanel::Tracker.new MIX_PANEL_TOKEN
       exec_default_appends_on @mixpanel
     end
 
@@ -266,7 +266,7 @@ describe Mixpanel::Tracker::Middleware do
 
   describe "Tracking appended events" do
     before do
-      @mixpanel = Mixpanel::Tracker.new(MIX_PANEL_TOKEN, {})
+      @mixpanel = Mixpanel::Tracker.new MIX_PANEL_TOKEN
       exec_default_appends_on @mixpanel
     end
 

data/spec/mixpanel/tracker_spec.rb

@@ -2,20 +2,20 @@ require 'spec_helper'
 
 describe Mixpanel::Tracker do
   before(:each) do
-    @mixpanel = Mixpanel::Tracker.new(MIX_PANEL_TOKEN, @env = {"REMOTE_ADDR" => "127.0.0.1"})
+    @mixpanel = Mixpanel::Tracker.new MIX_PANEL_TOKEN, { :env => {"REMOTE_ADDR" => "127.0.0.1"} }
   end
 
   context "Initializing object" do
     it "should have an instance variable for token and events" do
-      @mixpanel.instance_variables.map(&:to_s).should include("@token", "@env")
+      @mixpanel.instance_variables.map(&:to_s).should include('@token', '@async', '@persist', '@env')
     end
   end
 
   context "Cleaning appended events" do
     it "should clear the queue" do
-      @mixpanel.append_event("Sign up")
+      @mixpanel.append_track("Sign up")
       @mixpanel.queue.size.should == 1
-      @mixpanel.clear_queue
+      @mixpanel.queue.clear
       @mixpanel.queue.size.should == 0
     end
   end
@@ -23,60 +23,31 @@ describe Mixpanel::Tracker do
   context "Accessing Mixpanel through direct request" do
     context "Tracking events" do
       it "should track simple events" do
-        @mixpanel.track_event("Sign up").should == true
+        @mixpanel.track("Sign up").should == true
       end
-
-      it "should call request method with token, time value and ip address" do
-        params = {:event => "Sign up", :properties => {:token => MIX_PANEL_TOKEN, :time => Time.now.utc.to_i, :ip => "127.0.0.1"}}
-
-        @mixpanel.should_receive(:request).with(:track, params).and_return("1")
-        @mixpanel.track_event("Sign up").should == true
-      end
-
-      it "should call request method with token, and send ip address from HTTP_X_FORWARDED_FOR" do
-        @mixpanel = Mixpanel::Tracker.new(MIX_PANEL_TOKEN, @env = {"HTTP_X_FORWARDED_FOR" => "10.1.0.2"})
-
-        params = {:event => "Sign up", :properties => {:token => MIX_PANEL_TOKEN, :time => Time.now.utc.to_i, :ip => "10.1.0.2"}}
-
-        @mixpanel.should_receive(:request).with(:track, params).and_return("1")
-        @mixpanel.track_event("Sign up")
+      
+      it "should track events with properties" do
+        @mixpanel.track('Sign up', { :likeable => true }, { :api_key => 'asdf' }).should == true
       end
     end
     
-    context "Managing People" do
-      it "should set person data" do
-        @mixpanel.engage_set(DISTINCT_ID, :$email => 'test@example.com').should == true
+    context "Importing events" do
+      it "should import simple events" do
+        @mixpanel.import('Sign up').should == true
       end
       
-      it "should add person data" do
-        @mixpanel.engage_add(DISTINCT_ID, :custom => 99).should == true
+      it "should import events with properties" do
+        @mixpanel.import('Sign up', { :likeable => true }, { :api_key => 'asdf' }).should == true
       end
-      
-      it "should be able to call engage method directly" do
-        @mixpanel.engage(:set, DISTINCT_ID, :$email => 'test@example.com').should == true
-      end
-      
-      it "should call request method for setting" do
-        params = {
-          :$token       => MIX_PANEL_TOKEN,
-          :$distinct_id => DISTINCT_ID,
-          :$set         => {
-            :$email => 'test@example.com',
-            :custom => 'test'
-        }}
-        @mixpanel.should_receive(:request).with(:engage, params).and_return("1")
-        @mixpanel.engage(:set, DISTINCT_ID, :email => 'test@example.com', :custom => 'test')
+    end
+    
+    context "Engaging people" do
+      it "should set attributes" do
+        @mixpanel.set('person-a', { :email => 'me@domain.com', :likeable => false }).should == true
       end
       
-      it "should call request method for adding" do
-        params = {
-          :$token       => MIX_PANEL_TOKEN,
-          :$distinct_id => DISTINCT_ID,
-          :$add         => {
-            :custom => 99
-        }}
-        @mixpanel.should_receive(:request).with(:engage, params).and_return("1")
-        @mixpanel.engage(:add, DISTINCT_ID, :custom => 99)
+      it "should increment attributes" do
+        @mixpanel.increment('person-a', { :tokens => 3, :money => -1 }).should == true
       end
     end
   end
@@ -84,47 +55,39 @@ describe Mixpanel::Tracker do
   context "Accessing Mixpanel through javascript API" do
     context "Appending events" do
       it "should store the event under the appropriate key" do
-        @mixpanel.append_event("Sign up")
-        @env.has_key?("mixpanel_events").should == true
+        @mixpanel.instance_variable_get(:@env).has_key?("mixpanel_events").should == true
       end
 
       it "should be the same the queue than env['mixpanel_events']" do
-        @env['mixpanel_events'].object_id.should == @mixpanel.queue.object_id
+        @mixpanel.instance_variable_get(:@env)['mixpanel_events'].object_id.should == @mixpanel.queue.object_id
       end
 
       it "should append simple events" do
-        @mixpanel.append_event("Sign up")
-        mixpanel_queue_should_include(@mixpanel, "track", "Sign up", {})
+        props = { :time => Time.now, :ip => 'ASDF' }
+        @mixpanel.append_track "Sign up", props
+        mixpanel_queue_should_include(@mixpanel, "track", "Sign up", props)
       end
 
       it "should append events with properties" do
-        @mixpanel.append_event("Sign up", {:referer => 'http://example.com'})
-        mixpanel_queue_should_include(@mixpanel, "track", "Sign up", {:referer => 'http://example.com'})
+        props = { :referer => 'http://example.com', :time => Time.now, :ip => 'ASDF' }
+        @mixpanel.append_track "Sign up", props
+        mixpanel_queue_should_include(@mixpanel, "track", "Sign up", props)
       end
 
       it "should give direct access to queue" do
-        @mixpanel.append_event("Sign up", {:referer => 'http://example.com'})
+        @mixpanel.append_track("Sign up", {:referer => 'http://example.com'})
         @mixpanel.queue.size.should == 1
       end
 
-      it "should provide direct access to the JS api" do
-        @mixpanel.append_api('track', "Sign up", {:referer => 'http://example.com'})
-        mixpanel_queue_should_include(@mixpanel, "track", "Sign up", {:referer => 'http://example.com'})
-      end
-
-      it "should allow identify to be called through the JS api" do
-        @mixpanel.append_api('identify', "some@one.com")
-        mixpanel_queue_should_include(@mixpanel, "identify", "some@one.com")
-      end
-
       it "should allow identify to be called through the JS api" do
-        @mixpanel.append_api('identify', "some@one.com")
+        @mixpanel.append_identify "some@one.com"
         mixpanel_queue_should_include(@mixpanel, "identify", "some@one.com")
       end
 
       it "should allow the tracking of super properties in JS" do
-        @mixpanel.append_api('register', {:user_id => 12345, :email => "some@one.com"})
-        mixpanel_queue_should_include(@mixpanel, 'register', {:user_id => 12345, :email => "some@one.com"})
+        props = {:user_id => 12345, :gender => 'male'}
+        @mixpanel.append_register props
+        mixpanel_queue_should_include(@mixpanel, 'register', props)
       end
     end
   end
@@ -156,24 +119,4 @@ describe Mixpanel::Tracker do
       w2.should_not == w
     end
   end
-
-  context "Request modes" do
-    it "should use the track URL" do
-      @mixpanel.track_event("Sign up")
-      FakeWeb.last_request.path.to_s.include?(Mixpanel::Tracker::TRACK_ENDPOINT).should == true
-    end
-    
-    it "should use the engage URL" do
-      @mixpanel.engage(:set, DISTINCT_ID, :email => 'test@example.com')
-      FakeWeb.last_request.path.to_s.include?(Mixpanel::Tracker::ENGAGE_ENDPOINT).should == true
-    end
-    
-    it "should use the import URL" do
-      @mixpanel = Mixpanel::Tracker.new(MIX_PANEL_TOKEN, @env = {"REMOTE_ADDR" => "127.0.0.1"}, { :import => true, :api_key => "ABCDEFG" })
-      @mixpanel.track_event("Sign up")
-      path = FakeWeb.last_request.path.to_s
-      path.include?(Mixpanel::Tracker::IMPORT_ENDPOINT).should == true
-      path.include?("&api_key=ABCDEFG").should == true
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -3,18 +3,28 @@ require File.join(File.dirname(__FILE__), "../lib", "mixpanel")
 require 'rack/test'
 require 'fakeweb'
 require 'nokogiri'
+require 'active_support/core_ext/hash'
+
 Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 
 MIX_PANEL_TOKEN = "e2d8b0bea559147844ffab3d607d26a6"
-DISTINCT_ID     = "abcd1234"
+
 
 def mixpanel_queue_should_include(mixpanel, type, *arguments)
   mixpanel.queue.each do |event_type, event_arguments|
-    event_arguments.should == arguments.map{|arg| arg.to_json}
-    event_type.should == type
+    # hashes store keys in an undetermined order.  convert to json and back and compare hash to hash, not json to json
+    unjsonify(event_arguments).should == json_and_back(arguments)
   end
 end
 
+def json_and_back array
+  unjsonify array.collect { |arg| arg.to_json }
+end
+
+def unjsonify array
+  array.collect { |arg| JSON.parse(arg) rescue arg }
+end
+
 # Fakeweb
 FakeWeb.allow_net_connect = false
 FakeWeb.register_uri(:any, /http:\/\/api\.mixpanel\.com.*/, :body => "1")

data/spec/support/rack_apps.rb

@@ -1,5 +1,5 @@
 def setup_rack_application(application, options = {}, mixpanel_options = {})
-  stub!(:app).and_return(Mixpanel::Tracker::Middleware.new(application.new(options), MIX_PANEL_TOKEN, mixpanel_options))
+  stub!(:app).and_return(Mixpanel::Middleware.new(application.new(options), MIX_PANEL_TOKEN, mixpanel_options))
 end
 
 def html_document