wackamole 0.0.1

data/lib/controllers/mission.rb

@@ -0,0 +1,27 @@
+require 'chronic'
+
+module Mission  
+  
+  # ---------------------------------------------------------------------------
+  get '/mission' do
+    # reset app info
+    session[:app_info] = @app_info = nil
+    
+    load_report
+    erb :'mission/index'
+  end
+  
+  # ---------------------------------------------------------------------------
+  get '/mission/refresh' do
+    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] )    
+    load_report    
+    erb :'/mission/refresh_js', :layout => false
+  end  
+  
+end

data/lib/controllers/users.rb

@@ -0,0 +1,41 @@
+module Users
+  
+  # ---------------------------------------------------------------------------
+  # Paginate top users
+  get "/users/:page" do
+    page = params[:page] ? params[:page].to_i : 1
+
+    @users       = Wackamole::User.paginate_tops( @filter.to_conds, page )   
+    @search_path = "/users/search"
+    @filter_path = "/users/filter"
+   
+    if request.xhr?
+      erb :'users/index.js', :layout => false
+    else
+      erb :'users/index'
+    end
+  end
+  
+  # ---------------------------------------------------------------------------
+  # search users
+  post "/users/search" do
+    begin
+      @filter.search_terms = params[:search_filter][:search_terms]      
+      @users = Wackamole::User.paginate_tops( @filter.to_conds )
+    rescue => boom
+      logger.error boom
+      flash[:error] = boom
+      @users = [].paginate
+    end
+
+    erb :"users/filter.js", :layout => false
+  end
+    
+  # ---------------------------------------------------------------------------
+  # Filter
+  post "/users/filter" do    
+    @filter.from_options( params[:filter] )
+    @users = Wackamole::User.paginate_tops( @filter.to_conds )
+    erb :"users/filter.js", :layout => false
+  end  
+end

data/lib/helpers/dashboard_helper.rb

@@ -0,0 +1,32 @@
+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
+    
+    # -------------------------------------------------------------------------  
+    # Retrieve moled app info...
+    def load_app_info
+      @app_info = Wackamole::Feature.get_app_info
+      session[:app_info] = @app_info
+    end    
+    
+    # -------------------------------------------------------------------------
+    # Loads the application details
+    def load_app_details
+      @info = Wackamole::MoledInfo.collect_dashboard_info( @updated_on.clone.utc )
+    end
+    
+    # -------------------------------------------------------------------------
+    # Check for zeroed out series...
+    def zeroed_series?( series )
+      series.inject(0) { |res, s| res + s } == 0
+    end
+  end
+end

data/lib/helpers/features_helper.rb

@@ -0,0 +1,13 @@
+module FeaturesHelper
+  
+  helpers do
+    # ---------------------------------------------------------------------------
+    # Find feature context for log entry
+    def display_context( feature )
+      if feature['ctl']
+        return "#{feature['ctl']}##{feature['act']}"
+      end
+      feature['ctx']
+    end      
+  end
+end

data/lib/helpers/flash_helper.rb

@@ -0,0 +1,16 @@
+module FlashHelper
+ helpers do
+   
+   # clear out flash object
+   def clear_it!
+     @flash = session[:flash] || OrderedHash.new     
+     @flash.clear
+   end
+   
+   # add flash message
+   def flash_it!( type, msg )
+     @flash = session[:flash] || OrderedHash.new
+     @flash[type] = msg
+   end
+ end
+end

data/lib/helpers/logs_helper.rb

@@ -0,0 +1,116 @@
+module LogsHelper
+  
+  helpers do
+    # ---------------------------------------------------------------------------
+    def user_name_for( user_id )
+      user = Wackamole::User.users_cltn.find_one( user_id )
+      user['una']
+    end
+  
+    # ---------------------------------------------------------------------------
+    def feature_name_for( feature_id )
+      feature = Wackamole::Feature.features_cltn.find_one( feature_id )
+      if feature['ctx']
+        return feature['ctx']
+      end
+      "#{feature['ctrl']}##{feature['act']}"
+    end
+  
+    # ---------------------------------------------------------------------------
+    def human_type( type )
+      case type
+        when Rackamole.perf
+          "Performance"
+        when Rackamole.fault
+          "Exception"
+        else 
+          "Feature"
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Change ids to time
+    def timestamp_for( log )
+      begin    
+        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        = Time.utc( date_tokens[0], date_tokens[1], date_tokens[2], time_tokens[0], time_tokens[1], time_tokens[2] )
+        return time.getlocal.strftime( "%m/%d/%y %H:%M:%S")
+      rescue
+        ;
+      end
+      "N/A"
+    end
+
+    # ---------------------------------------------------------------------------
+    # Find feature context for log entry
+    def context_for( feature_id )
+      feature = Wackamole::Feature.features_cltn.find_one( feature_id )
+      if feature['ctl']
+        return "#{feature['ctl']}##{feature['act']}"
+      end
+      feature['ctx']
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Converts mole type to big icon
+    def mole_type_icon( type )
+      case type
+        when Rackamole.perf 
+          "perf_big.png"
+        when Rackamole.fault
+          "fault_big.png"
+        else                     
+          "info_big.png"
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # Converts hash to string
+    def dump_hash( hash )
+      content = []
+      hash.each_pair do |k,v|
+        content << content_tag( :span, "#{k} -> #{v}" )
+      end
+      content.join( "" )
+    end
+     
+    # ---------------------------------------------------------------------------
+    # Trim out extra host info if any
+    def format_host( host )    
+      return host.split( "." ).first if host.index( /\./ )
+      host
+    end
+   
+    # ---------------------------------------------------------------------------
+    # Check if request time is available
+    def request_time( req_time )
+      begin
+        "%4.2f" % req_time
+      rescue
+        "N/A"
+      end
+    end
+    
+    # ---------------------------------------------------------------------------
+    # Change log color depending on type
+    def row_class_for( type )
+      case type
+        when Rackamole.feature
+          "feature"
+        when Rackamole.perf 
+          "perf"
+        when Rackamole.fault
+          "fault"
+      end
+    end
+  
+    # ---------------------------------------------------------------------------
+    # 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"    
+    end
+  end
+end

