mole 0.0.1 → 1.0.0

data/lib/mole/e_mole.rb

@@ -28,7 +28,7 @@ module Mole
     alias_method_chain :feature_alerts, :setup
     
     # send out mole performance alert
-    def perf_alerts( context, user_id, options={} )                                           
+    def perf_alerts( context, user_id, options={} )                                                                      
       Mole.logger.debug "Sending perf email from #{::Mole.emole_from} -- to #{::Mole.emole_recipients}"                  
       subject     "[PERF] #{@host} -- #{Mole.application} -- #{user_id}"        
       body        :application  => ::Mole.application,       

data/lib/mole/models/mole_feature.rb

@@ -10,16 +10,16 @@ class MoleFeature < ActiveRecord::Base
     
     # find performance feature
     def find_performance_feature( app_name )
-      find_feature( performance, app_name )
+      find_or_create_feature( performance, app_name )
     end
                                  
     # find exception feature
     def find_exception_feature( app_name )         
-      find_feature( exception, app_name )
+      find_or_create_feature( exception, app_name )
     end
     
     def find_all_feature( app_name )
-      find_feature( all, app_name )
+      find_or_create_feature( all, app_name )
     end
              
     # Finds all the features available for a given application
@@ -32,8 +32,8 @@ class MoleFeature < ActiveRecord::Base
                         :order      => "name asc" )      
     end
       
-    # locates an existing feature or create a new one
-    def find_feature( name, app_name, ctx_name=nil )
+    # locates an existing feature or create a new one if it does not exist.
+    def find_or_create_feature( name, app_name, ctx_name=nil )
       if name.nil? or name.empty? 
         ::Mole.logger.error( "--- MOLE ERROR - Invalid feature. Empty or nil" ) 
         return nil

data/lib/mole/models/mole_log.rb

@@ -4,28 +4,7 @@
 class MoleLog < ActiveRecord::Base                                             
   belongs_to :mole_feature  
     
-  class << self                                     
-    # logs unchecked exception           
-    def check_it( context, user_id, args )     
-      if args[:boom]
-        args[:trace] = dump_stack( args[:boom] )
-        args[:boom]  = args[:boom].to_s
-      end
-      log_it( context, MoleFeature::find_exception_feature( ::Mole.application ), user_id, args ) if ::Mole::moleable?
-    end             
-                                       
-    # logs perf occurence
-    def perf_it( context, user_id, args )
-      log_it( context, MoleFeature::find_performance_feature( ::Mole.application ), user_id, args ) if ::Mole::moleable?
-    end
-          
-    # persists mole information to the database. 
-    # This call will store information on the mole dedicated tables namely 
-    # mole_features and mole_logs.                                  
-    def mole_it(context, feature, user_id, args)   
-      log_it( context, MoleFeature::find_feature( feature, ::Mole.application, context.class.name ), user_id, args ) if ::Mole::moleable?
-    end               
-    
+  class << self                                         
     # mole the bastard - create db entry into mole logs
     def log_it( context, feature, user_id, args )
       args    ||= "no args"                           
@@ -39,11 +18,6 @@ class MoleLog < ActiveRecord::Base
                       :browser_type => browser_type )
     end
                    
-    # dumps partial stack
-    def dump_stack( boom )      
-      buff = boom.backtrace[0...3].join( "-" )
-    end
-
     # extract orginating ip address and browser type                                               
     def log_details( context ) #:nodoc:
       ip_addr, browser_type = nil

data/lib/mole/moler.rb

@@ -12,7 +12,12 @@ module Mole
       # configuration to see if this event should be persisted to the db or
       # sent out to the logger.           
       def check_it( context, user_id, args )                                            
-        return unless ::Mole.moleable?
+        return unless ::Mole.moleable?   
+        # If exception is given record the first couple of frames
+        if args[:boom]
+          args[:trace] = dump_stack( args[:boom] )
+          args[:boom]  = args[:boom].to_s
+        end        
         if ::Mole.persistent?             
           MoleLog.log_it( context, MoleFeature::find_exception_feature( ::Mole.application ), user_id, args )             
         else                                                                            
@@ -38,14 +43,21 @@ module Mole
       def mole_it(context, feature, user_id, args)    
         return unless ::Mole.moleable?        
         if ::Mole.persistent?
