wackamole 0.0.3 → 0.0.4

data/Rakefile

@@ -37,6 +37,7 @@ depend_on "mongo_rack"            , ">= 0.0.1"
 depend_on "main"                  , ">= 4.2.0"
 depend_on "sinatra"               , ">= 0.9.4"
 depend_on "mongo_rack"            , ">= 0.0.3"
+depend_on "rackamole"             , ">= 0.0.3"
 
 # Rake
 task :default => ['fixtures:load','spec:run']

data/bin/setup_indexes

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'main'
+require 'mongo'
+require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib wackamole]))
+
+Main {  
+  option('reset', 'r') {
+    default     false
+    description "Reset all indexes"    
+  }
+
+  option('set', 's') {
+    default     false
+    description "Set all indexes"    
+  }
+
+  option('clear', 'c') {
+    default     false
+    description "Clear all indexes"    
+  }
+
+  option( 'verbose', 'v') {
+    default     false
+    description "Show verbose information"    
+  }
+  
+  environment( 'WACKAMOLE_ENV' ) {
+    default 'production'
+    description 'Wackamole env to choose from in landscape yml'
+  }
+      
+  # Enter main loop  
+  def run    
+    config_file = File.join( ENV['HOME'], %w[.wackamole wackamole.yml] )
+    Wackamole::Control.init_config( config_file, params['WACKAMOLE_ENV'].value )
+    Wackamole::Control.ensure_indexes!( 
+      params[:set].value, 
+      params[:reset].value, 
+      params[:verbose].value, 
+      params[:clear].value 
+    )
+  end
+}

data/bin/wackamole

@@ -9,8 +9,10 @@ Main {
     validate    { |pool| pool =~ URI_MATCH }
     description "specify session server uri. Must be of the form {[mongo|memcache]}://{host}:{port}/{[database_name|namespace]}[/{collection_name}]"
   }
-  environment( 'RACK_ENV' ) {
+  option( 'environment', 'e' ) {
+    argument :required
     default 'production'
+    description 'Specifies the env to run wackamole in'
   }
   
   @@options = {}
@@ -18,9 +20,9 @@ Main {
   # Enter main loop  
   def run
     require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib wackamole]))
-    
+        
     @@options = parse_args( params[:pool].value )
-    ENV['RACK_ENV'] = params['RACK_ENV'].value
+    ENV['RACK_ENV'] = params['environment'].value
     
     Thread.new do 
       puts "-"*100
