rackamole 0.3.5 → 0.3.6

data/README.rdoc

@@ -38,10 +38,11 @@
   Logging
   Hitimes
   mongo + mongo_ext
-  Twitter4r
   Chronic
   Erubis
-  Pony
+  Twitter4r  
+  Mail
+  Growl
 
 == INSTALL
 

data/Rakefile

@@ -32,4 +32,5 @@ depend_on "mongo_ext"    , ">= 0.17.1"
 depend_on "chronic"      , ">= 0.2.3"
 depend_on "twitter4r"    , ">= 0.3.0"
 depend_on "erubis"       , ">= 2.6.0"
-depend_on "pony"         , ">= 0.6"
+depend_on "mail"         , ">= 2.1.3"
+depend_on "ruby-growl"   , ">= 1.0.1"

data/lib/rackamole.rb

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

data/lib/rackamole/alert/emole.rb

@@ -27,7 +27,8 @@ module Rackamole::Alert
       tmpl       = File.join( template_root, %w[alert.erb] )
       template   = Erubis::Eruby.new( IO.read( tmpl ), :trim => true )
       body       = template.result( binding )
-      subject    = "Rackamole <#{alert_type( args )}> #{request_time?( args )}on #{args[:app_name]}.#{args[:host]} for user #{args[:user_name]}"
+      timing     = request_time( args ) if args[:type] == Rackamole.perf
+      subject    = "Rackamole <#{alert_type( args )}>#{timing ? " #{timing} " : ' '}on #{args[:app_name]}.#{args[:host]} for user #{args[:user_name]}"
       
       mail = Mail.new do
         from    options[:email][:from]
@@ -37,9 +38,9 @@ module Rackamole::Alert
       end      
       mail.deliver!      
       mail
-    rescue => boom
+    rescue => boom    
+      logger.error( "Rackamole email alert failed with error `#{boom}" )      
       boom.backtrace.each { |l| logger.error l }
-      logger.error( "Rackamole email alert failed with error `#{boom}" )
     end
             
     def self.section( title )
@@ -78,8 +79,8 @@ module Rackamole::Alert
         buff  = []
         value = args[key]
         
-        value = request_time?( args ) if key == :request_time
-        
+        value = request_time( args ) if key == :request_time
+
         _spew( buff, '--', (silent ? '' : '  '), key, value, silent )
         buff.join( "\n" )
       end
@@ -103,10 +104,12 @@ module Rackamole::Alert
           when Rackamole.fault
             buff << spew( :fault ) << spew( :stack ) + "\n"
           when Rackamole.perf
-            buff << "#{spew( :request_time )}/#{@options[:perf_threshold]}"
+            buff << "#{spew( :request_time )} [#{@options[:perf_threshold]}]"
         end
         buff << spew( :user_name) << spew( :url ) << spew( :path ) << spew( :status ) 
-        buff << spew( :method ) << spew( :request_time ) << spew( :ip )
+        buff << spew( :method )
+        buff << spew( :request_time ) unless args[:type] == Rackamole.perf 
+        buff << spew( :ip )
         buff.join( "\n" )
       end      
       def self.server()  [ spew( :host ), spew( :software ), spew( :ruby_version ) ]; end
@@ -117,8 +120,9 @@ module Rackamole::Alert
       def self.headers() [ spew( :headers, true ) ]; end
       
       # Dump request time if any...
-      def self.request_time?( args )
-        args[:request_time] ? ("%5.2f " % args[:request_time] ) : ''        
+      def self.request_time( args )
+        return '' unless args[:request_time]
+        "%1.2f" % args[:request_time]
       end
       
       # Identify the type of alert...        

data/lib/rackamole/alert/growl.rb

