aesop 1.1.0.1

data/lib/aesop/dispatchers/log_dispatcher.rb

@@ -0,0 +1,7 @@
+class Aesop::Dispatchers::LogDispatcher
+  include ::Aesop
+
+  def dispatch_exception(exception)
+    Aesop::Logger.info( exception.class.to_s )
+  end
+end

data/lib/aesop/exceptions.rb

@@ -0,0 +1,7 @@
+module Aesop
+  class RedisConnectionException < Exception; end
+  class DispatchException < Exception; end
+  class BootloaderException < Exception; end
+  class DispatcherLoadException < Exception; end
+  class IllegalArgumentException < Exception; end
+end

data/lib/aesop/logger.rb

@@ -0,0 +1,41 @@
+require 'log4r'
+
+module Aesop
+  module Logger
+    DEBUG  = 1
+    INFO   = 2
+    WARN   = 3
+    ERROR  = 4
+    FATAL  = 5
+
+    class << self
+
+      DEFAULT_OUTPUT = 'stdout'
+
+      def log
+        @logger ||= setup
+      end
+
+      def setup
+        logger = Log4r::Logger.new(configuration.name)
+        logger.level = configuration.level
+        logger.outputters = configuration.outputters
+        logger
+      end
+
+      def reset
+        @logger = nil
+      end
+
+      # makes this respond like a Log4r::Logger
+      def method_missing(sym, *args, &block)
+        log.send sym, *args, &block
+      end
+
+      def configuration
+        configatron.logger
+      end
+
+    end
+  end
+end

data/lib/aesop/merb/merb_boot_loader.rb

@@ -0,0 +1,8 @@
+module Aesop
+  class MerbBootLoader < Merb::BootLoader
+    after Merb::BootLoader::ChooseAdapter
+    def self.run
+      Aesop::Aesop.instance.init
+    end
+  end
+end

data/lib/aesop/rails/middleware.rb

@@ -0,0 +1,18 @@
+module Aesop
+  module Rails
+    class Middleware
+      def initialize( app )
+        @app = app
+      end
+
+      def call( env )
+        begin
+          response = @app.call(env)
+        rescue Exception => e
+          Aesop::Aesop.instance.catch_exception(e)
+        end
+        response
+      end
+    end
+  end
+end

data/lib/aesop/rails/railtie.rb

@@ -0,0 +1,18 @@
+module Aesop
+  class Railtie < ::Rails::Railtie
+
+    initializer "aesop.start_plugin" do |app|
+      Aesop::Aesop.instance.init
+
+      middleware = if defined?(ActionDispatch::DebugExceptions)
+        # Rails >= 3.2.0
+        "ActionDispatch::DebugExceptions"
+      else
+        # Rails < 3.2.0
+        "ActionDispatch::ShowExceptions"
+      end
+
+      app.config.middleware.insert_after middleware, "Aesop::Rails::Middleware"
+    end
+  end
+end

data/lib/aesop/recipes.rb

@@ -0,0 +1,20 @@
+module Aesop
+  module Capistrano
+    def self.load_into(configuration)
+      configuration.load do
+        after "deploy:finalize_update", "aesop:record_deployment"
+        namespace :aesop do
+          desc "Record the current time into a file called DEPLOY_TIME"
+          task :record_deployment, :roles => :app do
+            set :deployment_time, Time.now.to_i.to_s
+            put fetch(:deployment_time), "#{configuration.fetch(:release_path)}/DEPLOY_TIME"
+          end
+        end
+      end
+    end
+  end
+end
+
+if cap_config = Capistrano::Configuration.instance
+  Aesop::Capistrano.load_into(cap_config)
+end

data/lib/aesop/version.rb

@@ -0,0 +1,10 @@
+module Aesop
+  module Version
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 0
+    BUILD = 1
+  end
+
+  VERSION = [Version::MAJOR, Version::MINOR, Version::PATCH, Version::BUILD].compact.join('.')
+end