data/lib/helpers/main_helper.rb

@@ -0,0 +1,182 @@
+require 'json'
+require 'will_paginate/view_helpers/base'
+require 'will_paginate/view_helpers/link_renderer'
+
+# BOZO !! Refact helpers...
+module WillPaginate::ViewHelpers
+  class LinkRenderer
+    def url( page )
+      "#{@options[:params][:url]}/#{page}"
+    end
+  end
+end
+   
+module MainHelper  
+ helpers do   
+    include WillPaginate::ViewHelpers::Base   
+    
+    def pluralize( count, name )
+      count.to_s + " " + name + (count.to_i > 1 ? "s" : "")
+    end
+        
+    def javascript_tag( code )
+      content_tag( :script, code )
+    end
+    
+    def remote_function(options)
+      jq_options = {}
+      jq_options[:beforeSend] = options[:before] if options.has_key?( :before )
+      jq_options[:complete]   = options[:complete] if options.has_key?( :complete )
+      jq_options[:success]    = options[:success] if options.has_key?( :success )
+      jq_options[:error]      = options[:error] if options.has_key?( :error )      
+      jq_options[:url]        = options[:url]  if options.has_key?( :url )
+      jq_options[:data]       = options[:data] if options.has_key?( :data )      
+      jq_options[:dataType]   = options[:data_type] || 'script'
+      jq_options[:type]       = options[:type] || "GET"
+            
+      buff = []
+      jq_options.each_pair { |k,v| buff << "#{k}:'#{v}'" }
+      
+      "$.ajax({#{buff.join( "," )}})"
+    end    
+    
+    def periodically_call_remote(options = {})
+      frequency = options[:frequency] || 10 # every ten seconds by default
+      code = "setInterval(function() {#{remote_function(options)}}, #{frequency} * 1000)"
+      javascript_tag(code)
+    end
+    
+    def content_tag( tag, content, opts={} )
+      "<#{tag} #{html_options( opts )}>#{content}</#{tag}>"
+    end
+    
+    def options_for_select( list, selection )
+      buff = []
+      list.each do |option|
+        opts = {}
+        if option.is_a? Array
+          opts[:value]    = option.last
+          content         = option.first
+          opts[:selected] = "selected" if option.last == selection
+        else
+          content         = option
+          opts[:value]    = option
+          opts[:selected] = "selected" if option == selection          
+        end
+        buff << content_tag( :option, content, opts )
+      end
+      buff.join( "\n" )
+    end
+    
+    def image_tag( name, opts={} )
+      "<img src=\"/images/#{name}\" #{html_options( opts )}/>"
+    end
+    
+    def link_to_remote( name, url, opts={} )
+      "<a href=\"#\" onclick=\"#{remote_function({:url=>url})};return false;\" #{html_options(opts)}>#{name}</a>"
+    end
+    
+    # def form_remote_tag( name, opts={}, html_opts={} )
+    #   "<form onsubmit=\"#{remote_function(opts)};return false;\" #{html_options(html_opts)}></form>"
+    # end
+    
+    def link_to( name, url, opts={} )
+      "<a href=\"#{url}\" #{html_options(opts)}>#{name}</a>"
+    end
+      
+    def html_options( opts )
+      html = []
+      html << "id=\"#{opts[:id]}\""         if opts.has_key?( :id )
+      html << "border=\"#{opts[:border]}\"" if opts.has_key?( :border )
+      html << "class=\"#{opts[:class]}\""   if opts.has_key?( :class )
+      if opts.has_key?( :size )
+        size = opts[:size]
+        width, height = size.split( 'x' )
+        style = "width:#{width}px;height:#{height}px;"
+        if opts[:style]
+          opts[:style] += ";#{style}"
+        else
+          opts[:style] = style
+        end
+      end      
+      html << "style=\"#{opts[:style]}\""   if opts.has_key?( :style )
+      html << "selected=\"selected\""       if opts.has_key?( :selected )
+      html << "value=\"#{opts[:value]}\""   if opts.has_key?( :value )
+      html.empty? ? "" : html.join( " " )
+    end
+    
+    def stylesheets( styles )
+      buff = []
+      styles.each do |style|
+        buff << "<link rel=\"stylesheet\" href=\"#{v_styles( style )}\" type=\"text/css\" media=\"screen\" />"
+      end
+      buff.join( "\n" )
+    end
+    
+    def javascripts( scripts )
+      buff = []
+      scripts.each do |script|
+        buff << "<script src=\"#{v_js( script )}\" type=\"text/javascript\"></script>"
+      end
+      buff.join( "\n" )      
+    end
+          
+    def v_styles(stylesheet)
+      "/stylesheets/#{stylesheet}.css?" + File.mtime(File.join(Sinatra::Application.public, "stylesheets", "#{stylesheet}.css")).to_i.to_s
+    end
+    
+    def v_js(js)
+      "/javascripts/#{js}.js?" + File.mtime(File.join(Sinatra::Application.public, "javascripts", "#{js}.js")).to_i.to_s
+    end
+      
+    # truncate a string - won't work for multibyte      
+    def truncate(text, length = 30, truncate_string = "...")
+      return "" if text.nil?
+      l = length - truncate_string.size
+      text.size > length ? (text[0...l] + truncate_string).to_s : text
+    end
+      
+    def align_for( value )
+      return "right" if value.is_a?(Fixnum)
+      "left"
+    end
+    
+    # Add thousand markers
+    def format_number( value )
+      return value.to_s.gsub(/(\d)(?=\d{3}+(\.\d*)?$)/, '\1,') if value.instance_of?(Fixnum)
+      value
+    end
+               
+    def partial( page, options={} )
+      if object = options.delete(:object)        
+        template = page.to_s.split("/").last
+        options.merge!( :locals => { template.to_sym => object } )
+      end
+      
+      if page.to_s.index( /\// )
+        page = page.to_s.gsub( /\//, '/_' ) 
+      else 
+        page = "_" + page.to_s
+      end
+      erb page.to_sym, options.merge!( :layout => false )
+    end
+   
+    JS_ESCAPE_MAP = 
+    {
+      '\\'    => '\\\\',
+      '</'    => '<\/',
+      "\r\n"  => '\n',
+      "\n"    => '\n',
+      "\r"    => '\n',
+      '"'     => '\\"',
+      "'"     => "\\'" 
+    }   
+    def escape_javascript(javascript)
+      if javascript
+         javascript.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { JS_ESCAPE_MAP[$1] }
+      else
+         ''
+      end
+    end    
+  end  
+end

data/lib/helpers/mission_helper.rb

@@ -0,0 +1,59 @@
+module MissionHelper
+  helpers do 
+
+    # -------------------------------------------------------------------------
+    def load_report      
+      @old_reports = Wackamole::Mission.find( {}, :sort => [ [:app, Mongo::ASCENDING], [:env, Mongo::ASCENDING] ] ).to_a
+      
+      last_tick           = session[:last_tick]
+      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 )
+    end
+    
+    # -------------------------------------------------------------------------
+    # compute diff delta    
+    def delta?( diff )
+      diff == 0 ? content_tag( :span, diff, :class => "no_diff") : content_tag( :span, "+#{diff}", :class => "diff")
+    end
+    
+    # -------------------------------------------------------------------------
+    # Assign status fg for application
+    def assign_class( type, count, diff )
+      clazz = case type
+        when "faults"   : (diff > 0 ? "fault" : "")
+        when "perfs"    : (diff > 0 ? "perf" : "")
+        when "features" : (diff > 0 ? "active" : "inactive")
+        else              ""
+      end
+      clazz
+    end
+    
+    # -------------------------------------------------------------------------
+    # Computes count diff since last check point
+    def compute_diff( app_name, env, type_name, count )
+      old_count = find_report_count( app_name, env, type_name )
+      return (count - old_count) if( old_count )
+      count
+    end
+  
+    # =========================================================================
+    private
+  
+      # -----------------------------------------------------------------------
+      # Find report count for a given report
+      def find_report_count( app, env, type )
+        @old_reports.each do |report|
+          next unless report['app'] == app      
+          report['envs'].each_pair do |e, details|
+            next unless e == env        
+            details.each_pair do |type_name, count|
+              return count if type_name == type
+            end  
+          end      
+        end
+        nil
+      end    
+  end
+end