honeybadger 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a85ec9c99acf790b1dba514a10a36583c6f9704
-  data.tar.gz: fc26320ade5dea6c6a655d8fcbeddfd02b227f9c
+  metadata.gz: 2f0a64f658caa8ec626ba0c4a4a8ce4d0f258145
+  data.tar.gz: 8def10b166ae16d0faeab0cf7ec4c10fb2596cf3
 SHA512:
-  metadata.gz: 42e9fd0591c0a5f9830a94cf8014b67956c1908b857b031b664f2d7de872db58e6d2f43123a08dcc5c3ab58a6d82b4ea6fc195869d39e01414809bd548ae867d
-  data.tar.gz: 2669f5ecba56140789ff06ee00fe46c8b1274d4d95a1576fe4b2a2dba5089f27326e5d328eea7c2d468bd1d9af7f4450aa06d9c119d2d537126326f20daa0a4c
+  metadata.gz: cb3be63b99e2fbb896b7ac9f8f57eadc7c9d4369f46e09661ec23121fb833ee5edb228376d9066e6f031718d00abdff5d8750115cb4530fefa0bde6e7a09e930
+  data.tar.gz: 2eed6f1df816b815b90a07be55d474bf2924294e15120c4b546bd16ff744319133943b3f7a2a2234a3e900abdcaa2e4dfa4960dd4ffafd33410f231fd2818b28

data/CHANGELOG.md

@@ -5,6 +5,12 @@ adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [3.1.1] - 2017-04-13
+### Fixed
+- `honeybadger deploy` cli command now reads default environment from
+  honeybadger.yml/environment variable.
+- Fixed a conflict with the web-console gem.
+
 ## [3.1.0] - 2017-03-01
 ### Changed
 - Exceptions encountered while loading/evaluating honeybadger.yml are now raised

data/README.md