data/recipes/aesop.rb

@@ -0,0 +1,6 @@
+# The capistrano recipes in plugins are automatically
+# loaded from here.  From gems, they are available from
+# the lib directory.  We have to make them available from
+# both locations
+
+require File.join(File.dirname(__FILE__),'..','lib','aesop','recipes.rb')

data/spec/aesop/aesop_spec.rb

@@ -0,0 +1,276 @@
+require File.join( File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Aesop::Aesop do
+  subject{ Aesop::Aesop.instance }
+
+  context 'configuration' do
+    it 'calls load configuration on initialization' do
+      subject.should_receive(:load_configuration)
+      bootloader_double = double
+      bootloader_double.stub(:boot)
+      Aesop::Bootloader.stub(:new).and_return(bootloader_double)
+      Aesop::Aesop.instance.init
+    end
+
+    it 'loads default config when no config file exists' do
+      File.stub(:exist?).and_return(false)
+      config_location = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'config', 'init.rb'))
+      subject.should_receive(:load).with(config_location)
+      subject.load_configuration
+    end
+
+    it 'loads config file when it exists' do
+      File.stub(:exist?).and_return(true)
+      config_location = File.expand_path('config/aesop.rb')
+      subject.should_receive(:load).with(config_location)
+      subject.load_configuration
+    end
+
+    it 'can receive a block' do
+      expect do |block|
+        Aesop.configuration(&block)
+      end.to yield_with_args(configatron)
+    end
+
+    it 'returns the configuration if no block is given' do
+      Aesop.configuration.should == configatron
+    end
+  end
+
+  it 'exists' do
+    subject.should_not be_nil
+  end
+
+  context 'initialization' do
+    it 'boots using the bootloader' do
+      Aesop::Bootloader.any_instance.should_receive(:boot)
+      subject.init
+    end
+
+    it 'merges the redis password when it is given' do
+      password = "pa55word"
+      redis_conf = double
+      redis_conf.stub(:host)
+      redis_conf.stub(:port)
+      redis_conf.should_receive(:password).and_return(password)
+      subject.configuration.stub(:redis).and_return(redis_conf)
+      redis_options = subject.redis_options
+      redis_options.should have_key(:password)
+      redis_options[:password].should == password
+    end
+  end
+
+  context 'exceptions' do
+    before :all do
+      create_deploy_file(Time.now)
+      Aesop::Aesop.instance.init
+    end
+
+    let(:exception){ Exception.new }
+    let(:internal_exception){ Aesop::RedisConnectionException.new }
+
+    before :each do
+      subject.redis.stub(:get).and_return(nil)
+      subject.redis.stub(:set)
+    end
+
+    it 'raises an RedisConnectionException when a redis exception occurs' do
+      subject.instance_variable_set(:@redis, nil)
+      Redis.stub(:new){ raise RuntimeError.new }
+      lambda{subject.redis}.should raise_error( Aesop::RedisConnectionException )
+    end
+
+    it 'reconnectes when not connected to redis anymore' do
+      subject.redis.stub(:connected?).and_return(false)
+      expect(Redis).to receive(:new).and_call_original
+      subject.redis
+    end
+
+    it 'dispatches each and every exception when an array is provided' do
+      exceptions = []
+      5.times do
+        exceptions << exception
+      end
+      subject.should_receive(:catch_exception).with(exception).exactly(5).times
+      subject.catch_exceptions( exceptions )
+    end
+
+    it 'throws an error when #catch_exceptions is not called with an array' do
+      lambda{ subject.catch_exceptions( exception )}.should raise_error( Aesop::IllegalArgumentException )
+    end
+
+    it 'has a method to to register exceptions' do
+      subject.public_methods.map{|m| m.to_s}.should include 'catch_exception'
+    end
+
+    it 'checks to see if an exception should be dispatched' do
+      subject.should_receive(:should_dispatch?).with(exception)
+      subject.catch_exception( exception )
+    end
+
+    it 'checks if an exception is excluded from dispatching' do
+      subject.should_receive(:is_excluded?).with(exception)
+      subject.catch_exception( exception )
+    end
+
+    it 'does not dispatch when the exception is excluded' do
+      subject.stub(:is_excluded?).and_return(true)
+      subject.should_dispatch?(exception).should be_false
+    end
+
+    it 'does dispatch when the exception is not excluded' do
+      subject.stub(:is_excluded?).and_return(false)
+      subject.should_receive(:within_window?).with(exception).and_return(true)
+      subject.should_receive(:retrieve_exception_count).with(exception).and_return(11)
+      subject.should_receive(:exception_count_threshold).with(exception).and_return(10)
+      subject.should_dispatch?(exception).should be_true
+    end
+
+    it 'reads the excluded exceptions from the configuration' do
+      config_double = double("Configuration")
+      config_double.should_receive(:excluded_exceptions)
+      subject.stub(:configuration){ config_double }
+      subject.is_excluded?(exception)
+    end
+
+    it 'ignores exceptions from the excluded list' do
+      config_double = double("Configuration")
+      config_double.should_receive(:excluded_exceptions).and_return( [ArgumentError] )
+      subject.stub(:configuration){ config_double }
+      subject.is_excluded?( ArgumentError.new ).should be_true
+    end
+
+    it 'checks if an exception is an internal exception' do
+      subject.should_receive(:internal_exception?).with(exception)
+      subject.catch_exception( exception )
+    end
+
+    it 'knows when an exception is internal' do
+      subject.internal_exception?(exception).should be_false
+    end
+
+    it 'knows when an exception is external' do
+      subject.internal_exception?( internal_exception ).should be_true
+    end
+
+    it 'always dispatches Aesop exceptions' do
+      subject.stub(:exception_already_dispatched?).and_return(false)
+      subject.should_receive(:dispatch_exception).with( internal_exception )
+      subject.catch_exception(internal_exception)
+    end
+
+    it 'checks if the exception already occurred' do
+      subject.should_receive(:retrieve_exception_count).with(exception)
+      subject.should_dispatch?( exception )
+    end
+
+    it 'uses the exception threshold to determine whether the window is open' do
+      subject.should_receive(:exception_time_threshold).with(exception).and_return(3600)
+      subject.within_window?(exception)
+    end
+
+    it 'checks if the time window is open to dispatch' do
+      subject.should_receive(:within_window?).with(exception)
+      subject.should_dispatch?( exception )
+    end
+
+    it 'retrieves the deployment time to determine if the exception should be dispatched' do
+      subject.should_receive(:retrieve_deployment_time)
+      subject.should_dispatch?( exception )
+    end
+
+    it 'uses the exception_prefix when retrieving the exception' do
+      subject.should_receive(:exception_prefix).and_return("aesop:exceptions")
+      subject.retrieve_exception_count(exception)
+    end
+
+    it 'uses the exception_prefix when storing the exception occurrence' do
+      subject.should_receive(:exception_prefix).and_return("aesop:exceptions")
+      subject.store_exception_occurrence(exception)
+    end
+
+    it 'uses the exception count threshould when determining whether the occurrence should be dispatched' do
+      subject.stub(:within_window?).and_return(true)
+      subject.stub(:retrieve_exception_count).and_return(5)
+      subject.should_receive(:exception_count_threshold).with(exception).and_return(10)
+      subject.should_dispatch?(exception)
+    end
+
+    it 'does not dispatch when the amount of occurrences is smaller than the threshold' do
+      subject.should_not_receive(:dispatch_exception)
+      subject.should_receive(:within_window?).with(exception).and_return(true)
+      subject.should_receive(:retrieve_exception_count).with(exception).and_return(5)
+      subject.should_receive(:exception_count_threshold).with(exception).and_return(10)
+      subject.catch_exception(exception)
+    end
+
+    it 'dispatches when the amount of occurrences is greater then the threshold' do
+      subject.should_receive(:dispatch_exception).with(exception)
+      subject.should_receive(:within_window?).with(exception).and_return(true)
+      subject.should_receive(:retrieve_exception_count).with(exception).and_return(11)
+      subject.should_receive(:exception_count_threshold).with(exception).and_return(10)
+      subject.catch_exception(exception)
+    end
+
+    it 'looks up the exception in redis' do
+      subject.redis.should_receive(:get).with("aesop:exceptions:#{exception.class.to_s}:count")
+      subject.retrieve_exception_count( exception )
+    end
+
+    it 'records the occurrence of the exception while within the window' do
+      subject.should_receive(:within_window?).with(exception).and_return(false)
+      subject.should_receive(:store_exception_occurrence).with(exception)
+      subject.catch_exception(exception)
+    end
+
+    it 'records the occorrence of the exception while outside the window' do
+      subject.should_receive(:within_window?).with(exception).and_return(true)
+      subject.should_receive(:store_exception_occurrence).with(exception)
+      subject.catch_exception(exception)
+    end
+
+    it 'increments the number of occurrences of an exception when stored' do
+      subject.redis.should_receive(:incr).with("aesop:exceptions:#{exception.class.to_s}:count")
+      subject.catch_exception(exception)
+    end
+
+    it 'checks if the exception has been dispatched yet' do
+      subject.stub(:within_window?).and_return(true)
+      subject.stub(:retrieve_exception_count).and_return(100)
+      subject.stub(:exception_count_treshold).and_return(10)
+
+      subject.should_receive(:exception_already_dispatched?).with(exception)
+      subject.should_dispatch?(exception)
+    end
+
+    it 'does not dispatch the exception when it has already been dispatched' do
+      subject.stub(:within_window?).and_return(true)
+      subject.stub(:retrieve_exception_count).and_return(100)
+      subject.stub(:exception_count_treshold).and_return(10)
+
+      subject.stub(:exception_already_dispatched?).and_return(true)
+      subject.should_dispatch?(exception).should be_false
+    end
+
+    it 'dispatches the exception when it should be dispatched' do
+      subject.should_receive(:should_dispatch?).with(exception).and_return(true)
+      subject.should_receive(:dispatch_exception).with(exception)
+      subject.catch_exception(exception)
+    end
+
+    it 'records the dispatching of the exception' do
+      subject.should_receive(:record_exception_dispatch).with(exception)
+      subject.dispatch_exception(exception)
+    end
+
+    it 'stores the time of dispatch when an exception is dispatched' do
+      subject.redis.should_receive(:set).with("aesop:exceptions:#{exception.class.to_s}:dispatched", anything())
+      subject.dispatch_exception(exception)
+    end
+
+    it 'invokes the dispatcher when the exception should be dispatched' do
+      Aesop::Dispatcher.instance.should_receive(:dispatch_exception).with(exception)
+      subject.dispatch_exception(exception)
+    end
+  end
+end

