honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/cli/notify.rb

@@ -0,0 +1,66 @@
+require 'digest'
+require 'forwardable'
+require 'honeybadger/cli/main'
+require 'honeybadger/util/http'
+require 'honeybadger/util/stats'
+
+module Honeybadger
+  module CLI
+    class Notify
+      extend Forwardable
+
+      def initialize(options, args, config)
+        @options = options
+        @args = args
+        @config = config
+        @shell = ::Thor::Base.shell.new
+      end
+
+      def run
+        payload = {
+          api_key: config.get(:api_key),
+          notifier: NOTIFIER,
+          error: {
+            class: options['class'],
+            message: options['message']
+          },
+          request: {},
+          server: {
+            project_root: Dir.pwd,
+            environment_name: config.get(:env),
+            time: Time.now,
+            stats: Util::Stats.all
+          }
+        }
+
+        payload[:error][:fingerprint] = Digest::SHA1.hexdigest(options['fingerprint']) if option?('fingerprint')
+        payload[:error][:tags] = options['tags'].to_s.strip.split(',').map(&:strip) if option?('tags')
+
+        payload[:request][:component] = options['component'] if option?('component')
+        payload[:request][:action] = options['action'] if option?('action')
+        payload[:request][:url] = options['url'] if option?('url')
+
+        payload.delete(:request) if payload[:request].empty?
+
+        http = Util::HTTP.new(config)
+        result = http.post('/v1/notices', payload)
+        if result.code == '201'
+          say("Error notification complete.", :green)
+        else
+          say("Invalid response from server: #{result.code}", :red)
+          exit(1)
+        end
+      end
+
+      private
+
+      attr_reader :options, :args, :config
+
+      def_delegator :@shell, :say
+
+      def option?(key)
+        options.has_key?(key) && options[key] != key
+      end
+    end
+  end
+end

data/lib/honeybadger/cli/test.rb

