gricer 0.0.1

data/app/views/gricer/capture/index.html.erb

@@ -0,0 +1 @@
+<%= params.inspect %>

data/app/views/gricer/dashboard/_menu.html.erb

@@ -0,0 +1,10 @@
+<% items.each do |item| -%>
+  <% if item[1].to_sym == :menu -%>
+    <div>
+      <span><%= item[0] %></span>
+      <%= render 'menu', items: item[2] %>
+    </div>
+  <% else -%>
+    <%= link_to item[0], item[2], "data-gricer-#{item[1]}" => true %>
+  <% end -%>
+<% end -%>

data/app/views/gricer/dashboard/_overview.html.erb

@@ -0,0 +1,33 @@
+<div class='overview'>
+  <h2>
+    Overview for <%=l @stat_from%>
+    <% unless @stat_from == @stat_thru -%>
+      to <%=l @stat_thru%>
+    <% end -%>
+  </h2>
+  
+  <p>
+    <% sessions_count = sessions.count.try(:to_f) -%>
+    <%=t '.sessions', count: sessions_count.to_i %> 
+  </p>
+  <p>
+    <%=t '.new_sessions', count: sessions.new_visits.count %> 
+  </p>
+  <p>
+    <%=t '.new_visitors', percentage: format_percentage(sessions.new_visitors) %>
+  </p>
+  <p>
+    <% request_count = requests.count.try(:to_f) -%>
+    <%=t '.requests', count: request_count.to_i %> 
+  </p>
+  <p>
+    <%=t '.requests_per_session', count: '%3.2f' %  sessions.requests_per_session %> 
+  </p>
+
+  <p>
+    <%=t '.bounce_rate', percentage: format_percentage(sessions.bounce_rate) %>
+  </p>
+  <p>
+    <%=t '.avg_duration', time: format_seconds(sessions.avg_duration) %>
+  </p>
+</div>

data/app/views/gricer/dashboard/index.html.erb

@@ -0,0 +1,19 @@
+<div class="gricer-stat">
+  <div id="gricer-header">
+    <span class="path"></span>
+    <span class="dates">
+      <%= form_tag do -%>
+        <%= text_field_tag :from, @stat_from, id: 'gricer-from-field' -%>
+        -
+        <%= text_field_tag :thru, @stat_thru, id: 'gricer-thru-field' %>
+      <% end -%>
+    </span>
+  </div>
+  <div id="gricer-menu">
+    <%= render 'menu', items: ::Gricer.config.admin_menu %>  
+  </div>
+
+  <div id="gricer-container"></div>
+  
+  <%= javascript_include_tag :gricer_backend_jquery %>
+</div>

data/config/routes.rb

@@ -0,0 +1,51 @@
+Rails.application.routes.draw do
+  post 'gricer_capture/:id' => 'gricer/capture#index', as: :gricer_capture
+  
+  scope ::Gricer.config.admin_prefix do
+    root to: "gricer/dashboard#index", as: :gricer_root
+    post 'overview' => "gricer/dashboard#overview", as: :gricer_overview
+    
+    scope 'sessions' do
+      [
+        'agent.name', 'agent.os', 'agent.full_version', 'agent.major_version', 'agent.engine_name', 'agent.engine_version', 
+        'javascript', 'java', 'silverlight_version', 'silverlight_major_version', 'flash_version', 'flash_major_version',
+        'country', 'city', 'domain', 'screen_size', 'screen_width', 'screen_height', 'screen_depth',
+        'requested_locale_major', 'requested_locale_minor', 'requested_locale', 
+      ].each do |field|
+        name = field.gsub('.', '_')
+        get "#{name}_process" => "gricer/sessions#process_stats", field: field, as: "gricer_sessions_#{name}_process"
+        get "#{name}_spread" => "gricer/sessions#spread_stats", field: field, as: "gricer_sessions_#{name}_spread"
+      end
+    end
+    
+    scope 'requests' do
+      [
+        'agent.name', 'agent.os', 'agent.full_version', 'agent.major_version', 'agent.engine_name', 'agent.engine_version', 
+        'host', 'path', 'method', 'protocol', 'entry_path',
+        'referer_protocol', 'referer_host', 'referer_path', 'referer_params',
+        'search_engine', 'search_query',
+      ].each do |field|
+        name = field.gsub('.', '_')
+        get "#{name}_process" => "gricer/requests#process_stats", field: field, as: "gricer_requests_#{name}_process"
+        get "#{name}_spread" => "gricer/requests#spread_stats", field: field, as: "gricer_requests_#{name}_spread"
+      end
+    end
+  end
+end
+
+# Gricer::Engine.routes.draw do
+#   root to: "dashboard#index"
+#   
+#   scope 'sessions' do
+#     [
+#       'agent.name', 'agent.os', 'agent.full_version', 'agent.major_version', 'agent.engine_name', 'agent.engine_version', 
+#       'javascript', 'java', 'silverlight_version', 'silverlight_major_version', 'flash_version', 'flash_major_version',
+#       'country', 'city', 'domain', 'screen_size', 'screen_width', 'screen_height', 'screen_depth',
+#       'requested_major_locale', 'requested_minor_locale', 'requested_locale', 
+#     ].each do |field|
+#       name = field.gsub('.', '_')
+#       get "#{name}_process" => "sessions#process_stats", field: field, as: "gricer_session_#{name}_process"
+#       get "#{name}_spread" => "sessions#spread_stats", field: field, as: "gricer_session_#{name}_spread"
+#     end
+#   end
+# end

