exception_handling 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29c963a8d5c2ca837a7abcc3b4554d075fe9383a
-  data.tar.gz: 4307bfe7dee9b79fcb82f711d61f00edb81c27d5
+  metadata.gz: 89b539c359cfa4f2cc912eb43c189bbd3ced7398
+  data.tar.gz: 92b3d535adbc32c47c95a8bc43fb5b12ff44c8c7
 SHA512:
-  metadata.gz: dfa979ae72aff2be2c7ae721473ed379073194b9f15fbc84302eeaf48b43fcaa4191de9c08ba03b1a211311ffc443093bccac290d5a43f63fb09fa0f019ae02a
-  data.tar.gz: 5f3b24b043d0d5213fee3611f5552feb5144a5261a2810cb8ccb10997daea23b1d64d53e10f68ee2d78ae1744d35536bcdf16780239007a52e073d6cf1dc73b9
+  metadata.gz: 5265b86655170e953d0d10564783aac66c78a9ec85b2cc99fb17f9cfbfa3704445c8222f7c13f2877db67060a398134e2e5da4882e52c84b192f1303a0aed0b0
+  data.tar.gz: 90a07b46e4dbafd0665d7dc9b071c74a441ad019918b616b0b2f254ac21b657d38603a60682f5e3e7c0028a1c452744f8922924a6a2a3dc87ffcf7019fbe7dcc

data/.gitignore

@@ -1 +1,2 @@
 .idea
+.DS_Store

data/Gemfile.lock

@@ -1,11 +1,13 @@
 PATH
   remote: .
   specs:
-    exception_handling (0.2.0)
+    exception_handling (1.0.0)
       actionmailer (~> 3.2)
       actionpack (~> 3.2)
       activesupport (~> 3.2)
       eventmachine (>= 0.12.10)
+      hobo_support
+      invoca-utils (~> 0.0.2)
 
 GEM
   remote: https://rubygems.org/
@@ -26,32 +28,71 @@ GEM
     activemodel (3.2.19)
       activesupport (= 3.2.19)
       builder (~> 3.0.0)
