wackamole 0.0.9 → 0.1.2

data/lib/wackamole/models/feature.rb

@@ -19,7 +19,7 @@ module Wackamole
     # ---------------------------------------------------------------------------
     # Paginate top features
     def self.paginate_tops( conds, page=1, page_size=default_page_size )
-      tops = logs_cltn.group( [:fid], conds, { :count => 0 }, 'function(obj,prev) { prev.count += 1}', true )
+      tops = logs_cltn.group( [:fid], conds, { :count => 0 }, 'function(obj,prev) { prev.count += 1}' )
     
       all_features = features_cltn.find( {}, :fields => [:_id] )
       feature_ids  = all_features.map{ |f| f['_id'] }

data/lib/wackamole/models/log.rb

@@ -13,8 +13,7 @@ module Wackamole
   
     # ---------------------------------------------------------------------------
     # Fetch all logs matching the given condition
-    def self.paginate( conds, page=1, page_size=default_page_size )
-puts conds.inspect      
+    def self.paginate( conds, page=1, page_size=default_page_size )      
       matching = logs_cltn.find( conds )    
       WillPaginate::Collection.create( page, page_size, matching.count ) do |pager|
         pager.replace( logs_cltn.find( conds, 

data/lib/wackamole/models/mission.rb

@@ -7,60 +7,63 @@ module Wackamole
     # -----------------------------------------------------------------------
     # Pick up moled application pulse
     def self.pulse( last_tick )
-      count_to_date   = count_logs
-      count_today     = count_logs( last_tick, true )
-      count_last_tick = count_logs( last_tick )
-      { :to_date => count_to_date, :today => count_today, :last_tick => count_last_tick }      
-    end
-    
-    # -----------------------------------------------------------------------      
-    # generates mole logs conditons
-    def self.gen_conds( now, single_day )      
-      conds = {}
-      if now
-        if single_day
-          conds = SearchFilter.time_conds( now, 1 )
-        else
-          now = now.clone.utc
-          date_id     = now.to_date_id.to_s
-          time_id     = now.to_time_id
-          conds[:did] = { '$gte' => date_id }
-          conds[:tid] = { '$gte' => time_id }
+      zones = {}
+      Wackamole::Control.zones.each do |zone|
+        zones[zone] = {}
+        Wackamole::Control.mole_databases( zone ).each do |db_name|
+          db            = Wackamole::Control.db( zone, db_name )
+          app_name, env = Wackamole::Control.extract_app_info( db_name )
+          logs_cltn     = db['logs']
+          
+          zones[zone][app_name] = {} unless zones[zone][app_name]
+          zones[zone][app_name][env] = {} unless zones[zone][app_name][env]
+          
+          zones[zone][app_name][env][:to_date]   = count_logs( logs_cltn )
+          zones[zone][app_name][env][:today]     = count_logs( logs_cltn, last_tick, true )
+          zones[zone][app_name][env][:last_tick] = count_logs( logs_cltn, last_tick )
         end
       end
-      conds
+      zones
     end
-    
-    # -----------------------------------------------------------------------
-    # Compute mole counts for each moled apps
-    def self.count_logs( now=nil, single_day=false )
-      counts = {}
-      conds  = gen_conds( now, single_day )
+          
+    # =========================================================================
+    private
 
-      Wackamole::Control.mole_databases.each do |db_name|
-        db            = Wackamole::Control.db( db_name )
-        app_name, env = Wackamole::Control.extract_app_info( db_name )
-        logs_cltn     = db['logs']
-        
-        totals = { Rackamole.feature => 0, Rackamole.perf => 0, Rackamole.fault => 0 }
-        if counts[app_name]
-          counts[app_name][env] = totals
-        else
-          counts[app_name] = { env => totals }
-        end
-        row = counts[app_name][env]
+      # -----------------------------------------------------------------------
+      # Compute mole counts for each moled apps
+      def self.count_logs( logs_cltn, now=nil, single_day=false )
+        conds  = gen_conds( now, single_day )
+# puts conds.inspect        
+        totals = { 
+          Rackamole.feature => 0, 
+          Rackamole.perf    => 0, 
+          Rackamole.fault   => 0 
+        }        
         [Rackamole.feature, Rackamole.perf, Rackamole.fault].each do |t|
           conds[:typ] = t
-          logs  = logs_cltn.find( conds, :fields => [:_id] )
-          row[t] = logs.count
+          totals[t] = logs_cltn.find( conds, :fields => [:_id] ).count
         end
+        totals
       end
-      counts
-    end
-      
-    # =========================================================================
-    private
-
+    
+      # -----------------------------------------------------------------------      
+      # generates mole logs conditons
+      def self.gen_conds( now, single_day )      
+        conds = {}
+        if now
+          if single_day
+            conds = SearchFilter.time_conds( now, 0 )
+          else
+            now = now.clone.utc
+            date_id     = now.to_date_id.to_s
+            time_id     = now.to_time_id
+            conds[:did] = { '$gte' => date_id }
+            conds[:tid] = { '$gte' => time_id }
+          end
+        end
+        conds
+      end
+    
       # -----------------------------------------------------------------------
       # Map rackamole types to report types  
       def self.to_type_name( type )

data/lib/wackamole/models/mole_info.rb

@@ -9,7 +9,6 @@ module Wackamole
                             
     # ---------------------------------------------------------------------------
     # Collect various data points to power up dashboard 
-    # TODO - PERF - try just using cursor vs to_a
     def self.collect_dashboard_info( now )    
       info    = {}
       
@@ -20,13 +19,12 @@ module Wackamole
         
       # Fetch day logs          
       utc_time = now.clone.utc
-puts utc_time      
       conds = SearchFilter.time_conds( now, 0 )
+# puts conds.inspect      
       day_logs = logs_cltn.find( conds, 
         :fields => [:typ, :fid, :tid, :did, :uid], 
         :sort => [ [:tid => Mongo::ASCENDING] ] )
-puts conds.inspect
-puts day_logs.count
+# puts "Found logs #{day_logs.count}"        
       # Count all logs per hourly time period
       users         = Set.new
       features      = Set.new
@@ -36,7 +34,8 @@ puts day_logs.count
       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        
+        time_tokens = log['tid'].match( /(\d{2})(\d{2})(\d{2})/ ).captures
+# puts "#{log['did']} - #{log['tid']} - #{log['uid']}"
         log_utc     = Time.utc( date_tokens[0], date_tokens[1], date_tokens[2], time_tokens[0], time_tokens[1], time_tokens[2] )
         local       = log_utc.clone.localtime
         hour        = local.hour

data/lib/wackamole/models/search_filter.rb

@@ -141,7 +141,7 @@ module Wackamole
         to_utc   = Time.local( local_now.year, local_now.month, local_now.day, 23, 59, 59 ).utc
 
         from_date_id = from_utc.to_date_id.to_s
-        to_date_id   = to_utc.to_date_id.to_s          
+        to_date_id   = to_utc.to_date_id.to_s
         
         if from_date_id != to_date_id
           from_time_id = from_utc.to_time_id.to_s
@@ -151,7 +151,7 @@ module Wackamole
           conds[:did] = to_date_id
         end
       else
-        date         = Chronic.parse( "#{days == 1 ? "now" : "#{days} days ago"}" )
+        date         = Chronic.parse( "#{days == 0 ? "now" : "#{days} days ago"}" )
         current      = "%4d/%02d/%02d %02d:%02d:%02d" % [date.year, date.month, date.day, current_hour, 0, 1]
         time         = Chronic.parse( current ).utc
         conds[:did]  = { '$gte' => time.to_date_id.to_s }         

data/lib/wackamole/models/user.rb

@@ -12,7 +12,7 @@ module Wackamole
     # ---------------------------------------------------------------------------
     # 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 )    
+      tops = logs_cltn.group( [:uid], conds, { :count => 0 }, 'function(obj,prev) { prev.count += 1}' )    
       users = []
       tops.sort{ |a,b| b['count'] <=> a['count'] }.each do |row|
         users << { :uid => row['uid'], :total => row['count'].to_i, :details => [] }

data/public/stylesheets/wackamole.css

@@ -32,6 +32,17 @@ div#logo {
   margin-bottom: 5px;
 }
 
+span#version {
+  position:    relative;
+  top:        -12px;
+  left:        32px;
+  font-weight: bold;
+  color:       #316071;
+}
+a.logout {
+  font-size: 0.8em;
+}
+
 div#main {
   clear:      both;
   margin:     40px 10px 10px 20px;
@@ -63,6 +74,17 @@ div#navigation {
   background: #c1c1c1 url(../images/fade.png) repeat-x;  
 }
 
+a.nav_link {
+  color:           #646464;
+  font-weight:     bold;  
+  text-decoration: none;
+}
+a.nav_link:hover {
+  color        : #1779ff;
+  border-bottom: 1px #1779ff solid;
+  text-decoration: none;  
+}
+
 a.site_link {
   color:           #646464;
   font-weight:     bold;
@@ -80,26 +102,31 @@ a.current {
   border-bottom: 5px #646464 solid;
 }
 
-div#app_info {
+div#links {
   text-align: right;  
-  font-size:  2em;
 }
-div#app_info li {
-  color:#3968ff;
+div#links p {
+  text-align: right;
+  margin-top: 5px;  
 }