data/lib/gricer.rb

@@ -0,0 +1,36 @@
+require "gricer/config"
+require "gricer/engine"
+require "gricer/localization"
+
+require 'gricer/action_controller/base'
+require 'gricer/action_controller/track'
+
+require 'gricer/active_model/statistics'
+
+# Gricer is a web analytics gem for Rails 3.1 and beyond
+module Gricer
+  class << self    
+    # To access the actual configuration of your Gricer, you can call this function.
+    #
+    # An example would be <tt>Gricer.config.table_name_prefix = 'stats_'</tt>
+    #
+    # See Gricer::Config for configuration options.
+    #
+    # @return [Gricer::Config] The actual configuration instance of Gricer
+    # @see Gricer::Config
+    def config
+      @config ||= Config.new
+    end
+    
+    # To initialize Gricer it is handy to give it a block of options.
+    #
+    # See Gricer::Config for configuration options.
+    #
+    # @yield (config) The actual configuration instance of Gricer
+    # @return [Gricer::Config] The actual configuration instance of Gricer
+    # @see Gricer::Config
+    def configure(&block)
+      config.configure(&block)
+    end
+  end
+end

data/lib/gricer/action_controller/base.rb

@@ -0,0 +1,28 @@
+module Gricer
+  # Gricer's ActionController enhancements
+  module ActionController 
+    # Gricer's ActionController base enhancements
+    module Base
+
+      # Include the helper functions into controllers.
+      def self.included(base)
+        base.module_eval do
+          helper_attr :gricer_user_id
+        end
+      end
+
+      # This function is a stub for the mechanism to include the current
+      # users id into the statistics of gricer.
+      # @example The most common case would be to pass the current_user's id. So this is the code you should add to your appliction_controller
+      #   def gricer_user_id
+      #     current_user.try(:id)
+      #   end
+      # @return [Integer] 
+      def gricer_user_id
+        nil
+      end
+    end
+  end
+end
+
+ActionController::Base.send :include, Gricer::ActionController::Base

data/lib/gricer/action_controller/track.rb