+    activerecord (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
     activesupport (3.2.19)
       i18n (~> 0.6, >= 0.6.4)
       multi_json (~> 1.0)
+    arel (3.0.3)
     bourne (1.3.0)
       mocha (= 0.13.0)
     builder (3.0.4)
+    coderay (1.1.0)
     erubis (2.7.0)
     eventmachine (1.0.3)
     hike (1.2.3)
+    hobo_support (2.0.1)
+      rails (~> 3.2.0)
     i18n (0.6.11)
+    invoca-utils (0.0.2)
     journey (1.0.4)
+    json (1.8.1)
     mail (2.5.4)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
     metaclass (0.0.1)
+    method_source (0.8.2)
     mime-types (1.25.1)
     mocha (0.13.0)
       metaclass (~> 0.0.1)
     multi_json (1.10.1)
     polyglot (0.3.5)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
     rack (1.4.5)
     rack-cache (1.2)
       rack (>= 0.4)
+    rack-ssl (1.3.4)
+      rack
     rack-test (0.6.2)
       rack (>= 1.0)
+    rails (3.2.19)
+      actionmailer (= 3.2.19)
+      actionpack (= 3.2.19)
+      activerecord (= 3.2.19)
+      activeresource (= 3.2.19)
+      activesupport (= 3.2.19)
+      bundler (~> 1.0)
+      railties (= 3.2.19)
+    railties (3.2.19)
+      actionpack (= 3.2.19)
+      activesupport (= 3.2.19)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
     rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rr (1.1.2)
     shoulda (3.1.1)
       shoulda-context (~> 1.0)
       shoulda-matchers (~> 1.2)
@@ -59,21 +100,25 @@ GEM
     shoulda-matchers (1.5.6)
       activesupport (>= 3.0.0)
       bourne (~> 1.3)
+    slop (3.6.0)
     sprockets (2.2.2)
       hike (~> 1.2)
       multi_json (~> 1.0)
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
+    thor (0.19.1)
     tilt (1.4.1)
     treetop (1.4.15)
       polyglot
       polyglot (>= 0.3.1)
+    tzinfo (0.3.40)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   exception_handling!
-  mocha (= 0.13.0)
+  pry
   rake (>= 0.9)
+  rr
   shoulda (= 3.1.1)

data/README.md

@@ -0,0 +1,109 @@
+# ExceptionHandling
+
+Enable emails for your exceptions that occur in your application!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'exception_handling'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install exception_handling
+
+## Setup
+
+Add some code to initialize the settings in your application.
+For example:
+
+    require "exception_handling"
+
+    # required
+    ExceptionHandling.server_name             = Cluster['server_name']
+    ExceptionHandling.sender_address          = %("Exceptions" <exceptions@example.com>)
+    ExceptionHandling.exception_recipients    = ['exceptions@example.com']
+    ExceptionHandling.logger                  = Rails.logger
+
+    # optional
+    ExceptionHandling.escalation_recipients   = ['escalation@example.com']
+    ExceptionHandling.mailer_send_enabled     = true # false, will disable exception emails
+    ExceptionHandling.filter_list_filename    = "#{Rails.root}/config/exception_filters.yml"
+    ExceptionHandling.email_environment       = Rails.env
+    ExceptionHandling.eventmachine_safe       = false
+    ExceptionHandling.eventmachine_synchrony  = false
+
+
+## Usage
+
+Mixin the `ExceptionHandling::Methods` module into your controllers, models or classes. The example below adds it to all the controllers in you rails application:
+
+    class ApplicationController < ActionController::Base
+      include ExceptionHandling::Methods
+      ...
+    end
+
+Then call any method available in the `ExceptionHandling::Methods` mixin:
+
+    begin
+      ...
+    rescue => ex
+      log_error( ex, "A specific error occurred." )
+      flash.now['error'] = "A specific error occurred. Support has been notified."
+    end
+
+## Custom Hooks
+
+### custom_data_hook
+
+Emails are generated using the `.erb` templates in the [views](./views) directory.  You can add custom information to the exception data with a custom method. For example:
+
+    def append_custom_user_info(data)
+      begin
+        data[:user_details]                = {}
+        data[:user_details][:username]     = "CaryP"
+        data[:user_details][:organization] = "Invoca Engineering Dept."
+      rescue Exception => e
+        # don't let these out!
+      end
+    end
+
+Then tie this in using the `custom_data_hook`:
+
+    ExceptionHandling.custom_data_hook = method(:append_custom_user_info)
+
+
+### post_log_error_hook
+
+There is another hook available intended for custom actions after an error email is sent.  This can be used to send information about errors to your alerting subsystem.  For example:
+
+    def log_error_metrics(exception_data, exception)
+      if exception.is_a?(ExceptionHandling::Warning)
+        Invoca::Metrics::Client.metrics.counter("exception_handling/warning")
+      else
+        Invoca::Metrics::Client.metrics.counter("exception_handling/exception")
+      end
+    end
+    ExceptionHandling.post_log_error_hook = method(:log_error_metrics)
+
+
+## Testing
+
+There is a reusable rails controller stub that might be useful for your own tests.  To leverage it in your own test, simply add the following require to your unit tests:
+
+        require 'exception_handling/testing'
+
+We use it for testing that our `custom_data_hook` code is working properly.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -1,9 +1,17 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rake/testtask'
 
-task :default => :test
+namespace :test do
+
+  Rake::TestTask.new do |t|
+    t.name = :unit
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:unit'].comment = "Run the unit tests"
 
-desc "Run unit tests."
-task :test do
-  ruby "test/exception_handling_test.rb"
 end
+
+task :default => 'test:unit'

data/exception_handling.gemspec

@@ -1,24 +1,28 @@
 require File.expand_path('../lib/exception_handling/version', __FILE__)
 
-Gem::Specification.new do |gem|
-  gem.add_dependency 'eventmachine', '>=0.12.10'
-  gem.add_dependency 'activesupport', '~> 3.2'
-  gem.add_dependency 'actionpack', '~> 3.2'
-  gem.add_dependency 'actionmailer', '~> 3.2'
-  gem.add_development_dependency 'rake', '>=0.9'
-  gem.add_development_dependency 'shoulda', '=3.1.1'
-  gem.add_development_dependency 'mocha', '=0.13.0'
+Gem::Specification.new do |spec|
+  spec.authors       = ["Colin Kelley"]
+  spec.email         = ["colindkelley@gmail.com"]
+  spec.description   = %q{Exception handling logger/emailer}
+  spec.summary       = %q{Invoca's exception handling logger/emailer layer, based on exception_notifier. Works with Rails or EventMachine or EventMachine+Synchrony.}
+  spec.homepage      = "https://github.com/Invoca/exception_handling"
 
-  gem.authors       = ["Colin Kelley"]
-  gem.email         = ["colindkelley@gmail.com"]
-  gem.description   = %q{Exception handling logger/emailer}
-  gem.summary       = %q{Invoca's exception handling logger/emailer layer, based on exception_notifier. Works with Rails or EventMachine or EventMachine+Synchrony.}
-  gem.homepage      = "https://github.com/Invoca/exception_handling"
+  spec.files         = `git ls-files`.split($\)
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/.*\.rb})
+  spec.name          = "exception_handling"
+  spec.require_paths = ["lib"]
+  spec.version       = ExceptionHandling::VERSION
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/.*\.rb})
-  gem.name          = "exception_handling"
-  gem.require_paths = ["lib"]
-  gem.version       = ExceptionHandling::VERSION
+  spec.add_dependency 'eventmachine', '>=0.12.10'
+  spec.add_dependency 'activesupport', '~> 3.2'
+  spec.add_dependency 'actionpack', '~> 3.2'
+  spec.add_dependency 'actionmailer', '~> 3.2'
+  spec.add_dependency 'invoca-utils', '~> 0.0.2'
+  spec.add_dependency 'hobo_support'
+
+  spec.add_development_dependency 'rake', '>=0.9'
+  spec.add_development_dependency 'shoulda', '=3.1.1'
+  spec.add_development_dependency 'rr'
+  spec.add_development_dependency 'pry'
 end

