derailed-mole 1.0.10

data/config/database.yml

@@ -0,0 +1,21 @@
+# ------------------------ Databases ------------------------ 
+#
+# Local login
+local:     &local
+ adapter:  mysql
+ host:     localhost
+ username: root
+ password: 
+
+local_dev: &local_dev
+  <<:       *local
+  database: mole_dev
+  
+local_test: &local_test
+  <<: *local
+  database: mole_test
+
+# ------------------------ Environments ------------------------ 
+#  
+development: *local_dev 
+test:        *local_test

data/config/test_database.yml

@@ -0,0 +1,69 @@
+                                                  #
+# ------------------------ Databases ------------------------ 
+#
+
+# Production read-only
+read_only: &read_only
+  adapter:  mysql
+  host:     10.10.12.100
+  database: ci_sentiment_db
+  username: ciro  
+  password: ciro
+
+# Production writable
+writable: &writable
+ adapter: mysql
+ host:     10.10.12.101
+ database: ci_sentiment_db
+ username: ciprod
+ password: ciprod
+
+# Remote development database
+dev2: &dev2
+ adapter:  mysql
+ host:     dev2
+ encoding: utf8
+ database: ci_sentiment_db
+ username: root  
+ password: alchem1st
+
+# CC test database
+cc: &cc
+ adapter:  mysql
+ host:     10.10.14.105
+ encoding: utf8
+ database: sentiment_test
+ username: root  
+ password: alchem1st
+
+# Local login
+local: &local
+ adapter:  mysql
+ host:     localhost
+ username: root
+ password: 
+
+local_dev: &local_dev
+  <<: *local
+  database: sentiment_dev
+  
+local_test: &local_test
+  <<: *local
+  database: sentiment_test
+ 
+yahoo: &yahoo
+  adapter: mysql
+  database: ci_yahoo_db
+  host: 10.10.12.104
+  username: ciprod
+  password: ciprod
+#
+# ------------------------ Environments ------------------------ 
+#  
+development:      *local_dev 
+test:             *local_test
+beta:             *dev2
+production:       *writable
+cc:               *cc
+yahoo_production: *yahoo
+production_ro:    *read_only

data/lib/mole.rb