@@ -24,7 +24,7 @@ When an uncaught exception occurs, Honeybadger will POST the relevant data to th
 
 Rails and Sinatra are supported natively (install/configure the gem and you're done). For vanilla Rack apps, we provide a collection of middleware that must be installed manually.
 
-To use Rails 2.x, you'll need to use an earlier version of the Honeybadger gem. [Go to version 1.x of the gem docs](https://github.com/honeybadger-io/honeybadger-ruby/blob/1.16-stable/docs/index.md). 
+To use Rails 2.x, you'll need to use an earlier version of the Honeybadger gem. [Go to version 1.x of the gem docs](https://github.com/honeybadger-io/honeybadger-ruby/blob/1.16-stable/docs/index.md).
 
 Integrating with other libraries/frameworks is simple! [See the documentation](http://rubydoc.info/gems/honeybadger/) to learn about our public API, and see [Contributing](#contributing) to suggest a patch.
 
@@ -49,7 +49,7 @@ You can integrate honeybadger into any Ruby script via the `Honeybadger.notify`
 
 ## Getting Started
 
-Honeybadger works out of the box with all popular Ruby frameworks. Installation is just a matter of including the gem and setting your API key. In this section, we'll cover the basics. More advanced installations are covered later. 
+Honeybadger works out of the box with all popular Ruby frameworks. Installation is just a matter of including the gem and setting your API key. In this section, we'll cover the basics. More advanced installations are covered later.
 
 ### 1. Install the gem
 
@@ -93,7 +93,7 @@ This step isn't necessary if you're using our [Heroku add-on](https://elements.h
 
 #### Rails
 
-You're done! Any rake tasks and job queues that load the Rails environment are also covered. 
+You're done! Any rake tasks and job queues that load the Rails environment are also covered.
 
 For more info, check out our screencast on getting up and running with Honeybadger and Rails:
 
@@ -101,7 +101,7 @@ For more info, check out our screencast on getting up and running with Honeybadg
 
 #### Sinatra
 
-All you need to do is to include the honeybadger gem: 
+All you need to do is to include the honeybadger gem:
 
 ```ruby
 # Always require Sinatra first.
@@ -139,10 +139,28 @@ use Honeybadger::Rack::ErrorNotifier
 run app
 ```
 
+#### Plain Ruby
 
-## Advanced Configuration
+To use Honeybadger without any of the automatic integrations, `require
+honeybadger/ruby` instead of `require 'honeybadger'`:
 
-There are a few ways to configure the Honeybadger gem. You can use a YAML config file. You can use environment variables. Or you can use a combination of the two. 
+```
+require 'honeybadger/ruby'
+
+begin
+  # Failing code
+rescue => exception
+  Honeybadger.notify(exception)
+end
+```
+
+All of the public API methods are still available, but none of the plugins,
+framework integrations, or hooks are run. You will need to manually set up your
+own middleware and hooks for error monitoring in whatever frameworks you use.
+
+## Configuration
+
+There are a few ways to configure the Honeybadger gem. You can use a YAML config file. You can use environment variables. You can use Ruby. Or you can use a combination of the three.
 
 We put together a short video highligting a few of the most common configuration options:
 
@@ -151,7 +169,7 @@ We put together a short video highligting a few of the most common configuration
 
 ### YAML Configuration File
 
-By default, Honeybadger looks for a `honeybadger.yml` configuration file in the root of your project, and then `config/honeybadger.yml` (in that order). 
+By default, Honeybadger looks for a `honeybadger.yml` configuration file in the root of your project, and then `config/honeybadger.yml` (in that order).
 
 Here's what the simplest config file looks like:
 
@@ -167,7 +185,7 @@ Some configuration options are written in YAML as nested hashes. For example, he
 ```yaml
 ---
 logging:
-  path: "/path/to/honeybadger.log" 
+  path: "/path/to/honeybadger.log"
 request:
   filter_keys:
     - "credit_card"
@@ -206,11 +224,22 @@ All configuration options can also be read from environment variables (ENV). To
 export HONEYBADGER_LOGGING_PATH=/path/to/honeybadger.log
 ```
 
-ENV options override other options read from framework or `honeybadger.yml` sources, so both can be used together. 
+ENV options override other options read from framework or `honeybadger.yml` sources, so both can be used together.
+
+### Configuration via Ruby (programmatic)
+
+To configure Honeybadger from Ruby, use `Honeybadger.configure`:
+
+```ruby
+Honeybadger.configure do |config|
+  config.api_key = 'project api key'
+  config.exceptions.ignore += [CustomError]
+end
+```
 
 ## Configuration Options
 
-You can use any of the options below in your config file, or in the environment. 
+You can use any of the options below in your config file, or in the environment.
 
 
 
@@ -220,6 +249,7 @@ You can use any of the options below in your config file, or in the environment.
 |`env`                            | String  | The environment the app is running in. In Rails this defaults to `Rails.env`.<br/>_Default: `nil`_|
 |`report_data`                    | Boolean | Enable/disable reporting of data. Defaults to false for "test", "development", and "cucumber" environments.  <br>_Default: `true`_|
 |`root`                           | String  | The project's absolute root path.<br/>_Default: `Dir.pwd`_|
+|`revision`                       | String  | The project's git revision.<br/>_Default: revision detected from git_|
 |`hostname`                       | String  | The hostname of the current box.<br/>_Default: `Socket.gethostname`_|
 |`backend`                        | String  | An alternate backend to use for reporting data.<br/>_Default: `nil`_|
 |`debug`                          | Boolean | Enables verbose debug logging.<br/>_Default: `false`_|
@@ -228,7 +258,7 @@ You can use any of the options below in your config file, or in the environment.
 | `config_path`                   | String  | The path of the honeybadger config file. Can only be set via the `$HONEYBADGER_CONFIG_PATH` environment variable |
 |`development_environments`       | Array   | Environments which will not report data by default (use report_data to enable/disable explicitly).<br/>_Default: `["development", "test", "cucumber"]`_|
 |`plugins`                        | Array   | An optional list of plugins to load. Default is to load all plugins.<br/>_Default: `[]`_|
-|`plugins.skip`                   | Array   | An optional list of plugins to skip.<br/>_Default: `[]`_|
+|`skipped_plugins`                | Array   | An optional list of plugins to skip.<br/>_Default: `[]`_|
 |&nbsp;                           |         ||
 |__LOGGING__                      |         ||
 |`logging.path`                   | String  | The path (absolute, or relative from config.root) to the log file. Defaults to the rails logger or STDOUT. To log to standard out, use 'STDOUT'.<br/>_Default: `nil`_|
@@ -271,15 +301,17 @@ You can use any of the options below in your config file, or in the environment.
 |&nbsp;                           |         ||
 |__SIDEKIQ__                      |         ||
 |`sidekiq.attempt_threshold`      | Integer | The number of attempts before notifications will be sent.<br/>_Default: `0`_|
-|`sidekiq.use_component`          | Boolean | Automatically set the component to the class of the job. Helps with grouping.<br/>_Default: `false`_|
+|`sidekiq.use_component`          | Boolean | Automatically set the component to the class of the job. Helps with grouping.<br/>_Default: `true`_|
 |__DELAYED JOB__                  |         ||
 |`delayed_job.attempt_threshold`  | Integer | The number of attempts before notifications will be sent.<br/>_Default: `0`_|
+|__SHORYUKEN__                    |         ||
+|`shoryuken.attempt_threshold`    | Integer | The number of attempts before notifications will be sent.<br/>_Default: `0`_|
 |__SINATRA__                        |         ||
 |`sinatra.enabled`                | Boolean | Enable Sinatra auto-initialization.<br/>_Default: `true`_|
 
-## Public Methods 
+## Public Methods
 
-> What follows is a summary of the gem's most commonly-used public methods. For a more authoritative list, read the [full API documentation](http://www.rubydoc.info/gems/honeybadger/Honeybadger).
+> What follows is a summary of the gem's most commonly-used public methods. For a more authoritative list, read the [full API documentation](http://www.rubydoc.info/gems/honeybadger/Honeybadger/Agent).
 
 
 ### `Honeybadger.context()`: Set metadata to be sent if an exception occurs
@@ -306,6 +338,9 @@ end
 
 # Clearing global context:
 Honeybadger.context.clear!
+
+# Fetching current context
+Honeybadger.get_context
 ```
 
 ---
@@ -318,8 +353,8 @@ You normally won't have to use this method. Honeybadger detects and reports erro
 #### Use this method if:
 
 * You've rescued an exception, but still want to report it
-* You need to report an exception outside of a supported framework. 
-* You want complete control over what exception data is sent to us. 
+* You need to report an exception outside of a supported framework.
+* You want complete control over what exception data is sent to us.
 
 
 #### Examples:
@@ -329,7 +364,27 @@ You normally won't have to use this method. Honeybadger detects and reports erro
 begin
   fail 'oops'
 rescue => exception
-  Honeybadger.notify(exception) 
+  Honeybadger.notify(exception)
+end
+```
+
+---
+
+### `Honeybadger.configure()`: Configure Honeybadger from Ruby
+
+This method allows you to configure Honeybadger at runtime.
+
+#### Use this method if:
+
+* You want to change Honeybadger's configuration from inside Ruby rather than
+  (or in addition to) using the honeybadger.yml file or environment variables.
+
+#### Examples:
+
+```ruby
+Honeybadger.configure do |config|
+  config.api_key = 'project api key'
+  config.exceptions.ignore += [CustomError]
 end
 ```
 
@@ -364,8 +419,45 @@ end
 ```
 __WARNING:__ While it is possible to use this callback to modify the data that is reported to Honeybadger, this is not officially supported and may not be allowed in future versions of the gem.
 
+---
+
+### `Honeybadger.exception_fingerprint()`: Customize your error grouping.
 
-## Deployment Tracking 
+This method lets you add a callback that should return a unique string given a `Honeybadger::Notice` instance. All notices which match the same string will be grouped together in Honeybadger.
+
+#### Use this method if:
+
+* You currently receive too many error notifications
+* You want to group some errors together which are currently unique
+* You *don't* want to group some errors which are currently grouped
+
+#### Examples:
+
+```ruby
+Honeybadger.exception_fingerprint do |notice|
+  [notice[:error_class], notice[:component], notice[:backtrace].to_s].join(':')
+end
+```
+
+---
+
+### `Honeybadger.backtrace_filter()`: Filter your backtrace.
+
+This method allows you to add a callback which modifies each line of the backtrace before a notification happens.
+
+#### Use this method if:
+
+* You want to change or sanitize common data in your exception backtraces
+
+#### Examples:
+
+```ruby
+Honeybadger.backtrace_filter do |line|
+  line.gsub(/^\/my\/unknown\/bundle\/path/, "[GEM_ROOT]")
+end
+```
+
+## Deployment Tracking
 
 Honeybadger has an API to keep track of project deployments. Whenever you deploy, all errors for that environment will be resolved automatically. You can choose to enable or disable the auto-resolve feature from your Honeybadger project settings page.
 
@@ -385,7 +477,7 @@ Adding options to your&nbsp; _config/deploy.rb_&nbsp;file allows you to&nbsp;cus
 set :honeybadger_env, "preprod"
 ```
 
-You can use any of the following options when configuring capistrano. 
+You can use any of the following options when configuring capistrano.
 
 | Option                    |      |
 |-------------------------- | ---- |
@@ -425,16 +517,117 @@ bundle exec honeybadger deploy --environment=production
 Run&nbsp; `bundle exec honeybadger help deploy` for all available options.
 
 
+## Honeybadger CLI
+
+The Honeybadger CLI provides a Command Line Interface for various
+Honeybadger-related programs and utilities. All features are available through
+the `honeybadger` command and can be used independently of Bundler/Rails.
+
+When using the *honeybadger* gem with Bundler, run `bundle exec honeybadger`.
+
+To use outside of bundler, install the Honeybadger gem with `gem install
+honeybadger` and then run `honeybadger`.
+
+### CLI Configuration
+
+The `honeybadger` command optionally reads configuration from the following
+locations. Each location in the list takes precedence over the previous
+location:
+
+1. ~/honeybadger.yml
+2. ./config/honeybadger.yml
+3. ./honeybadger.yml
+4. Rails/Ruby configuration (only when called from a Rails app root)
+5. Environment variables
+6. Command-line flags (i.e. `--api-key`)
+
+The following configuration options are used by the CLI when applicable:
+`api_key`, `env`. See [Configuration Options](#configuration-options)
+
+All other options must be passed as command-line flags.
+
+### CLI Commands
+
+The following commands are available through the `honeybadger` CLI:
+
+| Command              | Description |
+| -------------------- | ----------- |
+| honeybadger deploy   | Notify Honeybadger of deployment |
+| honeybadger exec     | Execute a command. If the exit status is not 0, report the result to Honeybadger |
+| honeybadger help     | Describe available commands or one specific command |
+| honeybadger heroku   | Manage Honeybadger on Heroku |
+| honeybadger install  | Install Honeybadger into a new project |
+| honeybadger notify   | Notify Honeybadger of an error |
+| honeybadger test     | Send a test notification from Honeybadger |
+
+For additional info about each command, run `honeybadger help`.
+
+### Rails initialization
+
+When run from the root of a Rails project, the `honeybadger` command will load
+the Rails environment so that any framework/programmatic configuration is picked
+up.
+
+## Cron/command line monitoring
+
+`honeybadger exec` can be used from the command line/terminal to monitor failed
+commands.  To use it, prefix any normal command with `honeybadger exec` (much
+like `bundle exec`):
+
+```sh
+$ honeybadger exec my-command --my-flag
+```
+
+If the command executes successfully, honeybadger exits with code 0. It prints
+any output from the command by default. To use with cron's automatic email
+feature, use the `--quiet` flag, which will suppress all standard output from
+the origin command unless the command fails *and* the Honeybadger notification
+fails, in which case it will dump the output so that cron can send a backup
+email notification.
+
+For full usage run `honeybadger help exec`.
+
+## Notify from the command line
+
+To send a Honeybadger notification from the command line/terminal, use
+`honeybadger notify`:
+
+```sh
+$ honeybadger notify --message "This is an error from the command line"
+```
+
+For full usage run `honeybadger help notify`.
+
+## Reporting to multiple Honeybadger projects in the same app
+
+To send errors to another Honeybadger project, configure an additional agent:
+
+```ruby
+OtherBadger = Honeybadger::Agent.new
+
+OtherBadger.configure do |config|
+  config.api_key = 'project api key'
+end
+
+begin
+  # Failing code
+rescue => exception
+  OtherBadger.notify(exception)
+end
+```
+
+Agents do not use the global honeybadger.yml or environment variable
+configuration and must be configured manually after they are instantiated.
 
 ## Custom Error Pages
 
-The Honeybadger gem has a few special tags that it looks for whenever you render an error page. These can be used to display extra information about the error, or to ask the user for information about how they triggered the error. 
+The Honeybadger gem has a few special tags that it looks for whenever you render an error page. These can be used to display extra information about the error, or to ask the user for information about how they triggered the error.
 
 ### Displaying Error ID
 
 When an error is sent to Honeybadger, our API returns a unique UUID for the occurrence within your project. This UUID can be automatically displayed for reference on Rails error pages (e.g. `public/500.html`) or any rack output by including the `Honeybadger::UserInformer` middleware.
 
-To include the error id, simply place this magic HTML comment on your error page: 
+To include the error id, simply place this magic HTML comment on your error page:
 
 ```html
 <!-- HONEYBADGER ERROR -->
@@ -482,6 +675,90 @@ en:
         comment: "Comment (required)"
 ```
 
+## Testing Honeybadger in your integration tests
+
+It is possible to test Honeybadger's integration with your application using the
+included test backend.
+
+The test backend replaces the default server backend with a stub that records
+error notices rather than sending them, allowing all but the HTTP notification
+itself to be verified. Alternatively, you could use something like
+[WebMock](https://github.com/bblimke/webmock) to perform a similar test using
+the "server" backend.
+
+### Configuring the test backend
+
+To use the test backend, set the `backend` configuration option to "test" in
+honeybadger.yml for your test environment only:
+
+```yaml
+api_key: 'project api key'
+test:
+  backend: test
+```
+
+You can also use the *HONEYBADGER_BACKEND* environment variable to configure the
+test backend. Note that you must also configure your API key for the test to
+succeed.
+
+
+### Writing the integration test
+
+The test backend can be used in any testing framework to test any code which
+reports an error with `Honeybadger.notify`. A common scenario is to test the
+Rails-integration which reports exceptions in a Rails controller automatically.
+
+The following example uses RSpec to test error notification in a Rails
+controller.
+
+First, create the controller:
+
+```ruby
+# app/controllers/honeybadger_test_controller.rb
+class HoneybadgerTestController < ApplicationController
+  ERROR = RuntimeError.new("testing reporting an error to Honeybadger")
+
+  def index
+    raise ERROR
+  end
+end
+```
+
+Next, create a route. For security, it's a good idea to enable the route only in
+the test environment:
+
+```ruby
+  # config/routes.rb
+
+  # ...
+  get '/test/honeybadger' => 'honeybadger_test#index' if Rails.env.test?
+```
+
+Finally, create the integration test:
+
+```ruby
+# spec/features/honeybadger_spec.rb
+require 'rails_helper'
+
+describe "error notification" do
+  it "notifies Honeybadger" do
+    expect {
+      # Code to test goes here:
+      expect { visit '/test/honeybadger' }.to raise_error(HoneybadgerTestController::ERROR)
+
+      # Important: `Honeybadger.flush` ensures that asynchronous notifications
+      # are delivered before the test's remaining expectations are verified.
+      Honeybadger.flush
+    }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(1)
+    expect(Honeybadger::Backend::Test.notifications[:notices].first.error_message).to eq('testing reporting an error to Honeybadger')
+  end
+end
+```
+
+## Troubleshooting
+
+See [TROUBLESHOOTING.md](https://github.com/honeybadger-io/honeybadger-ruby/blob/master/TROUBLESHOOTING.md)
+
 ## Changelog
 
 See https://github.com/honeybadger-io/honeybadger-ruby/blob/master/CHANGELOG.md

data/TROUBLESHOOTING.md

@@ -8,9 +8,17 @@ one or all of our helpful founders will assist you!
 ## Upgrade the gem
 
 Before digging deeper into this guide, **make sure you are on the latest minor
-release of the honeybadger gem** (i.e. 2.x.x). There's a chance you've found a bug
+release of the honeybadger gem** (i.e. 3.x.x). There's a chance you've found a bug
 which has already been fixed!
 
+## Send a Test Exception
+
+You can send a test exception using the `honeybadger` command line utility:
+
+```bash
+$ honeybadger test
+```
+
 ## How to enable verbose logging
 
 Troubleshooting any of these issues will be much easier if you can see what's
@@ -62,6 +70,10 @@ development:
   report_data: true
 ```
 
+##### The `better_errors` gem is installed
+
+The [`better_errors` gem](https://github.com/charliesome/better_errors) conflicts with the Honeybadger gem when in development mode. To be able to report errors from development you must first temporarily disable/remove the `better_errors` gem. Better Errors should not affect production because it should never be enabled in production.
+
 #### Is the error ignored by default?
 
 Honeybadger ignores [this list of
@@ -87,28 +99,13 @@ rescue => e
 end
 ```
 
-#### Honeybadger is not started
-
-We currently initialize Rails and Sinatra apps automatically. If you use either
-of those frameworks and are not receiving error reports, then you probably have
-a different issue and should skip this section. For all other frameworks (or
-plain ol' Ruby), `Honeybadger.start()` must be called manually.
-
-To verify that Honeybadger is not started, [enable debug
-logging](#how-to-enable-verbose-logging) and then start your app; if Honeybadger
-was initialized, you should see something in the log output.
+### I'm not receiving notifications
 
-```
-** [Honeybadger] Starting Honeybadger version 2.1.0 level=1 pid=18077
-```
+#### Was the error reported already and is unresolved?
 
-If you don't get any logs prefixed with "** [Honeybadger]", then you can start
-Honeybadger manually like this:
-
-```ruby
-honeybadger_config = Honeybadger::Config.new
-Honeybadger.start(honeybadger_config)
-```
+By default we only send notifications the first time an exception happens, and
+when it re-occurs after being marked resolved. If an exception happens 100
+times, but was never resolved you'll only get 1 email about it.
 
 ## Sidekiq/Resque/ActiveJob/etc.
 
@@ -129,3 +126,12 @@ behavior:
 ```
 HONEYBADGER_EXCEPTIONS_IGNORE_ONLY=Error,ClassNames,Here bundle exec sidekiq
 ```
+
+## Command line utility
+
+If you get an error while running the `honeybadger` command line utility:
+
+0. Try prefixing the command with `bundle exec`...even if you normally rely on bin-stubs to do this for you
+1. Check `honeybadger help` if you're having trouble with the syntax for a specific command.
+2. Try enabling [verbose logging](#how-to-enable-verbose-logging) to get more info
+3. Ask Us! We're always here to help. Just copy the terminal output and email it to us at support@honeybadger.io

data/lib/honeybadger/cli/deploy.rb

@@ -18,7 +18,7 @@ module Honeybadger
 
       def run
         payload = {
-          environment: options['environment'],
+          environment: config.get(:env),
           revision: options['revision'],
           repository: options['repository'],
           local_username: options['user']

data/lib/honeybadger/config/defaults.rb

@@ -271,6 +271,11 @@ module Honeybadger
         default: 0,
         type: Integer
       },
+      :'shoryuken.attempt_threshold' => {
+        description: 'The number of attempts before notifications will be sent.',
+        default: 0,
+        type: Integer
+      },
       :'sidekiq.use_component' => {
         description: 'Automatically set the component to the class of the job. Helps with grouping.',
         default: true,

data/lib/honeybadger/plugins/rails.rb

@@ -4,11 +4,6 @@ module Honeybadger
   module Plugins
     module Rails
       module ExceptionsCatcher
-        def self.included(base)
-          base.send(:alias_method, :render_exception_without_honeybadger, :render_exception)
-          base.send(:alias_method, :render_exception, :render_exception_with_honeybadger)
-        end
-
         # Internal: Adds additional Honeybadger info to Request env when an
         # exception is rendered in Rails' middleware.
         #
@@ -18,7 +13,7 @@ module Honeybadger
         #
         # Returns the super value of the middleware's #render_exception()
         # method.
-        def render_exception_with_honeybadger(arg, exception)
+        def render_exception(arg, exception)
           if arg.kind_of?(::ActionDispatch::Request)
             request = arg
             env = request.env
@@ -30,7 +25,7 @@ module Honeybadger
           env['honeybadger.exception'] = exception
           env['honeybadger.request.url'] = request.url rescue nil
 
-          render_exception_without_honeybadger(arg, exception)
+          super(arg, exception)
         end
       end
 
@@ -41,10 +36,10 @@ module Honeybadger
           require 'rack/request'
           if defined?(::ActionDispatch::DebugExceptions)
             # Rails 3.2.x+
-            ::ActionDispatch::DebugExceptions.send(:include, ExceptionsCatcher)
+            ::ActionDispatch::DebugExceptions.prepend(ExceptionsCatcher)
           elsif defined?(::ActionDispatch::ShowExceptions)
             # Rails 3.0.x and 3.1.x
-            ::ActionDispatch::ShowExceptions.send(:include, ExceptionsCatcher)
+            ::ActionDispatch::ShowExceptions.prepend(ExceptionsCatcher)
           end
         end
       end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # Public: The current String Honeybadger version.
-  VERSION = '3.1.0'.freeze
+  VERSION = '3.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -142,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Error reports you can be happy about.