wackamole 0.0.1

data/lib/wackamole/models/mole_info.rb

@@ -0,0 +1,94 @@
+require 'benchmark'
+
+module Wackamole
+  class MoledInfo
+  
+    def self.logs_cltn()     Wackamole::Control.collection( 'logs' ) ;  end
+    def self.users_cltn()    Wackamole::Control.collection( 'users' );  end
+    def self.features_cltn() Wackamole::Control.collection( 'features' );  end  
+                            
+    # ---------------------------------------------------------------------------
+    # Collect various data points to power up dashboard 
+    # TODO - PERF - try just using cursor vs to_a
+    def self.collect_dashboard_info( now )    
+      info    = {}
+      day_logs = logs_cltn.find( { :did => now.to_date_id.to_s }, :fields => [:typ, :fid, :tid, :did, :uid] ).to_a
+        
+      # Fetch user count for this hour
+      users = day_logs.inject( Set.new ) do |set,log| 
+        set << log['uid'] if log['tid'] =~ /^#{"%02d" % now.hour}/
+        set
+      end
+      info[:total_users] = users_cltn.count
+      info[:user_load]   = users.size
+
+      # Fetch features for this hour    
+      features = day_logs.inject( Set.new ) do |set,log| 
+        set << log['fid'].to_s if log['tid'] =~ /^#{"%02d" % now.hour}/
+        set 
+      end
+      info[:total_features] = features_cltn.count
+      info[:feature_load]   = features.size
+    
+      info[:perf_load] = day_logs.inject(0) do |count,log| 
+        if log['tid'] =~ /^#{"%02d" % now.hour}/
+          count += (log['typ'] == Rackamole.perf ? 1 : 0 ) 
+        end
+        count
+      end
+      info[:fault_load] = day_logs.inject(0) do |count,log| 
+        if log['tid'] =~ /^#{"%02d" % now.hour}/
+          count += (log['typ'] == Rackamole.fault ? 1 : 0 ) 
+        end
+        count
+      end
+    
+      # Count all logs per hourly time period
+      times         = (0...24).to_a
+      time_info     = times.inject(OrderedHash.new) { |res,time| res[time] = { :user => 0, :feature => 0, :perf => 0, :fault => 0 };res }    
+      user_per_hour = {}
+      day_logs.each do |log|
+        date_tokens = log['did'].match( /(\d{4})(\d{2})(\d{2})/ ).captures
+        time_tokens = log['tid'].match( /(\d{2})(\d{2})(\d{2})/ ).captures    
+        utc         = Time.utc( date_tokens[0], date_tokens[1], date_tokens[2], time_tokens[0], time_tokens[1], time_tokens[2] )
+        time        = utc.getlocal.hour
+        if user_per_hour[time]
+          unless user_per_hour[time].include? log['uid']
+            time_info[time][:user] += 1
+            user_per_hour[time] << log['uid']
+          end
+        else
+          user_per_hour[time] = [ log['uid'] ]
+          time_info[time][:user] += 1
+        end
+        case log['typ']
+          when Rackamole.feature : time_info[time][:feature] += 1 if features.add?( log['fid'])
+          when Rackamole.perf    : time_info[time][:perf]    += 1
+          when Rackamole.fault   : time_info[time][:fault]   += 1
+        end
+      end
+        
+      # BOZO !! LAME ASS...
+      info[:user_series]    = []
+      info[:fault_series]   = []
+      info[:perf_series]    = []
+      info[:feature_series] = []
+      time_info.values.map do |hash| 
+        info[:user_series]    << hash[:user]
+        info[:fault_series]   << hash[:fault]
+        info[:perf_series]    << hash[:perf]
+        info[:feature_series] << hash[:feature]
+      end
+      info
+    end  
+        
+    # ===========================================================================
+    private
+        
+      # -------------------------------------------------------------------------
+      # Makes sure we have some indexes set
+      # BOZO !! Create script to set these up ?
+      def self.ensure_indexes
+      end
+  end
+end

data/lib/wackamole/models/search_filter.rb