@@ -0,0 +1,105 @@
+require 'ruby-growl'
+
+module Rackamole::Alert
+  # Leverages growl as a notification client.
+  class Growl
+
+    # Twitt an alert        
+    def self.deliver_alert( logger, options, attrs )
+      @growl ||= Growl.new( logger, options[:growl][:to] )
+      @growl.send_alert( attrs )
+    end
+            
+    # Send a growl notification for particular moled feature. A growl will
+    # be sent based on the configuration :growl defined on Rack::Mole component
+    # This option must specify the to ip addresses and the conditions
+    # that will trigger a growl defined by alert_on for the type of
+    # moled features to track via email. The notification will be sent via UDP,
+    # so you will need to make sure it is properly configured for your domain.
+    #
+    # NOTE: This is just a notification mechanism. All moled event will be either logged 
+    # or persisted in the db regardless.
+    #
+    # === Parameters:
+    # options    :: Mole options. The :growl key must contains :to addresses.
+    # args       :: The gathered information from the mole.
+    def initialize( logger, recipients )
+      raise "You must specify your growl :to addresses" unless recipients
+      @recipients = recipients
+      @logger   = logger
+      @growls   = {}
+    end
+       
+    # Send out a growl notification based of the watched features. A short message will be blasted to your growl
+    # client based on information reported by the mole.
+    # === Params:
+    # args :: The moled info for a given feature. 
+    def send_alert( args )
+      recipients.each do |recipient|
+        buff  = "#{args[:user_name]}:#{display_feature(args)}"
+        title = "#{args[:app_name]}(#{args[:environment]})"
+        case args[:type]
+          when Rackamole.feature
+            type     = "Feature"
+            title    = "[Feat] #{title}"
+            msg      = buff
+            priority = -2
+            sticky   = false
+          when Rackamole.perf
+            type     = "Perf" 
+            title    = "[Perf] #{title}"
+            msg      = "#{buff} #{format_time(args[:request_time])} secs"
+            priority = 2
+            sticky   = true
+          when Rackamole.fault
+            type     = "Fault"
+            title    = "[Fault] #{title}"
+            msg      = "#{buff}\n#{args[:fault]}"
+            priority = 2
+            sticky   = true            
+        end
+        growl( recipient ).notify( type, title, msg, priority, sticky )
+      end
+    rescue => boom
+       logger.error "Rackamole growl alert failed with error `#{boom}"
+    end
+        
+    # =========================================================================
+    private
+    
+       attr_reader :logger, :recipients #:nodoc:
+       
+       # Fetch or create growl application...
+       def growl( recipient )
+         return @growls[recipient[:ip]] if @growls[recipient[:ip]]
+         growl = ::Growl.new( recipient[:ip], 'rackamole', %w(Feature Perf Fault), nil, recipient[:password] )
+         @growls[recipient[:ip]] = growl
+         growl
+       end
+       
+       # Display controller/action or path depending on frmk used...
+       def display_feature( args )
+         return args[:path] unless args[:route_info]
+         "#{args[:route_info][:controller]}##{args[:route_info][:action]}"
+       end
+
+      # Format host ie fred@blee.com => fred
+      def format_host( host )
+        return host.gsub( /@.+/, '' ) if host =~ /@/
+        host
+      end
+      
+      # Format precision on request time
+      def format_time( time )
+        ("%4.2f" % time).to_f
+      end
+      
+      # Truncate for twitt max size      
+      # BOZO !! This will be hosed if not 1.9 for multibyte chars 
+      def truncate(text, length = 140, truncate_string = "...")
+        return "" if text.nil?
+        l = length - truncate_string.size
+        text.size > length ? (text[0...l] + truncate_string).to_s : text
+      end       
+  end
+end

data/lib/rackamole/alert/twitt.rb

@@ -12,14 +12,14 @@ module Rackamole::Alert
     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 
+    # by setting the :twitter option on the Rack::Mole. When a moled 
     # feature comes around it will be twitted on your configured account. This allow your
     # app to twitt about it's status and issues. Currently there are no provisions to throttle
     # the twitts, hence sending out twitt notifications of every moled features would not be 
     # a very good idea. Whereas sending twitts when your application bogs down or throws exception,
     # might be more appropriate. Further work will take place to throttle these events...
-    # Creating a private twitter account and asking folks in your group to follow might be an
-    # alternative to email.
+    # Creating a private twitter account and asking folks in your group to follow might be a
+    # nice alternative to email.
     #
     # NOTE: This is just an alert mechanism. All moled events will be either logged or persisted in the db
     # regardless.