@@ -0,0 +1,132 @@
+module Gricer
+  # Around-Filter for tracking requests in Gricer
+  class TrackRequestFilter
+    # Around-Filter for tracking requests in Gricer
+    # @param controller The controller from which this Filter was included.
+    # @yield The controller's code block
+    def self.filter(controller, &block)
+      if controller.controller_path =~ /^gricer\// or controller.request.path =~ ::Gricer.config.exclude_paths
+        Rails.logger.debug "Gricer Track Request: Do not track '#{controller.controller_path}##{controller.action_name}' by config"
+        block.call
+        return
+      end
+      
+      status = nil
+      
+      options = {
+        request: controller.request, 
+        controller: controller.controller_path,
+        action: controller.action_name,
+        params: controller.params,
+        session_id: controller.session[:gricer_session],
+        locale: I18n.locale
+      }
+
+      if controller.gricer_user_id
+        options[:user_id] = controller.gricer_user_id
+      end
+      
+      options.keys.each do |key|
+        Rails.logger.debug key
+      end
+      
+      gricer_request = ::Gricer::Request.create options
+      controller.gricer_request = gricer_request
+      controller.session[:gricer_session] = gricer_request.session_id
+        
+      begin
+        benchmark = Benchmark.measure(&block)
+        
+        gricer_request.update_attributes(
+          status_code: controller.response.status,
+          content_type: controller.response.content_type,
+          body_size: controller.response.body.size,
+          system_time: (benchmark.cstime*1000).to_i,
+          user_time: (benchmark.cutime*1000).to_i,
+          total_time: (benchmark.total*1000).to_i,
+          real_time: (benchmark.real*1000).to_i
+        )
+      rescue 
+        gricer_request.update_attributes(
+          status_code: 500,
+          content_type: controller.response.content_type,
+          body_size: controller.response.body.size
+        )
+        raise
+      end
+    end
+  end 
+  
+  # Helper Method to include Javascript code to capture extra values like screen size
+  module TrackHelper
+    # Include Gricer's Javascript code to track values like screen size. 
+    #
+    # You should include this at the end of your layout file. For pages matching the
+    # Gricer::Config.exclude_paths expression, nothing will be added to your page.
+    #
+    # @example For html.erb add at the end of your layout file:
+    #  <html>
+    #    <head>[...]</head>
+    #    <body>
+    #       [...]
+    #       <%= gricer_track_tag %>
+    #     </body>
+    #   </html>
+    #
+    # @example For html.haml add at the end of your layout file:
+    #  %html
+    #    %head
+    #      [...]
+    #    %body
+    #      [...]
+    #      = gricer_track_tag 
+    
+    def gricer_track_tag
+      if gricer_request and defined?(gricer_capture_path)
+        content_tag :script, "jQuery(function($) {$.post('#{gricer_capture_path(gricer_request.id)}', Gricer.prepareValues());});", type: 'text/javascript'
+      end
+    end
+  end
+  
+  module ActionController
+    # Gricer's Tracker module for ActionController
+    #
+    # To include the Tracker module into ActionController add
+    # gricer_track_requests to your ApplicationController or
+    # to any Controller you want to track with Gricer.
+    #
+    # @example 
+    #   class ApplicationController < ActionController::Base
+    #     protect_from_forgery
+    #     gricer_track_requests
+    #     [...]
+    #   end
+    
+    module Tracker
+      # Include the helper functions and around_filter into controllers.
+      def self.included(base)
+        base.append_around_filter TrackRequestFilter
+        base.helper TrackHelper
+        base.helper_method :gricer_request
+      end
+      
+      # Set the actual gricer request instance.
+      # @param gricer_request [Gricer::Request] The gricer request to be set as actual request instance.
+      def gricer_request=(gricer_request)
+        @gricer_request = gricer_request
+      end
+      
+      # Get the actual gricer request instance.
+      # @return [Gricer::Request]
+      def gricer_request
+        @gricer_request
+      end
+    end
+  end
+end
+
+class ActionController::Base
+  def self.gricer_track_requests(options = {})
+    include Gricer::ActionController::Tracker
+  end
+end

data/lib/gricer/active_model/statistics.rb