-div#app_info li span {
-  color:#666;
+span#timestamp {
 }
-div#app_info li#env {
-  color:        #c1c1c1;
-  font-size:    0.5em;
-  font-style:   italic;
+
+ul#app_info {
+  font-size:  1.5em;
+  margin-top: 10px;
 }
-div#app_info p {
-  text-align: right;
-  font-size:  1.0em;
+ul#app_info li {
 }
-span#timestamp {
+ul#app_info span.zone {
+  color:     #fe9500;
+}
+ul#app_info span.app {
+  color:      #666;
+}
+ul#app_info span.stage {
+  color:        #a1bf6d;
+  font-style:   italic;
 }
 
 #header {

data/spec/config/test.yml

@@ -1,3 +1,4 @@
-test:
-  host: localhost
-  port: 27099
+zones:
+  test:
+    host: localhost
+    port: 27099

data/spec/data/fixtures.rb

@@ -1,92 +1,92 @@
-require 'rackamole'
-
-class Fixtures
-
-  def self.test_time_id() @test_time ||= 20100101; end
-  
-  def self.load_data
-    puts "Loading fixture data..."    
-    Wackamole::Control.init_config( File.join(File.dirname(__FILE__), %w[.. config test.yml]), 'test' )
-    load_test_dbs
-    load_bogus_dbs
-  end
-
-  def self.load_test_dbs
-    con = Wackamole::Control.connection
-    %w[development test production].each{ |env| create_valid_mole_db( con, "fred", env) }
-  end
-  
-  def self.load_bogus_dbs
-    con = Wackamole::Control.connection
-    %w[mole_blee_mdb zorg_blee_dev_mdb].each do |db_name|
-      create_db( con, db_name )
-    end
-    # create mole db with wrong cltns
-    # BOZO !! An empty db does not show up?
-    db = create_db( con, "mole_zorg_wrong_mdb" )
-    %w[features1 logs1 users1].each { |cltn| db.drop_collection( cltn );db.create_collection( cltn ) }  
-    # missing cltn
-    db = create_db( con, "mole_zorg_missing_mdb" )
-    %w[features logs].each { |cltn| db.drop_collection( cltn );db.create_collection( cltn ) }
-  end
-
-  def self.create_db( con, db_name )
-    # if con.database_names.include?( db_name )
-    #   con.drop_database( db_name )
-    # end  
-    con.db( db_name, :strict => true )  
-  end
-
-  def self.create_valid_mole_db( con, app_name, env )
-    db_name = "mole_#{app_name}_#{env}_mdb"  
-    db = create_db( con, db_name )
-    %w[users features logs].each do |cltn_name|
-      db.drop_collection( cltn_name )
-      cltn = db.create_collection( cltn_name ) # :capped => false, :size => 1_000_000, :limit => 100 )
-      case cltn_name
-        when 'users'    : populate_users( cltn, app_name, env )      
-        when 'features' : populate_features( cltn, app_name, env )
-        when 'logs'     : populate_logs( cltn, app_name, env )
-      end
-    end
-  end
-
-  def self.populate_users( cltn, app_name, env )
-    10.times do |i|
-      cltn.insert( { :una => "blee_#{i}@#{app_name}.#{env}", :did => test_time_id.to_s } )
-    end
-  end
-
-  def self.populate_features( cltn, app_name, env )
-    10.times do |i|
-      cltn.insert( { :env => env, :app => app_name, :did => test_time_id.to_s, :ctx => "feature_#{i}" } )
-    end
-  end
-
-  def self.populate_logs( cltn, app_name, env )
-    features = cltn.db['features'].find( {} ).to_a
-    users   = cltn.db['users'].find( {} ).to_a
-    [Rackamole.feature, Rackamole.perf, Rackamole.fault].each do |type|
-      5.times do |i|
-        cltn.insert({ 
-          :typ => type, 
-          :fid => features[i]['_id'], 
-          :uid => users[i]['_id'], 
-          :did => test_time_id.to_s, 
-          :tid => "070000",      
-          :ip  => "127.0.0.#{i}" 
-        })
-      end
-      2.times do |i|    
-        cltn.insert({ 
-          :typ => type, 
-          :fid => features[5+i]['_id'], 
-          :uid => users[5+i]['_id'], 
-          :did => test_time_id.to_s, 
-          :tid => "080000",      
-          :ip  => "127.0.0.#{i}" 
-        })    
-      end
-    end
-  end  
-end
+# require 'rackamole'
+# 
+# class Fixtures
+# 
+#   def self.test_time_id() @test_time ||= 20100101; end
+#   
+#   def self.load_data
+#     puts "Loading fixture data..."    
+#     Wackamole::Control.init_config( File.join(File.dirname(__FILE__), %w[.. config test.yml]), 'test' )
+#     load_test_dbs
+#     load_bogus_dbs
+#   end
+# 
+#   def self.load_test_dbs
+#     con = Wackamole::Control.connection( 'test' )
+#     %w[development test production].each{ |env| create_valid_mole_db( con, "fred", env) }
+#   end
+#   
+#   def self.load_bogus_dbs
+#     con = Wackamole::Control.connection( 'test' )
+#     %w[mole_blee_mdb zorg_blee_dev_mdb].each do |db_name|
+#       create_db( con, db_name )
+#     end
+#     # create mole db with wrong cltns
+#     # BOZO !! An empty db does not show up?
+#     db = create_db( con, "mole_zorg_wrong_mdb" )
+#     %w[features1 logs1 users1].each { |cltn| db.drop_collection( cltn );db.create_collection( cltn ) }  
+#     # missing cltn
+#     db = create_db( con, "mole_zorg_missing_mdb" )
+#     %w[features logs].each { |cltn| db.drop_collection( cltn );db.create_collection( cltn ) }
+#   end
+# 
+#   def self.create_db( con, db_name )
+#     # if con.database_names.include?( db_name )
+#     #   con.drop_database( db_name )
+#     # end  
+#     con.db( db_name, :strict => true )  
+#   end
+# 
+#   def self.create_valid_mole_db( con, app_name, env )
+#     db_name = "mole_#{app_name}_#{env}_mdb"  
+#     db = create_db( con, db_name )
+#     %w[users features logs].each do |cltn_name|
+#       db.drop_collection( cltn_name )
+#       cltn = db.create_collection( cltn_name ) # :capped => false, :size => 1_000_000, :limit => 100 )
+#       case cltn_name
+#         when 'users'    : populate_users( cltn, app_name, env )      
+#         when 'features' : populate_features( cltn, app_name, env )
+#         when 'logs'     : populate_logs( cltn, app_name, env )
+#       end
+#     end
+#   end
+# 
+#   def self.populate_users( cltn, app_name, env )
+#     10.times do |i|
+#       cltn.insert( { :una => "blee_#{i}@#{app_name}.#{env}", :did => test_time_id.to_s } )
+#     end
+#   end
+# 
+#   def self.populate_features( cltn, app_name, env )
+#     10.times do |i|
+#       cltn.insert( { :env => env, :app => app_name, :did => test_time_id.to_s, :ctx => "feature_#{i}" } )
+#     end
+#   end
+# 
+#   def self.populate_logs( cltn, app_name, env )
+#     features = cltn.db['features'].find( {} ).to_a
+#     users   = cltn.db['users'].find( {} ).to_a
+#     [Rackamole.feature, Rackamole.perf, Rackamole.fault].each do |type|
+#       5.times do |i|
+#         cltn.insert({ 
+#           :typ => type, 
+#           :fid => features[i]['_id'], 
+#           :uid => users[i]['_id'], 
+#           :did => test_time_id.to_s, 
+#           :tid => "070000",      
+#           :ip  => "127.0.0.#{i}" 
+#         })
+#       end
+#       2.times do |i|    
+#         cltn.insert({ 
+#           :typ => type, 
+#           :fid => features[5+i]['_id'], 
+#           :uid => users[5+i]['_id'], 
+#           :did => test_time_id.to_s, 
+#           :tid => "080000",      
+#           :ip  => "127.0.0.#{i}" 
+#         })    
+#       end
+#     end
+#   end  
+# end