rackamole 0.0.9 → 0.1.0

data/Rakefile

@@ -28,6 +28,6 @@ PROJ.rcov.opts       = ["--sort", "coverage", "-T", '-x mongo']
 depend_on "logging"      , ">= 1.2.2"
 depend_on "hitimes"      , ">= 1.0.3"
 depend_on "mongo"        , ">= 0.17.1"
-# depend_on "darkfish-rdoc", ">= 1.1.5"
+depend_on "chronic"      , ">= 0.2.3"
 depend_on "twitter4r"    , ">= 0.3.0"
 depend_on "actionmailer" , ">= 2.1.0"

data/lib/rackamole/alert/twitt.rb

@@ -4,7 +4,13 @@ module Rackamole::Alert
   # Leverage twitter as a notification client. You can setup a private twitter account
   # and have your moled app twitt exception/perf alerts...
   class Twitt
-                
+
+    # Twitt an alert        
+    def self.deliver_alert( username, password, attrs )
+      @twitt ||= Twitt.new( username, password )
+      @twitt.send_alert( attrs )
+    end
+            
     # This class is used to send out moled twitter notification. This feature is enabled
     # by setting both :twitter_auth and twitt_on options on the Rack::Mole. When a moled 
     # feature comes around it will be twitted on your configured account. This allow your
@@ -41,8 +47,11 @@ module Rackamole::Alert
         when Rackamole.perf    : "[Perf] #{twitt_msg}\n#{format_time(args[:request_time])} secs"
         when Rackamole.fault   : "[Fault] #{twitt_msg}\n#{args[:fault]}"
         else nil
-      end      
-      twitt.status( :post, truncate( twitt_msg ) ) if twitt_msg
+      end
+      if twitt_msg
+        twitt_msg += " - #{args[:created_at].strftime( "%H:%M:%S")}"
+        twitt.status( :post, truncate( twitt_msg ) ) 
+      end
       twitt_msg
     rescue => boom
       $stderr.puts "TWITT mole failed with #{boom}"

data/lib/rackamole/mole.rb

@@ -17,10 +17,18 @@ module Rack
     # === Options
     #
     # :app_name       :: The name of the application (Default: Moled App)
+    # :log_level      :: Rackamole logger level. (Default: info )
     # :environment    :: The environment for the application ie :environment => RAILS_ENV
     # :perf_threshold :: Any request taking longer than this value will get moled. Default: 10secs
     # :moleable       :: Enable/Disable the MOle (Default:true)
     # :store          :: The storage instance ie log file or mongodb [Default:stdout]
+    # :expiration     :: Number of seconds to expiration. The mole will not keep sending alert if a particular
+    #                    mole type has been reported in the past. This threshold specifies the limit at which
+    #                    the previously sent alerts will expire and thus will be sent again. 
+    #                    For instance, it might be the case that the app is consistently slow for a particular action.
+    #                    On the first encounter an alert will be sent ( if configured ). Any subsequent requests for this action
+    #                    will not fire an alert until the expiration threshold is hit. The default is 1 hour. 
+    #                    Setting this threshold to Rackamole::Stash::Collector::NEVER will result in alerts being fired continually.
     # :user_key       :: If sessions are enable, this represents the session key for the user name or 
     #                    user_id.
     # ==
@@ -46,18 +54,22 @@ module Rack
     #   :email => { :from => 'fred@acme.com', :to => ['blee@acme.com', 'doh@acme.com'], :alert_on => [Rackamole.perf, Rackamole.fault]  }
     # ==
     #
-    def initialize( app, opts={} )
-      @app = app
+    def initialize( app, opts={} )    
+      @app       = app
       init_options( opts )
       validate_options
+      @logger = Rackamole::Logger.new( :logger_name => 'RACKAMOLE', :log_level => options[:log_level] )
     end
           
     # Entering the MOle zone...
     # Watches incoming requests and report usage information. The mole will also track request that
     # are taking longer than expected and also report any requests that are raising exceptions. 
-    def call( env )
+    def call( env )      
       # Bail if application is not moleable
       return @app.call( env ) unless moleable?
+                  
+      @stash = env['mole.stash'] if env['mole.stash']      
+      @stash = Rackamole::Stash::Collector.new( options[:app_name], options[:environment], options[:expiration] ) unless stash
             
       status, headers, body = nil
       elapsed = Hitimes::Interval.measure do
@@ -76,7 +88,7 @@ module Rack
   # ===========================================================================  
   private
        
-    attr_reader :options #:nodoc:
+    attr_reader :options, :logger, :stash #:nodoc:
         
     # Load up configuration options
     def init_options( opts )