@@ -0,0 +1,260 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? Mole
+  require 'activerecord'
+  module Mole                 
+    # :stopdoc:
+    LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+    PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    
+    # :startdoc:  
+    # The MOle can be ran in a couple of modes: Transient and Persistent         
+    # Transient mode will log the output to the specified log file
+    # Persistent mode will log the mole output to your db      
+    # The default is :transient
+    def self.run_modes #:nodoc:
+      [:transient, :persistent]
+    end
+  
+    # MOle Default settings 
+    def self.defaults #:nodoc:
+      @defaults ||= { 
+        :moleable         => false, 
+        :application      => "Default", 
+        :perf_threshold   => 5,          
+        :mode             => :transient,  
+        :emole_from       => "MOleBeatch",  
+        :emole_recipients => [],        
+        :mole_config      => nil,      
+        # logging options
+        :log_file           => $stdout,
+        :log_level          => :info,
+        :email_alerts_to    => "MOleBeatch",
+        :email_alert_level  => :error }      
+    end                               
+                                     
+    # Reset the configuration to what it would be when the class is parsed
+    # this is needed mainly for running specs.  This resets the class to the
+    # state it was before initialize is called.  initialize MUST be called
+    # after reset_configuration! is invoked
+    def self.reset_configuration! #:nodoc:
+      @logger.clear_appenders if @logger
+      @logger = nil
+      @config = nil
+    end
+            
+    # Initialize the MOle 
+    # Valid options are
+    # <tt>moleable</tt>::         specify if this application is moleable.
+    #                             Defaults to false.
+    # <tt>application</tt>::      the name of the application to be moled.
+    # <tt>perf_threshold</tt>::   the performance threshold over which a Mole condition will be issued.
+    #                             Defaults to 5 seconds
+    # <tt>mode</tt>::             the MOle logging mole. The mole can either log information to a db via
+    #                             the :persistent option or to a log file via the :transient flag.
+    #                             Defaults to transient
+    # <tt>emole_from</tt>::       the EMole originator when sending eMOle alerts.
+    # <tt>emole_recipients</tt>:: a collection of EMOle recipients
+    # <tt>mole_config</tt>::      the location of the MOle configuration file where the interceptors will
+    #                             be defined.
+    # <tt>log_file</tt>::         The log file to be used to log MOle interceptions
+    # <tt>log_level</tt>::        logging level ie :info, :debug, :error, :warn...
+    # <tt>email_alerts_to</tt>::  log level email alert recipients.
+    # <tt>email_alert_level</tt>:: specifies which log level will trigger email alerts to be sent   
+    def self.initialize( opts={} ) 
+      @config = defaults.merge( opts )    
+      @config[:email_alerts_to] = @config[:emole_recipients] if @config[:emole_recipients] and !@config[:emole_recipients].empty?
+      # Add the mole/lib to the ruby path...
+      $: << libpath
+      Mole.require_all_libs_relative_to __FILE__                                       
+    end
+      
+    # Loads the mole configuration file
+    # You can either specify a directory containing mole config files or 
+    # a single mole config file via the mole_config option.
+    def self.load_mole_configuration
+      return unless moleable?      
+      raise "Unable to find the MOle configuration from `#{conf_file}" if conf_file and !File.exists? conf_file      
+      unless @config_loaded
+        @config_loader = true
+        if File.directory? conf_file
+          logger.debug "--- Loading MOle configs files from directory `#{conf_file}"          
+          load_all_moles_relative_to( conf_file )
+        else
+          logger.debug "--- Loading single MOle config #{conf_file}"          
+          load conf_file
+        end
+      end
+      @config_loaded
+    end
+    
+    # Fetch the MOle configuration file
+    def self.conf_file #:nodoc:
+      config[:mole_config]
+    end
+                 
+    # EMole alert sender             
+    def self.emole_from #:nodoc:
+      config[:emole_from]
+    end
+                        
+    # EMole alert recipients
+    def self.emole_recipients  #:nodoc:
+      config[:emole_recipients]
+    end
+             
+    # Fetch the MOle configuration
+    def self.config  #:nodoc:
+      @config
+    end
+  
+    # Debug                        
+    def self.dump #:nodoc:
+      puts "" 
+      puts "Mole Configuration Landscape"    
+      config.keys.sort{ |a,b| a.to_s <=> b.to_s }.each do |k| 
+        key   = k.to_s.rjust(20)
+        value = config[k].to_s.rjust(97,".")
+        puts "#{key} : #{value}"
+      end
+    end
+
+    # get a hold of a logger.  This is the global logger for sentiment.
+    def self.logger #:nodoc:   
+      @logger ||= ::Mole::Logger.new( { :log_file          => config[:log_file], 
+                                        :logger_name       => "MOle",
+                                        :log_level         => config[:log_level],
+                                        :email_alerts_to   => config[:email_alerts_to],
+                                        :email_alert_level => config[:email_alert_level],
+                                        :additive          => false } )
+    end
+            
+    # The name of the MOled application
+    def self.application #:nodoc:
+      config[:application]
+    end                
+                          
+    # Is this application is MOleable
+    def self.moleable? #:nodoc:
+      config[:moleable]
+    end                
+                                         
+    # Returns the MOle perf threshold. If any MOled features takes longer
+    # than this time to complete, then an alarm will be triggered...
+    def self.perf_threshold #:nodoc:
+      config[:perf_threshold]
+    end
+        
+    # Enable to toggle between different log modes ie :persistent/:transient
+    def self.switch_mode( mode )
+      config[:mode] = mode
+    end
+                      
+    # Check if the MOle is running in persistent mode
+    def self.persistent?
+      config[:mode] == :persistent
+    end
+  
+    # Returns the library path for the module. If any arguments are given,
+    # they will be joined to the end of the libray path using
+    # <tt>File.join</tt>.
+    #
+    def self.libpath( *args ) #:nodoc:
+      args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+    end
+
+    # Returns the lpath for the module. If any arguments are given,
+    # they will be joined to the end of the path using
+    # <tt>File.join</tt>.
+    #
+    def self.path( *args ) #:nodoc:
+      args.empty? ? PATH : ::File.join(PATH, *args)
+    end
+
+    # Utility method used to require all files ending in .rb that lie in the
+    # directory below this file that has the same name as the filename passed
+    # in. Optionally, a specific _directory_ name can be passed in such that
+    # the _filename_ does not have to be equivalent to the directory.
+    #
+    def self.require_all_libs_relative_to( fname, dir = nil ) #:nodoc:
+      dir       ||= ::File.basename(fname, '.*')
+      search_me   = ::File.expand_path( ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+      Dir.glob(search_me).sort.each {|rb| require rb}
+    end
+
+    # Utility method used to load all MOle config files ending in .rb that lie in the
+    # directory below this file that has the same name as the filename passed
+    # in. Optionally, a specific _directory_ name can be passed in such that
+    # the _filename_ does not have to be equivalent to the directory.
+    #
+    def self.load_all_moles_relative_to( mole_dir ) #:nodoc:
+      search_me = ::File.join( mole_dir, '**', '*.rb')
+      Dir.glob(search_me).sort.each {|rb| load rb}
+    end
+    
+    # Stolen from inflector
+    def self.camelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    
+    # Fetch all ruby files in the given directory and return a cltn of class names
+    def self.find_controller_classes( dir )
+      classes   = []
+      search_me = ::File.expand_path( ::File.join(dir, '*.rb'))
+      # BOZO !! This kind of sucks - need to exclude application controller for rails otherwise class loading error ??
+      Dir.glob(search_me).sort.each {|rb| classes << camelize( File.basename( rb, ".rb") ) unless File.basename( rb, ".rb") == "application" }
+      classes
+    end
+    
+    # Automatically setup on perf MOle on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_perf( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz    = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        clazz.mole_perf( :features => features, &block )
+      end
+    end
+    
+    # Automatically setup MOle untrapped exception on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path
+    def self.auto_unchecked( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz    = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        clazz.mole_unchecked( :features => features, &block )
+      end
+    end
+
+    # Automatically setup MOle after filter on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_after( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        features.each do |feature|
+          clazz.mole_after( :feature => feature, &block )
+        end
+      end
+    end
+
+    # Automatically setup MOle after filter on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_before( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        features.each do |feature|
+          clazz.mole_before( :feature => feature, &block )
+        end
+      end
+    end
+    
+  end
+end

data/lib/mole/db/migrate.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+# -----------------------------------------------------------------------------
+# Sets up the MOle persistent layer
+# Two tables are involved: mole_features and mole_logs 
+# -----------------------------------------------------------------------------
+require 'rake'
+require 'rake/tasklib'
+
+module Mole
+  module Db           
+    class Migrate                     
+      def initialize( opts )
+        @direction = opts.direction
+        @config    = opts.configuration
+        @env       = opts.environment
+      end
+                                                      
+      # Creates a MOle migration by creating or dropping the MOle related tables    
+      def apply #:nodoc:
+        setup
+        @direction == :up ? migrate_up : migrate_down
+      end
+                                              
+      # Setup database connection prior to applying migrations
+      def setup #:nodoc:
+        require 'rubygems'
+        gem "activerecord"
+        require 'active_record'  
+        db_config = YAML.load_file( File.expand_path( @config ) )[@env]
+        ::ActiveRecord::Base.establish_connection(db_config)
+      end                                                   
+                        
+      # ---------------------------------------------------------------------
+      # Create mole persistence tables ( 2 tables mole_features/mole_logs )
+      def migrate_up
+        # Create the mole_features table if it doesn't exist
+        unless ActiveRecord::Schema.tables.include?('mole_features')
+          ActiveRecord::Schema.create_table('mole_features') do |t|
+            t.column :name,             :string     
+            t.column :context,          :string
+            t.column :app_name,         :string
+            t.column :created_at,       :datetime
+            t.column :updated_at,       :datetime
+          end
+          ActiveRecord::Schema.add_index( 'mole_features', 
+                                          ['name', 'context', 'app_name'], 
+                                          :name   => 'feature_idx')
+        end
+        # Create the mole_logs table if it doesn't exist
+        unless ActiveRecord::Schema.tables.include?('mole_logs')
+          ActiveRecord::Schema.create_table('mole_logs') do |t|
+            t.column :mole_feature_id,  :integer
+            t.column :user_id,          :integer
+            t.column :params,           :string, :limit => 1024    
+            t.column :ip_address,       :string
+            t.column :browser_type,     :string  
+            t.column :host_name,        :string
+            t.column :created_at,       :datetime
+            t.column :updated_at,       :datetime
+          end     
+          ActiveRecord::Schema.add_index( 'mole_logs', 
+                                          ['mole_feature_id','user_id'], 
+                                          :name   => "log_feature_idx" )
+          ActiveRecord::Schema.add_index( 'mole_logs', 
+                                          ['mole_feature_id','created_at'], 
+                                          :name   => "log_date_idx",
+                                          :unique => true )
+        end
+      end
+                                                     
+      # -------------------------------------------------------------------------
+      # Destroys mole persistence tables
+      def migrate_down
+        # Delete the mole_feature table
+        if ActiveRecord::Schema.tables.include?( 'mole_features' )                                                             
+          ActiveRecord::Schema.remove_index( 'mole_features', :name => 'feature_idx' )              
+          ActiveRecord::Schema.drop_table( 'mole_features' )
+        end
+    
+        # Delete the mole_logs table
+        if ActiveRecord::Schema.tables.include?( 'mole_logs' )
+          ActiveRecord::Schema.remove_index( 'mole_logs', :name => 'log_feature_idx' )        
+          ActiveRecord::Schema.remove_index( 'mole_logs', :name =>'log_date_idx' )              
+          ActiveRecord::Schema.drop_table( 'mole_logs' )
+        end
+      end                                      
+    end
+  end
+end

data/lib/mole/e_mole.rb

@@ -0,0 +1,75 @@
+require 'action_mailer'
+
+module Mole
+  class EMole < ActionMailer::Base        
+    self.template_root = File.join( File.dirname(__FILE__), %w[.. .. templates] )
+                            
+    def setup #:nodoc:
+      recipients  ::Mole.emole_recipients
+      from        ::Mole.emole_from             
+      @host = `hostname`      
+    end
+       
+    # Setup aspect
+    %w[perf exception feature].each do |asp|
+      module_eval "def #{asp}_alerts_with_setup( context, user_name, opts={} ) setup; #{asp}_alerts_without_setup( context, user_name, opts) end #:nodoc:"
+    end
+    
+    # send out feature alerts
+    def feature_alerts( context, user_id, options={} )
+      Mole.logger.debug "Sending feature email from #{::Mole.emole_from} -- to #{::Mole.emole_recipients}"                  
+      subject     "[FEATURE] #{options[:feature]} -- #{@host} -- #{Mole.application} -- #{user_id}"        
+      body        :application  => Mole.application,
+                  :host_name    => @host,
+                  :context      => context.class.name,
+                  :feature      => options[:feature],
+                  :args         => dump_args( options )
+    end                                  
+    alias_method_chain :feature_alerts, :setup
+    
+    # send out mole performance alert
+    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,       
+                  :host_name    => @host,      
+                  :context      => context.class.name,
+                  :feature      => options[:feature],                          
+                  :elapsed_time => options[:elapsed_time] ,
+                  :args         => dump_args( options )
+    end           
+    alias_method_chain :perf_alerts, :setup
+
+    # send out mole exception alerts
+    def exception_alerts( context, user_id, options={} )
+      Mole.logger.debug "Sending perf email from #{::Mole.emole_from} -- to #{::Mole.emole_recipients}"                  
+      subject     "[EXCEPTION] #{@host} -- #{Mole.application} -- #{user_id}"        
+      body        :application  => Mole.application,
+                  :host_name    => @host,
+                  :context      => context.class.name,
+                  :feature      => options[:feature],
+                  :boom         => options[:boom],  
+                  :trace        => dump_stack( options[:boom] ),
+                  :args         => dump_args( options )                  
+    end                                  
+    alias_method_chain :exception_alerts, :setup
+                   
+    # dumps partial stack
+    def dump_stack( boom )   
+      return boom if boom.is_a? String         
+      buff = boom.backtrace[0...3].join( "\r" )
+    end
+                                        
+    # dumps arguments
+    def dump_args( args )
+      return "N/A" unless args
+      buff = []
+      args.keys.sort { |a,b| a.to_s <=> b.to_s}.each do |k|  
+        key   = k.to_s.rjust(20)
+        value = args[k].to_s.rjust(97,".")
+        buff << "#{key} :  #{value}" 
+      end
+      buff.join( "\r" )
+    end
+  end
+end