@@ -27,6 +27,7 @@ module Rackamole::Alert
     # === Params:
     # username :: The name on the twitter account
     # password :: The password of your twitter account
+    # logger   :: Instance of the rackamole logger
     def initialize( logger, username, password )
       raise "You must specify your twitter account credentials" unless username or password
       @username = username

data/lib/rackamole/mole.rb

@@ -3,8 +3,8 @@ require 'json'
 require 'mongo'
 require 'yaml'
 
-# TODO - remove default app and db name
 # TODO - add recording for response
+# TODO - need plugable archictecture for alerts and stores
 module Rack
   class Mole
     
@@ -45,8 +45,8 @@ module Rack
     #    :user_key => { :session_key => :user_id, :extractor => lambda{ |id| User.find( id ).name} }
     # ==
     #
-    # :mole_excludes :: Exclude some of the paramaters that the mole would normaly include. The list of 
-    #                   customizable paramaters is: software, ip, browser type, url, path, status, headers and body.
+    # :mole_excludes :: Exclude some of the parameters that the mole would normally include. The list of 
+    #                   customizable parameters is: software, ip, browser type, url, path, status, headers and body.
     #                   This options takes an array of symbols. Defaults to [:body].
     # :perf_excludes :: Specifies a set of paths that will be excluded when a performance issue is detected.
     #                   This is useful when certain requests are known to be slow. When a match is found an
@@ -56,7 +56,7 @@ module Rack
     #   :perf_excludes => [ {:context => '/blee/fred}, {:context => /^\/duh.*/, :threshold => 10 } ]
     # ==
     # :excluded_paths:: Exclude paths that you do not wish to mole by specifying an array of regular expresssions.
-    # :param_excludes:: Exempt certain sensitive request parameters from being logged to the mole. Specify an array of keys as 
+    # :param_excludes:: Exempt certain sensitive request parameters from being logged to the mole. Specify an array of keys
     #                   as symbols ie [:password, :card_number].
     # :session_excludes:: Exempt session params from being logged by the mole. Specify an array of keys as symbols
     #                   ie [:fred, :blee] to exclude session[:fred] and session[:blee] from being stored.
@@ -76,6 +76,12 @@ module Rack
     #   :email => { :from => 'fred@acme.com', :to => ['blee@acme.com', 'doh@acme.com'], :alert_on => [Rackamole.perf, Rackamole.fault]  }
     # ==
     #
+    # :growl        :: You can set up rackamole to send growl notifications when certain features
+    #                  are encounters in the same way email and twitt alerts works. The :to options
+    #                  describes a collection of hash values with the ip and optional password to the recipients.
+    # ==
+    #   :growl => { :to => [{ :ip => '1.1.1.1' }], :alert_on => [Rackamole.perf, Rackamole.fault]  }
+    # ==    
     def initialize( app, opts={} )    
       @app       = app
       init_options( opts )
@@ -118,7 +124,7 @@ module Rack
         raise "Unable to find rackamole config file #{opts[:config_file]}" unless ::File.exists?( opts[:config_file] )
         begin
           opts = YAML.load( ERB.new( IO.read( opts[:config_file] ) ).result( binding ) )[env]
-          opts[:environment] = env
+          opts[:environment] = env 
         rescue => boom
           raise "Unable to parse Rackamole config file #{boom}"
         end        
@@ -151,6 +157,7 @@ module Rack
       # Barf early if something is wrong in the configuration
       configured?( :twitter, [:username, :password, :alert_on], true )
       configured?( :email  , [:from, :to, :alert_on], true )
+      configured?( :growl  , [:to, :alert_on], true )      
     end
     
     # Send moled info to store and potentially send out alerts...
@@ -172,6 +179,12 @@ module Rack
           logger.debug ">>> Sending out email on mole type #{attrs[:type]} from #{options[:email][:from]} to #{options[:email][:to].join( ", ")}"
           Rackamole::Alert::Emole.deliver_alert( logger, options, attrs ) 
         end