data/lib/exception_handling/log_stub_error.rb

@@ -0,0 +1,84 @@
+#
+# Used by functional tests to track exceptions.
+#
+
+module LogErrorStub
+  class UnexpectedExceptionLogged < StandardError; end
+  class ExpectedExceptionNotLogged < StandardError; end
+
+  def setup_log_error_stub
+    clear_exception_whitelist
+    stub_log_error unless respond_to?(:dont_stub_log_error) && dont_stub_log_error
+  end
+
+  def teardown_log_error_stub
+    ExceptionHandling.stub_handler = nil
+    return unless @exception_whitelist
+    @exception_whitelist.each do |item|
+      add_failure("log_error expected #{item[1][:expected]} times with pattern: '#{item[0].is_a?(Regexp) ? item[0].source : item[0]}' #{item[1][:count]} found #{item[1][:found]}") unless item[1][:expected] == item[1][:found]
+    end
+  end
+
+  attr_accessor :exception_whitelist
+
+  #
+  # Call this function in your functional tests - usually first line after a "should" statement
+  # once called, you can then call expects_exception
+  # By stubbing log error, ExceptionHandling will keep a list of all expected exceptions and
+  # gracefully note their occurrence.
+  #
+  def stub_log_error
+    ExceptionHandling.stub_handler = self
+  end
+
+  #
+  # Gets called by ExceptionHandling::log_error in test mode.
+  # If you have called expects_exception then this function will simply note that an
+  # instance of that exception has occurred - otherwise it will raise (which will
+  # generally result in a 500 return code for your test request)
+  #
+  def handle_stub_log_error(exception_data, always_raise = false)
+    raise_unexpected_exception(exception_data) if always_raise || !exception_filtered?(exception_data)
+  end
+
+  #
+  # Did the calling code call expects_exception on this exception?
+  #
+  def exception_filtered?(exception_data)
+    @exception_whitelist && @exception_whitelist.any? do |expectation|
+      if expectation[0] === exception_data[:error]
+        expectation[1][:found] += 1
+        true
+      end
+    end
+  end
+
+  #
+  # Call this from your test file to declare what exceptions you expect to raise.
+  #
+  def expects_exception(pattern, options = {})
+    @exception_whitelist ||= []
+    expected_count = options[:count] || 1
+    options = {:expected => expected_count, :found => 0}
+    if to_increment = @exception_whitelist.find {|ex| ex[0] == pattern}
+      to_increment[1][:expected] += expected_count
+    else
+      @exception_whitelist << [pattern, options]
+    end
+  end
+
+  def clear_exception_whitelist
+    @exception_whitelist = nil
+  end
+
+  private
+
+  def raise_unexpected_exception(exception_data)
+    raise(UnexpectedExceptionLogged,
+          exception_data[:error] + "\n" +
+          "---original backtrace---\n" +
+          exception_data[:backtrace].join("\n") + "\n" +
+          "------")
+  end
+
+end

