honeybadger 1.16.7 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f504706a430b22213b3c9981b53606bfffb5a3e
-  data.tar.gz: 19a64023b5f8f8e57742b9cca18957fbac3fb341
+  metadata.gz: 7da3276ec8bbc96881dc0edf11dfa62dfb0081dc
+  data.tar.gz: dd2d483879772690a1049a6de31bcaf37058d09a
 SHA512:
-  metadata.gz: 3515fc0c08d2ead1a57ed88426c770e3fb53a441b8e8345c5f6df99fdbcac1aeb85d4c1c4179ea379d6887eda35f59913afd070cca5bfd2abe9a66dbbc015d4a
-  data.tar.gz: 56102dc006a238c7d1c404146356f1e1180c7e909125b8db644243a7d2a1dbf5af5d98c1cd346c25a1d02e48b1e8792a54d67b70e60429976665a7c50db1a9ef
+  metadata.gz: afa97bb207635301b1106641a54408b1024858449a275b31ea7eec3fc4c404f69b4d65b3cffac35a70ab04866fa4f7fe36e277f8233fc6bba3743c90473cafdc
+  data.tar.gz: 0b46525e824d08b42af3415a0c687eeed306a788a229c6dcd069e72432716512093b8a70d0e4fba5044cdf1e85d521f5c6d98b8da732daa8abbd071816c76f31

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Honeybadger Industries LLC
+
+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.md

@@ -1,29 +1,52 @@
-# Honeybadger
+# Honeybadger for Ruby
 