@@ -0,0 +1,266 @@
+require 'erb'
+require 'forwardable'
+require 'honeybadger/cli/main'
+require 'pathname'
+
+module Honeybadger
+  module CLI
+    class Test
+      extend Forwardable
+
+      TEST_EXCEPTION = begin
+                         exception_name = ENV['EXCEPTION'] || 'HoneybadgerTestingException'
+                         Object.const_get(exception_name)
+                       rescue
+                         Object.const_set(exception_name, Class.new(Exception))
+                       end.new('Testing honeybadger via "honeybadger test". If you can see this, it works.')
+
+      class TestBackend
+        def initialize(backend)
+          @backend = backend
+        end
+
+        def self.callings
+          @callings ||= Hash.new {|h,k| h[k] = [] }
+        end
+
+        def notify(feature, payload)
+          response = @backend.notify(feature, payload)
+          self.class.callings[feature] << [payload, response]
+          response
+        end
+      end
+
+      def initialize(options)
+        @options = options
+        @shell = ::Thor::Base.shell.new
+      end
+
+      def run
+        require 'honeybadger/ruby'
+
+        begin
+          require File.join(Dir.pwd, 'config', 'application.rb')
+          raise LoadError unless defined?(::Rails)
+          require 'honeybadger/init/rails'
+          Rails.application.initialize!
+          say("Detected Rails #{Rails::VERSION::STRING}")
+        rescue LoadError
+          require 'honeybadger/init/ruby'
+        end
+
+        if Honeybadger.config.get(:api_key).to_s =~ BLANK
+          say("Unable to send test: Honeybadger API key is missing.", :red)
+          exit(1)
+        end
+
+        Honeybadger.config.set(:report_data, !options[:dry_run])
+        test_backend = TestBackend.new(Honeybadger.config.backend)
+        Honeybadger.config.backend = test_backend
+
+        at_exit do
+          Honeybadger.flush
+
+          if calling = TestBackend.callings[:notices].find {|c| c[0].exception.eql?(TEST_EXCEPTION) }
+            notice, response = *calling
+
+            if response.code != 201
+              host = Honeybadger.config.get(:'connection.host')
+              say(<<-MSG, :red)
+!! --- Honeybadger test failed ------------------------------------------------ !!
+
+The error notifier is installed, but we encountered an error:
+
+  #{response.code.kind_of?(Integer) ? "(#{response.code}) " : nil}#{response.error_message}
+
+To fix this issue, please try the following:
+
+  - Make sure the gem is configured properly.
+  - Retry executing this command a few times.
+  - Make sure you can connect to #{host} (`ping #{host}`).
+  - Email support@honeybadger.io for help. Include as much debug info as you
+    can for a faster resolution!
+
+!! --- End -------------------------------------------------------------------- !!
+MSG
+              exit(1)
+            end
+
+            say(generate_success_message(response), :green)
+
+            exit(0)
+          end
+
+          say(<<-MSG, :red)
+!! --- Honeybadger test failed ------------------------------------------------ !!
+
+Error: The test exception was not reported; the application may not be
+configured properly.
+
+This is usually caused by one of the following issues:
+
+  - There was a problem loading your application. Check your logs to see if a
+    different exception is being raised.
+  - The exception is being rescued before it reaches our Rack middleware. If
+    you're using `rescue` or `rescue_from` you may need to notify Honeybadger
+    manually: `Honeybadger.notify(exception)`.
+  - The honeybadger gem is misconfigured. Check the settings in your
+    honeybadger.yml file.
+MSG
+
+          notices = TestBackend.callings[:notices].map(&:first)
+          unless notices.empty?
+            say("\nThe following errors were reported:", :red)
+            notices.each {|n| say("\n  - #{n.error_class}: #{n.error_message}", :red) }
+          end
+
+          say("\nSee https://git.io/vXCYp for more troubleshooting help.\n\n", :red)
+          say("!! --- End -------------------------------------------------------------------- !!", :red)
+
+          exit(1)
+        end
+
+        run_test
+      end
+
+      private
+
+      attr_reader :options
+
+      def_delegator :@shell, :say
+
+      def run_test
+        if defined?(::Rails.application)
+          run_rails_test
+        else
+          run_standalone_test
+        end
+      end
+
+      def test_exception_class
+        exception_name = ENV['EXCEPTION'] || 'HoneybadgerTestingException'
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def run_standalone_test
+        Honeybadger.notify(TEST_EXCEPTION)
+      end
+
+      def run_rails_test
+        # Suppress error logging in Rails' exception handling middleware. Rails 3.0
+        # uses ActionDispatch::ShowExceptions to rescue/show exceptions, but does
+        # not log anything but application trace. Rails 3.2 now falls back to
+        # logging the framework trace (moved to ActionDispatch::DebugExceptions),
+        # which caused cluttered output while running the test task.
+        defined?(::ActionDispatch::DebugExceptions) and
+          ::ActionDispatch::DebugExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
+        defined?(::ActionDispatch::ShowExceptions) and
+          ::ActionDispatch::ShowExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
+
+        # Detect and disable the better_errors gem
+        if defined?(::BetterErrors::Middleware)
+          say('Better Errors detected: temporarily disabling middleware.', :yellow)
+          ::BetterErrors::Middleware.class_eval { def call(env) @app.call(env); end }
+        end
+
+        begin
+          require './app/controllers/application_controller'
+        rescue LoadError
+          nil
+        end
+
+        unless defined?(::ApplicationController)
+          say('Error: No ApplicationController found.', :red)
+          return false
+        end
+
+        eval(<<-CONTROLLER)
+        class Honeybadger::TestController < ApplicationController
+          # This is to bypass any filters that may prevent access to the action.
+          if respond_to?(:prepend_before_action)
+            prepend_before_action :test_honeybadger
+          else
+            prepend_before_filter :test_honeybadger
+          end
+          def test_honeybadger
+            puts "Raising '#{Honeybadger::CLI::Test::TEST_EXCEPTION.class.name}' to simulate application failure."
+            raise Honeybadger::CLI::Test::TEST_EXCEPTION
+          end
+          # Ensure we actually have an action to go to.
+          def verify; end
+        end
+        CONTROLLER
+
+        ::Rails.application.routes.tap do |r|
+          # RouteSet#disable_clear_and_finalize prevents existing routes from
+          # being cleared. We'll set it back to the original value when we're
+          # done so not to mess with Rails state.
+          d = r.disable_clear_and_finalize
+          begin
+            r.disable_clear_and_finalize = true
+            r.clear!
+            r.draw do
+              match 'verify' => 'honeybadger/test#verify', :as => 'verify', :via => :get
+            end
+            ::Rails.application.routes_reloader.paths.each{ |path| load(path) }
+            ::ActiveSupport.on_load(:action_controller) { r.finalize! }
+          ensure
+            r.disable_clear_and_finalize = d
+          end
+        end
+
+        ssl = defined?(::Rails.configuration.force_ssl) && ::Rails.configuration.force_ssl
+        env = ::Rack::MockRequest.env_for("http#{ ssl ? 's' : nil }://www.example.com/verify", 'REMOTE_ADDR' => '127.0.0.1')
+
+        ::Rails.application.call(env)
+      end
+
+      def generate_success_message(response)
+        notice_id = JSON.parse(response.body)['id']
+        notice_url = "https://app.honeybadger.io/notice/#{notice_id}"
+
+        unless options[:install]
+          return "⚡ Success: #{notice_url}"
+        end
+
+        <<-MSG
+⚡ --- Honeybadger is installed! -----------------------------------------------
+
+Good news: You're one deploy away from seeing all of your exceptions in
+Honeybadger. For now, we've generated a test exception for you:
+
+  #{notice_url}
+
+Optional steps:
+
+  - Show a feedback form on your error page:
+    http://docs.honeybadger.io/gem-feedback
+  - Show a UUID or link to Honeybadger on your error page:
+    http://docs.honeybadger.io/gem-informer
+  - Track deployments (if you're using Capistrano, we already did this):
+    http://docs.honeybadger.io/gem-deploys
+
+If you ever need help:
+
+  - Read the gem troubleshooting guide: https://git.io/vXCYp
+  - Check out our documentation: http://docs.honeybadger.io/
+  - Email the founders: support@honeybadger.io
+
+Most people don't realize that Honeybadger is a small, bootstrapped company. We
+really couldn't do this without you. Thank you for allowing us to do what we
+love: making developers awesome.
+
+Happy 'badgering!
+
+Sincerely,
+Ben, Josh and Starr
+https://www.honeybadger.io/about/
+
+⚡ --- End --------------------------------------------------------------------
+MSG
+      end
+    end
+  end
+end

data/lib/honeybadger/config.rb

@@ -10,7 +10,6 @@ require 'honeybadger/backend'
 require 'honeybadger/config/defaults'
 require 'honeybadger/util/http'
 require 'honeybadger/logging'
-require 'honeybadger/rack/request_hash'
 
 module Honeybadger
   class Config
@@ -20,9 +19,11 @@ module Honeybadger
 
     class ConfigError < StandardError; end
 
-    autoload :Callbacks, 'honeybadger/config/callbacks'
+    # Config subclasses have circular dependencies, so they must be loaded
+    # after constants are defined.
     autoload :Env, 'honeybadger/config/env'
     autoload :Yaml, 'honeybadger/config/yaml'
+    autoload :Ruby, 'honeybadger/config/ruby'
 
     KEY_REPLACEMENT = Regexp.new('[^a-z\d_]', Regexp::IGNORECASE).freeze
 
@@ -30,70 +31,100 @@ module Honeybadger
 
     NOT_BLANK = Regexp.new('\S').freeze
 
-    FEATURES = [:notices, :local_variables].freeze
-
-    MERGE_DEFAULT = [:'exceptions.ignore'].freeze
-
-    OVERRIDE = {
-      :'exceptions.ignore' => :'exceptions.ignore_only'
-    }.freeze
-
-    DEFAULT_REQUEST_HASH = {}.freeze
-
     def initialize(opts = {})
-      l = opts.delete(:logger)
-
-      @values = opts
-
-      priority = {}
-      priority.update(opts)
-      load_config_from_disk {|yml| priority.update(yml) }
-      priority.update(Env.new(ENV))
-      update(merge_defaults!(priority))
+      @ruby = opts.freeze
+      @env = {}.freeze
+      @yaml = {}.freeze
+      @framework = {}.freeze
+    end
+
+    attr_accessor :ruby, :env, :yaml, :framework
+
+    def init!(opts = {}, env = ENV)
+      self.framework = opts.freeze
+      self.env = Env.new(env).freeze
+      load_config_from_disk {|yaml| self.yaml = yaml.freeze }
+      init_logging!
+      init_backend!
+      logger.info(sprintf('Initializing Honeybadger Error Tracker for Ruby. Ship it! version=%s framework=%s', Honeybadger::VERSION, detected_framework))
+      logger.warn('Entering development mode: data will not be reported.') if dev? && backend.kind_of?(Backend::Null)
+      if valid? && !ping
+        logger.warn('Failed to connect to Honeybadger service -- please verify that api.honeybadger.io is reachable (connection will be retried).')
+      end
+      self
+    end
 
-      @logger = Logging::ConfigLogger.new(self, build_logger(l))
-      Logging::BootLogger.instance.flush(@logger)
+    def configure
+      ruby_config = Ruby.new(self)
+      yield(ruby_config)
+      self.ruby = ruby.merge(ruby_config).freeze
+      @logging = @backend = nil
+      self
+    end
 
-      @features = Hash[FEATURES.map{|f| [f, true] }]
+    def backtrace_filter
+      self[:backtrace_filter] = Proc.new if block_given?
+      self[:backtrace_filter]
     end
 
-    def_delegators :@values, :update
+    def exception_filter
+      self[:exception_filter] = Proc.new if block_given?
+      self[:exception_filter]
+    end
 
-    attr_reader :features
+    def exception_fingerprint
+      self[:exception_fingerprint] = Proc.new if block_given?
+      self[:exception_fingerprint]
+    end
 
     def get(key)
-      key = key.to_sym
-      if OVERRIDE.has_key?(key) && @values.has_key?(OVERRIDE[key])
-        @values[OVERRIDE[key]]
-      elsif @values.has_key?(key)
-        @values[key]
-      else
-        DEFAULTS[key]
+      [:@ruby, :@env, :@yaml, :@framework].each do |var|
+        source = instance_variable_get(var)
+        if source.has_key?(key)
+          return source[key]
+        end
       end
+
+      DEFAULTS[key]
     end
     alias [] :get
 
     def set(key, value)
-      @values[key] = value
+      self.ruby = ruby.merge(key => value).freeze
+      @logging = @backend = nil
     end
     alias []= :set
 
     def to_hash(defaults = false)
-      hash = defaults ? DEFAULTS.merge(@values) : @values
+      hash = [:@ruby, :@env, :@yaml, :@framework].reverse.reduce({}) do |a,e|
+        a.merge!(instance_variable_get(e))
+      end
+
+      hash = DEFAULTS.merge(hash) if defaults
+
       undotify_keys(hash.select {|k,v| DEFAULTS.has_key?(k) })
     end
-    alias :to_h :to_hash
+    alias to_h to_hash
 
-    def feature?(feature)
-      !!features[feature.to_sym]
-    end
+    # Internal Helpers
 
     def logger
-      @logger || Logging::BootLogger.instance
+      init_logging! unless @logger
+      @logger
     end
 
     def backend
-      Backend.for((self[:backend] || default_backend).to_sym).new(self)
+      init_backend! unless @backend
+      @backend
+    end
+
+    def backend=(backend)
+      set(:backend, backend)
+      @backend = nil
+    end
+
+    def disabled?
+      !!self[:disabled]
     end
 
     def dev?
@@ -106,14 +137,6 @@ module Honeybadger
       !self[:env] || !dev?
     end
 
-    def default_backend
-      if public?
-        :server
-      else
-        :null
-      end
-    end
-
     def valid?
       self[:api_key].to_s =~ /\S/
     end
@@ -127,28 +150,12 @@ module Honeybadger
       !!self[:'logging.debug']
     end
 
-    # Internal: Optional path to honeybadger.log log file. If nil, STDOUT will be used
-    # instead.
-    #
-    # Returns the Pathname log path if a log path was specified.
-    def log_path
-      if self[:'logging.path'] && self[:'logging.path'] != 'STDOUT'
-        locate_absolute_path(self[:'logging.path'], self[:root])
-      end
-    end
-
-    # Internal: Path to honeybadger.yml configuration file; this should be the
-    # root directory if no path was specified.
-    #
-    # Returns the Pathname configuration path.
-    def config_path
-      config_paths.first
-    end
+    def ignored_classes
+      ignore_only = get(:'exceptions.ignore_only')
+      return ignore_only if ignore_only
+      return DEFAULTS[:'exceptions.ignore'] unless ignore = get(:'exceptions.ignore')
 
-    def config_paths
-      Array(ENV['HONEYBADGER_CONFIG_PATH'] || get(:'config.path')).map do |c|
-        locate_absolute_path(c, self[:root])
-      end
+      DEFAULTS[:'exceptions.ignore'] | Array(ignore)
     end
 
     def ca_bundle_path
@@ -183,32 +190,12 @@ module Honeybadger
       end
     end
 
-    def request
-      Thread.current[:__honeybadger_request]
-    end
-
-    def with_request(request, &block)
-      Thread.current[:__honeybadger_request] = request
-      yield
-    ensure
-      Thread.current[:__honeybadger_request] = nil
-    end
-
     def max_queue_size
       self[:max_queue_size]
     end
 
-    def request_hash
-      return DEFAULT_REQUEST_HASH unless request
-      Rack::RequestHash.new(request)
-    end
-
     def params_filters
-      self[:'request.filter_keys'] + rails_params_filters
-    end
-
-    def rails_params_filters
-      request && request.env['action_dispatch.parameter_filter'] or []
+      Array(self[:'request.filter_keys'])
     end
 
     def excluded_request_keys
@@ -220,23 +207,6 @@ module Honeybadger
       end
     end
 
-    def write
-      path = config_path
-
-      if path.exist?
-        raise ConfigError, "The configuration file #{path} already exists."
-      elsif !path.dirname.writable?
-        raise ConfigError, "The configuration path #{path.dirname} is not writable."
-      end
-
-      File.open(path, 'w+') do |file|
-        file.write(<<-CONFIG)
----
-api_key: '#{self[:api_key]}'
-                   CONFIG
-      end
-    end
-
     def log_level(key = :'logging.level')
       case self[key].to_s
       when /\A(0|debug)\z/i then Logger::DEBUG
@@ -249,21 +219,33 @@ api_key: '#{self[:api_key]}'
     end
 
     def load_plugin?(name)
-      return false if includes_token?(self[:'plugins.skip'], name)
+      return false if includes_token?(self[:'skipped_plugins'], name)
       return true unless self[:plugins].kind_of?(Array)
       includes_token?(self[:plugins], name)
     end
 
+    # Internal: Match the project root.
+    #
+    # Returns Regexp matching the project root in a file string.
+    def root_regexp
+      return @root_regexp if @root_regexp
+      return nil if @no_root
+
+      root = get(:root).to_s
+      @no_root = true and return nil unless root =~ NOT_BLANK
+
+      @root_regexp = Regexp.new("^#{ Regexp.escape(root) }")
+    end
+
     def ping
       if result = send_ping
-        @features = symbolize_keys(result['features']) if result['features']
         return true
       end
 
       false
     end
 
-    def framework
+    def detected_framework
       if self[:framework] =~ NOT_BLANK
         self[:framework].to_sym
       elsif defined?(::Rails::VERSION) && ::Rails::VERSION::STRING > '3.0'
@@ -278,7 +260,7 @@ api_key: '#{self[:api_key]}'
     end
 
     def framework_name
-      case framework
+      case detected_framework
       when :rails then "Rails #{::Rails::VERSION::STRING}"
       when :sinatra then "Sinatra #{::Sinatra::VERSION}"
       when :rack then "Rack #{::Rack.release}"
@@ -287,20 +269,92 @@ api_key: '#{self[:api_key]}'
       end
     end
 
-    # Internal: Match the project root.
+    private
+
+    # Internal: Optional path to honeybadger.log log file.
     #
-    # Returns Regexp matching the project root in a file string.
-    def root_regexp
-      return @root_regexp if @root_regexp
-      return nil if @no_root
+    # Returns the Pathname log path if a log path was specified.
+    def log_path
+      return if log_stdout?
+      return if !self[:'logging.path']
+      locate_absolute_path(self[:'logging.path'], self[:root])
+    end
 
-      root = get(:root).to_s
-      @no_root = true and return nil unless root =~ NOT_BLANK
+    # Internal: Path to honeybadger.yml configuration file; this should be the
+    # root directory if no path was specified.
+    #
+    # Returns the Pathname configuration path.
+    def config_path
+      config_paths.first
+    end
 
-      @root_regexp = Regexp.new("^#{ Regexp.escape(root) }")
+    def config_paths
+      Array(ENV['HONEYBADGER_CONFIG_PATH'] || get(:'config.path')).map do |c|
+        locate_absolute_path(c, self[:root])
+      end
     end
 
-    private
+    def default_backend
+      return Backend::Server.new(self) if public?
+      Backend::Null.new(self)
+    end
+
+    def init_backend!
+      if self[:backend].is_a?(String) || self[:backend].is_a?(Symbol)
+        @backend = Backend.for(self[:backend].to_sym).new(self)
+        return
+      end
+
+      if ruby[:backend].respond_to?(:notify)
+        @backend = ruby[:backend]
+        return
+      end
+
+      if ruby[:backend]
+        logger.warn(sprintf('Unknown backend: %p; default will be used. Backend must respond to #notify', self[:backend]))
+      end
+
+      @backend = default_backend
+    end
+
+    def build_stdout_logger
+      logger = Logger.new($stdout)
+      logger.formatter = lambda do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+      logger.level = log_level
+      Logging::FormattedLogger.new(logger)
+    end
+
+    def build_file_logger(path)
+      Logger.new(path).tap do |logger|
+        logger.level = log_level
+        logger.formatter = Logger::Formatter.new
+      end
+    end
+
+    def log_stdout?
+      self[:'logging.path'] && self[:'logging.path'].to_s.downcase == 'stdout'
+    end
+
+    def build_logger
+      return ruby[:logger] if ruby[:logger]
+
+      return build_stdout_logger if log_stdout?
+
+      if path = log_path
+        FileUtils.mkdir_p(path.dirname) unless path.dirname.writable?
+        return build_file_logger(path)
+      end
+
+      return framework[:logger] if framework[:logger]
+
+      Logger.new('/dev/null')
+    end
+
+    def init_logging!
+      @logger = Logging::ConfigLogger.new(self, build_logger)
+    end
 
     # Internal: Does collection include the String value or Symbol value?
     #
@@ -349,25 +403,6 @@ api_key: '#{self[:api_key]}'
       end
     end
 
-    def build_logger(default = nil)
-      if path = log_path
-        FileUtils.mkdir_p(path.dirname) unless path.dirname.writable?
-        Logger.new(path).tap do |logger|
-          logger.level = log_level
-          logger.formatter = Logger::Formatter.new
-        end
-      elsif self[:'logging.path'] != 'STDOUT' && default
-        default
-      else
-        logger = Logger.new($stdout)
-        logger.level = log_level
-        logger.formatter = lambda do |severity, datetime, progname, msg|
-          "#{msg}\n"
-        end
-        Logging::FormattedLogger.new(logger)
-      end
-    end
-
     def load_config_from_disk
       if (path = config_paths.find(&:exist?)) && path.file?
         Yaml.new(path, self[:env]).tap do |yml|
@@ -375,11 +410,11 @@ api_key: '#{self[:api_key]}'
         end
       end
     rescue ConfigError => e
-      error("error while loading config from disk: #{e}")
+      error("Error loading config from disk: #{e}")
       nil
     rescue StandardError => e
       error {
-        msg = "error while loading config from disk class=%s message=%s\n\t%s"
+        msg = "Error loading config from disk. class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
       nil
@@ -392,29 +427,10 @@ api_key: '#{self[:api_key]}'
             new_hash[$1] ||= {}
             new_hash[$1] = undotify_keys(new_hash[$1].merge({$2 => v}))
           else
-            new_hash[k] = v
+            new_hash[k.to_s] = v
           end
         end
       end
     end
-
-    def symbolize_keys(hash)
-      Hash[hash.map {|k,v| [k.to_sym, v] }]
-    end
-
-    # Internal: Merges supplied config options with defaults.
-    #
-    # config - The Hash config options to merge.
-    #
-    # Returns the updated Hash config with merged values.
-    def merge_defaults!(config)
-      MERGE_DEFAULT.each do |option|
-        if config[option].kind_of?(Array)
-          config[option] = (DEFAULTS[option] | config[option])
-        end
-      end
-
-      config
-    end
   end
 end