@@ -86,7 +98,9 @@ module Rack
     # Mole default options
     def default_options
       { 
-        :moleable        =>  true,        
+        :moleable        =>  true,    
+        :log_level       =>  :info,
+        :expiration      =>  60*60, # 1 hour    
         :app_name        =>  "Moled App",
         :environment     =>  'test',
         :excluded_paths  =>  [/.?\.ico/, /.?\.png/],
@@ -109,24 +123,60 @@ module Rack
     end
     
     # Send moled info to store and potentially send out alerts...
-    def mole_feature( env, elapsed, status, headers, body )
-      attrs = mole_info( env, elapsed, status, headers, body )
+    def mole_feature( env, elapsed, status, headers, body )   
+      env['mole.stash'] = stash
       
+      attrs = mole_info( env, elapsed, status, headers, body )
+
+      # If nothing to mole bail out!
+      return if attrs.empty?
+
       # send info to configured store
       options[:store].mole( attrs )
       
-      # send email alert ?
-      if alertable?( :email, attrs[:type] )
-        Rackamole::Alert::Emole.deliver_alert( options[:email][:from], options[:email][:to], attrs ) 
+      # Check for dups. If we've logged this req before don't log it again...
+      unless duplicated?( env, attrs )
+        # send email alert ?
+        if alertable?( :email, attrs[:type] )
+          logger.debug ">>> Sending out email on mole type #{attrs[:type]} to #{options[:email][:to].join( ", ")}"
+          Rackamole::Alert::Emole.deliver_alert( options[:email][:from], options[:email][:to], attrs ) 
+        end
+      
+        # send twitter alert ?
+        if alertable?( :twitter, attrs[:type] )
+          logger.debug ">>> Sending out twitt on mole type #{attrs[:type]} on @#{options[:twitter][:username]}"
+          Rackamole::Alert::Twitt.deliver_alert( options[:twitter][:username], options[:twitter][:password], attrs )
+        end
+      end
+    rescue => boom
+      logger.error "!! MOLE RECORDING CRAPPED OUT !! -- #{boom}"
+      boom.backtrace.each { |l| logger.error l }
+    end
+    
+    # Check if we've already seen such an error
+    def duplicated?( env, attrs )
+      # Skip features for now...
+      return true if attrs[:type] == Rackamole.feature
+      
+      # Don't bother if expiration is set to never. ie fire alerts all the time
+      return false if options[:expiration] == Rackamole::Stash::Collector::NEVER
+      
+      now    = Time.now
+      app_id = [attrs[:app_name], attrs[:environment]].join( '_' )
+      path   = attrs[:route_info] ? "#{attrs[:route_info][:controller]}#{attrs[:route_info][:action]}" : attrs[:path]      
+                        
+      # Check expired entries
+      stash.expire!
+      
+      # check if we've seen this error before. If so stash it.
+      if attrs[:type] == Rackamole.fault
+        return stash.stash_fault( path, attrs[:stack].first, now.utc )
       end
       
-      # send twitter alert ?
-      if alertable?( :twitter, attrs[:type] )
-        twitt.send_alert( attrs ) 
+      # Check if we've seen this perf issue before. If so stash it
+      if attrs[:type] == Rackamole.perf
+        return stash.stash_perf( path, attrs[:request_time], now.utc )
       end      
-    rescue => boom
-      $stderr.puts "!! MOLE RECORDING CRAPPED OUT !! -- #{boom}"
-      boom.backtrace.each { |l| $stderr.puts l }
     end
     
     # Check if an options is set and configured
@@ -148,12 +198,7 @@ module Rack
       return false unless options[filter][:alert_on]
       options[filter][:alert_on].include?( type )
     end
-    
-    # Create or retrieve twitter client
-    def twitt
-      @twitt ||= Rackamole::Alert::Twitt.new( options[:twitter][:username], options[:twitter][:password] )
-    end
-        
+            
     # Check if this request should be moled according to the exclude filters        
     def mole_request?( request )
       options[:excluded_paths].each do |exclude_path|
@@ -166,9 +211,7 @@ module Rack
     def mole_info( env, elapsed, status, headers, body )      
       request = Rack::Request.new( env )
       info    = OrderedHash.new
-         
-      # dump( env )
-                  
+                           
       return info unless mole_request?( request )
                         
       session     = env['rack.session']      
@@ -206,6 +249,7 @@ module Rack
       info[:method]       = env['REQUEST_METHOD']
       info[:path]         = request.path
       info[:route_info]   = route if route
+      info[:created_at]   = Time.now.utc
       
       # Dump request params
       unless request.params.empty?
@@ -261,28 +305,27 @@ module Rack
     # Fetch route info if any...
     def get_route( request )
       return nil unless defined?( RAILS_ENV )
-      
       # Check for invalid route exception...
       begin
         return ::ActionController::Routing::Routes.recognize_path( request.path, {:method => request.request_method.downcase.to_sym } )
-      rescue
+      rescue => boom      
         return nil
       end
     end
     
-    # Dump env to stdout
-    # def dump( env, level=0 )
-    #   env.keys.sort{ |a,b| a.to_s <=> b.to_s }.each do |k|
-    #     value = env[k]
-    #     if value.respond_to?(:each_pair) 
-    #       puts "%s %-#{40-level}s" % ['  '*level,k]
-    #       dump( env[k], level+1 )
-    #     elsif value.instance_of?(::ActionController::Request) or value.instance_of?(::ActionController::Response) 
-    #       puts "%s %-#{40-level}s %s" % [ '  '*level, k, value.class ]
-    #     else
-    #       puts "%s %-#{40-level}s %s" % [ '  '*level, k, value.inspect ]
-    #     end        
-    #   end
-    # end
+    # Debug - Dump env to stdout
+    def dump( env, level=0 )
+      env.keys.sort{ |a,b| a.to_s <=> b.to_s }.each do |k|
+        value = env[k]
+        if value.respond_to?(:each_pair) 
+          puts "%s %-#{40-level}s" % ['  '*level,k]
+          dump( env[k], level+1 )
+        elsif value.instance_of?(::ActionController::Request) or value.instance_of?(::ActionController::Response) 
+          puts "%s %-#{40-level}s %s" % [ '  '*level, k, value.class ]
+        else
+          puts "%s %-#{40-level}s %s" % [ '  '*level, k, value.inspect ]
+        end        
+      end
+    end
   end
 end

data/lib/rackamole/stash/base.rb

@@ -0,0 +1,25 @@
+module Rackamole::Stash
+  # Stash mole information into the env. These objects are meant to track 
+  # instances of a similar event occurring in the application so that alerts
+  # are kept under control when shit hits the fan...
+  class Base    
+    attr_reader :path, :timestamp, :count
+
+    # =======================================================================--
+    protected
+        
+      def initialize( path, timestamp )
+        @path      = path
+        @count     = 1
+        @timestamp = timestamp
+      end
+
+    public
+        
+      # Update count and timestamp
+      def update( timestamp )
+        @timestamp  = timestamp
+        @count     += 1
+      end
+  end
+end

data/lib/rackamole/stash/collector.rb

@@ -0,0 +1,93 @@
+module Rackamole::Stash
+  # Caches perfs and faults. If either has been seen before update their 
+  # respective counts. This is used by the mole to track if a perf or exception
+  # was previously recorded.
+  class Collector
+    
+    attr_reader :app_id
+    
+    NEVER = -1
+    
+    def initialize( app_name, environment, expiration=24*60*60 )
+      @expiration = expiration
+      @app_id     = app_name + "_" + environment.to_s
+      @faults     = {}
+      @perfs      = {}
+    end
+
+    # Remove all entries that have expired
+    def expire!
+      expire_faults!
+      expire_perfs!
+    end
+    
+    # Delete all faults older than expiration
+    def expire_faults!
+      now = Time.now
+      faults.each_pair do |stack, fault|
+        if (now - fault.timestamp) >= expiration
+          faults.delete( stack )
+        end
+      end
+    end
+    
+    # Delete all perfs older than expiration
+    def expire_perfs!
+      now = Time.now.utc
+      perfs.each_pair do |path, perf|
+        if (now - perf.timestamp) >= expiration
+          perfs.delete( path )
+        end
+      end
+    end
+    
+    # Log or update fault if found...
+    # Returns true if updated or false if created
+    def stash_fault( path, stack, timestamp )
+      fault = find_fault( path, stack )
+      if fault
+        fault.update( timestamp )
+        return true
+      end
+      fault = create_fault( path, stack, timestamp )
+      faults[stack] = fault
+      false
+    end
+
+    # Log or update performance issue if found...
+    # Returns true if updated or false if created    
+    def stash_perf( path, elapsed, timestamp )
+      perf = find_perf( path )
+      if perf
+        perf.update( timestamp )
+        return true
+      end
+      perf = create_perf( path, elapsed, timestamp )
+      perfs[path] = perf
+      false
+    end
+        
+    # =========================================================================
+    private    
+    
+      attr_reader :faults, :perfs, :expiration
+       
+      def create_fault( path, stack, timestamp )
+        faults[stack] = Rackamole::Stash::Fault.new( path, stack, timestamp )
+      end
+
+      def create_perf( path, elapsed, timestamp )
+        perfs[path] = Rackamole::Stash::Perf.new( path, elapsed, timestamp )
+      end
+
+      # Check if we've seen a similar fault on this application
+      def find_fault( path, stack )
+        faults[stack]
+      end
+
+      # Check if we've seen this perf issue on this application
+      def find_perf( path )
+        perfs[path]
+      end       
+  end
+end

data/lib/rackamole/stash/fault.rb

@@ -0,0 +1,10 @@
+module Rackamole::Stash
+  class Fault < Rackamole::Stash::Base
+    attr_reader :stack
+    
+    def initialize( path, stack, timestamp )
+      super( path, timestamp )
+      @stack = stack
+    end    
+  end
+end

data/lib/rackamole/stash/perf.rb

@@ -0,0 +1,10 @@
+module Rackamole::Stash
+  class Perf < Rackamole::Stash::Base
+    attr_reader :elapsed
+    
+    def initialize( path, elapsed, timestamp )
+      super( path, timestamp )
+      @elapsed   = elapsed
+    end    
+  end
+end

data/lib/rackamole/store/mongo_db.rb

@@ -96,21 +96,22 @@ module Rackamole
             row[min_field(:context)] = args.delete( :path )
           end
           
-          feature = features.find_one( row )
-          return feature if feature
-          
-          id = features.save( row )
-          features.find_one( id )
+          feature = features.find_one( row, :fields => ['_id'] )
+          return feature['_id'] if feature
+
+          row[min_field(:created_at)] = args[:created_at]
+                    
+          features.save( row )
         end
                                     
         # Insert a new feature in the db
         # NOTE : Using min key to reduce storage needs. I know not that great for higher level api's :-(
         # also saving date and time as ints. same deal...
-        def save_log( feature, args )        
-          now = Time.now
+        def save_log( feature_id, args )
+          now = args.delete( :created_at )
           row = {
             min_field( :type )       => args[:type],
-            min_field( :feature_id ) => feature['_id'].to_s,
+            min_field( :feature_id ) => feature_id.to_s,
             min_field( :date_id )    => ("%4d%02d%02d" %[now.year, now.month, now.day]).to_i,
             min_field( :time_id )    => ("%02d%02d%02d" %[now.hour, now.min, now.sec] ).to_i
           }
@@ -151,7 +152,8 @@ module Rackamole
             :params       => :par,
             :ruby_version => :ver,
             :fault        => :msg,
-            :stack        => :sta
+            :stack        => :sta,
+            :created_at   => :cro
           }
         end      
     end

