honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/config/defaults.rb

@@ -23,7 +23,7 @@ module Honeybadger
 
     DEVELOPMENT_ENVIRONMENTS = ['development', 'test', 'cucumber'].map(&:freeze).freeze
 
-    DEFAULT_PATHS = ['honeybadger.yml', 'config/honeybadger.yml'].map(&:freeze).freeze
+    DEFAULT_PATHS = ['honeybadger.yml', 'config/honeybadger.yml', "#{ENV['HOME']}/honeybadger.yml"].map(&:freeze).freeze
 
     OPTIONS = {
       api_key: {
@@ -33,7 +33,7 @@ module Honeybadger
       },
       env: {
         description: 'The current application\'s environment name.',
-        default: ENV['HONEYBADGER_ENV'] || ENV['RACK_ENV'] || ENV['APP_ENV'],
+        default: nil,
         type: String
       },
       report_data: {
@@ -86,7 +86,7 @@ module Honeybadger
         default: nil,
         type: Array
       },
-      :'plugins.skip' => {
+      :'skipped_plugins' => {
         description: 'An optional list of plugins to skip.',
         default: nil,
         type: Array
@@ -223,7 +223,7 @@ module Honeybadger
       },
       :'exceptions.ignore_only' => {
         description: 'A list of exceptions to ignore (overrides the default ignored exceptions).',
-        default: [].freeze,
+        default: nil,
         type: Array
       },
       :'exceptions.ignored_user_agents' => {
@@ -268,7 +268,7 @@ module Honeybadger
       },
       :'sidekiq.use_component' => {
         description: 'Automatically set the component to the class of the job. Helps with grouping.',
-        default: false,
+        default: true,
         type: Boolean
       },
       :'sinatra.enabled' => {

data/lib/honeybadger/config/env.rb

@@ -1,21 +1,23 @@
 module Honeybadger
   class Config
-    class Env < ::Hash
+    module Env
       CONFIG_KEY = /\AHONEYBADGER_(.+)\Z/.freeze
       CONFIG_MAPPING = Hash[DEFAULTS.keys.map {|k| [k.to_s.upcase.gsub(KEY_REPLACEMENT, '_'), k] }].freeze
       ARRAY_VALUES = Regexp.new('\s*,\s*').freeze
 
-      def initialize(env = ENV)
+      def self.new(env = ENV)
+        hash = {}
+
         env.each_pair do |k,v|
           next unless k.match(CONFIG_KEY)
           next unless config_key = CONFIG_MAPPING[$1]
-          self[config_key] = cast_value(v, OPTIONS[config_key][:type])
+          hash[config_key] = cast_value(v, OPTIONS[config_key][:type])
         end
-      end
 
-      private
+        hash
+      end
 
-      def cast_value(value, type = String)
+      def self.cast_value(value, type = String)
         v = value.to_s
 
         if type == Boolean

data/lib/honeybadger/config/ruby.rb

@@ -0,0 +1,100 @@
+module Honeybadger
+  class Config
+    class Mash
+      KEYS = DEFAULTS.keys.map(&:to_s).freeze
+
+      def initialize(config, prefix: nil, hash: {})
+        @config = config
+        @prefix = prefix
+        @hash = hash
+      end
+
+      def to_hash
+        hash.to_hash
+      end
+      alias to_h to_hash
+
+      private
+
+      attr_reader :config, :prefix, :hash
+
+      def method_missing(method_name, *args, &block)
+        m = method_name.to_s
+        if mash?(m)
+          return Mash.new(config, prefix: key(m), hash: hash)
+        elsif setter?(m)
+          return hash.send(:[]=, key(m).to_sym, args[0])
+        elsif getter?(m)
+          return get(key(m))
+        end
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+
+      def mash?(method)
+        key = [prefix, method.to_s + '.'].compact.join('.')
+        KEYS.any? {|k| k.start_with?(key) }
+      end
+
+      def setter?(method_name)
+        return false unless method_name.to_s =~ /=\z/
+        key = key(method_name)
+        KEYS.any? {|k| k == key }
+      end
+
+      def getter?(method_name)
+        key = key(method_name)
+        KEYS.any? {|k| k == key }
+      end
+
+      def key(method_name)
+        parts = [prefix, method_name.to_s.chomp('=')]
+        parts.compact!
+        parts.join('.')
+      end
+
+      def get(key)
+        k = key.to_sym
+        return hash[k] if hash.has_key?(k)
+        config.get(k)
+      end
+    end
+
+    class Ruby < Mash
+      def logger=(logger)
+        hash[:logger] = logger
+      end
+
+      def logger
+        get(:logger)
+      end
+
+      def backend=(backend)
+        hash[:backend] = backend
+      end
+
+      def backend
+        get(:backend)
+      end
+
+      def backtrace_filter
+        hash[:backtrace_filter] = Proc.new if block_given?
+        get(:backtrace_filter)
+      end
+
+      def exception_filter
+        hash[:exception_filter] = Proc.new if block_given?
+        get(:exception_filter)
+      end
+
+      def exception_fingerprint
+        hash[:exception_fingerprint] = Proc.new if block_given?
+        get(:exception_fingerprint)
+      end
+    end
+  end
+end

data/lib/honeybadger/config/yaml.rb

@@ -4,40 +4,39 @@ require 'erb'
 
 module Honeybadger
   class Config
-    class Yaml < ::Hash
+    module Yaml
       DISALLOWED_KEYS = [:'config.path'].freeze
 
-      def initialize(path, env = 'production')
-        @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      def self.new(path, env = 'production')
+        path = path.kind_of?(Pathname) ? path : Pathname.new(path)
 
-        if !@path.exist?
-          raise ConfigError, "The configuration file #{@path} was not found."
-        elsif !@path.file?
-          raise ConfigError, "The configuration file #{@path} is not a file."
-        elsif !@path.readable?
-          raise ConfigError, "The configuration file #{@path} is not readable."
-        else
-          yaml = load_yaml
-          yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
-          update(dotify_keys(yaml))
+        if !path.exist?
+          raise ConfigError, "The configuration file #{path} was not found."
+        elsif !path.file?
+          raise ConfigError, "The configuration file #{path} is not a file."
+        elsif !path.readable?
+          raise ConfigError, "The configuration file #{path} is not readable."
         end
-      end
 
-      private
+        yaml = load_yaml(path)
+        yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
+
+        dotify_keys(yaml)
+      end
 
-      def load_yaml
-        yaml = YAML.load(ERB.new(@path.read).result)
+      def self.load_yaml(path)
+        yaml = YAML.load(ERB.new(path.read).result)
         case yaml
         when Hash
           yaml
         when NilClass, FalseClass
           {}
         else
-          raise ConfigError, "The configuration file #{@path} is invalid."
+          raise ConfigError, "The configuration file #{path} is invalid."
         end
       end
 
-      def dotify_keys(hash, key_prefix = nil)
+      def self.dotify_keys(hash, key_prefix = nil)
         {}.tap do |new_hash|
           hash.each_pair do |k,v|
             k = [key_prefix, k].compact.join('.')

data/lib/honeybadger/const.rb

@@ -1,25 +1,12 @@
 require 'honeybadger/version'
 
 module Honeybadger
-  autoload :Agent, 'honeybadger/agent'
-  autoload :Backend, 'honeybadger/backend'
-  autoload :Backtrace, 'honeybadger/backtrace'
-  autoload :Config, 'honeybadger/config'
-  autoload :Logging, 'honeybadger/logging'
-  autoload :Notice, 'honeybadger/notice'
-  autoload :Plugin, 'honeybadger/plugin'
-
+  # Autoloading allows middleware classes to be referenced in applications
+  # which include the optional Rack dependency without explicitly requiring
+  # these files.
   module Rack
     autoload :ErrorNotifier, 'honeybadger/rack/error_notifier'
     autoload :UserFeedback, 'honeybadger/rack/user_feedback'
     autoload :UserInformer, 'honeybadger/rack/user_informer'
-    autoload :RequestHash, 'honeybadger/rack/request_hash'
-  end
-
-  module Util
-    autoload :Sanitizer, 'honeybadger/util/sanitizer'
-    autoload :RequestSanitizer, 'honeybadger/util/request_sanitizer'
-    autoload :Stats, 'honeybadger/util/stats'
-    autoload :HTTP, 'honeybadger/util/http'
   end
 end

data/lib/honeybadger/context_manager.rb

@@ -0,0 +1,50 @@
+module Honeybadger
+  class ContextManager
+
+    def self.current
+      Thread.current[:__hb_context_manager] ||= new
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      _initialize
+    end
+
+    def clear!
+      _initialize
+    end
+
+    # Internal accessors
+
+    def set_context(hash)
+      @mutex.synchronize do
+        @context ||= {}
+        @context.update(hash)
+      end
+    end
+
+    def get_context
+      @mutex.synchronize { @context }
+    end
+
+    def set_rack_env(env)
+      @mutex.synchronize { @rack_env = env }
+    end
+
+    def get_rack_env
+      @mutex.synchronize { @rack_env }
+    end
+
+    private
+
+    attr_accessor :custom, :rack_env
+
+    def _initialize
+      @mutex.synchronize do
+        @context = nil
+        @rack_env = nil
+      end
+    end
+
+  end
+end

data/lib/honeybadger/init/rails.rb

@@ -1,11 +1,7 @@
 require 'rails'
 require 'yaml'
 
-require 'honeybadger/util/sanitizer'
-require 'honeybadger/util/request_payload'
-require 'honeybadger/rack/error_notifier'
-require 'honeybadger/rack/user_informer'
-require 'honeybadger/rack/user_feedback'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Init
@@ -15,29 +11,21 @@ module Honeybadger
           load 'honeybadger/tasks.rb'
         end
 
-        initializer 'honeybadger.install' do
-          config = Config.new(local_config)
-          if Honeybadger.start(config)
-            if config.feature?(:notices) && config[:'exceptions.enabled']
-              ::Rails.application.config.middleware.tap do |middleware|
-                middleware.insert(0, Honeybadger::Rack::ErrorNotifier, config)
-                middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer, config) if config[:'user_informer.enabled']
-                middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback, config) if config[:'feedback.enabled']
-              end
-            end
-          end
+        initializer 'honeybadger.install_middleware' do |app|
+          app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer)
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback)
         end
 