data/spec/aesop/bootloader_spec.rb

@@ -0,0 +1,138 @@
+require File.join( File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Aesop::Bootloader do
+  it 'exists' do
+    subject.should_not be_nil
+  end
+
+  context 'initialization' do
+    it 'attempts to read a DEPLOY file when boot is called' do
+      subject.should_receive :read_deploy_time
+      subject.boot
+    end
+
+    it 'calls load_dispatchers on boot' do
+      subject.should_receive :load_dispatchers
+      subject.boot
+    end
+
+    it 'loads all files in the dispatchers directory' do
+      dirname = File.dirname( File.join( File.dirname(__FILE__), '..', '..', 'lib', 'aesop', 'dispatchers' ) )
+      Dir["#{dirname}/dispatchers/**/*.rb"].each do |file|
+        subject.should_receive(:require).with( File.expand_path(file) )
+      end
+      subject.boot
+    end
+
+    it 'raises an BootloaderException when an exception occurs during bootloading' do
+      subject.stub(:determine_latest_deploy_time){ raise RuntimeError.new }
+      lambda{ subject.boot }.should raise_error( Aesop::BootloaderException )
+    end
+
+    it 'raises an DispatcherLoadException when an exception occurs during dispatch loading' do
+      subject.stub(:require){ raise RuntimeError.new }
+      lambda{ subject.load_dispatchers }.should raise_error( Aesop::DispatcherLoadException )
+    end
+  end
+
+  context 'reading DEPLOY file' do
+    it 'reads the configuration' do
+      subject.should_receive(:configuration).at_least(1).and_return(config)
+      subject.boot
+    end
+
+    it 'can retrieve the location of the deployment file' do
+      subject.deployment_file
+    end
+
+    it 'does not complain when the file does not exist' do
+      remove_deploy_file
+      deploy_time = subject.read_deploy_time
+      deploy_time.should be_nil
+    end
+
+    it 'reads a timestamp from redis' do
+      subject.should_receive(:read_current_timestamp)
+      subject.boot
+    end
+
+    it 'reads the timestamp from the file' do
+      now = Time.now
+      create_deploy_file(now)
+      subject.read_deploy_time.to_i.should == now.to_i
+    end
+
+    it 'uses #determine_latest_deploy_time to determine the latest deploy time' do
+      subject.should_receive(:determine_latest_deploy_time)
+      subject.boot
+    end
+
+    it 'determines the latest deploy time by reading deploy file and redis' do
+      subject.should_receive(:read_deploy_time)
+      subject.should_receive(:read_current_timestamp)
+      subject.determine_latest_deploy_time
+    end
+
+    it 'uses the time stored in the file when no time is stored in redis' do
+      now = Time.now
+      create_deploy_file(now)
+      subject.stub(:read_current_timestamp).and_return(0)
+      subject.determine_latest_deploy_time.should == now.to_i
+    end
+
+    it 'always stores the latest deploy time to redis' do
+      time = Time.now - 500
+      newer_time = Time.now
+      create_deploy_file(time)
+      subject.should_receive(:read_deploy_time).and_return(newer_time.to_i)
+      subject.should_receive(:store_timestamp).with(newer_time.to_i)
+      subject.boot
+    end
+
+    it 'stores a timestamp when a deployment file exists' do
+      create_deploy_file
+      subject.should_receive(:store_timestamp)
+      subject.boot
+    end
+
+    it 'uses the configuration to lookup the exception prefix' do
+      config_double = double()
+      config_double.should_receive( :exception_prefix ).and_return('aesop:exceptions')
+      subject.stub(:configuration).and_return(config_double)
+      subject.reset_exceptions
+    end
+
+    it 'resets all exceptions when #reset_exceptions is called' do
+      5.times do |i|
+        subject.redis.set("#{config.exception_prefix}:SomeException#{i}:count", i)
+      end
+
+      subject.reset_exceptions
+      subject.redis.keys("#{config.exception_prefix}:*").size.should == 0
+    end
+
+    it 'resets all exceptions when a new deployment has occured' do
+      older_time = Time.now - 500
+      newer_time = Time.now
+      subject.stub(:read_deploy_time).and_return(newer_time.to_i)
+      subject.stub(:read_current_timestamp).and_return(older_time.to_i)
+      subject.should_receive(:reset_exceptions)
+      subject.boot
+    end
+
+    it 'does not rest exceptions when the time in redis is newer' do
+      older_time = Time.now - 500
+      newer_time = Time.now
+      subject.stub(:read_deploy_time).and_return(older_time.to_i)
+      subject.stub(:read_current_timestamp).and_return(newer_time.to_i)
+      subject.should_not_receive(:reset_exceptions)
+      subject.boot
+    end
+
+    it 'stores the timestamp in redis in the aesop:deployment:timestamp key' do
+      time = 12345
+      subject.redis.should_receive(:set).with(config.deployment_key, time)
+      subject.store_timestamp( time )
+    end
+  end
+end