redis_analytics 0.7.1 → 1.0.0

data/lib/redis_analytics/configuration.rb

@@ -1,101 +1,101 @@
-  module RedisAnalytics
-    module Configuration
-      # Redis connection instance
-      attr_accessor :redis_connection
+module RedisAnalytics
+  module Configuration
+    # Redis connection instance
+    attr_accessor :redis_connection
 
-      # Redis namespace for keys
-      attr_writer :redis_namespace
+    # Redis namespace for keys
+    attr_writer :redis_namespace
 
-      # Name of the cookie which tracks first visitors
-      attr_writer :first_visit_cookie_name
+    # Name of the cookie which tracks first visitors
+    attr_writer :first_visit_cookie_name
 
-      # Name of the cookie which tracks current visits
-      attr_writer :current_visit_cookie_name
+    # Name of the cookie which tracks current visits
+    attr_writer :current_visit_cookie_name
 
-      # Minutes the visit should timeout after (if no hit is received)
-      attr_writer :visit_timeout
+    # Minutes the visit should timeout after (if no hit is received)
+    attr_writer :visit_timeout
 
-      # Endpoint for dashboard
-      attr_writer :dashboard_endpoint
+    # Endpoint for dashboard
+    attr_writer :dashboard_endpoint
 
-      # Endpoint for api
-      attr_writer :api_endpoint
+    # Endpoint for api
+    attr_writer :api_endpoint
 
-      attr_writer :path_filters
+    attr_writer :path_filters
 
-      attr_writer :filters
+    attr_writer :filters
 
-      # Path to the Geo IP Database file
-      attr_writer :geo_ip_data_path
+    # Path to the Geo IP Database file
+    attr_writer :geo_ip_data_path
 
-      # Redis namespace for keys
-      def redis_namespace
-        @redis_namespace ||= 'ra'
-      end
-
-      # Minutes the visit should timeout after (if no hit is received)
-      def visit_timeout
-        @visit_timeout ||= 30 # minutes
-      end
+    # Redis namespace for keys
+    def redis_namespace
+      @redis_namespace ||= 'ra'
+    end
 
-      # Name of the cookie which tracks first visitors (unknown visitors)
-      def first_visit_cookie_name
-        @first_visit_cookie_name ||= '_rucn'
-      end
+    # Minutes the visit should timeout after (if no hit is received)
+    def visit_timeout
+      @visit_timeout ||= 30 # minutes
+    end
 
-      # Name of the cookie which tracks visits
-      def current_visit_cookie_name
-        @current_visit_cookie_name ||= '_vcn'
-      end
+    # Name of the cookie which tracks first visitors (unknown visitors)
+    def first_visit_cookie_name
+      @first_visit_cookie_name ||= '_rucn'
+    end
 
-      def filters
-        @filters ||= []
-      end
+    # Name of the cookie which tracks visits
+    def current_visit_cookie_name
+      @current_visit_cookie_name ||= '_vcn'
+    end
 
-      def path_filters
-        @path_filters ||= []
-      end
+    def filters
+      @filters ||= []
+    end
 
-      def add_filter(&proc)
-        filters << RedisAnalytics::Filter.new(proc)
-      end
+    def path_filters
+      @path_filters ||= []
+    end
 
-      def add_path_filter(path)
-        path_filters << RedisAnalytics::PathFilter.new(path)
-      end
+    def add_filter(&proc)
+      filters << RedisAnalytics::Filter.new(proc)
+    end
 
-      def geo_ip_data_path
-        @geo_ip_data_path = ::File.expand_path(::File.join(::File.dirname(__FILE__),'..','..')) + "/bin/GeoIP.dat"
-      end
+    def add_path_filter(path)
+      path_filters << RedisAnalytics::PathFilter.new(path)
+    end
 
-      def visitor_recency_slices
-        @visitor_recency_slices ||= [1, 7, 30]
-      end
+    def geo_ip_data_path
+      @geo_ip_data_path = ::File.expand_path(::File.join(::File.dirname(__FILE__),'..','..')) + "/bin/GeoIP.dat"
+    end
 
