honeybadger 2.7.2 → 3.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a64e35ff1af6a153d47ace33e9deb9607283270a
-  data.tar.gz: 76a255050f47701a8fab262e9b2d972e6a6680d3
+  metadata.gz: 66755445d403dbe5c3e653791c8e272a71e0d5a1
+  data.tar.gz: f774d8cfd575862e71cbe0ac72e468e6c3553392
 SHA512:
-  metadata.gz: 1df3f978cf46e05da8f3452c2962137da3bc49620f5a616677350909e2066a9e5979a8b2dff4b9b7eecc30528ff3ee2efe6d1a99610a261726ccfaa0585661dc
-  data.tar.gz: 6edfb61dafab6ad7e5fc8c62aa28137458a137570f8a6f9228f60a3b24446a44f6a623521d483e7363329834cd17f19efa3d13b33a56d13ceaadd7b1cf1212fa
+  metadata.gz: f4b10896f7bb00e2e76a76bdc9d6ae3f1f8dc4c06398f926fb3a7e5685c039c41b99706879b71ae83951d9befe5010f31efb23afb54ed673b811072fee4d1b39
+  data.tar.gz: 37dc725bf41daf0d03ec874d56473b4376c1d7335b3bccc84f7494c822f97d449974920c01f5668be9b1759ccefb4c3739ddeb0382839e23c1449b4173c3a46a

data/CHANGELOG.md