@@ -33,19 +35,19 @@ Main {
       puts "\n"*2  
       puts ">>> Opening console..."
       puts "\n"*2
-      open( "http://localhost:#{default_port}/mission" )
+      open( "http://localhost:#{default_port}" )
     end
     
     # Clearing args for franky!
     ARGV.clear
     require 'sinatra'    
     require File.join(File.dirname(__FILE__), %w[.. lib app.rb])
-    Sinatra::Application.run! :port => default_port, :environment => 'production'
+    Sinatra::Application.run! :port => default_port, :environment => params['environment'].value
   end
   
   # default wackamole port
   def default_port() 7777; end
-  
+
   # sleepy time...
   def sleep_time() 3; end
   

data/config.ru

@@ -0,0 +1,18 @@
+#------------
+# Wackamole Sessions Options
+# 
+# @@options defines where Wackamole puts its sessions, which can be either mongo or memcache
+# if @@options is not defined mongo at localhost:27017 is used
+#
+# For customized sessions with Mongo uncomment and modify this line:
+# @@options={:protocol=>"mongo", :host=>"localhost", :port=>"11211", :db_name=>"wackamole_session", :cltn_name=>"sessions"}
+#
+# For Memcache session uncomment and modify this line:
+# @@options={:protocol=>"memcached", :host=>"localhost", :port=>"11211", :namespace=>"wackamole_session"}
+#
+#------------
+
+require 'rubygems'                                                                             
+require 'sinatra'                                                                              
+require File.join(File.dirname(__FILE__), %w[lib app.rb])                                      
+run Sinatra::Application

data/lib/app.rb

@@ -24,6 +24,7 @@ end
 
 configure do
   set :sessions, false
+  set :logging,  true
     
   Wackamole.load_all_libs_relative_to(__FILE__, 'helpers' )
   Wackamole.load_all_libs_relative_to(__FILE__, 'controllers' )
@@ -32,7 +33,8 @@ configure do
   if defined? @@options and @@options
     if @@options[:protocol] == 'mongo'
       use Rack::Session::Mongo, 
-        :server => "%s:%d/%s/%s" % [@@options[:host], @@options[:port], @@options[:db_name], @@options[:cltn_name]]
+        :server    => "%s:%d/%s/%s" % [@@options[:host], @@options[:port], @@options[:db_name], @@options[:cltn_name]],
+        :log_level => :debug
     else
       use Rack::Session::Memcache, 
         :memcache_server => "%s:%d" % [@@options[:host], @@options[:port]],
@@ -40,7 +42,9 @@ configure do
     end
   else
     # Default is a mongo session store
-    use Rack::Session::Mongo, :server => "%s:%d/%s/%s" % ['localhost', '27017', 'wackamole_ses', 'sessions']
+    use Rack::Session::Mongo, 
+      :server => "%s:%d/%s/%s" % ['localhost', '27017', 'wackamole_ses', 'sessions'],
+      :log_level => :error
   end  
   set :con, Wackamole::Control.init_config( default_config, Sinatra::Application.environment.to_s )
 end
@@ -55,13 +59,12 @@ before do
       session[:filter] = @filter
     end
     @updated_on   = Time.now
-    @refresh_rate = 60
-    
+    @refresh_rate = 30
     @app_info     = session[:app_info]
     begin
       Wackamole::Control.switch_mole_db!( @app_info[:app_name].downcase, @app_info[:stage] ) if @app_info
     rescue => boom
-puts boom      
+      $stderr.puts boom      
       @app_info          = nil
       session[:app_info] = nil
     end

data/lib/controllers/dashboard.rb

@@ -8,7 +8,6 @@ module Dashboard
   get '/dashboard/:app_name/:stage' do    
     Wackamole::Control.switch_mole_db!( params[:app_name].downcase, params[:stage] )
     
-    ensure_indexes!
     load_app_details
 
     # Reset app info
@@ -27,4 +26,17 @@ module Dashboard
     erb :'dashboard/refresh_js', :layout => false
   end
   
+  # ---------------------------------------------------------------------------  
+  get '/dashboard/logs/:app_name/:stage/:type' do
+    Wackamole::Control.switch_mole_db!( params[:app_name].downcase, params[:stage] )
+    load_app_details
+    load_app_info
+    
+    filter = Wackamole::SearchFilter.new
+    filter.mole_type( params[:type].to_i )
+puts "SETTING FILTER", filter.inspect    
+    session[:filter] = filter
+    redirect '/logs/1'
+  end
+  
 end

data/lib/controllers/features.rb

@@ -5,6 +5,8 @@ module Features
   get "/features/:page" do
     page = params[:page] ? params[:page].to_i : 1
         
+puts @filter.inspect
+        
     @features    = Wackamole::Feature.paginate_tops( @filter.to_conds, page )   
     @search_path = "/features/search"
     @filter_path = "/features/filter"
@@ -35,6 +37,8 @@ module Features
   # Filter
   post "/features/filter" do
     @filter.from_options( params[:filter] )
+    session[:filter] = @filter
+puts "Setting #{session[:filter].inspect}"        
     @features = Wackamole::Feature.paginate_tops( @filter.to_conds )
     erb :"features/filter.js", :layout => false
   end  

data/lib/controllers/logs.rb

@@ -2,12 +2,11 @@ module Logs
   
   # ---------------------------------------------------------------------------
   get "/logs/:page" do    
-    page       = params[:page] ? params[:page].to_i : 1
-    
+    page         = params[:page] ? params[:page].to_i : 1        
     @logs        = Wackamole::Log.paginate( @filter.to_conds, page)   
     @search_path = "/logs/search"
     @filter_path = "/logs/filter"
-    
+      
     if request.xhr?
       erb :'logs/index.js', :layout => false
     else
@@ -43,7 +42,17 @@ module Logs
     @filter = Wackamole::SearchFilter.new
     @filter.from_options( params[:filter] )
     session[:filter] = @filter
-    @logs = Wackamole::Log.paginate( @filter.to_conds )
-    erb :"logs/filter.js", :layout => false
+    
+    # elapsed = Benchmark.realtime do
+      @logs = Wackamole::Log.paginate( @filter.to_conds )
+    # end
+    # puts "Filter logs %5.4f" % elapsed
+
+    out = nil
+    # elapsed = Benchmark.realtime do
+      out = erb :"logs/filter.js", :layout => false
+    # end
+    # puts "Render logs %5.4f" % elapsed
+    out  
   end  
 end

data/lib/controllers/mission.rb

@@ -1,27 +1,34 @@
 require 'chronic'
 
-module Mission  
-  
+module Mission
   # ---------------------------------------------------------------------------
-  get '/mission' do
+  get '/' do
     # reset app info
     session[:app_info] = @app_info = nil
+  
+    last_tick           = session[:last_tick]
+    last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
+    session[:last_tick] = Time.now
     
-    load_report
+    @pulse = Wackamole::Mission.pulse( last_tick.utc )
+        
     erb :'mission/index'
   end
   
   # ---------------------------------------------------------------------------
   get '/mission/refresh' do
-    load_report
+    last_tick           = session[:last_tick]
+    last_tick           ||= Chronic.parse( "#{@refresh_rate} seconds ago" )
+    session[:last_tick] = Time.now
+      
+    @pulse = Wackamole::Mission.pulse( last_tick.utc )
+
     erb :'/mission/refresh_js', :layout => false
   end
 
-  # ---------------------------------------------------------------------------
-  get '/mission/fixed/:app/:env/:type' do
-    Wackamole::Mission.reset!( params[:app], params[:env], params[:type] )    
-    load_report    
-    erb :'/mission/refresh_js', :layout => false
-  end  
-  
+  # # ---------------------------------------------------------------------------
+  # get '/mission/fixed/:app/:env/:type' do
+  #   Wackamole::Mission.reset!( params[:app], params[:env], params[:type] )
+  #   erb :'/mission/refresh_js', :layout => false
+  # end  
 end

data/lib/controllers/users.rb

@@ -5,7 +5,12 @@ module Users
   get "/users/:page" do
     page = params[:page] ? params[:page].to_i : 1
 
+puts "User filter", @filter.inspect
+elapsed = Benchmark.realtime do  
     @users       = Wackamole::User.paginate_tops( @filter.to_conds, page )   
+end
+puts "Find users %5.4f" % elapsed
+
     @search_path = "/users/search"
     @filter_path = "/users/filter"
    
@@ -35,6 +40,8 @@ module Users
   # Filter
   post "/users/filter" do    
     @filter.from_options( params[:filter] )
+    session[:filter] = @filter
+puts "Setting user filter #{session[:filter].inspect}"    
     @users = Wackamole::User.paginate_tops( @filter.to_conds )
     erb :"users/filter.js", :layout => false
   end  

data/lib/helpers/dashboard_helper.rb

@@ -2,13 +2,13 @@ module DashboardHelper
   
   helpers do    
     
-    # -------------------------------------------------------------------------
-    # Make sure all indexes are set
-    def ensure_indexes!
-      Wackamole::Log.ensure_indexes!
-      Wackamole::User.ensure_indexes!
-      Wackamole::Feature.ensure_indexes!      
-    end
+    # # -------------------------------------------------------------------------
+    # # Make sure all indexes are set
+    # def ensure_indexes!
+    #   Wackamole::Log.ensure_indexes!
+    #   Wackamole::User.ensure_indexes!
+    #   Wackamole::Feature.ensure_indexes!      
+    # end
     
     # -------------------------------------------------------------------------  
     # Retrieve moled app info...

data/lib/helpers/logs_helper.rb

@@ -2,18 +2,30 @@ module LogsHelper
   
   helpers do
     # ---------------------------------------------------------------------------
-    def user_name_for( user_id )
-      user = Wackamole::User.users_cltn.find_one( user_id )
-      user['una']
+    def user_name_for( ctx, user_id )
+      return ctx[user_id] if ctx[user_id]
+      user  = Wackamole::User.users_cltn.find_one( user_id, :fields => [:una] )
+      value = user['una']
+      ctx[user_id] = value
+      value
     end
 
     # ---------------------------------------------------------------------------
     # Find feature context for log entry
-    def context_for( feature_id )   
-      feature = Wackamole::Feature.features_cltn.find_one( feature_id )
-      return "Unknown" unless feature      
-      return "#{feature['ctl']}##{feature['act']}" if feature['ctl']
-      feature['ctx']
+    def context_for( ctx, feature_id )   
+      return ctx[feature_id] if ctx[feature_id]
+      feature = Wackamole::Feature.features_cltn.find_one( feature_id, :fields => [:ctl, :act, :ctx] )
+      if feature
+        if feature['ctl']
+          value = "#{feature['ctl']}##{feature['act']}" 
+        else
+          value = feature['ctx']
+        end
+      else
+        value = "Unknown"
+      end
+      ctx[feature_id] = value
+      value
     end
     
     # ---------------------------------------------------------------------------
@@ -97,10 +109,15 @@ module LogsHelper
   
     # ---------------------------------------------------------------------------
     # Setup browser icon indicator
-    def browser_icon( browser )
-      img_name = browser
-      img_name = "unknown_browser" if img_name.nil? or img_name == "N/A"
-      image_tag "browsers/#{img_name.to_s.downcase.gsub( /\\/, '')}.png", :size => "20x20"    
+    def browser_class( browser )
+      class_name = browser['name'].downcase
+      if class_name == 'msie'
+        version = browser['version'].match( /(\d)\.\d/ ).captures.first
+        class_name = "ie_#{version.to_s}"
+      elsif class_name == "n/a"
+        class_name = 'unknown'
+      end 
+      class_name
     end
   end
 end

data/lib/helpers/mission_helper.rb

@@ -1,6 +1,12 @@
 module MissionHelper
   helpers do 
 
+    def extract_applications( pulse )
+      apps = OrderedHash.new
+      pulse[:to_date].keys.sort.each { |app_name| apps[app_name] = pulse[:to_date][app_name].keys.sort }
+      apps
+    end
+    
     # -------------------------------------------------------------------------
     def load_report      
       @old_reports = Wackamole::Mission.find( {}, :sort => [ [:app, Mongo::ASCENDING], [:env, Mongo::ASCENDING] ] ).to_a
@@ -8,7 +14,11 @@ module MissionHelper
       reset               = last_tick.nil?
       last_tick           = last_tick || Chronic.parse( '1 minute ago' )
       session[:last_tick] = Time.now
-      @reports = Wackamole::Mission.rollups( last_tick.utc, reset )
+      
+      elapsed = Benchmark.realtime do
+        @reports = Wackamole::Mission.rollups( last_tick.utc, reset )
+      end
+      puts "Rollups %5.4f" % elapsed
     end
     
     # -------------------------------------------------------------------------
@@ -19,13 +29,17 @@ module MissionHelper
     
     # -------------------------------------------------------------------------
     # Assign status fg for application
-    def assign_class( type, count, diff )
+    def assign_class( type, count )
       clazz = case type
-        when "faults"   : (diff > 0 ? "fault" : "")
-        when "perfs"    : (diff > 0 ? "perf" : "")
-        when "features" : (diff > 0 ? "active" : "inactive")
-        else              ""
-      end
+        when Rackamole.fault
+          (count > 0 ? "fault" : "")
+        when Rackamole.perf
+          (count > 0 ? "perf" : "")
+        when Rackamole.feature
+          (count > 0 ? "feature" : "" )
+        else              
+          ""
+      end      
       clazz
     end