@@ -0,0 +1,167 @@
+module Gricer
+  # Gricer's ActiveModel enhancements
+  module ActiveModel
+    # Gricer's statistics enhancements for ActiveModel
+    #
+    # To add statistics to an ActiveRecord just include the module:
+    #   class SomeDataModel < ::ActiveRecord::Base
+    #     include ActiveModel::Statistics
+    #     [...]
+    #   end
+    #
+    # This module provides two major enhancements:
+    #
+    # == Extendend attribute names
+    #
+    # You can use relation attributes by using a dot in your attribute name.
+    #
+    # *Example:*
+    #
+    # For getting the name of the attribute name of Agent associated to the Request:
+    #   Gricer::Request.human_attributes('agent.name')
+    #
+    # == Statistics functions and filters
+    #
+    # Methods for filtering, grouping, and counting records
+    module Statistics
+      # Extend the ActiveModel with the statistics class methods.
+      # @see ClassMethods
+      def self.included(base)
+        base.extend ClassMethods
+      end
+        
+      # Gricer's statistics enhancements for ActiveModel
+      #
+      # == Extended attribute names
+      # You can use relation attributes by using a dot in your attribute name.
+      #
+      # @example For getting the name of the attribute name of Agent associated to the Request:
+      #   Gricer::Request.human_attributes('agent.name')
+      module ClassMethods
+        # Filter records for the time between from and thru
+        # @param from [Date, Time] Only get records on or after this point of time
+        # @param thru [Date, Time] Only get records before this point of time
+        # @return [ActiveRecord::Relation]      
+        def between(from, thru)
+          #self.where(self.table_name => {:created_at.gte => from, :created_at.lt => thru})
+          self.where("\"#{table_name}\".\"created_at\" >= ? AND \"#{table_name}\".\"created_at\" < ?", from, thru)
+        end
+        
+        # Filter records for the dates between from and thru
+        # @param from [Date] Only get records on or after this date
+        # @param thru [Date] Only get records on or before this date
+        # @return [ActiveRecord::Relation]        
+        def between_dates(from, thru)
+          self.between(from.to_date.to_time, thru.to_date.to_time+1.day)
+        end
+        
+        # Group records by attribute.
+        # 
+        # @param attribute [String, Symbol] Attribute to group the records for. You can use gricers extended attribute names.
+        # @return [ActiveRecord::Relation] 
+        def grouped_by(attribute)
+          parts = attribute.to_s.split('.')
+          if parts[1].blank?
+            self.group(attribute)
+            .select(attribute)
+          else
+            if association = self.reflect_on_association(parts[0].to_sym)          
+              self.includes(association.name)
+              .group("\"#{association.table_name}\".\"#{parts[1]}\"")
+              .select("\"#{association.table_name}\".\"#{parts[1]}\"")
+            else
+              raise "Association '#{parts[0]}' not found on #{self.name}"
+            end
+          end
+        end
+
+        # Count records by attribute.
+        # 
+        # @param attribute [String, Symbol] Attribute name to count for. You can use gricers extended attribute names.
+        # @return [ActiveRecord::Relation] 
+        def count_by(attribute)
+          self.grouped_by(attribute).count(:id).sort{ |a,b| b[1] <=> a[1] }
+        end
+      
+        # Filter records by attribute's value.
+        # 
+        # @example
+        #   some_relation.filter('agent.name', 'Internet Explorer').filter('agent.os', 'Windows')
+        # @param attribute [String, Symbol] Attribute name to filter. You can use gricers extended attribute names. 
+        # @param value Attribute value to filter.
+        # @return [ActiveRecord::Relation] 
+
+        def filter_by(attribute, value)
+          return self if attribute.blank?
+          
+          Rails.logger.debug "Attr: #{attribute}, Value: #{value}"
+          
+          parts = attribute.to_s.split('.')
+          if parts[1].blank?
+            self.where(attribute => value)
+          else
+            if association = self.reflect_on_association(parts[0].to_sym)          
+              self.includes(association.name)
+              .where(association.table_name => {parts[1] => value})
+            else
+              raise "Association '#{parts[0]}' not found on #{self.name}"
+            end
+          end
+        end
+      
+        # Extends ActiveModel::Translation#human_attribute_name to use Gricer's extended attribute names.
+        #
+        # @param attribute [String, Symbol] Attribute name to get human name for. You can use gricers extended attribute names. 
+        # @param options [Hash] See ActiveModel::Translation for possible options.
+        # @return [String]
+        def human_attribute_name(attribute, options = {})
+          parts = attribute.to_s.split('.')
+          if parts[1].blank?
+            super attribute, options
+          else
+            if association = self.reflect_on_association(parts[0].to_sym)
+              association.active_record.human_attribute_name parts[1], options
+            else
+              parts[1].to_s.humanize
+            end
+          end
+          
+        end
+        
+        # Return hash for values of an attribute within the given time
+        #
+        #
+        # @example Get agent.name statistics for 2011-07-05 08:00 until 2011-07-06 08:00
+        #   Gricer::Request.stat('agent.name', '2011-07-05 08:00', '2011-07-06 08:00')
+        # @example Get agent.engine_version statistics for agents with engine_name = 'Presto' and values between 2011-07-05 08:00 and last hour with values in 15 minutes steps
+        #   Gricer::Request.where('gricer_agents.engine_name = ?', 'Presto').stat('agent.engine_version', '2011-07-05 08:00', Time.now - 1.hour, 15.minutes)
+        #
+        # @param attribute [String, Symbol] Attribute name to get data for. You can use gricers extended attribute names. 
+        # @param from [Date, Time] Only get records on or after this point of time
+        # @param thru [Date, Time] Only get records before this point of time
+        # @param step [Integer] Time interval for grouping values
+        # @return [Hash]
+        def stat(attribute, from, thru, step = 1.hour)
+          query = self.grouped_by(attribute)
+          
+          from = from.to_date.to_time
+          thru = thru.to_date.to_time+1.day
+
+          now = from
+
+          stats = {}
+
+          while now < thru do
+            self.between(now, now + step).count_by(attribute).each do |value|
+              stats[value[0]] ||= []
+              stats[value[0]] << [now.to_i*1000, value[1]]
+            end
+            now += step
+          end
+        
+          return stats
+        end
+      end
+    end
+  end
+end