-        private
-
-        def local_config
-          {
+        config.after_initialize do
+          Honeybadger.init!({
             :root           => ::Rails.root.to_s,
             :env            => ::Rails.env,
             :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
             :logger         => Logging::FormattedLogger.new(::Rails.logger),
             :framework      => :rails
-          }
+          })
+          Honeybadger.load_plugins!
         end
       end
     end

data/lib/honeybadger/init/rake.rb

@@ -1,3 +1,5 @@
+require 'honeybadger/ruby'
+
 # Patch Rake::Application to handle errors with Honeybadger
 module Honeybadger
   module RakeHandler

data/lib/honeybadger/init/ruby.rb

@@ -0,0 +1,9 @@
+require 'honeybadger/ruby'
+
+Honeybadger.init!({
+  :framework      => :ruby,
+  :env            => ENV['RUBY_ENV'] || ENV['RACK_ENV'],
+  :'logging.path' => 'STDOUT'
+})
+
+Honeybadger.load_plugins!

data/lib/honeybadger/init/sinatra.rb

@@ -1,3 +1,6 @@
+require 'sinatra/base'
+require 'honeybadger/ruby'
+
 module Honeybadger
   module Init
     module Sinatra
@@ -12,22 +15,26 @@ module Honeybadger
 
           def honeybadger_config(app)
             {
-              api_key: defined?(honeybadger_api_key) ? honeybadger_api_key : nil
+              api_key: defined?(honeybadger_api_key) ? honeybadger_api_key : nil,
+              env: ENV['APP_ENV'] || ENV['RACK_ENV'],
+              framework: :sinatra,
+              :'logging.path' => 'STDOUT'
             }
           end
 
           def install_honeybadger
