aesop 1.1.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTIwZWNjYjljOWYyYzBlYWViYTYyZWNiNmYxMWFhNDNiNzViOTI0YQ==
+  data.tar.gz: !binary |-
+    M2I2Y2Y5NWM1MDlmYjU0ODBhNzQ5Mzk2MmE3YTgwNjM0YWNjNzQwNA==
+SHA512:
+  metadata.gz: !binary |-
+    YmI1MzIxMjRkNjMxMjFjNWM1ZThhYWRkZGJmNTY0ZTM5MTJlNmU5Yjc0YzUz
+    MTVhOTIyODcwMDcyNTVkNjc1NTMxZGI2ODhkYWU3ZmQ1MWM0YTM5ZGE0NmVi
+    NjcwM2JjMDIyNGQyNWM5ODQwN2RiMWZlYWVlZDI3OGQzNjAyNjQ=
+  data.tar.gz: !binary |-
+    MTkzZDJlNDJjNmRhNGQ1MTBiZjBmMTNlNDM5NzU4YzE0NTkwMmZhNTNhMTBj
+    NzIzYzg0MTE3ZTUxYzNlZmU1NjgxNzg1OTBmOWVjOTE4YTNhNWZmNzBjYzdj
+    MDlkNjVlYzY3Y2JmNTI5MTViNjg0MDcxMzlmMGEzOTU4YmFkMTA=

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+DEPLOY_TIME
+.DS_STORE

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--backtrace
+--format documentation

data/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+cache: bundler
+services: redis
+
+jdk:
+  - oraclejdk7
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+  - jruby-19mode
+  - ruby-head
+  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx-19mode

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aesop.gemspec
+gemspec
+
+gem "configatron", :github => 'jwkoelewijn/configatron'
+
+group :test do
+  gem "codeclimate-test-reporter",  :require => false
+  gem "simplecov",                  :require => false
+  gem "capistrano-spec"
+  gem "capistrano", "~> 2.14.2"
+end

data/README.md

