referer_tracking 4.0.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 356dac126dad74ad063890ac8851947fa4ae89ed
-  data.tar.gz: 07c7475f65caa07e28863e02043d3b76fcf5a942
+  metadata.gz: f76b2d97ed6189bcd59080ee488692d971725a6d
+  data.tar.gz: f61ed77ebefe501cbe68f5d914dc99c1fcc4623e
 SHA512:
-  metadata.gz: 433d5868ee3e8cf9caaf9f4338995bb60c29ae1162aa4445b2e26526a550a4608bf1ad181cf1d87dc1437bda6a0a267a9a97b9c10e678791e1b88a2edf062fc5
-  data.tar.gz: a2db59067dfc85be6aa32e9a51b7c6b408cd0c7ef38bfb803b55ff03537fa28ecf056c95e4636b8415f54543de278d7039c6909676353c00ea74fe954af8d98b
+  metadata.gz: b72c2026389dd1ea8fa9d1e982cf5a32860c88984331dc4e9f59eddb6f94541a009f78f5801542bf02fa44f450b1b92c49e0f68cafd8d700af0e4c3d22365be2
+  data.tar.gz: 5ba921e4ddf08d95dddd2d2bc3f7f17bc47ac9c9fb41132cd4036a375942ee7e0bdf5cc80b41a8e70f04329b75ba6ecd90d025ab34176875829ea5b226643607

data/README.md

@@ -1,22 +1,61 @@
 # RefererTracking
 
 Referer tracking automates better tracking in your Rails app. It tells you who creates
-activerecord objects / models, where did they originally come from, what url did they use etc.
+activerecord objects / models, where did they originally come from (http referrer), what url did they use etc.
 It does it by saving referrer url to session and saving information about the request when creating new item.
-It enables you to optimize your web-app user interface and flow.
 
-Http referer_url and first_url are saved to session in controller before_filter. When creating a new model these values are
-saved to referer_trackings table. Also current request url and current request referer are saved.
+Also you have tools to add log lines to tracking to get better information about flow of the users or how ab-tests affect later usage.
 