-            config = Honeybadger::Config.new(honeybadger_config(self))
+            Honeybadger.init!(honeybadger_config(self))
+            Honeybadger.load_plugins!
 
+            config = Honeybadger.config
             return unless config[:'sinatra.enabled']
-            return unless Honeybadger.start(config)
 
-            install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier, config) if config.feature?(:notices) && config[:'exceptions.enabled']
+            install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier) if config[:'exceptions.enabled']
           end
 
-          def install_honeybadger_middleware(klass, config)
+          def install_honeybadger_middleware(klass)
             return if middleware.any? {|m| m[0] == klass }
-            use(klass, config)
+            use(klass)
           end
         end
       end

data/lib/honeybadger/notice.rb

@@ -6,6 +6,7 @@ require 'honeybadger/version'
 require 'honeybadger/backtrace'
 require 'honeybadger/util/stats'
 require 'honeybadger/util/sanitizer'
+require 'honeybadger/util/request_hash'
 require 'honeybadger/util/request_payload'
 
 module Honeybadger
@@ -130,12 +131,13 @@ module Honeybadger
       @opts = opts
       @config = config
 
-      @sanitizer = Util::Sanitizer.new
-      @request_sanitizer = Util::Sanitizer.new(filters: config.params_filters)
+      @rack_env = opts.fetch(:rack_env, nil)
+
+      @request_sanitizer = Util::Sanitizer.new(filters: params_filters)
 
       @exception = unwrap_exception(opts[:exception])