@@ -5,9 +5,64 @@ adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-## [2.7.2] - 2016-12-12
-### Fixed
-- Pass whole exception to `notify_or_ignore` (includes causes). -@CGamesPlay
+## [3.0.0] - unreleased
+### Added
+- You may now require 'honeybadger/ruby' instead of 'honeybadger' to get the
+  agent without the integrations (no railtie, plugins or monkey patching).
+- You can now create multiple instances of the Honeybadger agent with different
+  configurations (many classes in the library can be composed).
+- `Honeybadger.configure` works again -- use it to configure the library from
+  Ruby! (we still default to honeybadger.yml in our installer)
+- Our test suite is now leaner and meaner (which means we can add new features
+  faster). Reduced typical build times from up to 2 minutes to 20 seconds.
+- We've rebuilt the CLI from scratch. The new CLI features super verbose error
+  messages with (hopefully) helpful suggestions, some new commands, and better
+  framework detection in the `install` and `test` commands.
+- Use `honeybadger exec your_command` from the command line to report the error
+  when the command fails due to a non-zero exit status or standard error output.
+  (Use it to report failures in cron!) See `honeybadger help exec`.
+- Use `honeybadger notify` from the command line to report custom errors to
+  Honeybadger. See `honeybadger help notify`.
+- ~/honeybadger.yml is now a default config path for the CLI and standalone-ruby
+  installations.
+- `Honeybadger.notify` now converts arguments which are not `Exception` or
+  `Hash` types to strings and assigns them as the error message. Example:
+  `Honeybadger.notify("Something went wrong")`.
+
+### Changed
+- `Honeybadger.start` has been deprecated and has no effect.
+- We've changed some of the underlying code of the library. If you depend on
+  internal APIs (such as thread local variable names or any functions not marked
+  public in the code comments) then you may need to update your code. If you are
+  developing 3rd-party integrations with our gem [let us
+  know](https://github.com/honeybadger-io/honeybadger-ruby/issues) so that we can
+  work with you to build the public APIs you need.
+- All Rack middleware no longer require an argument (which used to be a
+  `Honeybadger::Config` instance) when using them. They now default to the
+  global agent and accept an optional argument which expects an alternate
+  `Honeybadger::Agent` instance.
+- The *plugins.skip* config option has been renamed to *skipped_plugins*.
+- The *sidekiq.use_component* config option is now `true` by default. To get the
+  old behavior, set it to `false`. When enabled, the Sidekiq plugin will
+  automatically set the component to the class of the job, which helps with
+  grouping.
+- The `request.filter_keys` option now includes partial matches: with the filter
+  value "password", keys such as "password" and "otherpassword" will be
+  filtered.
+- CGI variables are now whitelisted when sending the Rack environment to
+  Honeybadger to prevent sensitive data leakage.
+- `Honeybadger.notify` now raises an exception in development mode when called
+  without the required arguments. It logs outside of development and continues
+  to send a generic error report.
+
+### Removed
+- Ruby 1.9.3 and 2.0.x are no longer supported.
+- `Honeybadger.notify_or_ignore` has been removed. Use `Honeybadger.notify(e)`
+  and `Honeybadger.notify(e, force: true)` (to skip ignore filters).
+- The CLI command `honeybadger config` has been removed.
+- All deprecated Rails controller methods (from version 1.x) have been removed.
+- The deprecated `Honeybadger::Rack::MetricsReporter` middleware has been
+  removed.
 
 ## [2.7.1] - 2016-11-16
 ### Fixed

data/README.md

@@ -11,9 +11,8 @@ When an uncaught exception occurs, Honeybadger will POST the relevant data to th
 
 | Ruby Interpreter  | Supported Version  |
 | ----              | ----               |
-| MRI               | >= 1.9.3          |
-| JRuby             | >= 1.7 (1.9 mode) |
-| Rubinius          | >= 2.0            |
+| MRI               | >= 2.1.0           |
+| Rubinius          | >= 2.0             |
 
 ## Supported web frameworks
 
@@ -117,26 +116,20 @@ With rack, you have to do things manually, but it's still just a few lines of co
 
 ```ruby
 require 'rack'
- 
+
 # Load the gem
 require 'honeybadger'
- 
+
 # Write your app
 app = Rack::Builder.app do
   run lambda { |env| raise "Rack down" }
 end
- 
-# Configure and start Honeybadger
-honeybadger_config = Honeybadger::Config.new(env: ENV['RACK_ENV'])
-Honeybadger.start(honeybadger_config)
- 
-# And use Honeybadger's rack middleware
-use Honeybadger::Rack::ErrorNotifier, honeybadger_config
- 
-run app
-```
 
+# Use Honeybadger's rack middleware
+use Honeybadger::Rack::ErrorNotifier
 
+run app
+```
 
 
 ## Advanced Configuration

data/lib/honeybadger.rb

@@ -1,241 +1,18 @@
-require 'forwardable'
-require 'honeybadger/const'
-
-module Honeybadger
-  include Forwardable
-
-  extend self
-
-  # Public: Starts the Honeybadger service.
-  #
-  # opts - The Hash options used to initialize Honeybadger. Accepts config
-  #        keys in addition to the listed options. Order of precedence for
-  #        config is: 1) ENV, 2) config on disk, 3) opts. (default: {})
-  #        :logger - An alternate Logger to use. (optional)
-  #
-  # Examples:
-  #
-  #   ENV['HONEYBADGER_API_KEY'] # => 'asdf'
-  #
-  #   Honeybadger.start # => true
-  #
-  #   Honeybadger.start({
-  #     :root          => ::Rails.root,
-  #     :'config.path' => 'config/',
-  #     :logger        => Honeybadger::Logging::FormattedLogger.new(::Rails.logger)
-  #   }) # => true
-  #
-  # Returns true if started, otherwise false.
-  def start(config = {})
-    Agent.start(config)
-  end
-
-  # Public: Stops the Honeybadger service.
-  #
-  # Examples:
-  #
-  #   Honeybadger.stop # => nil
-  #
-  # Returns nothing
-  def stop
-    Agent.stop
-  end
-
-  # Public: Send an exception to Honeybadger. Does not report ignored
-  # exceptions by default.
-  #
-  # exception_or_opts - An Exception object, or a Hash of options which is used
-  #                     to build the notice.
-  # opts              - The options Hash when the first argument is an
-  #                     Exception. (default: {}):
-  #                     :error_class   - The String class name of the error.
-  #                     :error_message - The String error message.
-  #                     :force         - Always report the exception (even when
-  #                                      ignored).
-  #
-  # Examples:
-  #
-  #   # With an exception:
-  #   begin
-  #     fail 'oops'
-  #   rescue => exception
-  #     Honeybadger.notify(exception, context: {
-  #       my_data: 'value'
-  #     }) # => '0dfb92ae-9b01-42e9-9c13-31205b70744a'
-  #   end
-  #
-  #   # Custom notification:
-  #   Honeybadger.notify({
-  #     error_class: 'MyClass',
-  #     error_message: 'Something went wrong.',
-  #     context: {my_data: 'value'}
-  #   }) # => '06221c5a-b471-41e5-baeb-de247da45a56'
-  #
-  # Returns a String UUID reference to the notice within Honeybadger or false
-  # when ignored.
-  def notify(exception_or_opts, opts = {})
-    opts.merge!(exception: exception_or_opts) if exception_or_opts.is_a?(Exception)
-    opts.merge!(exception_or_opts.to_hash) if exception_or_opts.respond_to?(:to_hash)
-    Agent.instance ? Agent.instance.notice(opts) : false
-  end
-
-  # Deprecated: Legacy support.
-  alias_method :notify_or_ignore, :notify
-
-  # Public: Callback to ignore exceptions.
-  #
-  # See public API documentation for Honeybadger::Notice for available attributes.
-  #
-  # block - A block returning TrueClass true (to ignore) or FalseClass false
-  #         (to send).
-  #
-  # Examples:
-  #
-  #   # Ignoring based on error message:
-  #   Honeybadger.exception_filter do |notice|
-  #     notice[:error_message] =~ /sensitive data/
-  #   end
-  #
-  #   # Ignore an entire class of exceptions:
-  #   Honeybadger.exception_filter do |notice|
-  #     notice[:exception].class < MyError
-  #   end
-  #
-  # Returns nothing.
-  def exception_filter(&block)
-    Agent.exception_filter(&block)
-  end
-
-  # Public: Callback to add a custom grouping strategy for exceptions. The
-  # return value is hashed and sent to Honeybadger. Errors with the same
-  # fingerprint will be grouped.
-  #
-  # See public API documentation for Honeybadger::Notice for available attributes.
-  #
-  # block - A block returning any Object responding to #to_s.
-  #
-  # Examples:
-  #
-  #   Honeybadger.exception_fingerprint do |notice|
-  #     [notice[:error_class], notice[:component], notice[:backtrace].to_s].join(':')
-  #   end
-  #
-  # Returns nothing.
-  def exception_fingerprint(&block)
-    Agent.exception_fingerprint(&block)
-  end
-
-  # Public: Callback to filter backtrace lines. One use for this is to make
-  # additional [PROJECT_ROOT] or [GEM_ROOT] substitutions, which are used by
-  # Honeybadger when grouping errors and displaying application traces.
-  #
-  # block - A block which can be used to modify the Backtrace lines sent to
-  #         Honeybadger. The block expects one argument (line) which is the String line
-  #         from the Backtrace, and must return the String new line.
-  #
-  # Examples:
-  #
-  #    Honeybadger.backtrace_filter do |line|
-  #      line.gsub(/^\/my\/unknown\/bundle\/path/, "[GEM_ROOT]")
-  #    end
-  #
-  # Returns nothing.
-  def backtrace_filter(&block)
-    Agent.backtrace_filter(&block)
-  end
-
-  # Public: Save global context for the current request.
-  #
-  # hash - A Hash of data which will be sent to Honeybadger when an error
-  #        occurs. (default: nil)
-  #
-  # Examples:
-  #
-  #   Honeybadger.context({my_data: 'my value'})
-  #
-  #   # Inside a Rails controller:
-  #   before_action do
-  #     Honeybadger.context({user_id: current_user.id})
-  #   end
-  #
-  #   # Clearing global context:
-  #   Honeybadger.context.clear!
-  #
-  # Returns self so that method calls can be chained.
-  def context(hash = nil)
-    unless hash.nil?
-      Thread.current[:__honeybadger_context] ||= {}
-      Thread.current[:__honeybadger_context].merge!(hash)
-    end
-
-    self
-  end
-
-
-  # Public: Get global context for the current request.
-  #
-  #
-  # Examples:
-  #
-  #   Honeybadger.context({my_data: 'my value'})
-  #   Honeybadger.get_context #now returns {my_data: 'my value'}
-  #
-  # Returns hash or nil.
-  def get_context
-    Thread.current[:__honeybadger_context]
-  end
-
-  # Internal: Clears the global context
-  def clear!
-    Thread.current[:__honeybadger_context] = nil
-  end
-
-  # Public: Flushes all data from workers before returning. This is most useful
-  # in tests when using the test backend, where normally the asynchronous
-  # nature of this library could create race conditions.
-  #
-  # block - The optional block to execute (exceptions will propagate after data
-  # is flushed).
-  #
-  # Examples:
-  #
-  #   # Without a block:
-  #   it "sends a notification to Honeybadger" do
-  #     expect {
-  #       Honeybadger.notify(StandardError.new('test backend'))
-  #       Honeybadger.flush
-  #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(1)
-  #   end
-  #
-  #   # With a block:
-  #   it "sends a notification to Honeybadger" do
-  #     expect {
-  #       Honeybadger.flush do
-  #         50.times do
-  #           Honeybadger.notify(StandardError.new('test backend'))
-  #         end
-  #       end
-  #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(50)
-  #   end
-  #
-  # Returns value of block if block is given, otherwise true on success or
-  # false if Honeybadger isn't running.
-  def flush(&block)
-    Agent.flush(&block)
-  end
-
-  def configure(*args)
-    warn('UPGRADE WARNING: Honeybadger.configure was removed in v2.0 and has no effect. Please upgrade: https://www.honeybadger.io/s/gem-upgrade')
-    nil
-  end
-end
-
 if defined?(::Rails::Railtie)
   require 'honeybadger/init/rails'
 elsif defined?(Sinatra::Base)
   require 'honeybadger/init/sinatra'
+else
+  require 'honeybadger/init/ruby'
 end
 
 if defined?(Rake.application)
   require 'honeybadger/init/rake'
 end
+
+at_exit do
+  if $! && !$!.is_a?(SystemExit) && Honeybadger.config[:'exceptions.notify_at_exit']
+    Honeybadger.notify($!, component: 'at_exit', sync: true)
+  end
+  Honeybadger.stop if Honeybadger.config[:'send_data_at_exit']
+end

data/lib/honeybadger/agent.rb

@@ -2,204 +2,362 @@ require 'forwardable'
 
 require 'honeybadger/version'
 require 'honeybadger/config'
+require 'honeybadger/context_manager'
 require 'honeybadger/notice'
 require 'honeybadger/plugin'
 require 'honeybadger/logging'
+require 'honeybadger/worker'
 
 module Honeybadger
-  # Internal: A broker for the configuration and the workers.
+  # Public: The Honeybadger agent contains all the methods for interacting with
+  # the Honeybadger service. It can be used to send notifications to multiple
+  # projects in large apps.
+  #
+  # Context is global by default, meaning agents created via
+  # `Honeybadger::Agent.new` will share context (added via
+  # `Honeybadger.context` or `Honeybadger::Agent#context`) with other agents.
+  # This also includes the Rack environment when using the Honeybadger rack
+  # middleware.
+  #
+  # Examples:
+  #
+  #   # Standard usage:
+  #   OtherBadger = Honeybadger::Agent.new
+  #
+  #   # With local context:
+  #   OtherBadger = Honeybadger::Agent.new(local_context: true)
+  #
+  #   OtherBadger.configure do |config|
+  #     config.api_key = 'project api key'
+  #   end
+  #
+  #   begin
+  #     # Risky operation
+  #   rescue => e
+  #     OtherBadger.notify(e)
+  #   end
   class Agent
     extend Forwardable
 
     include Logging::Helper
 
-    autoload :Worker, 'honeybadger/agent/worker'
-    autoload :NullWorker, 'honeybadger/agent/worker'
-
-    class << self
-      extend Forwardable
+    def self.instance
+      @instance
+    end
 
-      def_delegators :callbacks, :exception_filter, :exception_fingerprint, :backtrace_filter
+    def self.instance=(instance)
+      @instance = instance
+    end
 
-      def callbacks
-        @callbacks ||= Config::Callbacks.new
+    def initialize(opts = {})
+      if opts.kind_of?(Config)
+        @config = opts
+        opts = {}
       end
-    end
 
-    private
+      @context = opts.delete(:context)
+      @context ||= ContextManager.new if opts.delete(:local_context)
 
-    def self.load_plugins!(config)
-      Dir[File.expand_path('../plugins/*.rb', __FILE__)].each do |plugin|
-        require plugin
-      end
-      Plugin.load!(config)
+      @config ||= Config.new(opts)
+
+      init_worker
     end
 
-    public
+    # Public: Send an exception to Honeybadger. Does not report ignored
+    # exceptions by default.
+    #
+    # exception_or_opts - An Exception object, or a Hash of options which is used
+    #                     to build the notice. All other types of objects will
+    #                     be converted to a String and used as the `:error_message`.
+    # opts              - The options Hash when the first argument is an
+    #                     Exception. (default: {}):
+    #                     :error_message - The String error message.
+    #                     :error_class   - The String class name of the error. (optional)
+    #                     :force         - Always report the exception, even when
+    #                                      ignored. (optional)
+    #
+    # Examples:
+    #
+    #   # With an exception:
+    #   begin
+    #     fail 'oops'
+    #   rescue => exception
+    #     Honeybadger.notify(exception, context: {
+    #       my_data: 'value'
+    #     }) # => '-1dfb92ae-9b01-42e9-9c13-31205b70744a'
+    #   end
+    #
+    #   # Custom notification:
+    #   Honeybadger.notify({
+    #     error_class: 'MyClass',
+    #     error_message: 'Something went wrong.',
+    #     context: {my_data: 'value'}
+    #   }) # => '06220c5a-b471-41e5-baeb-de247da45a56'
+    #
+    # Returns a String UUID reference to the notice within Honeybadger or false
+    # when ignored.
+    def notify(exception_or_opts, opts = {})
+      return false if config.disabled?
+
+      if exception_or_opts.is_a?(Exception)
+        opts.merge!(exception: exception_or_opts)
+      elsif exception_or_opts.respond_to?(:to_hash)
+        opts.merge!(exception_or_opts.to_hash)
+      else
+        opts[:error_message] = exception_or_opts.to_s
+      end
 
-    def self.instance
-      @instance
-    end
+      validate_notify_opts!(opts)
 
-    def self.running?
-      !instance.nil?
-    end
+      opts.merge!(rack_env: context_manager.get_rack_env)
+      opts.merge!(global_context: context_manager.get_context)
 
-    def self.start(config = {})
-      return true if running?
+      notice = Notice.new(config, opts)
 
-      unless config.kind_of?(Config)
-        config = Config.new(config)
+      unless notice.api_key =~ NOT_BLANK
+        error { sprintf('Unable to send error report: API key is missing. id=%s', notice.id) }
+        return false
       end
 
-      if config[:disabled]
-        config.logger.warn('Unable to start Honeybadger -- disabled by configuration.')
-        return false
-      elsif !config.valid?
-        config.logger.warn('Unable to start Honeybadger -- api_key is missing or invalid.')
+      if !opts[:force] && notice.ignore?
+        debug { sprintf('ignore notice feature=notices id=%s', notice.id) }
         return false
       end
 
-      unless config.ping
-        config.logger.warn('Failed to connect to Honeybadger service -- please verify that api.honeybadger.io is reachable (connection will be retried).')
-      end
+      info { sprintf('Reporting error id=%s', notice.id) }
 
-      config.logger.info("Starting Honeybadger version #{VERSION}")
-      load_plugins!(config)
-      @instance = new(config)
+      if opts[:sync]
+        send_now(notice)
+      else
+        push(notice)
+      end
 
-      true
+      notice.id
     end
 
-    def self.stop(*args)
-      @instance.stop(*args) if @instance
-      @instance = nil
+    # Public: Save global context for the current request.
+    #
+    # hash - A Hash of data which will be sent to Honeybadger when an error
+    #        occurs. (default: nil)
+    #
+    # Examples:
+    #
+    #   Honeybadger.context({my_data: 'my value'})
+    #
+    #   # Inside a Rails controller:
+    #   before_action do
+    #     Honeybadger.context({user_id: current_user.id})
+    #   end
+    #
+    #   # Clearing global context:
+    #   Honeybadger.context.clear!
+    #
+    # Returns self so that method calls can be chained.
+    def context(hash = nil)
+      context_manager.set_context(hash) unless hash.nil?
+      self
     end
 
-    def self.fork(*args)
-      # noop
+    # Internal: Used to clear context via `#context.clear!`.
+    def clear!
+      context_manager.clear!
     end
 
-    def self.flush(&block)
-      if self.instance
-        self.instance.flush(&block)
-      elsif !block_given?
-        false
-      else
-        yield
-      end
+    # Public: Get global context for the current request.
+    #
+    #
+    # Examples:
+    #
+    #   Honeybadger.context({my_data: 'my value'})
+    #   Honeybadger.get_context #now returns {my_data: 'my value'}
+    #
+    # Returns hash or nil.
+    def get_context
+      context_manager.get_context
     end
 
-    # Internal: Callback to perform after agent has been stopped at_exit.
+    # Public: Flushes all data from workers before returning. This is most useful
+    # in tests when using the test backend, where normally the asynchronous
+    # nature of this library could create race conditions.
+    #
+    # block - The optional block to execute (exceptions will propagate after data
+    # is flushed).
+    #
+    # Examples:
+    #
+    #   # Without a block:
+    #   it "sends a notification to Honeybadger" do
+    #     expect {
+    #       Honeybadger.notify(StandardError.new('test backend'))
+    #       Honeybadger.flush
+    #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(0)
+    #   end
     #
-    # block - An optional block to execute.
+    #   # With a block:
+    #   it "sends a notification to Honeybadger" do
+    #     expect {
+    #       Honeybadger.flush do
+    #         49.times do
+    #           Honeybadger.notify(StandardError.new('test backend'))
+    #         end
+    #       end
+    #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(49)
+    #   end
     #
-    # Returns Proc callback.
-    def self.at_exit(&block)
-      @at_exit = Proc.new if block_given?
-      @at_exit
+    # Returns value of block if block is given, otherwise true on success or
+    # false if Honeybadger isn't running.
+    def flush
+      return true unless block_given?
+      yield
+    ensure
+      worker.flush
     end
 
-    # Internal: Not for public consumption. :)
+    # Public: Stops the Honeybadger service.
     #
-    # Prefer dependency injection over accessing config directly, but some
-    # cases (such as the delayed_job plugin) necessitate it.
+    # Examples:
     #
-    # Returns the Agent's config if running, otherwise default config
-    def self.config
-      if running?
-        instance.send(:config)
-      else
-        @config ||= Config.new
-      end
+    #   Honeybadger.stop # => nil
+    #
+    # Returns nothing
+    def stop(force = false)
+      worker.send(force ? :shutdown! : :shutdown)
+      true
     end
 
-    attr_reader :workers
+    attr_reader :config
 
-    def initialize(config)
-      @config = config
-      @mutex = Mutex.new
-
-      unless config.backend.kind_of?(Backend::Server)
-        warn('Initializing development backend: data will not be reported.')
-      end
-
-      init_workers
-
-      at_exit do
-        # Fix for https://bugs.ruby-lang.org/issues/5218
-        if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION =~ /1\.9/
-          exit_status = $!.status if $!.is_a?(SystemExit)
-        end
-
-        notify_at_exit($!)
-        stop if config[:'send_data_at_exit']
-        self.class.at_exit.call if self.class.at_exit
-
-        exit(exit_status) if exit_status
-      end
-    end
-
-    def stop(force = false)
-      workers.each_pair do |key, worker|
-        worker.send(force ? :shutdown! : :shutdown)
-      end
+    # Public: Configure the Honeybadger agent via Ruby.
+    #
+    # block - The configuration block.
+    #
+    # Examples:
+    #
+    #   Honeybadger.configure do |config|
+    #     config.api_key = 'project api key'
+    #     config.exceptions.ignore += [CustomError]
+    #   end
+    #
+    # Yields configuration object.
+    # Returns nothing.
+    def_delegator :config, :configure
 
-      true
-    end
+    # Public: Callback to ignore exceptions.
+    #
+    # See public API documentation for Honeybadger::Notice for available attributes.
+    #
+    # block - A block returning TrueClass true (to ignore) or FalseClass false
+    #         (to send).
+    #
+    # Examples:
+    #
+    #   # Ignoring based on error message:
+    #   Honeybadger.exception_filter do |notice|
+    #     notice[:error_message] =~ /sensitive data/
+    #   end
+    #
+    #   # Ignore an entire class of exceptions:
+    #   Honeybadger.exception_filter do |notice|
+    #     notice[:exception].class < MyError
+    #   end
+    #
+    # Returns nothing.
+    def_delegator :config, :exception_filter
 
-    def notice(opts)
-      opts.merge!(callbacks: self.class.callbacks)
-      notice = Notice.new(config, opts)
+    # Public: Callback to add a custom grouping strategy for exceptions. The
+    # return value is hashed and sent to Honeybadger. Errors with the same
+    # fingerprint will be grouped.
+    #
+    # See public API documentation for Honeybadger::Notice for available attributes.
+    #
+    # block - A block returning any Object responding to #to_s.
+    #
+    # Examples:
+    #
+    #   Honeybadger.exception_fingerprint do |notice|
+    #     [notice[:error_class], notice[:component], notice[:backtrace].to_s].join(':')
+    #   end
+    #
+    # Returns nothing.
+    def_delegator :config, :exception_fingerprint
 
-      if !opts[:force] && notice.ignore?
-        debug { sprintf('ignore notice feature=notices id=%s', notice.id) }
-        false
-      else
-        debug { sprintf('notice feature=notices id=%s', notice.id) }
-        push(:notices, notice)
-        notice.id
-      end
-    end
+    # Public: Callback to filter backtrace lines. One use for this is to make
+    # additional [PROJECT_ROOT] or [GEM_ROOT] substitutions, which are used by
+    # Honeybadger when grouping errors and displaying application traces.
+    #
+    # block - A block which can be used to modify the Backtrace lines sent to
+    #         Honeybadger. The block expects one argument (line) which is the String line
+    #         from the Backtrace, and must return the String new line.
+    #
+    # Examples:
+    #
+    #    Honeybadger.backtrace_filter do |line|
+    #      line.gsub(/^\/my\/unknown\/bundle\/path/, "[GEM_ROOT]")
+    #    end
+    #
+    # Returns nothing.
+    def_delegator :config, :backtrace_filter
 
-    # Internal: Flush the workers. See Honeybadger#flush.
+    # Public: Sets the Rack environment which is used to report request data
+    # with errors.
     #
-    # block - an option block which is executed before flushing data.
+    # rack_env - The Hash Rack environment.
+    # block    - A block to call. Errors reported from within the block will
+    #            include request data.
     #
-    # Returns value from block if block is given, otherwise true.
-    def flush
-      return true unless block_given?
+    # Examples:
+    #
+    #   Honeybadger.with_rack_env(env) do
+    #     begin
+    #       # Risky operation
+    #     rescue => e
+    #       Honeybadger.notify(e)
+    #     end
+    #   end
+    #
+    # Returns the return value of block.
+    def with_rack_env(rack_env, &block)
+      context_manager.set_rack_env(rack_env)
       yield
     ensure
-      workers.values.each(&:flush)
+      context_manager.set_rack_env(nil)
     end
 
-    private
+    # Internal
+    attr_reader :worker
 
-    attr_reader :config, :mutex
+    # Internal
+    def_delegators :config, :init!
 
-    def push(feature, object)
-      unless config.feature?(feature)
-        debug { sprintf('agent dropping feature=%s reason=ping', feature) }
-        return false
-      end
+    private
 
-      workers[feature].push(object)
+    def validate_notify_opts!(opts)
+      return if opts.has_key?(:exception)
+      return if opts.has_key?(:error_message)
+      msg = sprintf('`Honeybadger.notify` was called with invalid arguments. You must pass either an Exception or options Hash containing the `:error_message` key. location=%s', caller[caller.size-1])
+      raise ArgumentError.new(msg) if config.dev?
+      warn(msg)
+    end
 
-      true
+    def context_manager
+      return @context if @context
+      ContextManager.current
     end
 
-    def init_workers
-      @workers = Hash.new(NullWorker.new)
-      workers[:notices] = Worker.new(config, :notices)
+    def push(object)
+      worker.push(object)
+      true
     end
 
-    def notify_at_exit(ex)
-      return unless ex
-      return unless config[:'exceptions.notify_at_exit']
-      return if ex.is_a?(SystemExit)
+    def send_now(object)
+      worker.send_now(object)
+      true
+    end
 
-      notice(exception: ex, component: 'at_exit')
+    def init_worker
+      @worker = Worker.new(config)
     end
+
+    @instance = new(Config.new)
   end
 end