+[![Code Climate](https://codeclimate.com/github/honeybadger-io/honeybadger-ruby/badges/gpa.svg)](https://codeclimate.com/github/honeybadger-io/honeybadger-ruby)
 [![Build Status](https://secure.travis-ci.org/honeybadger-io/honeybadger-ruby.png?branch=master)](http://travis-ci.org/honeybadger-io/honeybadger-ruby)
 [![Gem Version](https://badge.fury.io/rb/honeybadger.png)](http://badge.fury.io/rb/honeybadger)
 
 This is the notifier gem for integrating apps with the :zap: [Honeybadger Exception Notifier for Ruby and Rails](http://honeybadger.io).
 
-When an uncaught exception occurs, Honeybadger will POST the relevant data
-to the Honeybadger server specified in your environment.
+When an uncaught exception occurs, Honeybadger will POST the relevant data to the Honeybadger server specified in your environment.
 
 ## Supported Ruby versions
 
-#### IMPORTANT: As of version 1.16.0, Ruby 1.8.7 and 1.9.2 are unsupported. Please ensure you are running Ruby 1.9.3 or greater before upgrading.
+Honeybadger officially supports the following Ruby versions and implementations:
 
-Honeybadger supports Ruby 1.9.3 through 2.2.
+| Ruby          | Version           |
+| ------------- | ------------------|
+| MRI           | >= 1.9.3          |
+| JRuby         | >= 1.7 (1.9 mode) |
+| Rubinius      | >= 2.0            |
 
-## Supported Rails versions
+## Supported frameworks
 
-Honeybadger supports Rails 2.3 through Rails 4.2 (latest releases).
+The following frameworks are supported:
+
+| Framework     | Version       | Native?    |
+| ------------- | ------------- |------------|
+| Rails         | >= 3.0        | yes        |
+| Sinatra       | >= 1.2.1      | yes        |
+| Rack          | >= 1.0        | middleware |
+
+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.
+
+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.
 
 ## Documentation
 
-[View the Documentation](http://docs.honeybadger.io/article/50-honeybadger-gem-documentation)
+* [Basic usage](http://rubydoc.info/gems/honeybadger/)
+* [Full documentation](http://docs.honeybadger.io/article/50-honeybadger-gem-documentation)
+
+## Changelog
+
+See https://github.com/honeybadger-io/honeybadger-ruby/releases
 
 ## Contributing
 
+If you're adding a new feature, please [submit an issue](https://github.com/honeybadger-io/honeybadger-ruby/issues/new) as a preliminary step; that way you can be (moderately) sure that your pull request will be accepted.
+
+### To contribute your code:
+
 1. Fork it.
 2. Create a topic branch `git checkout -b my_branch`
 3. Commit your changes `git commit -am "Boom"`
@@ -32,15 +55,13 @@ Honeybadger supports Rails 2.3 through Rails 4.2 (latest releases).
 
 ### Running the tests
 
-We're using the
-[appraisal](https://github.com/thoughtbot/appraisal) gem to run our test
-suite against multiple versions of Rails. To run the Cucumber features,
-use `rake appraisal cucumber`. Type `rake -T` for a complete list of
-available tasks.
+We're using the [Appraisal](https://github.com/thoughtbot/appraisal) gem to run
+our [RSpec](https://www.relishapp.com/rspec/) test suite against multiple
+versions of [Rails](http://rubyonrails.org/).
 
-The RSpec test suite can be run with `rake`, or
-`rake appraisal:rails2.3` to include Rails-specific specs.
+* The unit test suite can be run with `rake` (aliased to `rake spec:unit`).
+* The integration test suite can be run with `rake spec:features`.
 
 ### License
 
-The Honeybadger gem is MIT licensed. See the [MIT-LICENSE](https://raw.github.com/honeybadger-io/honeybadger-ruby/master/MIT-LICENSE) file in this repository for details. 
+The Honeybadger gem is MIT licensed. See the [LICENSE](https://raw.github.com/honeybadger-io/honeybadger-ruby/master/LICENSE) file in this repository for details.

data/bin/honeybadger

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/honeybadger/cli.rb', __FILE__)
+
+Honeybadger::CLI.start(ARGV)

data/lib/honeybadger.rb

@@ -1,204 +1,180 @@
-require 'net/http'
-require 'net/https'
-require 'json'
-require 'digest'
-require 'logger'
-
-require 'honeybadger/dependency'
-require 'honeybadger/configuration'
-require 'honeybadger/backtrace'
-require 'honeybadger/notice'
-require 'honeybadger/rack'
-require 'honeybadger/sender'
-require 'honeybadger/stats'
-require 'honeybadger/user_informer'
-require 'honeybadger/user_feedback'
-require 'honeybadger/integrations'
-
-require 'honeybadger/railtie' if defined?(Rails::Railtie)
-require 'honeybadger/monitor'
+require 'forwardable'
+require 'honeybadger/const'
 
 module Honeybadger
-  VERSION = '1.16.7'.freeze
-  LOG_PREFIX = "** [Honeybadger] ".freeze
-
-  HEADERS = {
-    'Content-type' => 'application/json',
-    'Content-Encoding' => 'deflate',
-    'Accept'       => 'text/json, application/json',
-    'User-Agent'   => "HB-Ruby #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}"
-  }.freeze
-
-  class << self
-    # The sender object is responsible for delivering formatted data to the
-    # Honeybadger server. Must respond to #send_to_honeybadger. See Honeybadger::Sender.
-    attr_accessor :sender
-
-    # A Honeybadger configuration object. Must act like a hash and return sensible
-    # values for all Honeybadger configuration options. See Honeybadger::Configuration.
-    attr_writer :configuration
-
-    # Tell the log that the Notifier is good to go
-    def report_ready
-      write_verbose_log("Notifier #{VERSION} ready to catch errors", :info)
-    end
-
-    # Prints out the environment info to the log for debugging help
-    def report_environment_info
-      write_verbose_log("Environment Info: #{environment_info}")
-    end
-
-    # Prints out the response body from Honeybadger for debugging help
-    def report_response_body(response)
-      write_verbose_log("Response from Honeybadger: \n#{response}")
-    end
-
-    # Returns the Ruby version, Rails version, and current Rails environment
-    def environment_info
-      info = "[Ruby: #{RUBY_VERSION}]"
-      info << " [#{configuration.framework}]" if configuration.framework
-      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
-    end
-
-    # Writes out the given message to the #logger
-    def write_verbose_log(message, level = Honeybadger.configuration.debug ? :info : :debug)
-      logger.send(level, LOG_PREFIX + message) if logger
-    end
-
-    # Look for the Rails logger currently defined
-    def logger
-      self.configuration.logger
-    end
-
-    # Public: Call this method to modify defaults in your initializers.
-    #
-    # Examples:
-    #
-    #   Honeybadger.configure do |config|
-    #     config.api_key = '1234567890abcdef'
-    #     config.secure  = false
-    #   end
-    #
-    # Yields Honeybadger configuration
-    def configure(silent = false)
-      yield(configuration)
-      self.sender = Sender.new(configuration)
-      report_ready unless silent
-      self.sender
-    end
-
-    # Public: The configuration object.
-    # See Honeybadger.configure
-    #
-    # Returns Honeybadger configuration
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Internal: Contacts the Honeybadger service and configures features
-    #
-    # configuration - the Configuration object to use
-    #
-    # Returns Hash features on success, NilClass on failure
-    def ping(configuration)
-      if configuration.public?
-        if result = sender.ping({ :version => Honeybadger::VERSION, :framework => configuration.framework, :environment => configuration.environment_name, :hostname => configuration.hostname })
-          if features = result['features']
-            configuration.features = features
-            configuration.metrics = false unless features['metrics']
-            configuration.traces = false unless features['traces']
-            features
-          end
-        end
-      end
-    end
-
-    # Public: Sends an exception manually using this method, even when you are not in a controller.
-    #
-    # exception - The exception you want to notify Honeybadger about.
-    # options   - Data that will be sent to Honeybadger.
-    #             :api_key          - The API key for this project. The API key is a unique identifier
-    #                                 that Honeybadger 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+.
-    #             :rack_env         - The Rack environment.
-    #             :session          - The contents of the user's session.
-    #             :environment_name - The application environment name.
-    #             :context          - Custom hash to send
-    #
-    # Returns exception ID from Honeybadger on success, false on failure
-    def notify(exception, options = {})
-      send_notice(build_notice_for(exception, options))
-    end
-
-    # Public: Sends the notice unless it is one of the default ignored exceptions
-    # see Honeybadger.notify
-    def notify_or_ignore(exception, opts = {})
-      notice = build_notice_for(exception, opts)
-      send_notice(notice) unless notice.ignore?
-    end
-
-    def build_lookup_hash_for(exception, options = {})
-      notice = build_notice_for(exception, options)
-
-      result = {}
-      result[:action]           = notice.action      rescue nil
-      result[:component]        = notice.component   rescue nil
-      result[:error_class]      = notice.error_class if notice.error_class
-      result[:environment_name] = 'production'
-
-      unless notice.backtrace.lines.empty?
-        result[:file]        = notice.backtrace.lines[0].file
-        result[:line_number] = notice.backtrace.lines[0].number
-      end
-
-      result
-    end
-
-    def context(hash = nil)
-      unless hash.nil?
-        Thread.current[:honeybadger_context] ||= {}
-        Thread.current[:honeybadger_context].merge!(hash)
-      end
+  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
 
-      self
-    end
+  # Public: Stops the Honeybadger service.
+  #
+  # Examples:
+  #
+  #   Honeybadger.stop # => nil
+  #
+  # Returns nothing
+  def stop
+    Agent.stop
+  end
 
-    def clear!
-      Thread.current[:honeybadger_context] = nil
-    end
+  # Public: Send an exception to Honeybadger.
+  #
+  # 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.
+  #
+  # 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.
+  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
 
-    private
+  # 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
 
-    def send_notice(notice)
-      return false unless sender
+  # 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
 
-      if configuration.public?
-        if configuration.async?
-          configuration.async.call(notice)
-        else
-          Honeybadger.sender.send_to_honeybadger(notice)
-        end
-      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 backtrace_filter(&block)
+    Agent.backtrace_filter(&block)
+  end
 
-    def build_notice_for(exception, opts = {})
-      exception = unwrap_exception(exception)
-      opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
-      opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
-      Notice.new(configuration.merge(opts))
-    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
 
-    def unwrap_exception(exception)
-      return exception unless configuration.unwrap_exceptions
-      exception.respond_to?(:original_exception) && exception.original_exception ||
-      exception.respond_to?(:continued_exception) && exception.continued_exception ||
-      exception.respond_to?(:cause) && exception.cause ||
-      exception
-    end
+  # Internal: Clears the global context
+  def clear!
+    Thread.current[:__honeybadger_context] = nil
   end
 end
 
-unless defined?(Rails)
-  Honeybadger::Dependency.inject!
+if defined?(::Rails::Railtie)
+  require 'honeybadger/init/rails'
+elsif defined?(Sinatra::Base)
+  require 'honeybadger/init/sinatra'
 end