-      @error_class = exception_attribute(:error_class) {|exception| exception.class.name }
-      @error_message = exception_attribute(:error_message, 'Notification') do |exception|
+      @error_class = exception_attribute(:error_class, 'Notice') {|exception| exception.class.name }
+      @error_message = exception_attribute(:error_message, 'No message provided') do |exception|
         "#{exception.class.name}: #{exception.message}"
       end
       @backtrace = parse_backtrace(exception_attribute(:backtrace, caller))
@@ -224,7 +226,8 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :opts, :context, :stats, :now, :pid, :causes, :sanitizer, :request_sanitizer
+    attr_reader :config, :opts, :context, :stats, :now, :pid, :causes,
+      :request_sanitizer, :rack_env
 
     def ignore_by_origin?
       return false if opts[:origin] != :rake
@@ -233,9 +236,8 @@ module Honeybadger
     end
 
     def ignore_by_callbacks?
-      opts[:callbacks] &&
-        opts[:callbacks].exception_filter &&
-        opts[:callbacks].exception_filter.call(self)
+      config.exception_filter &&
+        config.exception_filter.call(self)
     end
 
     # Gets a property named "attribute" of an exception, either from
@@ -286,21 +288,26 @@ module Honeybadger
         end
       end
 
-      ignored_class ? @ignore_by_class.call(ignored_class) : config[:'exceptions.ignore'].any?(&@ignore_by_class)
+      ignored_class ? @ignore_by_class.call(ignored_class) : config.ignored_classes.any?(&@ignore_by_class)
     end
 
     def construct_backtrace_filters(opts)
       [
-        opts[:callbacks] ? opts[:callbacks].backtrace_filter : nil
+        config.backtrace_filter
       ].compact | BACKTRACE_FILTERS
     end
 
+    def request_hash
+      return {} unless rack_env
+      Util::RequestHash.from_env(rack_env)
+    end
+
     # Internal: Construct the request object with data from various sources.
     #
     # Returns Request.
     def construct_request_hash(config, opts)
       request = {}
-      request.merge!(config.request_hash)
+      request.merge!(request_hash)
       request.merge!(opts)
       request[:component] = opts[:controller] if opts.has_key?(:controller)
       request[:params] = opts[:parameters] if opts.has_key?(:parameters)
@@ -311,14 +318,14 @@ module Honeybadger
 
     def construct_context_hash(opts)
       context = {}
-      context.merge!(Thread.current[:__honeybadger_context]) if Thread.current[:__honeybadger_context]
+      context.merge!(opts[:global_context]) if opts[:global_context]
       context.merge!(opts[:context]) if opts[:context]
       context.empty? ? nil : context
     end
 
     def fingerprint_from_opts(opts)
       callback = opts[:fingerprint]
-      callback ||= opts[:callbacks] && opts[:callbacks].exception_fingerprint
+      callback ||= config.exception_fingerprint
 
       if callback.respond_to?(:call)
         callback.call(self)
@@ -347,7 +354,7 @@ module Honeybadger
     end
 
     def s(data)
-      sanitizer.sanitize(data)
+      Util::Sanitizer.sanitize(data)
     end
 
     # Internal: Fetch local variables from first frame of backtrace.
@@ -451,6 +458,14 @@ module Honeybadger
       c
     end
 
+    def params_filters
+      config.params_filters + rails_params_filters
+    end
+
+    def rails_params_filters
+      rack_env && Array(rack_env['action_dispatch.parameter_filter']) or []
+    end
+
     # Internal: This is how much Honeybadger cares about Rails developers. :)
     #
     # Some Rails projects include ActionDispatch::TestProcess globally for the