+
+        # send growl alert ?
+        if alertable?( :growl, attrs[:type] )
+          logger.debug ">>> Sending out growl on mole type #{attrs[:type]} to @#{options[:growl][:to].inspect}"
+          Rackamole::Alert::Growl.deliver_alert( logger, options, attrs )
+        end
       
         # send twitter alert ?
         if alertable?( :twitter, attrs[:type] )

data/lib/rackamole/store/log.rb

@@ -48,11 +48,11 @@ module Rackamole::Store
         log.info "-"*100
         log.info case args[:type]
           when Rackamole.feature 
-            "FEATURE m()le"
+            "FEATURE"
           when Rackamole.fault
-            "FAULT m()le"
+            "FAULT"
           when Rackamole.perf
-            "PERFORMANCE m()le"
+            "PERFORMANCE"
         end
       end
       

data/spec/data/create_secure_db.rb

@@ -0,0 +1,7 @@
+# BOZO !! Rake task
+require 'rubygems'
+require 'mongo'
+
+con = Mongo::Connection.new( 'localhost' )
+db  = con.db( 'sec_app_test_mdb' )
+db.add_user( 'fred', 'letmein' )

data/spec/expected_results/mole_exception.log

@@ -1,5 +1,5 @@
 ----------------------------------------------------------------------------------------------------
-FAULT m()le
+FAULT
 Type                 : 2
 App_name             : "Test app"
 Environment          : :test

data/spec/expected_results/mole_feature.log

@@ -1,5 +1,5 @@
 ----------------------------------------------------------------------------------------------------
-FEATURE m()le
+FEATURE
 Type                 : 0
 App_name             : "Test app"
 Environment          : :test

data/spec/expected_results/mole_perf.log

@@ -1,5 +1,5 @@
 ----------------------------------------------------------------------------------------------------
-PERFORMANCE m()le
+PERFORMANCE
 Type                 : 1
 App_name             : "Test app"
 Environment          : :test

data/spec/rackamole/alert/emole_spec.rb

@@ -55,10 +55,10 @@ describe Rackamole::Alert::Emole do
     
     it "should send a feature email correctly" do
       alert = Rackamole::Alert::Emole.deliver_alert( nil, @options, @args )
-      alert.body.should    == feature_body
-      alert.subject.should == "Rackamole <Feature> on Test.Fred for user Fernand"
-      alert.from.should    == ["fernand"]
-      alert.to.should      == ["fernand", 'bobo', 'blee']
+      alert.body.to_s.should == feature_body
+      alert.subject.should   == "Rackamole <Feature> on Test.Fred for user Fernand"
+      alert.from.should      == ["fernand"]
+      alert.to.should        == ["fernand", 'bobo', 'blee']
     end
 
     it "should send a perf email correctly" do
@@ -160,13 +160,12 @@ Performance alert on application Test on host Fred
 ----------------------------------------
 o What
 
-  request_time: 15.2/10
+  request_time: 15.20 [10]
   user_name: Fernand
   url: http://bumblebeetuna/fred/blee
   path: /fred/blee
   status: 200
   method: POST
-  request_time: 15.2
   ip: 
 
 ----------------------------------------

data/spec/rackamole/alert/growl_spec.rb