@@ -0,0 +1,8 @@
+aesop
+=====
+
+[![Build Status](https://travis-ci.org/jwkoelewijn/aesop.png?branch=master)](https://travis-ci.org/jwkoelewijn/aesop)
+[![Code Climate](https://codeclimate.com/github/jwkoelewijn/aesop.png)](https://codeclimate.com/github/jwkoelewijn/aesop)
+
+
+Like the boy who cried wolf, it is possible to receive so many error reports that you, as a developer/maintainer can get numb to new errors. With Aesop, errors will only be dispatched within a specified time after the last deployment and only if it did occur more often than a certain, configurable threshold.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/aesop.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aesop/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aesop"
+  spec.version       = Aesop::VERSION
+  spec.authors       = ["J.W. Koelewijn"]
+  spec.email         = ["jwkoelewijn@gmail.com"]
+  spec.description   = %q{Check deployment time, write it to Redis and when exceptions are thrown, check if it should send notification}
+  spec.summary       = %q{Manage exception notification}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "redis"
+  spec.add_dependency "hiredis"
+  spec.add_dependency "configatron"
+  spec.add_dependency "log4r"
+end

data/config/init.rb

@@ -0,0 +1,24 @@
+require 'configatron'
+
+configatron.redis do |redis|
+  redis.host = 'localhost'
+  redis.port = 6379
+  redis.password = ''
+  redis.database = 1
+end
+
+configatron.logger do |logger|
+  logger.name = 'Aesop'
+  logger.level = Aesop::Logger::INFO
+  logger.outputters = 'stdout'
+end
+
+configatron.deployment_key   = 'aesop:deployment:timestamp'
+configatron.deployment_file  = 'DEPLOY_TIME'
+configatron.exception_prefix = 'aesop:exceptions'
+configatron.exception_count_threshold = 10
+configatron.exception_time_threshold  = 60*60
+
+configatron.phonenumbers = []
+configatron.dispatchers  = [:log_dispatcher]
+configatron.excluded_exceptions = []

data/lib/aesop.rb

@@ -0,0 +1,27 @@
+require "aesop/version"
+require "configatron"
+require "aesop/configuration"
+require "aesop/exceptions"
+require "aesop/logger"
+#Kernel.load File.join(File.dirname(__FILE__), '..', 'config', 'init.rb')
+
+require "aesop/aesop"
+require "aesop/bootloader"
+require "aesop/dispatcher"
+require "aesop/rails/middleware"
+require "redis"
+require "hiredis"
+
+if defined?(Merb) && defined?(Merb::BootLoader)
+  require "aesop/merb/merb_boot_loader"
+elsif defined? Rails
+  if Rails.respond_to?(:version) && Rails.version > '3'
+    require "aesop/rails/railtie"
+  else
+    # After verison 2.0 of Rails we can access the configuration directly.
+    # We need it to add dev mode routes after initialization finished.
+    Aesop::Aesop.instance.init
+  end
+else
+  Aesop::Aesop.instance.init
+end

data/lib/aesop/aesop.rb

@@ -0,0 +1,135 @@
+require 'singleton'
+
+class Aesop::Aesop
+  include Singleton
+  include ::Aesop
+
+  def init
+    load_configuration
+    Aesop::Bootloader.new.boot
+  end
+
+  def load_configuration
+    config_file = if File.exist?("config/aesop.rb")
+      File.expand_path("config/aesop.rb")
+    else
+      File.expand_path(File.join( File.dirname(__FILE__), '..', '..', 'config', 'init.rb'))
+    end
+    load config_file
+    Aesop::Logger.debug("Loaded config in #{config_file}")
+  end
+
+  def catch_exceptions( exceptions )
+    if exceptions.is_a?(Array)
+      exceptions.each{ |e| catch_exception(e) }
+    else
+      raise IllegalArgumentException.new("#catch_exceptions should be called with an Array as argument, maybe use #catch_exception instead?")
+    end
+  end
+
+  def catch_exception(exception)
+    store_exception_occurrence(exception)
+    if should_dispatch?(exception)
+      dispatch_exception(exception)
+    end
+  end
+
+  def should_dispatch?(exception)
+    return false if is_excluded?(exception) || exception_already_dispatched?(exception)
+    return true if internal_exception?(exception)
+    current_amount = retrieve_exception_count(exception)
+    within_window?(exception) && (current_amount >= exception_count_threshold(exception))
+  end
+
+  def internal_exception?(exception)
+    parts = exception.class.name.split("::")
+    res = (parts.size > 1 && parts.first == "Aesop")
+    Aesop::Logger.debug("#{exception.class.to_s} is #{res ? "": "not "}an internal exception and will #{res ? "" : "not "}be dispatched right away")
+    res
+  end
+
+  def exception_count_threshold(exception)
+    configuration.exception_count_threshold
+  end
+
+  def record_exception_dispatch(exception)
+    redis.set( "#{exception_prefix}:#{exception.class.to_s}:dispatched", Time.now.to_i )
+  end
+
+  def dispatch_exception(exception)
+    record_exception_dispatch(exception)
+    Aesop::Dispatcher.instance.dispatch_exception(exception)
+  end
+
+  def exception_already_dispatched?(exception)
+    res = !redis.get( "#{exception_prefix}:#{exception.class.to_s}:dispatched" ).nil?
+    Aesop::Logger.debug("#{exception.class.to_s} has #{res ? "already" : "not yet"} been dispatched")
+    res
+  end
+
+  def retrieve_exception_count(exception)
+    res = redis.get( "#{exception_prefix}:#{exception.class.to_s}:count" ).to_i
+    Aesop::Logger.debug("This is occurrence number #{res} of #{exception.class.to_s}")
+    res
+  end
+
+  def exception_prefix
+    configuration.exception_prefix
+  end
+
+  def within_window?( exception )
+    res = if deployed_time = retrieve_deployment_time
+      (Time.now - deployed_time) < exception_time_threshold(exception)
+    else
+      false
+    end
+    Aesop::Logger.debug("#{exception.class.to_s} is#{res ? " " : " not "}within the window")
+    res
+  end
+
+  def is_excluded?( exception )
+    res = if (exceptions = configuration.excluded_exceptions)
+      exceptions.include?( exception.class )
+    else
+      false
+    end
+    Aesop::Logger.debug( "#{exception.class.to_s} is#{res ? " " : " not "}excluded")
+    res
+  end
+
+  def exception_time_threshold( exception )
+    configuration.exception_time_threshold
+  end
+
+  def retrieve_deployment_time
+    timestamp = redis.get( configuration.deployment_key ).to_i
+    Time.at(timestamp)
+  end
+
+  def store_exception_occurrence(exception)
+    redis.incr( "#{exception_prefix}:#{exception.class.to_s}:count" )
+  end
+
+  def redis_options
+    options = {
+      :host => configuration.redis.host,
+      :port => configuration.redis.port,
+    }
+    if (password = configuration.redis.password) && !password.empty?
+      options.merge!(:password => password)
+    end
+    options
+  end
+
+  def redis
+    if @redis.nil? || !@redis.connected?
+      begin
+        @redis = Redis.new(redis_options)
+        @redis.select( configuration.redis.database )
+      rescue => e
+        raise RedisConnectionException.new( e )
+      end
+    end
+    @redis
+  end
+end

data/lib/aesop/bootloader.rb

@@ -0,0 +1,76 @@
+class Aesop::Bootloader
+  include ::Aesop
+
+  def boot
+    load_dispatchers
+    begin
+      if time = determine_latest_deploy_time
+        Aesop::Logger.info("Last deployment was at #{Time.at(time)}")
+        store_timestamp( time )
+      end
+    rescue => e
+      raise Aesop::BootloaderException.new(e)
+    end
+  end
+
+  def determine_latest_deploy_time
+    file_time = read_deploy_time
+    redis_time = read_current_timestamp
+
+    if file_time
+      if redis_time > 0
+        reset_exceptions if file_time > redis_time
+        [redis_time, file_time].max
+      else
+        reset_exceptions
+        file_time
+      end
+    else
+      redis_time ? redis_time : Time.now.to_i
+    end
+  end
+
+  def read_deploy_time
+    if File.exists?(deployment_file)
+      File.open(deployment_file) do |file|
+        file.read.to_i
+      end
+    else
+      return nil
+    end
+  end
+
+  def load_dispatchers
+    begin
+      current_dir = File.dirname(__FILE__)
+      Dir["#{current_dir}/dispatchers/**/*.rb"].each do |file|
+        require File.expand_path(file)
+      end
+    rescue => e
+      raise DispatcherLoadException.new(e)
+    end
+  end
+
+  def read_current_timestamp
+    redis.get( configuration.deployment_key ).to_i
+  end
+
+  def store_timestamp( time )
+    redis.set( configuration.deployment_key, time.to_i )
+  end
+
+  def deployment_file
+    self.configuration.deployment_file
+  end
+
+  def reset_exceptions
+    Aesop::Logger.debug("Resetting stored exception occurrences")
+    redis.keys( "#{configuration.exception_prefix}:*" ).each do |key|
+      redis.del key
+    end
+  end
+
+  def redis
+    Aesop.instance.redis
+  end
+end

data/lib/aesop/configuration.rb

@@ -0,0 +1,13 @@
+module Aesop
+  def configuration
+    configatron
+  end
+
+  def self.configuration
+    if block_given?
+      yield configatron
+    else
+      configatron
+    end
+  end
+end

data/lib/aesop/dispatcher.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+module Aesop
+  module Dispatchers
+  end
+end
+
+class Aesop::Dispatcher
+  include Singleton
+  include ::Aesop
+
+  def initialize
+    collect_dispatchers
+  end
+
+  def dispatch_exception(exception)
+    dispatchers.each do |dispatcher|
+      begin
+        Aesop::Logger.debug("#{dispatcher.class.to_s}: dispatching #{exception.class.to_s}")
+        dispatcher.dispatch_exception(exception)
+      rescue => e
+        Aesop::Logger.error( "Exception in #{dispatcher.class.to_s}: Exception: #{exception.class.to_s}. Trying to dispatch: #{e.class.to_s}: #{e.message}" )
+      end
+    end
+  end
+
+  def instantiate_dispatcher( symbol )
+    Aesop::Logger.debug("Instantiating #{to_classname(symbol)}")
+    Aesop::Dispatchers.const_get( to_classname(symbol) ).new
+  end
+
+  def collect_dispatchers
+    configuration.dispatchers.each do |dispatch_symbol|
+      instance = instantiate_dispatcher( dispatch_symbol )
+      register_dispatcher(instance)
+    end
+  end
+
+  def register_dispatcher( dispatcher )
+    dispatchers << dispatcher
+  end
+
+  def dispatchers
+    @dispatchers ||= []
+  end
+
+  def to_classname(symbol)
+    symbol.to_s.split(/[-_]/).map(&:capitalize).join
+  end
+end