@@ -0,0 +1,192 @@
+require 'chronic'
+
+module Wackamole
+  class SearchFilter
+  
+    attr_accessor :time_frame, :feature_id, :type, :browser_type, :search_terms
+
+    # ---------------------------------------------------------------------------
+    # Ctor
+    def initialize
+      reset!
+    end
+
+    # ---------------------------------------------------------------------------
+    # Reset filter to defaults
+    def reset!
+      @feature_id   = -1
+      @time_frame   = SearchFilter.time_frames.first
+      @browser_type = SearchFilter.browser_types.first
+      @type         = SearchFilter.mole_types.first
+      @search_terms = ""
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Available browsers
+    def self.browser_types
+      @browsers ||= [ 'All', 'Unknown', 'Firefox', 'Safari', 'MSIE 8.0', 'MSIE 7.0', 'MSIE 6.0', 'Opera', 'Chrome' ] 
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Available time frames
+    def self.time_frames
+      @time_frames ||= ['today', '2 days', '1 week', '2 weeks', '1 month', '3 months', '6 months', '1 year' ]
+    end
+
+    # ---------------------------------------------------------------------------
+    # Collection of mole types
+    def self.mole_types
+      @types ||= %w[All Feature Perf Fault]
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Find all features  
+    def features
+      features = Feature.features_cltn.find().to_a
+      features = features.map { |f| [context_for(f), f['_id']] } 
+      features.sort! { |a,b| a.first <=> b.first }
+      features.insert( 0, ["All", -1] )
+    end
+
+    # ---------------------------------------------------------------------------
+    # Retrieves feature context
+    def context_for( f )
+      return "#{f['ctl']}##{f['act']}" if f['ctl']
+      f['ctx']
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Fetch filter start date id
+    def from_date_id
+      start = Chronic.parse( time_frame + ( time_frame == SearchFilter.time_frames.first ? "" : " ago" ) )
+      start.to_date_id
+    end
+
+    # ---------------------------------------------------------------------------
+    # fetch time series from time frame
+    def time_ids
+      now          = Time.now
+      start        = Chronic.parse( time_frame + ( time_frame == SearchFilter.time_frames.first ? "" : " ago" ) )
+      corpus_end   = DateTime.new( now.year, now.month, now.day )
+      corpus_start = DateTime.new( start.year, start.month, start.day )
+    
+      calc_date   = corpus_start
+      time_series = []  
+      while calc_date <= corpus_end do   
+        time_series << calc_date.to_date_id
+        calc_date += 1
+      end     
+      time_series
+    end                  
+  
+    # ---------------------------------------------------------------------------
+    # fetch time series from time frame
+    def time_series    
+      now          = Time.now
+      start        = Chronic.parse( time_frame + ( time_frame == SearchFilter.time_frames.first ? "" : " ago" ) )
+      corpus_end   = DateTime.new( now.year, now.month, now.day )
+      corpus_start = DateTime.new( start.year, start.month, start.day )
+    
+      calc_date   = corpus_start
+      time_series = []  
+      while calc_date <= corpus_end do   
+        time_series << calc_date.strftime( "%Y-%m-%d" )
+        calc_date += 1
+      end     
+      time_series
+    end                  
+        
+    # ---------------------------------------------------------------------------
+    # Populate filter from request params
+    def from_options( options )
+      return unless options
+      options.each_pair do |k,v|
+        # value = k.index( /_id$/) ? v.to_i : v
+        self.send( "#{k}=", v )
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Spews filter conditions
+    def to_conds
+      conds = {}
+    
+      # filter mole_types
+      if type != 'All'
+        conds[:typ] = map_mole_type( type )
+      end
+    
+      if browser_type != 'All'
+        conds[:bro] = browser_type
+      end
+    
+      # filter mole_features
+      unless feature_id.to_s == "-1"
+        conds[:fid] = Mongo::ObjectID.from_string( feature_id )
+      end
+                    
+      # filter by date
+      time = Chronic.parse( time_frame + ( time_frame == SearchFilter.time_frames.first ? "" : " ago" ) )
+      conds[:did] = { '$gte' => time.to_date_id.to_s }
+      
+      unless search_terms.empty?
+        tokens = search_terms.split( ":" ).collect{ |c| c.strip }
+        key    = tokens.shift
+        if key
+          if key == "user"
+            users = Wackamole::User.users_cltn.find( { :una => Regexp.new( tokens.first ) }, :fields => ['_id'] )
+            conds[field_map( key )] = { '$in' => users.collect{ |u| u['_id'] } }
+          elsif tokens.size == 2
+            conds["#{field_map(key)}.#{tokens.first}"] = Regexp.new( tokens.last )
+          elsif tokens.size == 1
+            conds[field_map(key)] = Regexp.new( tokens.first )
+          else
+            raise "Unable to evaluate search terms"
+          end
+        end
+      end
+      conds
+    end
+    
+    # ===========================================================================
+    private
+  
+      # ---------------------------------------------------------------------------
+      # Search filter key name map
+      def field_map( key )
+        case key.to_sym
+          when :user    : :uid
+          when :method  : :met
+          when :host    : :hos
+          when :session : :ses
+          when :params  : :par
+          else            key
+        end
+      end
+  
+      # Map named type to fixnum value
+      def map_mole_type( type )
+        case type
+          when 'Feature' 
+            Rackamole.feature
+          when 'Perf'   
+            Rackamole.perf
+          when 'Fault'  
+            Rackamole.fault
+          else         
+            raise "Invalid mole type `#{type}"
+        end
+      end
+    
+      # ---------------------------------------------------------------------------
+      # Zeroed out now
+      def now
+        to_zero_hour( Time.now )
+      end
+  
+      # Zeros out time info
+      def to_zero_hour( time )
+        Time.gm( time.year, time.month, time.day, 0, 0, 0 )
+      end
+  end
+end