data/lib/rackamole.rb

@@ -1,7 +1,7 @@
 module Rackamole
 
   # :stopdoc:
-  VERSION = '0.0.9'
+  VERSION = '0.1.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/samples/rails/moled/app/controllers/fred_controller.rb

@@ -1,5 +1,6 @@
 class FredController < ApplicationController
   def index
+    sleep( 1 )
     session[:fred] = 'hello'
   end
   

data/samples/rails/moled/config/environment.rb

@@ -9,7 +9,14 @@ require File.join(File.dirname(__FILE__), 'boot')
 Rails::Initializer.run do |config|
   
   require 'rackamole'
-  config.middleware.use Rack::Mole, { :app_name => "My Cool App", :user_key => :user_name }
+  config.middleware.use Rack::Mole, { 
+    :app_name => "Moled Rails", 
+    :user_key       => :user_name,
+    :expiration     => 60,
+    :perf_threshold => 0.2,
+    :twitter        => { :username => 'moled', :password => 'fernand~1', :alert_on => [Rackamole.perf, Rackamole.fault] },
+    :user_key => :user_name 
+  }
   
   # Settings in config/environments/* take precedence over those specified here.
   # Application configuration should go into files in config/initializers

data/samples/rails/moled/log/development.log

@@ -78,3 +78,23 @@ Processing FredController#show (for 127.0.0.1 at 2009-11-15 11:54:08) [GET]
   Parameters: {"id"=>"10"}
 Rendering fred/show
 Completed in 7ms (View: 6, DB: 0) | 200 OK [http://localhost/fred/10]
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:08:32) [GET]
+Rendering fred/index
+Completed in 135ms (View: 11, DB: 0) | 200 OK [http://localhost/fred]
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:08:40) [GET]
+Rendering fred/index
+Completed in 2ms (View: 0, DB: 0) | 200 OK [http://localhost/fred]
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:09:19) [GET]
+Rendering fred/index
+Completed in 1004ms (View: 2, DB: 0) | 200 OK [http://localhost/fred]
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:09:23) [GET]
+Rendering fred/index
+Completed in 1002ms (View: 1, DB: 0) | 200 OK [http://localhost/fred]

data/samples/rails/moled/log/production.log

@@ -34,3 +34,13 @@ RuntimeError (Oh snap!):
   app/controllers/fred_controller.rb:7:in `edit'
 
 Rendering /Users/fgaliana/work/git/rackamole/samples/rails/moled/public/500.html (500 Internal Server Error)
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:10:07) [GET]
+Rendering fred/index
+Completed in 1003ms (View: 1, DB: 0) | 200 OK [http://localhost/fred]
+
+
+Processing FredController#index (for 127.0.0.1 at 2009-11-28 13:10:11) [GET]
+Rendering fred/index
+Completed in 1001ms (View: 0, DB: 0) | 200 OK [http://localhost/fred]

data/samples/sinatra/moled.rb

@@ -2,34 +2,56 @@ require 'rubygems'
 require 'sinatra'
 require 'rackamole'
 
-configure do
-  set :sessions, true
-  set :environment, :development
-  use Rack::Reloader
-  use Rack::Mole, { :app_name => "My Sinatra App", :user_key => :user_name }
+set :environment, :production
+
+configure :production do
+  set :sessions,    true
+  use Rack::Lint
+  use Rack::Session::Cookie
+  use Rack::Mole, { 
+    :app_name       => "Moled Franky", 
+    :log_level      => :debug,
+    :user_key       => :user_name,
+    :expiration     => 10,
+    :perf_threshold => 0.2,
+    :twitter        => { :username => 'moled', :password => 'fernand~1', :alert_on => [Rackamole.perf, Rackamole.fault] },
+    :excluded_paths => [ /.+?\.css/, /.+?\.png/ ]
+  }
 end
 
 before do
   session[:user_name] = "Fernand"
 end
 
+get '/' do
+  puts "Yo"
+  erb :index
+end
+
 get '/normal' do  
-  @blee = "Snap!!"
-  session[:fred] = "duh me"
+  @blee          = "Hello World!"
+  session[:fred] = "oh dear"
+  
   erb :normal
 end
 
+post '/post' do
+  @post = params[:blee]
+  erb :post
+end
+
 get '/params/:id' do  
-  @blee = params[:id]
-  session[:fred] = "duh me"
+  @blee          = params[:id]
+  session[:blee] = "something interesting"
+  
   erb :params
 end
 
 get '/error' do
-  raise "Oh Shit!!"
+  raise "Oh Snap!"
 end
 
 get '/slow' do
-  sleep 10
-  '<h1> I am the slow one...</h1>'
+  sleep 0.2
+  erb :slow
 end

data/samples/sinatra/public/stylesheets/styles.css

@@ -0,0 +1,58 @@
+* {
+  outline-color: invert;
+  outline-style: none;
+  outline-width: medium;
+  margin:        0px;
+  padding:       0px;
+}             
+
+body {
+	font-family:        "Trebuchet","Lucida Grande","Lucida Sans Unicode","bitstream vera sans","trebuchet ms","verdana";
+  background:       #f4f4f4 repeat-x top left;
+	color:            #ffffff;
+  font-size:        2em;
+	font-size-adjust: none;
+	font-stretch:     normal;
+	font-style:       normal;
+	font-variant:     normal;
+	font-weight:      normal;
+  margin:           0;
+}
+
+#overall {
+  margin:     0px auto;
+  width:      1000px;
+  overflow:   none;
+  margin-top: 30px;
+}
+
+#logo {
+  float:left;
+  width:45%;
+  margin-bottom:10px;
+}
+
+#main {
+  clear:    left;
+  margin:   20px 10px 10px 20px;
+  overflow: none;
+}
+
+h1 {
+  font-size:   2.2em;
+  color:       #434343;
+}
+
+a {
+  color:           #cccccc;
+  text-decoration: none;
+}
+
+a:hover {
+  text_decoration: underline;
+}
+
+input {
+  font-size: 1em;
+  color:     #cccccc;  
+}

data/samples/sinatra/views/index.erb

@@ -0,0 +1,14 @@
+<h1>Mole sampler</h1>
+
+<ul>
+  <li><a href="/normal">Plain ol' get</a></li>
+  <li><a href="/params/10">Get with params</a></li>
+  <li><a href="/error">Uncaught fault</a></li>
+  <li><a href="/slow">Slow request</a></li>
+  <li>
+    <form action="/post" method="post" >
+      <input type="text" name="blee"/>
+      <input type="submit" value="push me"/>
+    </form>
+  </li>
+</ul>

data/samples/sinatra/views/layout.erb

@@ -0,0 +1,23 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <title>R A C K A M O L E - Sampler</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />    
+    <link rel="icon" href="/favicon.ico" type="image/x-icon"/>
+    <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon"/>    
+    <link rel="stylesheet" href="/stylesheets/styles.css" type="text/css" media="screen" />
+  </head>
+
+  <body id="body">
+    <div id="overall">      
+      <div id="logo">
+        <a href="/">
+          <img src='/images/mole_logo.png' style="border:none"/>
+        </a>
+      </div>      
+      <div id="main">
+        <%= yield %>
+      </div>
+    </div>      
+  </body>
+</html>

data/samples/sinatra/views/params.erb

@@ -1 +1 @@
-<h1>Params -- <%=@blee%></h1>
+<h1>Params -- <%=@post%></h1>

data/samples/sinatra/views/post.erb

@@ -0,0 +1 @@
+<h1>Posted - <%=@post%></h1>

data/samples/sinatra/views/slow.erb

@@ -0,0 +1 @@
+<h1>I am the slow one</h1>

data/spec/rackamole/alert/twitt_spec.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'chronic'
 
 describe Rackamole::Alert::Twitt do
   before( :each ) do
@@ -22,11 +23,23 @@ describe Rackamole::Alert::Twitt do
   describe '#send_alert' do
     before( :each ) do      
       @args = OrderedHash.new
-      @args[:type]      = Rackamole.feature
-      @args[:app_name]  = 'Test'
-      @args[:host]      = 'Fred'
-      @args[:user_name] = 'Fernand'
-      @args[:path]      = '/blee/fred'
+      @args[:type]       = Rackamole.feature
+      @args[:app_name]   = 'Test'
+      @args[:host]       = 'Fred'
+      @args[:user_name]  = 'Fernand'
+      @args[:path]       = '/blee/fred'
+      @args[:created_at] = Chronic.parse( "2009/11/19" )
+    end
+
+    it "should twitt a feature alert using class method correctly" do
+      twitt  = mock( Rackamole::Alert::Twitt )
+      client = Twitter::Client.stub!( :new )
+      
+      Rackamole::Alert::Twitt.should_receive( :new ).with( 'blee', 'duh').once.and_return( twitt )
+      # client.should_receive( :new ).once.and_return( client )
+      twitt.should_receive( :send_alert ).with( @args ).once.and_return( "yeah" )      
+      
+      Rackamole::Alert::Twitt.deliver_alert( "blee", "duh", @args )
     end
     
     it "should twitt a feature alert correctly" do
@@ -36,7 +49,7 @@ describe Rackamole::Alert::Twitt do
       # client.should_receive( :new ).exactly(1).with( 'fernand', 'blee' )
       client.should_receive( :status ).once
     
-      @alert.send_alert( @args ).should == "[Feature] Test on Fred - Fernand\n/blee/fred"
+      @alert.send_alert( @args ).should == "[Feature] Test on Fred - Fernand\n/blee/fred - 12:00:00"
     end
   
     it "should twitt a perf alert correctly" do
@@ -48,7 +61,7 @@ describe Rackamole::Alert::Twitt do
       @alert.should_receive( :twitt ).once.and_return( client )
       client.should_receive( :status ).once
     
-      @alert.send_alert( @args ).should == "[Perf] Test on Fred - Fernand\n/blee/fred\n10.0 secs"
+      @alert.send_alert( @args ).should == "[Perf] Test on Fred - Fernand\n/blee/fred\n10.0 secs - 12:00:00"
     end
 
     it "should twitt a perf alert correctly" do
@@ -60,7 +73,7 @@ describe Rackamole::Alert::Twitt do
       @alert.should_receive( :twitt ).once.and_return( client )
       client.should_receive( :status ).once
     
-      @alert.send_alert( @args ).should == "[Fault] Test on Fred - Fernand\n/blee/fred\nOh snap!"
+      @alert.send_alert( @args ).should == "[Fault] Test on Fred - Fernand\n/blee/fred\nOh snap! - 12:00:00"
     end
   end
 

data/spec/rackamole/mole_spec.rb

@@ -4,8 +4,21 @@ describe Rack::Mole do
   include Rack::Test::Methods
     
   before :each do
-    @response = [ 200, {"Content-Type" => "text/plain"}, ["success"] ]
-    @test_env = { 'rack.session' => { :user_id => 100 }, 'HTTP_X_FORWARDED_FOR' => '1.1.1.1', 'HTTP_USER_AGENT' => "Firefox" }    
+    @response   = [ 200, {"Content-Type" => "text/plain"}, ["success"] ]
+    @test_store = TestStore.new    
+    @test_env   = { 
+      'rack.session'         => { :user_id => 100, :username => "fernand" }, 
+      'HTTP_X_FORWARDED_FOR' => '1.1.1.1', 
+      'HTTP_USER_AGENT'      => "Firefox" 
+    }
+    @opts       = {
+      :app_name       => "Test App", 
+      :environment    => :test,
+      :excluded_paths => ['/should_bail'],      
+      :perf_threshold => 0.1,
+      :user_key       => :username,
+      :store          => @test_store
+    }
   end
       
   class TestStore
@@ -32,58 +45,158 @@ describe Rack::Mole do
     end
   end
 
-  it "should mole a framwework exception correctly" do
-    @test_store = TestStore.new
-    error_app( 
-      :app_name       => "Test App", 
-      :environment    => :test,
-      :perf_threshold => 0.1,
-      :user_key       => { :session_key => :user_id, :extractor => lambda{ |k| "Test user #{k}"} },
-      :store          => @test_store )
+  def slow_app( opts={} )
+    response = @response
+    @app ||= Rack::Builder.new do
+      use Rack::Lint
+      use Rack::Mole, opts
+      run lambda { |env| sleep(0.2); response }
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  describe "fault duplicate" do 
+    before( :each ) do
+      error_app( @opts )
+    end
+        
+    it "should mole a fault issue correctly" do      
+      begin
+        get "/", nil, @test_env
+      rescue
+        last_request.env['mole.stash'].should_not be_nil
+        fault = last_request.env['mole.stash'].send( :find_fault, "/", "./spec/rackamole/mole_spec.rb:44:in `error_app'" )
+        fault.should_not be_nil
+        fault.count.should == 1
+      end
+    end
+
+    it "should trap a recuring fault on given path correctly" do
+      env = @test_env
+      2.times do |i|
+        begin
+          get "/", nil, env
+        rescue
+          last_request.env['mole.stash'].should_not be_nil
+          fault = last_request.env['mole.stash'].send( :find_fault, "/", "./spec/rackamole/mole_spec.rb:44:in `error_app'" )
+          fault.should_not be_nil
+          fault.count.should == i+1
+          env = last_request.env
+        end
+      end
+    end
+
+    it "should trap a recuring fault on different path correctly" do    
+      env = @test_env
+      2.times do |i|
+        begin        
+          env['PATH_INFO'] = "/#{i}"
+          get "/#{i}", nil, env
+        rescue
+          last_request.env['mole.stash'].should_not be_nil
+          fault = last_request.env['mole.stash'].send( :find_fault, "/", "./spec/rackamole/mole_spec.rb:44:in `error_app'" )          
+          fault.should_not be_nil
+          fault.count.should == i+1
+          env = last_request.env
+        end
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  describe "performance duplicate" do 
+    before( :each ) do
+      @test_store = TestStore.new
+      slow_app( @opts )
+    end
     
+    it "should mole a perf issue correctly" do    
+      get "/", nil, @test_env
+      last_request.env['mole.stash'].should_not be_nil    
+      perf = last_request.env['mole.stash'].send( :find_perf, "/" )
+      perf.should_not be_nil
+      perf.count.should == 1
+    end
+
+    it "should trap a recuring perf on given path correctly" do
+      env = @test_env
+      2.times do |i| 
+        get "/", nil, env
+        perf = last_request.env['mole.stash'].send( :find_perf, "/" )
+        perf.should_not be_nil
+        perf.count.should == i+1
+        env = last_request.env
+      end
+    end
+
+    it "should trap a recuring perf on different path correctly" do    
+      env = @test_env
+      2.times do |i|
+        env['PATH_INFO'] = "/#{i}"
+        get "/#{i}", nil, env
+        last_request.env['mole.stash'].should_not be_nil
+        count = 0
+        while count <= i
+          perf = last_request.env['mole.stash'].send( :find_perf, "/#{count}" )
+          perf.should_not be_nil
+          perf.count.should == 1
+          count += 1
+        end
+        env = last_request.env
+      end
+    end
+  end
+  
+  # ---------------------------------------------------------------------------  
+  it "should mole a framwework exception correctly" do
+    error_app( @opts )    
     begin
       get "/", nil, @test_env
     rescue 
-      @test_store.mole_result[:stack].should have(4).items      
+      @test_store.mole_result[:stack].should have(4).items
+      last_request.env['mole.stash'].should_not be_nil
+      fault = last_request.env['mole.stash'].send( :find_fault, "/", "./spec/rackamole/mole_spec.rb:44:in `error_app'" )
+      fault.should_not be_nil
+      fault.count.should == 1
     end
   end
     
+  # ---------------------------------------------------------------------------    
   describe 'moling a request' do
     before :each do
-      @test_store = TestStore.new
-      app( 
-        :app_name       => "Test App", 
-        :environment    => :test,
-        :perf_threshold => 0.1,        
-        :user_key       => { :session_key => :user_id, :extractor => lambda{ |k| "Fernand (#{k})"} },
-        :store          => @test_store )
+      app( @opts )
     end
     
     it "should set the mole meta correctly" do
       get "/fred/blee", nil, @test_env
-      @test_store.mole_result[:app_name].should    == "Test App"
-      @test_store.mole_result[:environment].should == :test
-      @test_store.mole_result[:user_id].should     == 100
-      @test_store.mole_result[:user_name].should   == 'Fernand (100)'
-      @test_store.mole_result[:ip].should          == '1.1.1.1'
-      @test_store.mole_result[:browser].should     == 'Firefox'
-      @test_store.mole_result[:method].should      == 'GET'
-      @test_store.mole_result[:url].should         == 'http://example.org/fred/blee'
-      @test_store.mole_result[:path].should        == '/fred/blee'
-      @test_store.mole_result[:type].should        == Rackamole.feature
-      @test_store.mole_result[:params].should      be_nil
-      @test_store.mole_result[:session].should_not be_nil
-      @test_store.mole_result[:session].should    == { :user_id => '100' }
+      @test_store.mole_result[:app_name].should     == "Test App"
+      @test_store.mole_result[:environment].should  == :test
+      @test_store.mole_result[:user_id].should      be_nil
+      @test_store.mole_result[:user_name].should    == 'fernand'
+      @test_store.mole_result[:ip].should           == '1.1.1.1'
+      @test_store.mole_result[:browser].should      == 'Firefox'
+      @test_store.mole_result[:method].should       == 'GET'
+      @test_store.mole_result[:url].should          == 'http://example.org/fred/blee'
+      @test_store.mole_result[:path].should         == '/fred/blee'
+      @test_store.mole_result[:type].should         == Rackamole.feature
+      @test_store.mole_result[:params].should       be_nil
+      @test_store.mole_result[:session].should_not  be_nil
+      @test_store.mole_result[:session].keys.should have(2).items
     end
     
     it "mole an exception correctly" do
       begin
         raise 'Oh snap!'
       rescue => boom
-        get "/crap/out", nil, @test_env.merge( { 'mole.exception' => boom } )
+        @test_env['mole.exception'] = boom
+        get "/crap/out", nil, @test_env
         @test_store.mole_result[:type].should  == Rackamole.fault
         @test_store.mole_result[:stack].should have(4).items
-        @test_store.mole_result[:fault].should == 'Oh snap!'        
+        @test_store.mole_result[:fault].should == 'Oh snap!'
+        last_request.env['mole.stash'].should_not be_nil
+        fault = last_request.env['mole.stash'].send( :find_fault, "/", "./spec/rackamole/mole_spec.rb:189" )
+        fault.should_not be_nil
+        fault.count.should == 1
       end
     end
         
@@ -91,26 +204,86 @@ describe Rack::Mole do
         get "/", { :blee => 'duh' }, @test_env
         @test_store.mole_result[:params].should == { :blee => "duh".to_json }
     end
+    
+    it "should not mole an exclusion" do
+      get '/should_bail', nil, @test_env      
+      @test_store.mole_result.should be_nil
+    end
   end
       
+  # ---------------------------------------------------------------------------      
   describe 'username in session' do
-    before :each do
-      @test_store = TestStore.new
-      app( 
-        :app_name       => "Test App", 
-        :environment    => :test,
-        :perf_threshold => 0.1,
-        :user_key       => :user_name,
-        :store          => @test_store )
-    end
-    
     it "should pickup the user name from the session correctly" do
-      get "/", nil, @test_env.merge( { 'rack.session' => { :user_name => "Fernand" } } )
+      app( @opts )
+      get "/", nil, @test_env      
       @test_store.mole_result[:user_id].should   be_nil
-      @test_store.mole_result[:user_name].should == 'Fernand'
+      @test_store.mole_result[:user_name].should == 'fernand'
+    end
+    
+    it "should extract a username correctly" do
+      @opts[:user_key] = { :session_key => :user_id, :extractor => lambda { |k| "Fernand #{k}" } }    
+      app( @opts )    
+      get "/", nil, @test_env
+      @test_store.mole_result[:user_id].should   == 100
+      @test_store.mole_result[:user_name].should == 'Fernand 100'
+    end      
+  end
+
+  describe "rails env" do
+    it "should find route info correctly" do
+      RAILS_ENV = true
+      ActionController::Routing::Routes.stub!( :recognize_path ).and_return( { :controller => 'fred', :action => 'blee' } )
+      rack = Rack::Mole.new( nil )
+      
+      # routes.should_receive( 'recognize_path' ).with( 'fred', { :method => 'blee' } ).and_return(  )
+      res = rack.send( :get_route, OpenStruct.new( :path => "/", :request_method => "GET") )
+      res.should_not          be_nil
+      res[:controller].should == 'fred'
+      res[:action].should     == 'blee'
     end
   end
   
+  # ---------------------------------------------------------------------------      
+  describe 'sending alerts' do
+    it "should send out alerts on the first occurrance of a perf issue" do
+      Rackamole::Alert::Twitt.stub!( :deliver_alert )
+      Rackamole::Alert::Emole.stub!( :deliver_alert )
+
+      @opts[:twitter] = { :username => "fred", :password => "blee", :alert_on => [Rackamole.perf] }
+      @opts[:email]   = { :from => "fred", :to => ["blee"], :alert_on => [Rackamole.perf] }
+      
+      slow_app( @opts )
+      
+      Rackamole::Alert::Emole.should_receive( :deliver_alert ).once
+      Rackamole::Alert::Twitt.should_receive( :deliver_alert ).once      
+      
+      get "/", nil, @test_env
+    end    
+    
+    it "should should not send several alerts on an occurance of the same issue" do
+      Rackamole::Alert::Twitt.stub!( :deliver_alert )
+      Rackamole::Alert::Emole.stub!( :deliver_alert )
+
+      @opts[:twitter] = { :username => "fred", :password => "blee", :alert_on => [Rackamole.perf] }
+      @opts[:email]   = { :from => "fred", :to => ["blee"], :alert_on => [Rackamole.perf] }
+
+      slow_app( @opts )
+            
+      env = @test_env
+      # First time ok
+      Rackamole::Alert::Emole.should_receive( :deliver_alert ).once
+      Rackamole::Alert::Twitt.should_receive( :deliver_alert ).once      
+      get "/", nil, env
+      env = last_request.env
+      # Second time - no alerts
+      Rackamole::Alert::Emole.should_not_receive( :deliver_alert )
+      Rackamole::Alert::Twitt.should_not_receive( :deliver_alert )
+      get "/", nil, env      
+    end    
+    
+  end
+  
+  # ---------------------------------------------------------------------------  
   describe '#alertable?' do
     before( :each ) do
       @rack = Rack::Mole.new( nil, 
@@ -121,7 +294,7 @@ describe Rack::Mole do
         },
         :email => { 
           :from     => 'fred', 
-          :to       => 'blee', 
+          :to       => ['blee'], 
           :alert_on => [Rackamole.perf, Rackamole.fault, Rackamole.feature] 
         } )
     end
