markbates-hoptoad_notifier 1.2

data/INSTALL

@@ -0,0 +1,55 @@
+HoptoadNotifier
+===============
+
+This is the notifier plugin for integrating apps with Hoptoad.
+
+When an uncaught exception occurs, HoptoadNotifier will POST the relevant data 
+to the Hoptoad server specified in your environment.
+
+
+INSTALLATION
+------------
+
+REMOVE EXCEPTION_NOTIFIER
+
+In your ApplicationController, REMOVE this line:
+
+  include ExceptionNotifiable
+
+In your config/environment* files, remove all references to ExceptionNotifier
+
+Remove the vendor/plugins/exception_notifier directory.
+
+INSTALL HOPTOAD_NOTIFIER
+
+From your project's RAILS_ROOT, run:
+
+  script/plugin install git://github.com/thoughtbot/hoptoad_notifier.git
+
+CONFIGURATION
+
+You should have something like this in config/initializers/hoptoad.rb.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = '1234567890abcdef'
+  end
+  
+(Please note that this configuration should be in a global configuration, and
+is *not* enrivonment-specific. Hoptoad is smart enough to know what errors are
+caused by what environments, so your staging errors don't get mixed in with
+your production errors.)
+
+After this is in place, all exceptions will be logged to Hoptoad where they can 
+be aggregated, filtered, sorted, analyzed, massaged, and searched.
+
+** NOTE FOR RAILS 1.2.* USERS: **
+You will need to copy the hoptoad_notifier_tasks.rake file into your
+RAILS_ROOT/lib/tasks directory in order for the following to work:
+
+You can test that hoptoad is working in your production environment by using 
+this rake task (from RAILS_ROOT):
+
+  rake hoptoad:test
+
+If everything is configured properly, that task will send a notice to hoptoad 
+which will be visible immediately.

data/README

