rails_exception_handler 1.0.0

data/.travis.yml

@@ -0,0 +1,11 @@
+before_script:
+  - "spec/exception_handler_test_app/script/setup"
+
+notifications:
+  disable: true
+
+rvm:
+  - 1.9.2
+  - 1.8.7
+  - ree
+  - ruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+group :test do
+  gem "rails", '3.0.9'
+  gem "rspec-rails"
+  gem "rack-test", '0.5.7'
+  gem "mysql2", '0.2.6'
+end

data/Gemfile.lock

@@ -0,0 +1,91 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.9)
+      actionpack (= 3.0.9)
+      mail (~> 2.2.19)
+    actionpack (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.19)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    mysql2 (0.2.6)
+    polyglot (0.3.1)
+    rack (1.2.3)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.9)
+      actionmailer (= 3.0.9)
+      actionpack (= 3.0.9)
+      activerecord (= 3.0.9)
+      activeresource (= 3.0.9)
+      activesupport (= 3.0.9)
+      bundler (~> 1.0)
+      railties (= 3.0.9)
+    railties (3.0.9)
+      actionpack (= 3.0.9)
+      activesupport (= 3.0.9)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.4)
+    rake (0.9.2)
+    rdoc (3.8)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    rspec-rails (2.6.1)
+      actionpack (~> 3.0)
+      activesupport (~> 3.0)
+      railties (~> 3.0)
+      rspec (~> 2.6.0)
+    thor (0.14.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mysql2 (= 0.2.6)
+  rack-test (= 0.5.7)
+  rails (= 3.0.9)
+  rspec-rails

data/LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Bjørn Trondsen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,192 @@
+# Rails Exception Handler [![Build Status](http://travis-ci.org/Sharagoz/rails_execption_handler.png)](http://travis-ci.org/#!/Sharagoz/rails_exception_handler)
+
+This is an exception handler for Rails 3 built as Rack middleware. It enables you to save the key information from the error message in a database somewhere and display a customized error message to the user within the applications layout file. You can hook this gem into all your rails apps and gather the exception reports in one place. If you make yourself a simple web front on top of that you have a user friendly way of keeping track of exceptions raised by your rails apps.
+
+## Installation
+Add this line to your Gemfile:
+
+```
+config.gem 'rails_exception_handler', '~> 1.0'
+```
+
+Create an initializer in **config/initializers** called **rails_exception_handler.rb** and uncomment the options where you want something other than the default:
+
+```ruby
+RailsExceptionHandler.configure do |config|
+  # config.environments = [:development, :test, :production]                # Defaults to [:production]
+  # config.storage_strategies = [:active_record, :rails_log, :remote_url => {:target => 'http://example.com'}] # Defaults to []
+  # config.fallback_layout = 'home'                                         # Defaults to 'application'
+  # config.store_user_info = {:method => :current_user, :field => :login}   # Defaults to false
+  # config.responses['404'] = "<h1>404</h1><p>Page not found</p>"
+  # config.responses['500'] = "<h1>500</h1><p>Internal server error</p>"
+  # config.filters = [                                                      # No filters are  enabled by default
+  #   :all_404s,
+  #   :no_referer_404s,
+  #   {:user_agent_regxp => /\b(ApptusBot|TurnitinBot|DotBot|SiteBot)\b/i},
+  #   {:target_url_regxp => /\b(myphpadmin)\b/i}
+  #]
+end
+```
+
+## Configuration options explained
+
+### environments
+An array of symbols that says which Rails environments you want the exception handler to run in.
+
+```ruby
+config.environments = [:production, :test, :development]
+```
+
+Default value: [:production]
+
+### storage_strategies
+An array of zero or more symbols that says which storage strategies you want to use. Each are explained in detail in separate sections at the end of this document.
+
+```ruby
+config.storage_strategies = [:active_record, :rails_log, :remote_url => {:target => 'http://example.com'}]
+```
+
+Default value: []
+
+
+### fallback_layout
+
+```ruby
+config.fallback_layout = 'home'
+```
+
+Default value: 'application'
+
+The exception handler will always use the layout file of the controller action that was accessed when the error occured. However, when routing errors occures there are no controller action to get this layout from, so it falls back to the default 'application' layout that most apps have. If your application does not have a layout file called 'application', then you need to override this, otherwise a "missing layout" exception will occur.
+
+### store_user_info
+
+Having some way of identifying the user can be very useful at times, so I always store information on who generated the exception in applications that have a log in feature.
+To enable this you need to specify the name of the controller method that provides the user object and the name of the field which contains the info you want to save.
+
+```ruby
+config.store_user_info = {:method => :current_user, :field => :login}
+```
+
+Default value: false (no info will be stored)
+If you turn this on and the error is generated by a client that is not logged in, then "Anonymous" will be used.
+
+### filters
+
+All filters are disabled by default. I recommend you deploy your application this way, and then add filters as they become necessary.
+The only reason I've ever wanted filtering have been due to what seem like poorly programmed web crawlers and black bots probing for security holes.
+Every once in a while I'll get dozens of errors within a few minutes caused by a bot looking for things like Joomla/Wordpress libraries with known security holes, or a web crawler that follows the target of forms.
+
+**:all_404s**
+
+```ruby
+config.filters = [:all_404s]
+```
+
+When turned on the following exceptions will no longer be stored: ActionController::RoutingError, AbstractController::ActionNotFound, ActiveRecord::RecordNotFound
+Consider this a last resort. You will miss all "real" 404s when this is turned on, like broken redirections.
+
+**:no_referer_404s**
+
+```ruby
+config.filters = [:no_referer_404s]
+```
+
+ActionController::RoutingError, AbstractController::ActionNotFound, ActiveRecord::RecordNotFound will be ignored if it was caused by a request without a referer.
+This is very effective against bots. 99.9% of the time a routing error with no referer will be caused by a bot, and then once in a while it will be caused by a real user that happened to generate an error on the first page he opened. You will get a lot less false positives with this filter than :all_404s.
+
+**:user_agent_regxp**
+
+The legit bots usually adds something to the user agent string that lets you identify them. You can use this to filter out the errors they genereate, and be pretty sure you are not going to get any false positives.
+The regular expression I use looks something like this:
+
+```ruby
+config.filters = [:user_agent_regxp => /\b(ZyBorg|Yandex|Jyxobot|Huaweisymantecspider|ApptusBot|TurnitinBot|DotBot)\b/i]
+```
+
+If you (like me) dont know regular expressions by heart, then http://www.rubular.com/ is great tool to use when creating a regxp.
+
+**:target_url_regxp**
+
+Sometimes the bad bots add a common user agent string and a referer to their requests, which makes it hard to filter them without filtering all routing errors. I guess they do this to make it look less suspicious.
+What you can often do is to filter on what they target, which is usually security holes in some well known library like phpMyAdmin.
+
+```ruby
+config.filters = [:target_url_regxp => /\b(phpMyAdmin|joomla|wordpress)\b/i]
+```
+
+## Storage strategy - active record
+```ruby
+config.storage_strategies = [:active_record]
+```
+This means that the error reports will be stored through active record directly to a database, which is pretty much the whole reason why I created this library in the first place. A new entry called **exception_database** is needed in **database.yml**:
+
+```
+# for mysql the entry would look something like this:
+exception_database:
+  adapter: mysql2
+  encoding: utf8
+  reconnect: false
+  database: your_database
+  pool: 5
+  username: user
+  password: secret
+  host: 127.0.0.1
+```
+
+You could of course store the error messages in the same database as the application uses, but one of the main purposes of this library is to enable you to easily store error reports from many applications in the same database, so I recommend you set up a separate dedicated database for this.
+
+The exception database needs a table called **error_messages**. Here's a migration script that you can use to create the table with the necessary fields:
+
+```ruby
+class CreateErrorMessages < ActiveRecord::Migration
+  def self.up
+    create_table :error_messages do |t|
+      t.text :class_name
+      t.text :message
+      t.text :trace
+      t.text :params
+      t.text :target_url
+      t.text :referer_url
+      t.text :user_agent
+      t.string :user_info
+      t.string :app_name
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :error_messages
+  end
+end
+```
+
+## Storage strategy - rails log
+
+```ruby
+config.storage_strategies = [:rails_log]
+```
+
+An error will be logged in the standard rails log. The log i located in the RAILS_ROOT/log directory and is named after the Rails environment.
+Example of what a report might look like:
+
+```
+TARGET:     http://example.com/users
+REFERER:    http://example.com/
+PARAMS:     {"controller"=>"users", "action"=>"index"}
+USER_AGENT: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.112 Safari/534.30
+USER_INFO:  matz
+ActionView::Template::Error (ActionView::Template::Error):
+activesupport (3.0.7) lib/active_support/whiny_nil.rb:48:in `method_missing'
+actionpack (3.0.7) lib/action_view/template.rb:135:in `block in render'
+activesupport (3.0.7) lib/active_support/notifications.rb:54:in `instrument'
+(the rest of the stack trace has been omitted from the example)
+```
+
+## Storage strategy - remote url
+```ruby
+config.storage_strategies = [:remote_url => {:target => 'http://example.com/error_messages'}]
+```
+This option is meant for those who want to store the exception in a database table, but does not have direct access to the database itself, making active_record store unsuitable. You need a web app on a server that has access to the database. An HTTP POST request will be sent to the specified URL with the error message as data.
+If you use a Rails app at the other end you should simply be able to do _ErrorMessage.create(params[:error_message])_ to save the report.

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake'
+
+task :default => :test
+
+desc 'Run tests'
+task :test do
+  files = ["spec/unit/handler_spec.rb",
+           "spec/unit/parser_spec.rb",
+           "spec/unit/configuration_spec.rb",
+           "spec/integration/rails_exception_handler_spec.rb", 
+           "spec/integration/configuration_spec.rb"
+          ]
+  system "bundle exec rspec #{files.join(' ')}"
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rails_exception_handler"
+  gem.homepage = "http://github.com/Sharagoz/rails_exception_handler"
+  gem.license = "MIT"
+  gem.summary = %Q{Exception Handling for Rails 3}
+  gem.description = %Q{}
+  gem.email = "contact@sharagoz.com"
+  gem.authors = ["Sharagoz"]
+  gem.extra_rdoc_files = ['README.markdown']
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/app/controllers/error_response_controller.rb

@@ -0,0 +1,6 @@
+class ErrorResponseController < ApplicationController
+  def index
+    render(:text => RailsExceptionHandler.configuration.responses[@_env['exception_handler.response_code']],
+           :layout => @_env['exception_handler.layout'])
+  end
+end

data/app/models/error_message.rb

@@ -0,0 +1,3 @@
+class ErrorMessage < ActiveRecord::Base
+  establish_connection(:exception_database)
+end

data/lib/patch/show_exceptions.rb

@@ -0,0 +1,14 @@
+# This patch enables the exception handler to catch routing errors
+module ActionDispatch
+  class ShowExceptions
+    private
+      def render_exception_with_template(env, exception)
+        if(RailsExceptionHandler.configuration.environments.include?(Rails.env.to_sym))
+          RailsExceptionHandler::Handler.new(env, exception).handle_exception
+        else
+          raise "RailsExceptionHandler: This patch should not have been loaded"
+        end
+      end
+      alias_method_chain :render_exception, :template
+  end
+end

data/lib/rails_exception_handler/configuration.rb

@@ -0,0 +1,13 @@
+class RailsExceptionHandler::Configuration
+  attr_accessor :storage_strategies, :environments, :filters, :responses, :fallback_layout, :store_user_info
+
+  def initialize
+    @environments = [:production]
+    @storage_strategies = []
+    @filters = []
+    @store_user_info = false
+    @fallback_layout = 'application'
+    @responses = { '404' => '<h1>Page not found</h1><p>The page you were looking for could not be found.</p>',
+                   '500' => '<h1>Internal server error</h1><p>The application has encountered an unexpected issue.</p>' }
+  end
+end

data/lib/rails_exception_handler/handler.rb

@@ -0,0 +1,69 @@
+class RailsExceptionHandler::Handler
+  def initialize(env, exception)
+    @exception = exception
+    @env = env
+    @request = ActionDispatch::Request.new(@env)
+    @parsed_error = nil
+    if(@env['action_controller.instance'])
+      @controller = @env['action_controller.instance']
+    else
+      # During routing errors a controller object must be created manually and the before filters run, 
+      # in case they are used to set up the authentication mechanism that provides the current_user object
+      @controller = ApplicationController.new
+      @controller.request = @request
+      filters = @controller._process_action_callbacks.collect {|cb| cb.filter if(cb.kind == :before)}
+      filters.each { |filter| @controller.send(filter) }
+    end
+  end
+
+  def handle_exception
+    @parsed_error = RailsExceptionHandler::Parser.new(@exception, @request, @controller)
+    store_error unless(@parsed_error.ignore?)
+    return response
+  end
+  
+  private
+
+  def store_error
+    RailsExceptionHandler.configuration.storage_strategies.each do |strategy|
+      if(strategy.class == Symbol)
+        send("store_in_#{strategy}")
+      elsif(strategy.class == Hash && strategy[:remote_url])
+        store_in_remote_url(strategy[:remote_url])
+      else
+        raise "RailsExceptionHandler: Unknown storage strategy #{strategy.inspect}"
+      end
+    end
+  end
+
+  def store_in_active_record
+    ErrorMessage.create(@parsed_error.relevant_info)
+  end
+
+  def store_in_rails_log
+    info = @parsed_error.relevant_info
+    message  = "TARGET:     #{info[:target_url]}\n"
+    message += "REFERER:    #{info[:referer_url]}\n"
+    message += "PARAMS:     #{info[:params]}\n"
+    message += "USER_AGENT: #{info[:user_agent]}\n"
+    message += "USER_INFO:  #{info[:user_info]}\n"
+    message += "#{info[:class_name]} (#{info[:message]}):\n"
+    message += Rails.backtrace_cleaner.clean(info[:trace].split("\n"), :noise).join("\n")
+    Rails.logger.fatal(message)
+  end
+
+  def store_in_remote_url(args)
+    uri = URI.parse(args[:target])
+    params = {}
+    @parsed_error.relevant_info.each do |key,value|
+      params["error_message[#{key}]"] = value
+    end
+    Net::HTTP::post_form(uri, params)
+  end
+
+  def response
+    @env['exception_handler.layout'] = @controller.send(:_default_layout) || RailsExceptionHandler.configuration.fallback_layout
+    @env['exception_handler.response_code'] = @parsed_error.routing_error? ? '404' : '500'
+    ErrorResponseController.action(:index).call(@env)
+  end
+end

data/lib/rails_exception_handler/parser.rb

@@ -0,0 +1,73 @@
+class RailsExceptionHandler::Parser
+  def initialize(exception, request, controller)
+    @exception = exception
+    @request  = request
+    @controller = controller
+  end
+
+  def relevant_info
+    info = {}
+    info[:app_name] =     Rails.application.class.parent_name
+    info[:class_name] =   @exception.class.to_s
+    info[:message] =      @exception.to_s
+    info[:trace] =        @exception.backtrace.join("\n")
+    info[:target_url] =   @request.url
+    info[:referer_url] =  @request.referer
+    info[:params] =       @request.params.inspect
+    info[:user_agent] =   @request.user_agent
+    info[:user_info] =    user_info
+    info[:created_at] =   Time.now
+    return info
+  end
+
+  def ignore?
+    filters = RailsExceptionHandler.configuration.filters
+    filters.each do |filter|
+      if(filter.class == Symbol)
+        result = send("filter_#{filter}")
+      elsif(filter.class == Hash)
+        result = send("filter_#{filter.flatten[0]}", filter.flatten[1])
+      else
+        raise "RailsExceptionHandler: Unknown filter #{filter.inspect}"
+      end
+      return true if(result)
+    end
+    return false
+  end
+
+  def routing_error?
+    routing_errors = [ActionController::RoutingError, AbstractController::ActionNotFound, ActiveRecord::RecordNotFound]
+    routing_errors.include?(@exception.class)
+  end
+
+  private
+
+  def blank_referer?
+    relevant_info[:referer_url] == "/" || relevant_info[:referer_url].blank?
+  end
+
+  def user_info
+    config = RailsExceptionHandler.configuration.store_user_info
+    return nil unless(config)
+    user_object = @controller.send(config[:method])
+    user_object ? user_object.send(config[:field]) : 'Anonymous'
+  end
+
+  def filter_all_404s
+    routing_error?
+  end
+
+  def filter_no_referer_404s
+    routing_error? && blank_referer?
+  end
+
+  def filter_user_agent_regxp(regxp)
+    result = relevant_info[:user_agent].match(regxp)
+    result != nil
+  end
+
+  def filter_target_url_regxp(regxp)
+    result = relevant_info[:target_url].match(regxp)
+    result != nil
+  end
+end

data/lib/rails_exception_handler.rb

@@ -0,0 +1,37 @@
+class RailsExceptionHandler
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    @app.call(env)
+  rescue Exception => e
+    Handler.new(env, e).handle_exception
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+    return unless configuration.environments.include?(Rails.env.to_sym)
+
+    Rails.configuration.middleware.use(RailsExceptionHandler)
+
+    Rails.configuration.action_dispatch.show_exceptions = true
+    require File.expand_path(File.dirname(__FILE__)) + '/patch/show_exceptions.rb'
+
+    %w{ models controllers }.each do |dir|
+      path = File.join(File.dirname(__FILE__), '../app', dir)
+      $LOAD_PATH << path
+      ActiveSupport::Dependencies.autoload_paths << path
+      ActiveSupport::Dependencies.autoload_once_paths.delete(path)
+    end
+  end
+end
+
+require 'rails_exception_handler/configuration.rb'
+require 'rails_exception_handler/handler.rb'
+require 'rails_exception_handler/parser.rb'
+require 'net/http'

data/rails_exception_handler.gemspec

@@ -0,0 +1,87 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rails_exception_handler}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sharagoz"]
+  s.date = %q{2011-07-17}
+  s.description = %q{}
+  s.email = %q{contact@sharagoz.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".travis.yml",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENCE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "app/controllers/error_response_controller.rb",
+    "app/models/error_message.rb",
+    "lib/patch/show_exceptions.rb",
+    "lib/rails_exception_handler.rb",
+    "lib/rails_exception_handler/configuration.rb",
+    "lib/rails_exception_handler/handler.rb",
+    "lib/rails_exception_handler/parser.rb",
+    "rails_exception_handler.gemspec",
+    "spec/integration/configuration_spec.rb",
+    "spec/integration/rails_exception_handler_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/test_macros.rb",
+    "spec/testapp_30/.gitignore",
+    "spec/testapp_30/Gemfile",
+    "spec/testapp_30/Gemfile.lock",
+    "spec/testapp_30/Rakefile",
+    "spec/testapp_30/app/controllers/application_controller.rb",
+    "spec/testapp_30/app/controllers/home_controller.rb",
+    "spec/testapp_30/app/helpers/application_helper.rb",
+    "spec/testapp_30/app/models/stored_exception.rb",
+    "spec/testapp_30/app/views/home/view_error.html.erb",
+    "spec/testapp_30/app/views/layouts/fallback.html.erb",
+    "spec/testapp_30/app/views/layouts/home.html.erb",
+    "spec/testapp_30/config.ru",
+    "spec/testapp_30/config/application.rb",
+    "spec/testapp_30/config/boot.rb",
+    "spec/testapp_30/config/database.yml",
+    "spec/testapp_30/config/environment.rb",
+    "spec/testapp_30/config/environments/development.rb",
+    "spec/testapp_30/config/environments/production.rb",
+    "spec/testapp_30/config/environments/test.rb",
+    "spec/testapp_30/config/examples/database.yml",
+    "spec/testapp_30/config/locales/en.yml",
+    "spec/testapp_30/config/routes.rb",
+    "spec/testapp_30/db/migrate/20110630174538_create_error_messages.rb",
+    "spec/testapp_30/db/migrate/20110702131654_add_sessions_table.rb",
+    "spec/testapp_30/db/schema.rb",
+    "spec/testapp_30/db/seeds.rb",
+    "spec/testapp_30/lib/tasks/.gitkeep",
+    "spec/testapp_30/script/rails",
+    "spec/testapp_30/script/setup",
+    "spec/testapp_30/vendor/plugins/.gitkeep",
+    "spec/unit/configuration_spec.rb",
+    "spec/unit/handler_spec.rb",
+    "spec/unit/parser_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/Sharagoz/rails_exception_handler}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Exception Handling for Rails 3}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+