@@ -143,6 +316,7 @@ describe Rack::Mole do
     end    
   end
 
+  # ---------------------------------------------------------------------------
   describe '#configured?' do
     before( :each ) do
       options = {
@@ -176,6 +350,7 @@ describe Rack::Mole do
     end    
   end
   
+  # ---------------------------------------------------------------------------
   describe '#id_browser' do
     before :all do
       @rack = Rack::Mole.new( nil )

data/spec/rackamole/stash/collector_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'chronic'
+
+describe Rackamole::Stash::Collector do
+  before( :each ) do
+    @now       = Chronic.parse( "11/27/2009" )
+    @collector = Rackamole::Stash::Collector.new( "Fred", "test" )
+  end
+
+  describe "#stash" do  
+    it "should record fault information correctly" do
+      begin
+        raise "Oh snap!"
+      rescue => boom
+        @collector.stash_fault( "/", boom.backtrace.first, @now )
+        @collector.send( :faults ).size.should == 1
+      
+        fault = @collector.send( :find_fault, "/", boom.backtrace.first )          
+        fault.should_not                be_nil
+        fault.send( :path ).should      == "/"
+        fault.send( :stack ).should     == "./spec/rackamole/stash/collector_spec.rb:13"
+        fault.send( :timestamp ).should == @now
+      end
+    end
+
+    it "should record perf information correctly" do
+      @collector.stash_perf( "/", 10.0, @now )
+      @collector.send( :perfs ).size.should == 1
+    
+      perf = @collector.send( :find_perf, "/" )          
+      perf.should_not                be_nil
+      perf.send( :path ).should      == "/"
+      perf.send( :elapsed ).should   == 10.0
+      perf.send( :timestamp ).should == @now
+    end
+  end
+  
+  describe "#expire" do
+    before( :all ) do
+      @now       = Chronic.parse( "11/27/2009" )
+      @yesterday = Chronic.parse( "yesterday", :now => @now )
+    end
+    
+    it "should expire fault correctly" do
+      begin
+        raise "Oh snap!"
+      rescue => boom
+        @collector.stash_fault( "/", boom.backtrace.first, @yesterday )
+        @collector.send( :faults ).size.should == 1
+        @collector.expire_faults!
+        @collector.send( :faults ).size.should == 0
+      end
+    end
+    
+    it "should expire perf correctly" do
+      @collector.stash_perf( "/", 10, @yesterday )
+      @collector.send( :perfs ).size.should == 1
+      @collector.expire_perfs!
+      @collector.send( :perfs ).size.should == 0
+    end
+  end
+  
+end
+  

data/spec/rackamole/stash/fault_spec.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'chronic'
+
+describe Rackamole::Stash::Fault do
+  before( :all ) do
+    @now = Chronic.parse( "11/27/2009" )
+  end
+  
+  it "should record fault information correctly" do
+    begin
+      raise "Oh snap!"
+    rescue => boom
+      fault = Rackamole::Stash::Fault.new( "/", boom.backtrace.first, @now )
+      fault.send( :path ).should      == "/"
+      fault.send( :stack ).should     == "./spec/rackamole/stash/fault_spec.rb:11"
+      fault.send( :timestamp ).should == @now
+    end
+  end
+end
+  

data/spec/rackamole/stash/perf_spec.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'chronic'
+
+describe Rackamole::Stash::Perf do
+  before( :all ) do
+    @now = Chronic.parse( "11/27/2009" )
+  end
+  
+  it "should record perf information correctly" do
+    perf = Rackamole::Stash::Perf.new( "/", 10.0, @now )
+    perf.send( :path ).should      == "/"
+    perf.send( :elapsed ).should   == 10.0
+    perf.send( :timestamp ).should == @now
+  end
+end
+  

data/spec/rackamole/store/mongo_db_spec.rb

@@ -30,6 +30,7 @@ describe Rackamole::Store::MongoDb do
       @args[:method]       = 'GET'
       @args[:params]       = { :blee => "duh".to_json }
       @args[:session]      = { :fred => 10.to_json }
+      @args[:created_at]   = Time.now.utc
     end
     
     it "should mole a context based feature correctly" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rackamole
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Fernand Galiana
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-25 00:00:00 -07:00
+date: 2009-11-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,6 +42,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.17.1
     version: 
+- !ruby/object:Gem::Dependency 
+  name: chronic
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
 - !ruby/object:Gem::Dependency 
   name: twitter4r
   type: :runtime
@@ -106,10 +116,13 @@ files:
 - lib/rackamole/alert/emole.rb
 - lib/rackamole/alert/templates/rackamole/alert/emole/alert.erb
 - lib/rackamole/alert/twitt.rb
-- lib/rackamole/config.rb
 - lib/rackamole/interceptor.rb
 - lib/rackamole/logger.rb
 - lib/rackamole/mole.rb
+- lib/rackamole/stash/base.rb
+- lib/rackamole/stash/collector.rb
+- lib/rackamole/stash/fault.rb
+- lib/rackamole/stash/perf.rb
 - lib/rackamole/store.rb
 - lib/rackamole/store/log.rb
 - lib/rackamole/store/mongo_db.rb
@@ -164,10 +177,16 @@ files:
 - samples/rails/moled/script/server
 - samples/rails/moled/test/performance/browsing_test.rb
 - samples/rails/moled/test/test_helper.rb
-- samples/sinatra/blee.rb
 - samples/sinatra/moled.rb
+- samples/sinatra/public/.DS_Store
+- samples/sinatra/public/images/mole_logo.png
+- samples/sinatra/public/stylesheets/styles.css
+- samples/sinatra/views/index.erb
+- samples/sinatra/views/layout.erb
 - samples/sinatra/views/normal.erb
 - samples/sinatra/views/params.erb
+- samples/sinatra/views/post.erb
+- samples/sinatra/views/slow.erb
 - spec/expected_results/mole_exception.log
 - spec/expected_results/mole_feature.log
 - spec/expected_results/mole_perf.log
@@ -176,6 +195,9 @@ files:
 - spec/rackamole/interceptor_spec.rb
 - spec/rackamole/logger_spec.rb
 - spec/rackamole/mole_spec.rb
+- spec/rackamole/stash/collector_spec.rb
+- spec/rackamole/stash/fault_spec.rb
+- spec/rackamole/stash/perf_spec.rb
 - spec/rackamole/store/log_spec.rb
 - spec/rackamole/store/mongo_db_spec.rb
 - spec/rackamole_spec.rb
@@ -194,6 +216,7 @@ files:
 - tasks/zentest.rake
 - z_experiments/config.rb
 - z_experiments/config_sample.rb
+- z_experiments/configuration.rb
 has_rdoc: true
 homepage: http://www.rackamole.com
 licenses: []

data/samples/sinatra/blee.rb

@@ -1,7 +0,0 @@
-require 'rubygems'
-require 'sinatra'
-require 'forwardable'
-
-get '/' do
-  'Hello world!'
-end