@@ -0,0 +1,171 @@
+HoptoadNotifier
+===============
+
+This is the notifier plugin for integrating apps with Hoptoad.
+
+When an uncaught exception occurs, HoptoadNotifier will POST the relevant data 
+to the Hoptoad server specified in your environment.
+
+INSTALLATION
+------------
+
+REMOVE EXCEPTION_NOTIFIER
+
+In your ApplicationController, REMOVE this line:
+
+  include ExceptionNotifiable
+
+In your config/environment* files, remove all references to ExceptionNotifier
+
+Remove the vendor/plugins/exception_notifier directory.
+
+INSTALL HOPTOAD_NOTIFIER
+
+From your project's RAILS_ROOT, run:
+
+  script/plugin install git://github.com/thoughtbot/hoptoad_notifier.git
+
+CONFIGURATION
+
+You should have something like this in config/initializers/hoptoad.rb.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = '1234567890abcdef'
+  end
+
+(Please note that this configuration should be in a global configuration, and
+is *not* environment-specific. Hoptoad is smart enough to know what errors are
+caused by what environments, so your staging errors don't get mixed in with
+your production errors.)
+
+That should be it! Now all exceptions will be logged to Hoptoad where they can
+be aggregated, filtered, sorted, analyzed, massaged, and searched. In previous
+releases you had to include HoptoadNotifier::Catcher into your
+ApplicationController, but the plugin takes care of that now.
+
+** NOTE FOR RAILS 1.2.* USERS: **
+You will need to copy the hoptoad_notifier_tasks.rake file into your
+RAILS_ROOT/lib/tasks directory in order for the following to work:
+
+You can test that hoptoad is working in your production environment by using 
+this rake task (from RAILS_ROOT):
+
+  rake hoptoad:test
+
+If everything is configured properly, that task will send a notice to hoptoad 
+which will be visible immediately.
+
+USAGE
+
+For the most part, hoptoad works for itself.  Once you've included the notifier 
+in your ApplicationController (which is now done automatically by the plugin), 
+all errors will be rescued by the #rescue_action_in_public provided by the plugin.
+
+If you want to log arbitrary things which you've rescued yourself from a 
+controller, you can do something like this:
+
+  ...
+  rescue => ex
+    notify_hoptoad(ex)
+    flash[:failure] = 'Encryptions could not be rerouted, try again.'
+  end
+  ...
+
+The #notify_hoptoad call will send the notice over to hoptoad for later 
+analysis.
+
+GOING BEYOND EXCEPTIONS
+
+You can also pass a hash to notify_hoptoad method and store whatever you want, not just an exception. And you can also use it anywhere, not just in controllers:
+
+  begin 
+    params = { 
+      # params that you pass to a method that can throw an exception 
+    }
+    my_unpredicable_method(params) 
+  rescue => e
+    HoptoadNotifier.notify(
+      :error_class => "Special Error", 
+      :error_message => "Special Error: #{e.message}", 
+      :request => { :params => params }
+    )
+  end
+
+While in your controllers you use the notify_hoptoad method, anywhere else in your code, use HoptoadNotifier.notify. Hoptoad will get all the information about the error itself. As for a hash, these are the keys you should pass:
+
+  * :error_class – Use this to group similar errors together. When Hoptoad catches an exception it sends the class name of that exception object.
+  * :error_message – This is the title of the error you see in the errors list. For exceptions it is "#{exception.class.name}: #{exception.message}"
+  * :request – While there are several ways to send additional data to Hoptoad, passing a Hash with :params key as :request as in the example above is the most common use case. When Hoptoad catches an exception in a controller, the actual HTTP client request is being sent using this key.
+
+Hoptoad merges the hash you pass with these default options:
+
+  def default_notice_options
+    { 
+      :api_key => HoptoadNotifier.api_key, 
+      :error_message => 'Notification', 
+      :backtrace => caller, 
+      :request => {}, 
+      :session => {}, 
+      :environment => ENV.to_hash 
+    } 
+  end
+
+You can override any of those parameters.
+
+FILTERING
+
+You can specify a whitelist of errors, that Hoptoad will not report on.  Use 
+this feature when you are so apathetic to certain errors that you don't want 
+them even logged.
+
+This filter will only be applied to automatic notifications, not manual 
+notifications (when #notify is called directly).
+
+Hoptoad ignores the following exceptions by default:
+  ActiveRecord::RecordNotFound
+  ActionController::RoutingError
+  ActionController::InvalidAuthenticityToken
+  CGI::Session::CookieStore::TamperedWithCookie
+  
+To ignore errors in addition to those, specify their names in your Hoptoad 
+configuration block.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key      = '1234567890abcdef'
+    config.ignore       << ActiveRecord::IgnoreThisError
+  end
+
+To ignore *only* certain errors (and override the defaults), use the 
+#ignore_only attribute.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key      = '1234567890abcdef'
+    config.ignore_only  = [ActiveRecord::IgnoreThisError]
+  end
+
+To ignore certain user agents, add in the #ignore_user_agent attribute as a
+string or regexp:
+
+  HoptoadNotifier.configure do |config|
+    config.api_key      = '1234567890abcdef'
+    config.ignore_user_agent  << /Ignored/
+    config.ignore_user_agent << 'IgnoredUserAgent'
+  end
+
+TESTING
+
+When you run your tests, you might notice that the hoptoad service is recording
+notices generated using #notify when you don't expect it to.  You can 
+use code like this in your test_helper.rb to redefine that method so those 
+errors are not reported while running tests.
+
+  module HoptoadNotifier::Catcher
+    def notify(thing)
+      # do nothing.
+    end
+  end
+
+THANKS
+
+Thanks to Eugene Bolshakov for the excellent write-up on GOING BEYOND EXCEPTIONS, which we have included above.
+

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the hoptoad_notifier plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the hoptoad_notifier plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HoptoadNotifier'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Run ginger tests'
+task :ginger do
+  $LOAD_PATH << File.join(*%w[vendor ginger lib])
+  ARGV.clear
+  ARGV << 'test'
+  load File.join(*%w[vendor ginger bin ginger])
+end

data/lib/hoptoad_notifier.rb

@@ -0,0 +1,386 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'active_support'
+
+# Plugin for applications to automatically post errors to the Hoptoad of their choice.
+module HoptoadNotifier
+
+  IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                    'ActionController::RoutingError',
+                    'ActionController::InvalidAuthenticityToken',
+                    'CGI::Session::CookieStore::TamperedWithCookie',
+                    'ActionController::UnknownAction']
+
+  # Some of these don't exist for Rails 1.2.*, so we have to consider that.
+  IGNORE_DEFAULT.map!{|e| eval(e) rescue nil }.compact!
+  IGNORE_DEFAULT.freeze
+
+  IGNORE_USER_AGENT_DEFAULT = []
+
+  class << self
+    attr_accessor :host, :port, :secure, :api_key, :http_open_timeout, :http_read_timeout,
+                  :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :application_path,
+                  :public_environments, :current_environment
+
+    def backtrace_filters
+      @backtrace_filters ||= []
+    end
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary. For example, by default a path matching the RAILS_ROOT
+    # constant will be transformed into "[RAILS_ROOT]"
+    def filter_backtrace &block
+      self.backtrace_filters << block
+    end
+
+    # The port on which your Hoptoad server runs.
+    def port
+      @port || (secure ? 443 : 80)
+    end
+
+    # The host to connect to.
+    def host
+      @host ||= 'hoptoadapp.com'
+    end
+    
+    # The file path of the application. If RAILS_ROOT is defined it will default
+    # to that, otherwise the default will be FileUtils.pwd.
+    def application_path
+      @application_path ||= defined?(RAILS_ROOT) ? RAILS_ROOT : FileUtils.pwd
+    end
+    
+    # An array of environments that are considered 'public' Default is:
+    # ['production', 'staging']
+    def public_environments
+      @public_environments ||= ['production', 'staging']
+    end
+    
+    def current_environment=(environment)
+      @current_environment = environment
+      ENV['RAILS_ENV'] = environment unless ENV['RAILS_ENV']
+    end
+    
+    def current_environment
+      @current_environment ||= defined?(RAILS_ENV) ? RAILS_ENV : 'development'
+    end
+
+    # The HTTP open timeout (defaults to 2 seconds).
+    def http_open_timeout
+      @http_open_timeout ||= 2
+    end
+
+    # The HTTP read timeout (defaults to 5 seconds).
+    def http_read_timeout
+      @http_read_timeout ||= 5
+    end
+
+    # Returns the list of errors that are being ignored. The array can be appended to.
+    def ignore
+      @ignore ||= (HoptoadNotifier::IGNORE_DEFAULT.dup)
+      @ignore.flatten!
+      @ignore
+    end
+
+    # Sets the list of ignored errors to only what is passed in here. This method
+    # can be passed a single error or a list of errors.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Returns the list of user agents that are being ignored. The array can be appended to.
+    def ignore_user_agent
+      @ignore_user_agent ||= (HoptoadNotifier::IGNORE_USER_AGENT_DEFAULT.dup)
+      @ignore_user_agent.flatten!
+      @ignore_user_agent
+    end
+
+    # Sets the list of ignored user agents to only what is passed in here. This method
+    # can be passed a single user agent or a list of user agents.
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    # Returns a list of parameters that should be filtered out of what is sent to Hoptoad.
+    # By default, all "password" attributes will have their contents replaced.
+    def params_filters
+      @params_filters ||= %w(password)
+    end
+
+    def environment_filters
+      @environment_filters ||= %w()
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # HoptoadNotifier.configure do |config|
+    #   config.api_key = '1234567890abcdef'
+    #   config.secure  = false
+    # end
+    #
+    # NOTE: secure connections are not yet supported.
+    def configure
+      add_default_filters
+      yield self
+      if defined?(ActionController::Base) && !ActionController::Base.include?(HoptoadNotifier::Catcher)
+        ActionController::Base.send(:include, HoptoadNotifier::Catcher)
+      end
+    end
+
+    def protocol #:nodoc:
+      secure ? "https" : "http"
+    end
+
+    def url #:nodoc:
+      URI.parse("#{protocol}://#{host}:#{port}/notices/")
+    end
+
+    def default_notice_options #:nodoc:
+      {
+        :api_key       => HoptoadNotifier.api_key,
+        :error_message => 'Notification',
+        :backtrace     => caller,
+        :request       => {},
+        :session       => {},
+        :environment   => ENV.to_hash
+      }
+    end
+
+    # You can send an exception manually using this method, even when you are not in a
+    # controller. You can pass an exception or a hash that contains the attributes that
+    # would be sent to Hoptoad:
+    # * api_key: The API key for this project. The API key is a unique identifier that Hoptoad
+    #   uses for identification.
+    # * error_message: The error returned by the exception (or the message you want to log).
+    # * backtrace: A backtrace, usually obtained with +caller+.
+    # * request: The controller's request object.
+    # * session: The contents of the user's session.
+    # * environment: ENV merged with the contents of the request's environment.
+    def notify notice = {}
+      Sender.new.notify_hoptoad( notice )
+    end
+
+    def add_default_filters
+      self.backtrace_filters.clear
+
+      filter_backtrace do |line|
+        line.gsub(/#{application_path}/, "[RAILS_ROOT]")
+      end
+
+      filter_backtrace do |line|
+        line.gsub(/^\.\//, "")
+      end
+
+      filter_backtrace do |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      end
+
+      filter_backtrace do |line|
+        line if line !~ /lib\/#{File.basename(__FILE__)}/
+      end
+    end
+  end
+
+  # Include this module in Controllers in which you want to be notified of errors.
+  module Catcher
+
+    def self.included(base) #:nodoc:
+      if base.instance_methods.include? 'rescue_action_in_public' and !base.instance_methods.include? 'rescue_action_in_public_without_hoptoad'
+        base.send(:alias_method, :rescue_action_in_public_without_hoptoad, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_hoptoad)
+      end
+    end
+
+    # Overrides the rescue_action method in ActionController::Base, but does not inhibit
+    # any custom processing that is defined with Rails 2's exception helpers.
+    def rescue_action_in_public_with_hoptoad exception
+      notify_hoptoad(exception) unless ignore?(exception) || ignore_user_agent?
+      rescue_action_in_public_without_hoptoad(exception)
+    end
+
+    # This method should be used for sending manual notifications while you are still
+    # inside the controller. Otherwise it works like HoptoadNotifier.notify.
+    def notify_hoptoad hash_or_exception
+      if public_environment?
+        notice = normalize_notice(hash_or_exception)
+        notice = clean_notice(notice)
+        send_to_hoptoad(:notice => notice)
+      end
+    end
+
+    alias_method :inform_hoptoad, :notify_hoptoad
+
+    # Returns the default logger or a logger that prints to STDOUT. Necessary for manual
+    # notifications outside of controllers.
+    def logger
+      ActiveRecord::Base.logger
+    rescue
+      @logger ||= Logger.new(STDERR)
+    end
+
+    private
+
+    def public_environment? #nodoc:
+      HoptoadNotifier.public_environments.include?(HoptoadNotifier.current_environment)
+    end
+
+    def ignore?(exception) #:nodoc:
+      ignore_these = HoptoadNotifier.ignore.flatten
+      ignore_these.include?(exception.class) || ignore_these.include?(exception.class.name)
+    end
+
+    def ignore_user_agent? #:nodoc:
+      HoptoadNotifier.ignore_user_agent.flatten.any? { |ua| ua === request.user_agent }
+    end
+
+    def exception_to_data exception #:nodoc:
+      data = {
+        :api_key       => HoptoadNotifier.api_key,
+        :error_class   => exception.class.name,
+        :error_message => "#{exception.class.name}: #{exception.message}",
+        :backtrace     => exception.backtrace,
+        :environment   => ENV.to_hash
+      }
+
+      if self.respond_to? :request
+        data[:request] = {
+          :params      => request.parameters.to_hash,
+          :rails_root  => File.expand_path(HoptoadNotifier.application_path),
+          :url         => "#{request.protocol}#{request.host}#{request.request_uri}"
+        }
+        data[:environment].merge!(request.env.to_hash)
+      end
+
+      if self.respond_to? :session
+        data[:session] = {
+          :key         => session.instance_variable_get("@session_id"),
+          :data        => session.instance_variable_get("@data")
+        }
+      end
+
+      data
+    end
+
+    def normalize_notice(notice) #:nodoc:
+      case notice
+      when Hash
+        HoptoadNotifier.default_notice_options.merge(notice)
+      when Exception
+        HoptoadNotifier.default_notice_options.merge(exception_to_data(notice))
+      end
+    end
+
+    def clean_notice(notice) #:nodoc:
+      notice[:backtrace] = clean_hoptoad_backtrace(notice[:backtrace])
+      if notice[:request].is_a?(Hash) && notice[:request][:params].is_a?(Hash)
+        notice[:request][:params] = filter_parameters(notice[:request][:params]) if respond_to?(:filter_parameters)
+        notice[:request][:params] = clean_hoptoad_params(notice[:request][:params])
+      end
+      if notice[:environment].is_a?(Hash)
+        notice[:environment] = filter_parameters(notice[:environment]) if respond_to?(:filter_parameters)
+        notice[:environment] = clean_hoptoad_environment(notice[:environment])
+      end
+      clean_non_serializable_data(notice)
+    end
+
+    def send_to_hoptoad data #:nodoc:
+      headers = {
+        'Content-type' => 'application/x-yaml',
+        'Accept' => 'text/xml, application/xml'
+      }
+
+      url = HoptoadNotifier.url
+
+      http = Net::HTTP::Proxy(HoptoadNotifier.proxy_host,
+                              HoptoadNotifier.proxy_port,
+                              HoptoadNotifier.proxy_user,
+                              HoptoadNotifier.proxy_pass).new(url.host, url.port)
+
+      http.use_ssl = true
+        http.read_timeout = HoptoadNotifier.http_read_timeout
+        http.open_timeout = HoptoadNotifier.http_open_timeout
+      http.use_ssl = !!HoptoadNotifier.secure 
+
+      response = begin
+                   http.post(url.path, stringify_keys(data).to_yaml, headers)
+                 rescue TimeoutError => e
+                   logger.error "Timeout while contacting the Hoptoad server." if logger
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        logger.info "Hoptoad Success: #{response.class}" if logger
+      else
+        logger.error "Hoptoad Failure: #{response.class}\n#{response.body if response.respond_to? :body}" if logger
+      end
+    end
+
+    def clean_hoptoad_backtrace backtrace #:nodoc:
+      if backtrace.to_a.size == 1
+        backtrace = backtrace.to_a.first.split(/\n\s*/)
+      end
+
+      filtered = backtrace.to_a.map do |line|
+        HoptoadNotifier.backtrace_filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end
+
+      filtered.compact
+    end
+
+    def clean_hoptoad_params params #:nodoc:
+      params.each do |k, v|
+        params[k] = "[FILTERED]" if HoptoadNotifier.params_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+
+    def clean_hoptoad_environment env #:nodoc:
+      env.each do |k, v|
+        env[k] = "[FILTERED]" if HoptoadNotifier.environment_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+
+    def clean_non_serializable_data(notice) #:nodoc:
+      notice.select{|k,v| serializable?(v) }.inject({}) do |h, pair|
+        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
+        h
+      end
+    end
+
+    def serializable?(value) #:nodoc:
+      value.is_a?(Fixnum) || 
+      value.is_a?(Array)  || 
+      value.is_a?(String) || 
+      value.is_a?(Hash)   || 
+      value.is_a?(Bignum)
+    end
+
+    def stringify_keys(hash) #:nodoc:
+      hash.inject({}) do |h, pair|
+        h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+        h
+      end
+    end
+
+  end
+
+  # A dummy class for sending notifications manually outside of a controller.
+  class Sender
+    def rescue_action_in_public(exception)
+    end
+
+    include HoptoadNotifier::Catcher
+  end
+end
+

data/tasks/hoptoad_notifier_tasks.rake

@@ -0,0 +1,63 @@
+namespace :hoptoad do
+  desc "Notify Hoptoad of a new deploy."
+  task :deploy => :environment do
+    require 'hoptoad_tasks'
+    HoptoadTasks.deploy_to(ENV['TO'])
+  end
+
+  desc "Verify your plugin installation by sending a test exception to the hoptoad service"
+  task :test => :environment do
+    require 'action_controller/test_process'
+
+    request = ActionController::TestRequest.new
+
+    response = ActionController::TestResponse.new
+
+    class HoptoadTestingException < RuntimeError; end
+
+    unless HoptoadNotifier.api_key
+      puts "Hoptoad needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    in_controller = ApplicationController.included_modules.include? HoptoadNotifier::Catcher
+    in_base = ActionController::Base.included_modules.include? HoptoadNotifier::Catcher
+    if !in_controller || !in_base
+      puts "HoptoadNotifier::Catcher must be included inside your ApplicationController class."
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_hoptoad
+      def test_hoptoad
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing hoptoad via "rake hoptoad:test". If you can see this, it works.'
+      end
+
+      def rescue_action exception
+        rescue_action_in_public exception
+      end
+
+      def public_environment?
+        true
+      end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "HoptoadTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+    end
+
+    puts 'Processing request.'
+    class HoptoadVerificationController < ApplicationController; end
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: markbates-hoptoad_notifier
+version: !ruby/object:Gem::Version 
+  version: "1.2"
+platform: ruby
+authors: 
+- Thoughtbot
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-26 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin that reports exceptions to Hoptoad.
+email: info@thoughtbot.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- INSTALL
+- lib/hoptoad_notifier.rb
+- Rakefile
+- README
+- tasks/hoptoad_notifier_tasks.rake
+has_rdoc: true
+homepage: http://github.com/thoughtbot/hoptoad_notifier
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rails plugin that reports exceptions to Hoptoad.
+test_files: []
+