-          MoleLog.log_it( context, MoleFeature::find_feature( feature, ::Mole.application, context.class.name ), user_id, args )
+          MoleLog.log_it( context, MoleFeature::find_or_create_feature( feature, ::Mole.application, context.class.name ), user_id, args )
         else
           ::Mole.logger.log_it( context, feature, user_id, args )
         end
         # Send out email notification if requested   
-        args[:feature] = feature
-        Mole::EMole.deliver_feature_alerts( context, user_id, args ) if args[:email] and args[:email] == true                        
-      end  
+        if args[:email] and args[:email] == true 
+          args[:feature] = feature
+          Mole::EMole.deliver_feature_alerts( context, user_id, args )                         
+        end
+      end         
+      
+      # dumps partial stack
+      def dump_stack( boom )      
+        buff = boom.backtrace[0...3].join( "-" )
+      end      
     end             
   end
 end

data/lib/mole/version.rb

@@ -1,8 +1,8 @@
 module Mole
   module Version
-    MAJOR = 0
+    MAJOR = 1
     MINOR = 0
-    TINY  = 1
+    TINY  = 0
     
     # Returns the version string for the library.
     #

data/lib/mole.rb

@@ -26,9 +26,8 @@ unless defined? Mole
         :perf_threshold   => 5,          
         :mode             => :transient,  
         :emole_from       => "MOleBeatch",  
-        :mole_config      => nil,
-        :emole_recipients => [],
-      
+        :emole_recipients => [],        
+        :mole_config      => nil,      
         # logging options
         :log_file           => $stdout,
         :log_level          => :info,

data/spec/emole_spec.rb

@@ -9,8 +9,8 @@ describe Mole::EMole do
   before( :each ) do      
     ::Mole.reset_configuration!
     ::Mole.initialize( :moleable         => true, 
-                     :emole_from       => "MOleBeatch@liquidrail.com", 
-                     :emole_recipients => ['fernand@liquidrail.com'] )
+                       :emole_from       => "MOleBeatch@liquidrail.com", 
+                       :emole_recipients => ['fernand@liquidrail.com'] )
   end
   
   it "should send out a correct perf alert" do

data/spec/models/mole_feature_spec.rb

@@ -15,14 +15,14 @@ describe MoleFeature do
   end     
   
   it "should create a new feature" do
-    feature = MoleFeature.find_feature( "Fred", ::Mole.application, self.class.name )
+    feature = MoleFeature.find_or_create_feature( "Fred", ::Mole.application, self.class.name )
     feature.should_not     be_nil
     feature.name.should    == "Fred"
     feature.context.should == self.class.name
   end  
   
   it "should not create a feature with no name" do
-    feature = MoleFeature.find_feature( "", ::Mole.application, self.class.name )
+    feature = MoleFeature.find_or_create_feature( "", ::Mole.application, self.class.name )
     feature.should be_nil
   end    
   
@@ -30,7 +30,7 @@ describe MoleFeature do
     %w[ all performance exception].each do |f|
       MoleFeature.send( "find_#{f}_feature".to_sym, ::Mole.application )
     end                                                                              
-    MoleFeature.find_feature( "Fred", ::Mole.application, self.class.name )
+    MoleFeature.find_or_create_feature( "Fred", ::Mole.application, self.class.name )
     features = MoleFeature.find_features( ::Mole.application )
     features.should have(4).mole_features
   end

data/spec/models/mole_log_spec.rb

@@ -4,59 +4,46 @@ describe MoleLog do
   before( :each ) do    
     ::Mole.reset_configuration!
     ::Mole.initialize( :mode => :persistent, :log_level => :info, :moleable => true )
+    @args = { :blee => "Hello", :duh => "World" }
   end
                       
-  it "should log unchecked exceptions correctly" do   
+  it "should log unchecked exceptions correctly" do
+     args = @args 
+     feature = MoleFeature.find_exception_feature( ::Mole.application )
+     feature.should_not be_nil      
      begin
        raise "Something crapped out"
-     rescue => boom
-       MoleLog.check_it( self, 100, :blee => "Hello", :duh => "World", :boom => boom )
+     rescue => boom     
+       args[:boom] = Mole::Moler.dump_stack( boom )
+       MoleLog.log_it( self, feature, 100, args )
      end