-      def default_range
-        @default_range = :day
-      end
+    def visitor_recency_slices
+      @visitor_recency_slices ||= [1, 7, 30]
+    end
 
-      def redis_key_timestamps # [format, expire in seconds or nil]
-        ['%Y', '%Y_%m', '%Y_%m_%d', '%Y_%m_%d_%H', '%Y_%m_%d_%H_%M']
-      end
+    def default_range
+      @default_range = :day
+    end
 
-      def time_range_formats
-        [[:year, :month, "%b"], [:week, :day, "%a"], [:day, :hour, "%l%P"]]
-      end
+    def redis_key_timestamps # [format, expire in seconds or nil]
+      ['%Y', '%Y_%m', '%Y_%m_%d', '%Y_%m_%d_%H', '%Y_%m_%d_%H_%M']
+    end
 
-      def configure
-        yield self
-      end
+    def time_range_formats
+      [[:year, :month, "%b"], [:week, :day, "%a"], [:day, :hour, "%l%P"]]
+    end
 
-      def api_endpoint
-        @api_endpoint || dashboard_endpoint + '/api'
-      end
+    def configure
+      yield self
+    end
 
-      def dashboard_endpoint
-        @dashboard_endpoint || '/redis_analytics'
-      end
+    def api_endpoint
+      @api_endpoint || dashboard_endpoint + '/api'
+    end
 
+    def dashboard_endpoint
+      @dashboard_endpoint || '/redis_analytics'
     end
+
   end
+end
 

data/lib/redis_analytics/engine.rb

@@ -13,6 +13,13 @@ module RedisAnalytics
       initializer "redis_analytics.view_helpers" do |app|
         ActionController::Base.send :include, RedisAnalytics::Helpers
       end
+      
+      initializer "redis_analytics.precompile.hook", group: :all do |app|
+        app.config.assets.precompile += %w[
+        redis_analytics/redis_analytics.js
+        redis_analytics/redis_analytics.css
+      ]
+      end
     end
   end
 end

data/lib/redis_analytics/filter.rb

@@ -1,32 +1,32 @@
-  module RedisAnalytics
-    class Filter
-      attr_reader :filter_proc
+module RedisAnalytics
+  class Filter
+    attr_reader :filter_proc
 
-      def initialize(filter_proc)
-        @filter_proc = filter_proc
-      end
-
-      def matches?(request, response)
-        filter_proc.call(request, response)
-      end
+    def initialize(filter_proc)
+      @filter_proc = filter_proc
+    end
 
+    def matches?(request, response)
+      filter_proc.call(request, response)
     end
 
-    class PathFilter
-      attr_reader :filter_path
+  end
+
+  class PathFilter
+    attr_reader :filter_path
 
-      def initialize(filter_path)
-        @filter_path = filter_path
-      end
+    def initialize(filter_path)
+      @filter_path = filter_path
+    end
 
-      def matches?(request_path)
-        if filter_path.is_a?(String)
-          request_path == filter_path
-        elsif filter_path.is_a?(Regexp)
-          request_path =~ filter_path
-        end
+    def matches?(request_path)
+      if filter_path.is_a?(String)
+        request_path == filter_path
+      elsif filter_path.is_a?(Regexp)
+        request_path =~ filter_path
       end
     end
-
   end
 
+end
+

data/lib/redis_analytics/helpers.rb

@@ -1,74 +1,74 @@
-  module RedisAnalytics
-    module Helpers
+module RedisAnalytics
+  module Helpers
 
-      FORMAT_SPECIFIER = [['%Y', 365], ['%m', 30], ['%d', 24], ['%H', 60], ['%M', 60]]
+    FORMAT_SPECIFIER = [['%Y', 365], ['%m', 30], ['%d', 24], ['%H', 60], ['%M', 60]]
 
-      GRANULARITY = ['yearly', 'monthly', 'dayly', 'hourly', 'minutely']
+    GRANULARITY = ['yearly', 'monthly', 'dayly', 'hourly', 'minutely']
 