data/lib/wackamole/models/user.rb

@@ -0,0 +1,46 @@
+require 'will_paginate/collection'
+
+module Wackamole
+  class User
+  
+    def self.logs_cltn()  Wackamole::Control.collection( 'logs' ) ;  end  
+    def self.users_cltn() Wackamole::Control.collection( 'users' );  end
+  
+    # Pagination size
+    def self.default_page_size() @page_size ||= 20; end
+  
+    # ---------------------------------------------------------------------------
+    # Find all users matching criteria and returns pagination collection
+    def self.paginate_tops( conds, page=1, page_size=default_page_size )
+      tops = logs_cltn.group( [:uid], conds, { :count => 0 }, 'function(obj,prev) { prev.count += 1}', true )    
+      users = []
+      tops.sort{ |a,b| b['count'] <=> a['count'] }.each do |row|
+        users << { :uid => row['uid'], :total => row['count'].to_i, :details => [] }
+      end
+    
+      WillPaginate::Collection.create( page, page_size, users.size ) do |pager|      
+        offset = (page-1)*page_size
+        result = users[offset...(offset+page_size)]
+        result.each do |u|
+          user = users_cltn.find_one( u[:uid] ) #, :fields => [:una] )
+          raise "Unable to find user with id `#{u[:uid].inspect}" unless user
+          u[:name] = user['una']
+        end
+        pager.replace( result )
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Make sure indexes are setup for users
+    def self.ensure_indexes!
+      indexes       = users_cltn.index_information
+      created_count = 0
+      
+      unless indexes.has_key?( :una )
+        users_cltn.create_index( :una )
+        created_count += 1
+      end
+      created_count
+    end
+  end
+end

data/public/javascripts/application.js

@@ -0,0 +1,28 @@
+function truncate(str, limit) 
+{
+  var bits, i;
+  bits = str.split('');
+  if (bits.length > limit) {
+    for (i = bits.length - 1; i > -1; --i) {
+      if (i > limit) {
+        bits.length = i;
+      }
+      else if (' ' === bits[i]) {
+        bits.length = i;
+        break;
+      }
+    }
+    bits.push('...');
+  }
+  return bits.join('');
+}
+
+
+function blee( url )
+{
+  if( url == "/explore")
+    window.location = url;
+  else
+    $.ajax( {url: url, dataType: 'script', method: 'GET'} );
+  return false;
+}