-     except_feature = MoleFeature.find_exception_feature( ::Mole.application )
-     except_feature.should_not be_nil     
-     
-     log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', except_feature.id] )     
-     log.should_not           be_nil
-     log.should               have(1).mole_log     
-     log.first.user_id.should == 100
+     check_it( feature, 100, @args )   
   end
       
-  it "should log perf exception correctly" do
-     MoleLog.perf_it( self, 100, :blee => "Hello", :duh => "World" )
-     perf_feature = MoleFeature.find_performance_feature( ::Mole.application )
-     perf_feature.should_not be_nil     
-     
-     log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', perf_feature.id] )     
-     log.should_not           be_nil
-     log.should               have(1).mole_log     
-     log.first.user_id.should == 100
+  it "should log perf exception correctly" do                       
+     feature = MoleFeature.find_performance_feature( ::Mole.application )
+     feature.should_not be_nil         
+     MoleLog.log_it( self, feature, 200, @args )
+     check_it( feature, 200, @args )
   end
 
   it "should mole a feature correctly" do
-     MoleLog.mole_it( "Test", "fred", 100, :blee => "Hello", :duh => "World" )
-     feature = MoleFeature.find_feature( "fred", ::Mole.application, "Test".class.name )
-     feature.should_not be_nil     
-     
-     log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', feature.id] )     
-     log.should_not           be_nil
-     log.should               have(1).mole_log     
-     log.first.user_id.should == 100
+     feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, "Test".class.name )
+     feature.should_not be_nil         
+     MoleLog.log_it( "Test", feature, 300, @args )
+     check_it( feature, 300, @args )
   end
 
   it "should log request info correctly" do
-     ctrl = Moled::Controller.new
-     MoleLog.mole_it( ctrl, "fred", 100, :blee => "Hello", :duh => "World" )
-     feature = MoleFeature.find_feature( "fred", ::Mole.application, ctrl.class.name )
-     feature.should_not be_nil     
-     
-     log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', feature.id] )     
-     log.should_not           be_nil
-     log.should               have(1).mole_log     
-     log.first.user_id.should == 100                 
-     log.first.ip_address.should    == "1.1.1.1"
-     log.first.browser_type.should  == "GodZilla"
+     ctrl    = Moled::Controller.new
+     feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, ctrl.class.name )
+     feature.should_not be_nil          
+     MoleLog.log_it( ctrl, feature, 400, @args )
+     log = check_it( feature, 400, @args )
+     log.ip_address.should    == "1.1.1.1"
+     log.browser_type.should  == "GodZilla"
   end   
-                   
+  
   module Moled
     class Controller
       class Request

data/spec/moler_spec.rb

@@ -1,64 +1,76 @@
 require File.join(File.dirname(__FILE__), "spec_helper" )           
+                   
+require 'action_mailer'
+ActionMailer::Base.delivery_method       = :sendmail
+ActionMailer::Base.raise_delivery_errors = true                                       
 
 describe Mole::Moler do     
   TEST_LOG = "/tmp/test.log"                    
   before( :each ) do                                          
     ::Mole.reset_configuration!
     @io = StringIO.new
-    ::Mole.initialize( :mode => :transient, :logger_name => "Test", :log_file => @io, :moleable => true )            
+    ::Mole.initialize( :mode             => :transient, 
+                       :logger_name      => "Test", 
+                       :log_file         => @io, 
+                       :moleable         => true,
+                       :emole_from       => "MOleBeatch@liquidrail.com", 
+                       :emole_recipients => ['fernand@liquidrail.com'] )
+    @args = { :blee => "Hello", :duh => "World" }
   end
                         
   it "should log unchecked to the db exceptions correctly" do
-    ::Mole.switch_mode :persistent        
-    ::Mole::Moler.check_it( self, 100, :blee => "Hello", :duh => "World" )
-    except_feature = MoleFeature.find_exception_feature( ::Mole.application )
-    except_feature.should_not be_nil     
-
-    log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', except_feature.id] )     
-    log.should_not           be_nil
-    log.should               have(1).mole_log     
-    log.first.user_id.should == 100
+    ::Mole.switch_mode :persistent   
+    begin
+      raise "Something bad happened !"
+    rescue => boom
+      @args[:boom] = boom     
+      ::Mole::Moler.check_it( self, 100, @args )
+    end
+    feature = MoleFeature.find_exception_feature( ::Mole.application )
+    feature.should_not be_nil     
+    check_it( feature, 100, @args )
   end
       
   it "should log perf exception to the db correctly" do             
     ::Mole.switch_mode :persistent