-      private
-      def method_missing(meth, *args, &block)
-        if meth.to_s =~ /^(minute|hour|dai|day|month|year)ly_([a-z_0-9]+)$/
-          granularity = ($1 == 'dai' ? 'day' : $1) + 'ly'
-          metric_name = $2
-          data(granularity, metric_name, *args)
-        else
-          super
-        end
+    private
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^(minute|hour|dai|day|month|year)ly_([a-z_0-9]+)$/
+        granularity = ($1 == 'dai' ? 'day' : $1) + 'ly'
+        metric_name = $2
+        data(granularity, metric_name, *args)
+      else
+        super
       end
+    end
 
-      def metric_type(metric_name)
-        RedisAnalytics.redis_connection.hget("#{RedisAnalytics.redis_namespace}:#METRICS", metric_name)
-      end
+    def metric_type(metric_name)
+      RedisAnalytics.redis_connection.hget("#{RedisAnalytics.redis_namespace}:#METRICS", metric_name)
+    end
 
-      def data(granularity, metric_name, from_date, options = {})
-        aggregate = options[:aggregate] || false
-        x = granularity[0..-3]
+    def data(granularity, metric_name, from_date, options = {})
+      aggregate = options[:aggregate] || false
+      x = granularity[0..-3]
 
-        to_date = (options[:to_date] || Time.now).send("end_of_#{x}")
-        i = from_date.send("beginning_of_#{x}")
+      to_date = (options[:to_date] || Time.now).send("end_of_#{x}")
+      i = from_date.send("beginning_of_#{x}")
 
-        union = []
-        time = []
-        begin
-          slice_key = i.strftime(FORMAT_SPECIFIER[0..GRANULARITY.index(granularity)].map{|x| x[0]}.join('_'))
-          union << "#{RedisAnalytics.redis_namespace}:#{metric_name}:#{slice_key}"
-          time << slice_key.split('_')
-          i += 1.send(x)
-        end while i <= to_date
-        seq = get_next_seq
-        if metric_type(metric_name) == 'String'
-          if aggregate
-            union_key = "#{RedisAnalytics.redis_namespace}:#{seq}"
-            RedisAnalytics.redis_connection.zunionstore(union_key, union)
-            RedisAnalytics.redis_connection.expire(union_key, 100)
-            return Hash[RedisAnalytics.redis_connection.zrange(union_key, 0, -1, :with_scores => true)]
-          else
-            return time.zip(union.map{|x| Hash[RedisAnalytics.redis_connection.zrange(x, 0, -1, :with_scores => true)]})
-          end
-        elsif metric_type(metric_name) == 'Fixnum'
-          if aggregate
-            return RedisAnalytics.redis_connection.mget(*union).map(&:to_i).inject(:+)
-          else
-            return time.zip(RedisAnalytics.redis_connection.mget(*union).map(&:to_i))
-          end
+      union = []
+      time = []
+      begin
+        slice_key = i.strftime(FORMAT_SPECIFIER[0..GRANULARITY.index(granularity)].map{|x| x[0]}.join('_'))
+        union << "#{RedisAnalytics.redis_namespace}:#{metric_name}:#{slice_key}"
+        time << slice_key.split('_')
+        i += 1.send(x)
+      end while i <= to_date
+      seq = get_next_seq
+      if metric_type(metric_name) == 'String'
+        if aggregate
+          union_key = "#{RedisAnalytics.redis_namespace}:#{seq}"
+          RedisAnalytics.redis_connection.zunionstore(union_key, union)
+          RedisAnalytics.redis_connection.expire(union_key, 100)
+          return Hash[RedisAnalytics.redis_connection.zrange(union_key, 0, -1, :with_scores => true)]
+        else
+          return time.zip(union.map{|x| Hash[RedisAnalytics.redis_connection.zrange(x, 0, -1, :with_scores => true)]})
+        end
+      elsif metric_type(metric_name) == 'Fixnum'
+        if aggregate
+          return RedisAnalytics.redis_connection.mget(*union).map(&:to_i).inject(:+)
         else