@@ -0,0 +1,95 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+require 'chronic'
+
+describe Rackamole::Alert::Growl do
+  before( :each ) do
+    @recipients = [ {:ip => '1.1.1.1', :password => 'blee' } ]
+    @alert = Rackamole::Alert::Growl.new( nil, :growl => { :to => @recipients } )
+  end
+    
+  describe '#display_feature' do
+    it "should display a rails feature correctly" do
+      @alert.send( :display_feature, :route_info => { :controller => 'fred', :action => 'blee'} ).should == "fred#blee"
+    end
+    
+    it "should display a path feature for other rack framword" do
+      @alert.send( :display_feature, :path => '/fred/blee' ).should == "/fred/blee"
+    end
+  end
+  
+  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[:created_at] = Chronic.parse( "2009/11/19" )
+    end
+
+    it "should growl a feature alert using class method correctly" do
+      growl  = mock( Rackamole::Alert::Growl )
+      client = Growl.stub!( :new )
+      
+      Rackamole::Alert::Growl.should_receive( :new ).with( nil, @recipients ).once.and_return( growl )
+      growl.should_receive( :send_alert ).with( @args ).once.and_return( "yeah" )      
+      
+      Rackamole::Alert::Growl.deliver_alert( nil, { :growl => { :to => @recipients } }, @args )
+    end
+    
+    it "should growl a feature alert correctly" do
+      client = stub( Growl )
+
+      @alert.should_receive( :growl ).once.and_return( client )
+      client.should_receive( :notify ).once
+    
+      @alert.send_alert( @args )
+    end
+  
+    it "should growl a perf alert correctly" do
+      @args[:type]         = Rackamole.perf
+      @args[:request_time] = 10.0
+      
+      client = stub( Growl )
+    
+      @alert.should_receive( :growl ).once.and_return( client )
+      client.should_receive( :notify ).once
+    
+      @alert.send_alert( @args )
+    end
+
+    it "should twitt a perf alert correctly" do
+      @args[:type]  = Rackamole.fault
+      @args[:fault] = 'Oh snap!'
+      
+      client = stub( Growl )
+    
+      @alert.should_receive( :growl ).once.and_return( client )
+      client.should_receive( :notify ).once
+    
+      @alert.send_alert( @args )
+    end
+  end
+
+  describe "#format_time" do
+    it "should format a request time correctly" do
+      @alert.send( :format_time, 12.1234455 ).should == 12.12
+    end
+  end
+  
+  describe "#format_host" do
+    it "should format a host with domain name correctly" do
+      @alert.send( :format_host, 'blee@acme.com' ).should == 'blee'
+    end
+    
+    it "should deal with ip host" do
+      @alert.send( :format_host, '1.1.1.1' ).should == '1.1.1.1'
+    end
+
+    it "should deal with aliases" do
+      @alert.send( :format_host, 'fred' ).should == 'fred'
+    end
+  end
+  
+end

data/spec/rackamole/store/mongo_db_spec.rb

@@ -170,7 +170,7 @@ describe Rackamole::Store::MongoDb do
       store = Rackamole::Store::MongoDb.new( 
         :host     => 'localhost', 
         :port     => 27017, 
-        :db_name  => 'mole_sec_app_test_mdb',
+        :db_name  => 'sec_app_test_mdb',
         :username => 'fred',
         :password => 'letmein',
         :logger   => Rackamole::Logger.new( :file_name => $stdout, :log_level => 'info' ) )
@@ -181,7 +181,7 @@ describe Rackamole::Store::MongoDb do
         store = Rackamole::Store::MongoDb.new( 
           :host     => 'localhost', 
           :port     => 27017, 
-          :db_name  => 'mole_sec_app_test_mdb',
+          :db_name  => 'sec_app_test_mdb',
           :username => 'fred',
           :password => 'hoy',
           :logger   => Rackamole::Logger.new( :file_name => $stdout, :log_level => 'info' ) )      

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rackamole
 version: !ruby/object:Gem::Version 
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors: 
 - Fernand Galiana
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-17 00:00:00 -06:00
+date: 2010-03-22 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -83,14 +83,24 @@ dependencies:
         version: 2.6.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: pony
+  name: mail
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0.6"
+        version: 2.1.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-growl
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: bones
@@ -118,6 +128,7 @@ files:
 - Rakefile
 - lib/rackamole.rb
 - lib/rackamole/alert/emole.rb
+- lib/rackamole/alert/growl.rb
 - lib/rackamole/alert/templates/alert.erb
 - lib/rackamole/alert/twitt.rb
 - lib/rackamole/interceptor.rb
@@ -131,10 +142,12 @@ files:
 - lib/rackamole/store/log.rb
 - lib/rackamole/store/mongo_db.rb
 - lib/rackamole/utils/agent_detect.rb
+- spec/data/create_secure_db.rb
 - spec/expected_results/mole_exception.log
 - spec/expected_results/mole_feature.log
 - spec/expected_results/mole_perf.log
 - spec/rackamole/alert/emole_spec.rb
+- spec/rackamole/alert/growl_spec.rb
 - spec/rackamole/alert/twitt_spec.rb
 - spec/rackamole/interceptor_spec.rb
 - spec/rackamole/logger_spec.rb