-    ::Mole::Moler.perf_it( self, 100, :blee => "Hello", :duh => "World" )
-    perf_feature = MoleFeature.find_performance_feature( ::Mole.application )
-    perf_feature.should_not be_nil     
-
-    log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', perf_feature.id] )     
-    log.should_not           be_nil
-    log.should               have(1).mole_log     
-    log.first.user_id.should == 100
+    ::Mole::Moler.perf_it( self, 100, @args )
+    feature = MoleFeature.find_performance_feature( ::Mole.application )
+    feature.should_not be_nil     
+    check_it( feature, 100, @args )
   end
 
   it "should mole a feature to the db correctly" do                 
     ::Mole.switch_mode :persistent
-    ::Mole::Moler.mole_it( "Test", "fred", 100, :blee => "Hello", :duh => "World" )
-    feature = MoleFeature.find_feature( "fred", ::Mole.application, "Test".class.name )
+    ::Mole::Moler.mole_it( "Test", "fred", 100, @args )
+    feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, "Test".class.name )
     feature.should_not be_nil     
+    check_it( feature, 100, @args )
+  end
 
-    log = MoleLog.find( :all, :conditions => ['mole_feature_id = ?', feature.id] )     
-    log.should_not           be_nil
-    log.should               have(1).mole_log     
-    log.first.user_id.should == 100
+  it "should log a feature to the db and send an email correctly" do             
+    ::Mole.switch_mode :persistent      
+    @args[:email] = true
+    ::Mole::Moler.mole_it( "Test", "fred", 100, @args )
+    feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, "Test".class.name )
+    feature.should_not be_nil     
+    check_it( feature, 100, { :email => true, :blee => "Hello", :duh => "World" } )
   end
   
   it "should log unchecked exceptions to the logger correctly" do   
     ::Mole.switch_mode :transient
-    ::Mole::Moler.check_it( self, 100, :blee => "Hello", :duh => "World" )
+    ::Mole::Moler.check_it( self, 100, @args )
     @io.string[@io.string.index( "---" )..@io.string.size].should == "--- 100 -> blee=>Hello, duh=>World\n"
   end
 
   it "should log perf exception to the logger correctly" do             
     ::Mole.switch_mode :transient
-    ::Mole::Moler.perf_it( self, 100, :blee => "Hello", :duh => "World" )                                  
+    ::Mole::Moler.perf_it( self, 100, @args )                                  
     @io.string[@io.string.index( "---" )..@io.string.size].should == "--- 100 -> blee=>Hello, duh=>World\n"    
   end
 
   it "should mole a feature to the logger correctly" do             
     ::Mole.switch_mode :transient
-    ::Mole::Moler.mole_it( "Test", "Fred", 100, :blee => "Hello", :duh => "World" )                                  
+    ::Mole::Moler.mole_it( "Test", "Fred", 100, @args )                                  
     @io.string[@io.string.index( "---" )..@io.string.size].should == "--- 100 -> blee=>Hello, duh=>World\n"    
   end
   

data/spec/spec_helper.rb

@@ -56,4 +56,21 @@ Spec::Runner.configure do |config|
     rescue
     end
   end
+end      
+                              
+# Convenience to check mole_logs
+def check_it( feature, user_id, args={} )
+  log = MoleLog.find( :first, :conditions => ['mole_feature_id = ?', feature.id] )     
+  log.should_not     be_nil
+  log.user_id.should == user_id         
+  log_args = YAML.load( log.params )
+  check_args( log_args, args )
+  log
 end                           
+def check_args( args, expected_args )
+  args.should have(expected_args.size).items
+  expected_args.keys.each do |k| 
+    args[k].should_not be_nil
+    args[k].should == expected_args[k]
+  end
+end                        

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: mole
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2008-03-01 00:00:00 -07:00
+  version: 1.0.0
+date: 2008-03-02 00:00:00 -07:00
 summary: A flexible way to track user's interactions within your ruby web applications
 require_paths: 
 - lib