-          if Metrics.public_instance_methods.any?{|m| m.to_s =~ /^#{metric_name}_ratio_per_(hit|visit)$/}
-            aggregate ? {} : time.zip([{}] * time.length)
-          elsif Metrics.public_instance_methods.any?{|m| m.to_s =~ /^#{metric_name}_count_per_(hit|visit)$/}
-            aggregate ? 0 : time.zip([0] * time.length)
-          else
-            aggregate ? 0 : time.zip([0] * time.length)
-          end
+          return time.zip(RedisAnalytics.redis_connection.mget(*union).map(&:to_i))
+        end
+      else
+        if Metrics.public_instance_methods.any?{|m| m.to_s =~ /^#{metric_name}_ratio_per_(hit|visit)$/}
+          aggregate ? {} : time.zip([{}] * time.length)
+        elsif Metrics.public_instance_methods.any?{|m| m.to_s =~ /^#{metric_name}_count_per_(hit|visit)$/}
+          aggregate ? 0 : time.zip([0] * time.length)
+        else
+          aggregate ? 0 : time.zip([0] * time.length)
         end
       end
+    end
 
-      def get_next_seq
-        seq = RedisAnalytics.redis_connection.incr("#{RedisAnalytics.redis_namespace}:#SEQUENCER")
-      end
+    def get_next_seq
+      seq = RedisAnalytics.redis_connection.incr("#{RedisAnalytics.redis_namespace}:#SEQUENCER")
+    end
 
-      def time_range
-        (request.cookies["_rarng"] || RedisAnalytics.default_range).to_sym
-      end
+    def time_range
+      (request.cookies["_rarng"] || RedisAnalytics.default_range).to_sym
     end
   end
+end
 

data/lib/redis_analytics/metrics.rb

@@ -1,95 +1,95 @@
-  module RedisAnalytics
-    module Metrics
+module RedisAnalytics
+  module Metrics
 
-      attr_reader :visit_time_count_per_visit
-      attr_reader :visits_count_per_visit, :first_visits_count_per_visit, :repeat_visits_count_per_visit
-      attr_reader :unique_visits_ratio_per_visit
-      attr_reader :page_views_count_per_hit, :second_page_views_count_per_hit
+    attr_reader :visit_time_count_per_visit
+    attr_reader :visits_count_per_visit, :first_visits_count_per_visit, :repeat_visits_count_per_visit
+    attr_reader :unique_visits_ratio_per_visit
+    attr_reader :page_views_count_per_hit, :second_page_views_count_per_hit
 
-      # Developers can override or define new public methods here
-      # Methods should start with track and end with count or types
-      # Return types should be Fixnum or String resp.
-      # If you return nil or an error nothing will be tracked
+    # Developers can override or define new public methods here
+    # Methods should start with track and end with count or types
+    # Return types should be Fixnum or String resp.
+    # If you return nil or an error nothing will be tracked
 
-      def browser_ratio_per_visit
-        user_agent.name.to_s
-      end
+    def browser_ratio_per_visit
+      user_agent.name.to_s
+    end
 
-      def platform_ratio_per_visit
-        user_agent.platform.to_s
-      end
+    def platform_ratio_per_visit
+      user_agent.platform.to_s
+    end
 
-      def country_ratio_per_visit
-        if defined?(GeoIP)
-          begin
-            g = GeoIP.new(RedisAnalytics.geo_ip_data_path)
-            geo_country_code = g.country(@rack_request.ip).to_hash[:country_code2]
-            if geo_country_code and geo_country_code =~ /^[A-Z]{2}$/
-              return geo_country_code
-            end
-          rescue Exception => e
-            warn "Unable to fetch country info #{e}"
+    def country_ratio_per_visit
+      if defined?(GeoIP)
+        begin
+          g = GeoIP.new(RedisAnalytics.geo_ip_data_path)
+          geo_country_code = g.country(@rack_request.ip).to_hash[:country_code2]
+          if geo_country_code and geo_country_code =~ /^[A-Z]{2}$/
+            return geo_country_code
           end
+        rescue Exception => e
+          warn "Unable to fetch country info #{e}"
         end
       end
+    end
 
-      def recency_ratio_per_visit
-        # tracking for visitor recency
-        if @last_visit_time # from first_visit_cookie
-          days_since_last_visit = ((@t.to_i - @last_visit_time.to_i)/(24*3600)).round
-          if days_since_last_visit <= 1
-            return 'd'
-          elsif days_since_last_visit <= 7
-            return 'w'
-          elsif days_since_last_visit <= 30
-            return 'm'
-          else
-            return 'o'
-          end
+    def recency_ratio_per_visit
+      # tracking for visitor recency
+      if @last_visit_time # from first_visit_cookie
+        days_since_last_visit = ((@t.to_i - @last_visit_time.to_i)/(24*3600)).round
+        if days_since_last_visit <= 1
+          return 'd'
+        elsif days_since_last_visit <= 7
+          return 'w'
+        elsif days_since_last_visit <= 30
+          return 'm'
+        else
+          return 'o'
         end
       end
+    end
 
-      def device_ratio_per_visit
-        return ((user_agent.mobile? or user_agent.tablet?) ? 'mobile' : 'desktop')
-      end
+    def device_ratio_per_visit
+      return ((user_agent.mobile? or user_agent.tablet?) ? 'mobile' : 'desktop')
+    end
 
-      def referrer_ratio_per_visit
-        if @rack_request.referrer
-          ['google', 'bing', 'yahoo', 'cleartrip', 'github'].each do |referrer|
-            # this will track x.google.mysite.com as google so its buggy, fix the regex
-            if m = @rack_request.referrer.match(/^(https?:\/\/)?([a-zA-Z0-9\.\-]+\.)?(#{referrer})\.([a-zA-Z\.]+)(:[0-9]+)?(\/.*)?$/)
-              "REFERRER => #{m.to_a[3]}"
-              referrer = m.to_a[3]
-            else
-              referrer = 'other'
-            end
+    def referrer_ratio_per_visit
+      if @rack_request.referrer
+        ['google', 'bing', 'yahoo', 'cleartrip', 'github'].each do |referrer|
+          # this will track x.google.mysite.com as google so its buggy, fix the regex
+          if m = @rack_request.referrer.match(/^(https?:\/\/)?([a-zA-Z0-9\.\-]+\.)?(#{referrer})\.([a-zA-Z\.]+)(:[0-9]+)?(\/.*)?$/)
+            "REFERRER => #{m.to_a[3]}"
+            referrer = m.to_a[3]
+          else
+            referrer = 'other'
           end
-        else
-          referrer = 'organic'
         end
-        return referrer
-      end
-
-      # track the ratio of URL's visits
-      def url_ratio_per_hit
-        return @rack_request.path
-      end
-      
-      # track the landing pages ratio
-      def landing_page_ratio_per_hit
-        return @rack_request.path if @page_view_seq_no.to_i == 0
+      else
+        referrer = 'organic'
       end
+      return referrer
+    end
 
-      # track the landing pages ratio
-      def http_response_ratio_per_hit
-        return @rack_response.status.to_s
-      end
+    # track the ratio of URL's visits
+    def url_ratio_per_hit
+      return @rack_request.path
+    end
+    
+    # track the landing pages ratio
+    def landing_page_ratio_per_hit
+      return @rack_request.path if @page_view_seq_no.to_i == 0
+    end
 
-      private
-      def user_agent
-        Browser.new(:ua => @rack_request.user_agent, :accept_language => 'en-us')
-      end
+    # track the landing pages ratio
+    def http_response_ratio_per_hit
+      return @rack_response.status.to_s
+    end
 
+    private
+    def user_agent
+      Browser.new(:ua => @rack_request.user_agent, :accept_language => 'en-us')
     end
+
   end
+end