data/lib/{exception_handling_mailer.rb → exception_handling/mailer.rb}

@@ -4,7 +4,7 @@ module ExceptionHandling
   class Mailer < ActionMailer::Base
     default :content_type => "text/html"
 
-    self.append_view_path "#{File.dirname(__FILE__)}/../views"
+    self.append_view_path "#{File.dirname(__FILE__)}/../../views"
 
     [:email_environment, :server_name, :sender_address, :exception_recipients, :escalation_recipients].each do |method|
       define_method method do

data/lib/exception_handling/methods.rb

@@ -0,0 +1,69 @@
+module ExceptionHandling
+  module Methods # included on models and controllers
+
+    protected
+
+    def log_error(exception_or_string, exception_context = '')
+      controller = self if respond_to?(:request) && respond_to?(:session)
+      ExceptionHandling.log_error(exception_or_string, exception_context, controller)
+    end
+
+    def log_error_rack(exception_or_string, exception_context = '', rack_filter = '')
+      ExceptionHandling.log_error_rack(exception_or_string, exception_context, rack_filter)
+    end
+
+    def log_warning(message)
+      log_error(Warning.new(message))
+    end
+
+    def log_info(message)
+      ExceptionHandling.logger.info( message )
+    end
+
+    def log_debug(message)
+      ExceptionHandling.logger.debug( message )
+    end
+
+    def ensure_safe(exception_context = "")
+      begin
+        yield
+      rescue => ex
+        log_error ex, exception_context
+        nil
+      end
+    end
+
+    def escalate_error(exception_or_string, email_subject)
+      ExceptionHandling.escalate_error(exception_or_string, email_subject)
+    end
+
+    def escalate_warning(message, email_subject)
+      ExceptionHandling.escalate_warning(message, email_subject)
+    end
+
+    def ensure_escalation(*args)
+      ExceptionHandling.ensure_escalation(*args) do
+        yield
+      end
+    end
+
+    # Store aside the current controller when included
+    LONG_REQUEST_SECONDS = (defined?(Rails) && Rails.env == 'test' ? 300 : 30)
+    def set_current_controller
+      ExceptionHandling.current_controller = self
+      result = nil
+      time = Benchmark.measure do
+        result = yield
+      end
+      name = " in #{controller_name}::#{action_name}" rescue " "
+      log_error( "Long controller action detected#{name} %.4fs  " % time.real ) if time.real > LONG_REQUEST_SECONDS && !['development', 'test'].include?(ExceptionHandling.email_environment)
+      result
+    ensure
+      ExceptionHandling.current_controller = nil
+    end
+
+    def self.included( controller )
+      controller.around_filter :set_current_controller if controller.respond_to? :around_filter
+    end
+  end
+end

data/lib/exception_handling/testing.rb

@@ -0,0 +1,65 @@
+
+# some useful test objects
+
+module ExceptionHandling
+  module Testing
+    class ControllerStub
+
+      class Request
+        attr_accessor :parameters, :protocol, :host, :request_uri, :env, :session_options
+        def initialize
+          @parameters  = {:id => "1"}
+          @protocol    = 'http'
+          @host        = 'localhost'
+          @request_uri = "/fun/testing.html?foo=bar"
+          @env         = {:HOST => "local"}
+          @session_options = { :id => '93951506217301' }
+        end
+      end
+
+      attr_accessor :request, :session
+      class << self
+        attr_accessor :around_filter_method
+      end
+
+      def initialize
+        @request = Request.new
+        @session_id = "ZKL95"
+        @session =
+            if defined?(Username)
+              {
+                :login_count => 22,
+                :username_id => Username.first.id,
+                :user_id     => User.first.id,
+              }
+            else
+              { }
+            end
+      end
+
+      def simulate_around_filter( &block )
+        set_current_controller( &block )
+      end
+
+      def controller_name
+        "ControllerStub"
+      end
+
+      def action_name
+        "test_action"
+      end
+
+      def self.around_filter( method )
+        ControllerStub.around_filter_method = method
+      end
+
+      def complete_request_uri
+        "#{@request.protocol}#{@request.host}#{@request.request_uri}"
+      end
+
+      include ExceptionHandling::Methods
+
+    end
+
+  end
+end

data/lib/exception_handling/version.rb

@@ -1,3 +1,3 @@
 module ExceptionHandling
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end