-You can query how specific objects were made by querying following. It will let you know how did the user end up in your page and where did he create the object.
+[<img src="https://secure.travis-ci.org/holli/referer_tracking.png" />](http://travis-ci.org/holli/referer_tracking)
+
+## Example use cases
 
 ```
-  RefererTracking::RefererTracking.where(:trackable_type => 'class_name').collect{|rt| [rt.first_url, rt.referer_url, rt.current_request_referer_url]}
+- Example configuration
+- In UsersController.create
+  - referer_tracking_after_create(@user) # saves all referrer etc information
+  - @user.tracking_add_log_line('signup_ab_testing_b_variation') # having ab testing? Mark where user is going
+- In SessionsController.create
+  - @user.tracking_add_log_line('10:th login')
+- In some scheduled script
+  - @user.tracking_update_status('active') if @user.login_count > 10 && @user.blog_posts.count > 1
 ```
 
-[<img src="https://secure.travis-ci.org/holli/referer_tracking.png" />](http://travis-ci.org/holli/referer_tracking)
+Later you can query how specific objects were made. It will let you know how did the user end up in your page and where did he create the object. This gem helps you to save data. But you still have to do the queries scripts yourself.
+
+**How about last 100 objects with information about first pages (landing pages) and their flow**
+
+```
+RefererTracking::Tracking.where(:trackable_type => 'User').last(100).collect{|tracking| [tracking.first_url, tracking.referer_url, tracking.current_request_referer_url]}
+# [['http://mysite.com/landing_page_01', 'http://google.com/...', 'http://mysite.com/signup_v01/hello'] ... ]
+```
+
+**How does specific landing page work**
+
+```
+landing_a = RefererTracking::Tracking.where(:trackable_type => 'User').find_all{|tracking| tracking.first_url.match(/yourdomain.com\/landing_page_b/)}
+puts landing_a.collect{|tracking| tracking.trackable.name}
+   - instead of just looking creation numbers you can also see who came from there and how fast did they do their 10:th login
+```
+
+**Checking if some flow results in better conversion than other**
+
+```
+variation_a = RefererTracking::Tracking.where(:trackable_type => 'User').find_all{|tracking| tracking.get_log_lines('signup_ab_testing_a_variation')}
+variation_b = RefererTracking::Tracking.where(:trackable_type => 'User').find_all{|tracking| tracking.get_log_lines('signup_ab_testing_b_variation')}
+puts "var_a: #{variation_a.size}, active count #{variation_a.count{|tracking| tracking.status == 'active'}"
+puts "var_b: #{variation_b.size}, active count #{variation_b.count{|tracking| tracking.status == 'active'}"
+```
 
-## Monitored items
+**Or maybe checking how user_agent affects conversion**
+
+```
+RefererTracking::Tracking.where(:trackable_type => 'User').find_all{|tracking| tracking.user_agent.to_s.include?('Android')}
+```
+
+
+
+## Automatically monitored items
 
 ```
 - session_referer_url - where did the user originally come from - saved in session
@@ -30,6 +69,8 @@ You can query how specific objects were made by querying following. It will let
 - user_agent, ip, session_id
 - cookies_yaml - saves cookies if enabled in initializers with RefererTracking.save_cookies = true
                - handy for parsing information related to google analytics, e.g. number of visits
+- status - use by model.tracking_update_status('active') etc to add information
+- log - so you can add lines later
 ```
 
 
@@ -46,24 +87,42 @@ in /gemfile
 
 ```
 
-## Configure
+## Configure / Usage
 
 ```
 
-ApplicationController
-  include RefererTracking::ControllerAddons
+class ApplicationController ... # in application_controller.rb
+  include RefererTracking::ControllerAddons # saves first visit infos to session and cookie
+end
+
+class User < Activerecord::Base
+  has_tracking
 end
 
-OtherController
+# By using sweepers
+# also add to Gemfile "gem 'rails-observers'"
+class UsersController
   # This monitors saved items and creates RefererTracking items in db, enable in controllers you want it to be used
   cache_sweeper RefererTracking::Sweeper
 end
 
-/config/initializers/referer_tracking.rb
-  # Referer tracking is enabled for these models
-  RefererTracking.add_tracking_to(User)
-  # RefererTracking.add_tracking_to(User, Messages) # for multiple models
+# Or by using custom methods
+class UsersController
+  def create
+    @user = User.create
+    referer_tracking_after_create(@user)
+  end
+
+  def login
+    if @user.login_count == 10
+      @user.tracking_add_log_line("10_logins")
+    end
+  end
+
+end
+
 
+/config/initializers/referer_tracking.rb # if you want to modify defaults, see https://github.com/holli/referer_tracking/blob/master/lib/referer_tracking.rb#L5
   RefererTracking.save_cookies = true # saves all cookies to db
   RefererTracking.set_referer_cookies = true # saves referer and first url data to cookie
                    # You should use it unless you are very performance minded : http://yuiblog.com/blog/2007/03/01/performance-research-part-3/
@@ -91,12 +150,17 @@ end
 
 **Helpers include**
 
-- referer_tracking_first_request?
-- referer_tracking_add_info(key, value) # only set in the first time called - saved in session
-- referer_tracking_set_info(key, value) # change value always - saved in session
-- referer_tracking_get_key(key)
-- referer_tracking_request_set_info
-- referer_tracking_request_add_infos # hash of current request infos
+- **In Controllers**
+  - referer_tracking_first_request?
+  - referer_tracking_add_info(key, value) # only set in the first time called - saved in session
+  - referer_tracking_set_info(key, value) # change value always - saved in session
+  - referer_tracking_get_key(key)
+  - referer_tracking_request_set_info
+  - referer_tracking_request_add_infos # hash of current request infos
+- **In Models** (E.g. when including in user-model)
+  - user.tracking_update_status('active')
+  - user.tracking_add_log_line('10:th login') # e.g. to track users flow
+  - user.tracking.get_log_lines(/login/) # results all log lines matching regexp
 
 ## Inside
 
@@ -105,7 +169,7 @@ is not recommended but possible with session[:referer_tracking]. Information is
 
 ## Requirements
 
-Gem has been tested with ruby 1.9.3, ruby 2.1 and Rails 3.1.
+Gem has been tested with latest Ruby and Rails combinations, see https://github.com/holli/referer_tracking/blob/master/.travis.yml for more info.
 
 [<img src="https://secure.travis-ci.org/holli/referer_tracking.png" />](http://travis-ci.org/holli/referer_tracking)
 

data/app/models/referer_tracking/tracking.rb

@@ -0,0 +1,53 @@
+module RefererTracking
+  class Tracking < ActiveRecord::Base
+    self.table_name = "referer_trackings"
+    belongs_to :trackable, :polymorphic => true
+    serialize :infos_session, Hash
+    serialize :infos_request, Hash
+    attr_accessible :trackable_id, :trackable_type, :cookie_referer_url, :cookie_first_url, :user_agent, :cookies_yaml, :current_request_referer_url
+
+    def first_url_combined
+      cookie_first_url || session_first_url
+    end
+    def referer_url_combined
+      cookie_referer_url || session_referer_url
+    end
+
+
+
+    def status=(new_status)
+      if status != new_status
+        write_attribute(:status, new_status)
+        add_log_line("status #{new_status}", save_model: false)
+      end
+    end
+    def update_status(new_status, save_model: true)
+      if status != new_status
+        write_attribute(:status, new_status)
+        add_log_line("status #{new_status}", save_model: save_model)
+      end
+    end
+
+    def add_log_line(log_line, save_model: true)
+      Rails.logger.info("RefererTracking add_log_line to #{trackable_type}.#{trackable_id}: #{log_line}")
+
+      log_line = log_line.to_s.gsub("\n", ' ')
+      str = "#{Time.now.utc.to_s(:db)}: #{log_line}\n"
+      self.log = log.to_s + str
+
+      save if save_model
+    end
+
+    def get_log_lines(regexp)
+      lines = log.to_s.lines.find_all{|str| str.match(regexp)}
+      lines.collect{|str| [ActiveSupport::TimeZone["UTC"].parse(str), str.split(": ", 2).last.to_s.strip]}
+    end
+
+    def log=(val)
+      write_attribute :log, val
+    end
+    private :'log='
+
+
+  end
+end

data/db/migrate/20150424090312_log_and_status.rb

@@ -0,0 +1,6 @@
+class LogAndStatus < ActiveRecord::Migration
+  def change
+    add_column :referer_trackings, :log, :text
+    add_column :referer_trackings, :status, :string
+  end
+end

data/lib/referer_tracking.rb

@@ -1,42 +1,71 @@
-# Since ActionController::Caching::Sweeper was removed from rails core in 4
-# and moved to gem rails-observers, we have trouble loading stuff in the right order
-# (see lib/referer_tracking/sweeper.rb).
-# Manually loading these here fixes the problem for now:
-require "rails/observers/activerecord/active_record"
-require "rails/observers/action_controller/caching"
-
 require "referer_tracking/engine"
-require "referer_tracking/controller_addons"
-require "referer_tracking/sweeper"
 
 module RefererTracking
 
-  mattr_accessor :save_cookies, :set_referer_cookies, :set_referer_cookies_name, :set_referer_cookies_first_url_max_length, :set_referer_cookies_ref_url_max_length
+  mattr_accessor :save_cookies, :set_referer_cookies, :set_referer_cookies_name, :set_referer_cookies_first_url_max_length, :set_referer_cookies_ref_url_max_length, :use_observer_sweeper_if_found
 
   self.save_cookies = true
   self.set_referer_cookies = true
   self.set_referer_cookies_name = 'ref_track'
   self.set_referer_cookies_first_url_max_length = 400
   self.set_referer_cookies_ref_url_max_length = 200
+  self.use_observer_sweeper_if_found = true # if you have gem 'rails-observers' included we will use sweepers to save infos
 
-  def self.add_tracking_to(*models_list)
-    models_list.each do |model|
-      model.class_eval do
-        include RefererTracking::TrackableModule
-      end
+
+
+  mattr_accessor :add_observe_to_classes
+  self.add_observe_to_classes = []
+  def self.add_sweeper_model(model)
+    unless RefererTracking.add_observe_to_classes.include?(model)
+      RefererTracking.add_observe_to_classes.push(model)
+      RefererTracking.copy_sweeper_models_to_sweeper
     end
+  end
 
-    RefererTracking::Sweeper.class_eval do
-      observe models_list
+  def self.copy_sweeper_models_to_sweeper
+    if defined?(RefererTracking::Sweeper) && RefererTracking.use_observer_sweeper_if_found
+      RefererTracking::Sweeper.class_eval do
+        observe RefererTracking.add_observe_to_classes
+      end
+      Rails.logger.info("RefererTracking sweeper observing classes #{RefererTracking::Sweeper.observed_classes}")
     end
   end
 
-  module TrackableModule
-    def self.included(base)
-      base.class_eval do
-        has_one :referer_tracking, :class_name => "RefererTracking::RefererTracking", :as => :trackable
+
+
+  class Railtie < Rails::Railtie
+    initializer 'referer_tracking.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        require 'referer_tracking/active_record_extensions'
+        ActiveRecord::Base.send(:extend, RefererTracking::ActiveRecordExtension)
+      end
+    end
+
+    initializer 'referer_tracking.sweeper', :after => 'action_controller.caching.sweepers' do
+      ActiveSupport.on_load(:action_controller) do
+        if defined?(ActionController::Caching::Sweeper)
+          require "referer_tracking/sweeper"
+          RefererTracking.copy_sweeper_models_to_sweeper
+        end
+      end
+    end
+
+    initializer 'referer_tracking.sweeper', :after => 'action_controller.caching.sweepers' do
+      ActiveSupport.on_load(:action_controller) do
+        if defined?(ActionController::Caching::Sweeper) && RefererTracking.use_observer_sweeper_if_found
+          require "referer_tracking/sweeper"
+          RefererTracking.copy_sweeper_models_to_sweeper
+        end
+      end
+    end
+
+    initializer 'referer_tracking.controller_addons', :after => 'action_controller' do
+      ActiveSupport.on_load(:action_controller) do
+        require "referer_tracking/controller_addons"
       end
     end
+
   end
-  
+
 end
+

data/lib/referer_tracking/active_record_extensions.rb

@@ -0,0 +1,11 @@
+module RefererTracking::ActiveRecordExtension
+  def has_referer_tracking
+    has_one :tracking, :class_name => "RefererTracking::Tracking", :as => :trackable
+    class_eval do
+      delegate :add_log_line, to: :tracking, prefix: true, allow_nil: true
+      delegate :'update_status', to: :tracking, prefix: true, allow_nil: true
+    end
+
+    RefererTracking.add_sweeper_model(self)
+  end
+end

data/lib/referer_tracking/controller_addons.rb

@@ -28,6 +28,61 @@ module RefererTracking::ControllerAddons
     end
   end
 
+  def referer_tracking_after_create(record)
+    @referer_tracking_saved_records = [] if @referer_tracking_saved_records.nil?
+    if session && session["referer_tracking"]
+      ses = session["referer_tracking"]
+
+      ref_mod = @referer_tracking_saved_records.find { |ref_mod| ref_mod.trackable == record || (record.id && ref_mod.trackable_id == record.id && ref_mod.trackable_type == record.class.to_s) }
+      if ref_mod.nil?
+        #ref_mod = RefererTracking::Tracking.new(:trackable_id => record.id, :trackable_type => record.class.to_s)
+        ref_mod = record.build_tracking
+        @referer_tracking_saved_records.push(ref_mod)
+      end
+
+      ses.each_pair do |key, value|
+        ref_mod[key] = value if ref_mod.has_attribute?(key)
+        ref_mod.infos_session[key] = value unless [:session_referer_url, :session_first_url].include?(key)
+      end
+
+      req = @referer_tracking_request_add_infos
+      if req && req.is_a?(Hash)
+        req.each_pair do |key, value|
+          ref_mod[key] = value if ref_mod.has_attribute?(key)
+          ref_mod.infos_request[key] = value
+        end
+      end
+
+      ref_mod[:ip] = request.ip
+      ref_mod[:user_agent] = request.env['HTTP_USER_AGENT']
+      ref_mod[:current_request_url] = request.url
+      ref_mod[:current_request_referer_url] = request.env["HTTP_REFERER"] # or request.headers["HTTP_REFERER"]
+      ref_mod[:session_id] = request.session["session_id"]
+
+      unless cookies[RefererTracking.set_referer_cookies_name].blank?
+        cookie_ver, cookie_time_org, cookie_first_url, cookie_referer_url = cookies[RefererTracking.set_referer_cookies_name].to_s.split("|||")
+        ref_mod[:cookie_first_url] = cookie_first_url
+        ref_mod[:cookie_referer_url] = cookie_referer_url
+        ref_mod[:cookie_time] = Time.at(cookie_time_org.to_i)
+      end
+
+      if RefererTracking.save_cookies
+        begin
+          ref_mod[:cookies_yaml] = cookies.instance_variable_get('@cookies').to_yaml
+        rescue
+          str = "referer_tracking after create problem encoding cookie yml, probably non utf8 chars #{e}"
+          logger.error(str)
+          ref_mod[:cookies_yaml] = "error: #{str}"
+        end
+      end
+
+      ref_mod.save unless ref_mod.trackable.new_record?
+    end
+
+  rescue Exception => e
+    Rails.logger.info "RefererTracking::Sweeper.after_create problem with creating record: #{e}"
+  end
+
   ###############################################
   # Session add methods
 
@@ -77,6 +132,7 @@ module RefererTracking::ControllerAddons
     request.user_agent =~ /bot/i
   end
 
+  ###############################################
 
   def self.included(base)
     base.class_eval do
@@ -88,5 +144,6 @@ module RefererTracking::ControllerAddons
     end
   end
 
+
 end
 

data/lib/referer_tracking/sweeper.rb

@@ -1,73 +1,11 @@
 class RefererTracking::Sweeper < ActionController::Caching::Sweeper
-  def after_create(record)
-    if session && session["referer_tracking"]
-      ses = session["referer_tracking"]
-
-      ref_mod = RefererTracking::RefererTracking.new(
-          :trackable_id => record.id, :trackable_type => record.class.to_s)
-
-      ses.each_pair do |key, value|
-        ref_mod[key] = value if ref_mod.has_attribute?(key)
-        ref_mod.infos_session[key] = value unless [:session_referer_url, :session_first_url].include?(key)
-      end
-
-      req = assigns(:referer_tracking_request_add_infos)
-      if req && req.is_a?(Hash)
-        req.each_pair do |key, value|
-          ref_mod[key] = value if ref_mod.has_attribute?(key)
-          ref_mod.infos_request[key] = value
-        end
-      end
-
-      ref_mod[:ip] = request.ip
-      ref_mod[:user_agent] = request.env['HTTP_USER_AGENT']
-      ref_mod[:current_request_url] = request.url
-      ref_mod[:current_request_referer_url] = request.env["HTTP_REFERER"] # or request.headers["HTTP_REFERER"]
-      ref_mod[:session_id] = request.session["session_id"]
-
-      unless cookies[RefererTracking.set_referer_cookies_name].blank?
-        cookie_ver, cookie_time_org, cookie_first_url, cookie_referer_url = cookies[RefererTracking.set_referer_cookies_name].to_s.split("|||")
-        ref_mod[:cookie_first_url] = RefererTracking::Sweeper.try_to_parse(cookie_first_url)
-        ref_mod[:cookie_referer_url] = RefererTracking::Sweeper.try_to_parse(cookie_referer_url)
-        ref_mod[:cookie_time] = Time.at(cookie_time_org.to_i)
-      end
+  # https://github.com/rails/rails-observers/blob/master/lib/rails/observers/active_model/observing.rb
 
-      if RefererTracking.save_cookies
-        begin
-          ref_mod[:cookies_yaml] = cookies.instance_variable_get('@cookies').to_yaml
-        rescue
-          str = "referer_tracking after create problem encoding cookie yml, probably non utf8 chars #{e}"
-          logger.error(str)
-          ref_mod[:cookies_yaml] = "error: #{str}"
-        end
-      end
-
-      ref_mod.save
+  def after_create(record)
+    if controller && controller.respond_to?(:referer_tracking_after_create)
+      controller.referer_tracking_after_create(record)
     end
-
-  rescue Exception => e
-    Rails.logger.info "RefererTracking::Sweeper.after_create problem with creating record: #{e}"
   end
 
-  def self.try_to_parse(url)
-    orig_url = url
-    rescued = false
-    err_count = 0
-    err_limit = 4
-    loop do
-      err = false
-      begin
-        URI.parse(url)
-      rescue URI::InvalidURIError
-        rescued = true
-        err = true
-        err_count+= 1
-        url = url[0...-1]
-      end
-      break if !err or err_count == err_limit
-    end
-    if(rescued && defined? logger) then logger.info("failed parsing with url: " +orig_url) end
-    return (err_count == err_limit) ? orig_url : url
-  end
 end